mirror of https://github.com/lammps/lammps.git
615 lines
21 KiB
Plaintext
615 lines
21 KiB
Plaintext
cmake_minimum_required(VERSION 3.10)
|
|
# When using CMake 3.4 and later, don't export symbols from executables unless
|
|
# the CMAKE_ENABLE_EXPORTS variable is set.
|
|
if(POLICY CMP0065)
|
|
cmake_policy(SET CMP0065 NEW)
|
|
endif()
|
|
if (POLICY CMP0077)
|
|
cmake_policy(SET CMP0077 NEW)
|
|
endif()
|
|
if(CMAKE_EXECUTABLE_SUFFIX)
|
|
set(CMAKE_EXECUTABLE_SUFFIX_TMP ${CMAKE_EXECUTABLE_SUFFIX})
|
|
endif()
|
|
|
|
project(libjpeg-turbo C)
|
|
set(VERSION 2.1.3)
|
|
set(COPYRIGHT_YEAR "1991-2022")
|
|
string(REPLACE "." ";" VERSION_TRIPLET ${VERSION})
|
|
list(GET VERSION_TRIPLET 0 VERSION_MAJOR)
|
|
list(GET VERSION_TRIPLET 1 VERSION_MINOR)
|
|
list(GET VERSION_TRIPLET 2 VERSION_REVISION)
|
|
function(pad_number NUMBER OUTPUT_LEN)
|
|
string(LENGTH "${${NUMBER}}" INPUT_LEN)
|
|
if(INPUT_LEN LESS OUTPUT_LEN)
|
|
math(EXPR ZEROES "${OUTPUT_LEN} - ${INPUT_LEN} - 1")
|
|
set(NUM ${${NUMBER}})
|
|
foreach(C RANGE ${ZEROES})
|
|
set(NUM "0${NUM}")
|
|
endforeach()
|
|
set(${NUMBER} ${NUM} PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
pad_number(VERSION_MINOR 3)
|
|
pad_number(VERSION_REVISION 3)
|
|
set(LIBJPEG_TURBO_VERSION_NUMBER ${VERSION_MAJOR}${VERSION_MINOR}${VERSION_REVISION})
|
|
|
|
# CMake 3.14 and later sets CMAKE_MACOSX_BUNDLE to TRUE by default when
|
|
# CMAKE_SYSTEM_NAME is iOS, tvOS, or watchOS, which breaks the libjpeg-turbo
|
|
# build. (Specifically, when CMAKE_MACOSX_BUNDLE is TRUE, executables for
|
|
# Apple platforms are built as application bundles, which causes CMake to
|
|
# complain that our install() directives for executables do not specify a
|
|
# BUNDLE DESTINATION. Even if CMake did not complain, building executables as
|
|
# application bundles would break our iOS packages.)
|
|
set(CMAKE_MACOSX_BUNDLE FALSE)
|
|
|
|
string(TIMESTAMP DEFAULT_BUILD "%Y%m%d")
|
|
set(BUILD ${DEFAULT_BUILD} CACHE STRING "Build string (default: ${DEFAULT_BUILD})")
|
|
|
|
# NOTE: On Windows, this does nothing except when using MinGW or Cygwin.
|
|
# CMAKE_BUILD_TYPE has no meaning in Visual Studio, and it always defaults to
|
|
# Debug when using NMake.
|
|
if(NOT CMAKE_BUILD_TYPE)
|
|
set(CMAKE_BUILD_TYPE Release)
|
|
endif()
|
|
message(STATUS "CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}")
|
|
|
|
message(STATUS "VERSION = ${VERSION}, BUILD = ${BUILD}")
|
|
|
|
include(cmakescripts/PackageInfo.cmake)
|
|
|
|
# Detect CPU type and whether we're building 64-bit or 32-bit code
|
|
math(EXPR BITS "${CMAKE_SIZEOF_VOID_P} * 8")
|
|
string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} CMAKE_SYSTEM_PROCESSOR_LC)
|
|
set(COUNT 1)
|
|
foreach(ARCH ${CMAKE_OSX_ARCHITECTURES})
|
|
if(COUNT GREATER 1)
|
|
message(FATAL_ERROR "The libjpeg-turbo build system does not support multiple values in CMAKE_OSX_ARCHITECTURES.")
|
|
endif()
|
|
math(EXPR COUNT "${COUNT}+1")
|
|
endforeach()
|
|
if(CMAKE_SYSTEM_PROCESSOR_LC MATCHES "x86_64" OR
|
|
CMAKE_SYSTEM_PROCESSOR_LC MATCHES "amd64" OR
|
|
CMAKE_SYSTEM_PROCESSOR_LC MATCHES "i[0-9]86" OR
|
|
CMAKE_SYSTEM_PROCESSOR_LC MATCHES "x86" OR
|
|
CMAKE_SYSTEM_PROCESSOR_LC MATCHES "ia32")
|
|
if(BITS EQUAL 64 OR CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
|
|
set(CPU_TYPE x86_64)
|
|
else()
|
|
set(CPU_TYPE i386)
|
|
endif()
|
|
if(NOT CMAKE_SYSTEM_PROCESSOR STREQUAL ${CPU_TYPE})
|
|
set(CMAKE_SYSTEM_PROCESSOR ${CPU_TYPE})
|
|
endif()
|
|
elseif(CMAKE_SYSTEM_PROCESSOR_LC STREQUAL "aarch64" OR
|
|
CMAKE_SYSTEM_PROCESSOR_LC MATCHES "^arm")
|
|
if(BITS EQUAL 64)
|
|
set(CPU_TYPE arm64)
|
|
else()
|
|
set(CPU_TYPE arm)
|
|
endif()
|
|
elseif(CMAKE_SYSTEM_PROCESSOR_LC MATCHES "^ppc" OR
|
|
CMAKE_SYSTEM_PROCESSOR_LC MATCHES "^powerpc")
|
|
set(CPU_TYPE powerpc)
|
|
else()
|
|
set(CPU_TYPE ${CMAKE_SYSTEM_PROCESSOR_LC})
|
|
endif()
|
|
if(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64" OR
|
|
CMAKE_OSX_ARCHITECTURES MATCHES "arm64" OR
|
|
CMAKE_OSX_ARCHITECTURES MATCHES "i386")
|
|
set(CPU_TYPE ${CMAKE_OSX_ARCHITECTURES})
|
|
endif()
|
|
if(CMAKE_OSX_ARCHITECTURES MATCHES "ppc")
|
|
set(CPU_TYPE powerpc)
|
|
endif()
|
|
if(MSVC_IDE AND CMAKE_GENERATOR_PLATFORM MATCHES "arm64")
|
|
set(CPU_TYPE arm64)
|
|
endif()
|
|
|
|
message(STATUS "${BITS}-bit build (${CPU_TYPE})")
|
|
|
|
macro(report_directory var)
|
|
if(CMAKE_INSTALL_${var} STREQUAL CMAKE_INSTALL_FULL_${var})
|
|
message(STATUS "CMAKE_INSTALL_${var} = ${CMAKE_INSTALL_${var}}")
|
|
else()
|
|
message(STATUS "CMAKE_INSTALL_${var} = ${CMAKE_INSTALL_${var}} (${CMAKE_INSTALL_FULL_${var}})")
|
|
endif()
|
|
mark_as_advanced(CLEAR CMAKE_INSTALL_${var})
|
|
endmacro()
|
|
|
|
set(DIRLIST "BINDIR;DATAROOTDIR;DOCDIR;INCLUDEDIR;LIBDIR")
|
|
if(UNIX)
|
|
list(APPEND DIRLIST "MANDIR")
|
|
endif()
|
|
foreach(dir ${DIRLIST})
|
|
report_directory(${dir})
|
|
endforeach()
|
|
|
|
|
|
###############################################################################
|
|
# CONFIGURATION OPTIONS
|
|
###############################################################################
|
|
|
|
macro(boolean_number var)
|
|
if(${var})
|
|
set(${var} 1 ${ARGN})
|
|
else()
|
|
set(${var} 0 ${ARGN})
|
|
endif()
|
|
endmacro()
|
|
|
|
option(ENABLE_SHARED "Build shared libraries" FALSE)
|
|
boolean_number(ENABLE_SHARED)
|
|
option(ENABLE_STATIC "Build static libraries" TRUE)
|
|
boolean_number(ENABLE_STATIC)
|
|
option(REQUIRE_SIMD "Generate a fatal error if SIMD extensions are not available for this platform (default is to fall back to a non-SIMD build)" FALSE)
|
|
boolean_number(REQUIRE_SIMD)
|
|
option(WITH_12BIT "Encode/decode JPEG images with 12-bit samples (implies WITH_ARITH_DEC=0 WITH_ARITH_ENC=0 WITH_JAVA=0 WITH_SIMD=0 WITH_TURBOJPEG=0 )" FALSE)
|
|
boolean_number(WITH_12BIT)
|
|
option(WITH_ARITH_DEC "Include arithmetic decoding support when emulating the libjpeg v6b API/ABI" TRUE)
|
|
boolean_number(WITH_ARITH_DEC)
|
|
option(WITH_ARITH_ENC "Include arithmetic encoding support when emulating the libjpeg v6b API/ABI" TRUE)
|
|
boolean_number(WITH_ARITH_ENC)
|
|
if(CMAKE_C_COMPILER_ABI MATCHES "ELF X32")
|
|
set(WITH_JAVA 0)
|
|
else()
|
|
option(WITH_JAVA "Build Java wrapper for the TurboJPEG API library (implies ENABLE_SHARED=1)" FALSE)
|
|
boolean_number(WITH_JAVA)
|
|
endif()
|
|
option(WITH_JPEG7 "Emulate libjpeg v7 API/ABI (this makes ${CMAKE_PROJECT_NAME} backward-incompatible with libjpeg v6b)" FALSE)
|
|
boolean_number(WITH_JPEG7)
|
|
option(WITH_JPEG8 "Emulate libjpeg v8 API/ABI (this makes ${CMAKE_PROJECT_NAME} backward-incompatible with libjpeg v6b)" FALSE)
|
|
boolean_number(WITH_JPEG8)
|
|
option(WITH_MEM_SRCDST "Include in-memory source/destination manager functions when emulating the libjpeg v6b or v7 API/ABI" TRUE)
|
|
boolean_number(WITH_MEM_SRCDST)
|
|
option(WITH_SIMD "Include SIMD extensions, if available for this platform" FALSE)
|
|
boolean_number(WITH_SIMD)
|
|
option(WITH_TURBOJPEG "Include the TurboJPEG API library and associated test programs" FALSE)
|
|
boolean_number(WITH_TURBOJPEG)
|
|
option(WITH_FUZZ "Build fuzz targets" FALSE)
|
|
|
|
macro(report_option var desc)
|
|
if(${var})
|
|
message(STATUS "${desc} enabled (${var} = ${${var}})")
|
|
else()
|
|
message(STATUS "${desc} disabled (${var} = ${${var}})")
|
|
endif()
|
|
endmacro()
|
|
|
|
if(WITH_JAVA)
|
|
set(ENABLE_SHARED 1)
|
|
endif()
|
|
|
|
# Explicitly setting CMAKE_POSITION_INDEPENDENT_CODE=FALSE disables PIC for all
|
|
# targets, which will cause the shared library builds to fail. Thus, if shared
|
|
# libraries are enabled and CMAKE_POSITION_INDEPENDENT_CODE is explicitly set
|
|
# to FALSE, we need to unset it, thus restoring the default behavior
|
|
# (automatically using PIC for shared library targets.)
|
|
if(DEFINED CMAKE_POSITION_INDEPENDENT_CODE AND
|
|
NOT CMAKE_POSITION_INDEPENDENT_CODE AND ENABLE_SHARED)
|
|
unset(CMAKE_POSITION_INDEPENDENT_CODE CACHE)
|
|
endif()
|
|
|
|
report_option(ENABLE_SHARED "Shared libraries")
|
|
report_option(ENABLE_STATIC "Static libraries")
|
|
|
|
if(ENABLE_SHARED)
|
|
set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR})
|
|
endif()
|
|
|
|
if(WITH_JPEG8 OR WITH_JPEG7)
|
|
set(WITH_ARITH_ENC 1)
|
|
set(WITH_ARITH_DEC 1)
|
|
endif()
|
|
if(WITH_JPEG8)
|
|
set(WITH_MEM_SRCDST 0)
|
|
endif()
|
|
|
|
if(WITH_12BIT)
|
|
set(WITH_ARITH_DEC 0)
|
|
set(WITH_ARITH_ENC 0)
|
|
set(WITH_JAVA 0)
|
|
set(WITH_SIMD 0)
|
|
set(WITH_TURBOJPEG 0)
|
|
set(BITS_IN_JSAMPLE 12)
|
|
else()
|
|
set(BITS_IN_JSAMPLE 8)
|
|
endif()
|
|
report_option(WITH_12BIT "12-bit JPEG support")
|
|
|
|
if(WITH_ARITH_DEC)
|
|
set(D_ARITH_CODING_SUPPORTED 1)
|
|
endif()
|
|
if(NOT WITH_12BIT)
|
|
report_option(WITH_ARITH_DEC "Arithmetic decoding support")
|
|
endif()
|
|
|
|
if(WITH_ARITH_ENC)
|
|
set(C_ARITH_CODING_SUPPORTED 1)
|
|
endif()
|
|
if(NOT WITH_12BIT)
|
|
report_option(WITH_ARITH_ENC "Arithmetic encoding support")
|
|
endif()
|
|
|
|
if(NOT WITH_12BIT)
|
|
report_option(WITH_TURBOJPEG "TurboJPEG API library")
|
|
report_option(WITH_JAVA "TurboJPEG Java wrapper")
|
|
endif()
|
|
|
|
if(WITH_MEM_SRCDST)
|
|
set(MEM_SRCDST_SUPPORTED 1)
|
|
set(MEM_SRCDST_FUNCTIONS "global: jpeg_mem_dest; jpeg_mem_src;")
|
|
endif()
|
|
if(NOT WITH_JPEG8)
|
|
report_option(WITH_MEM_SRCDST "In-memory source/destination managers")
|
|
endif()
|
|
|
|
set(SO_AGE 2)
|
|
if(WITH_MEM_SRCDST)
|
|
set(SO_AGE 3)
|
|
endif()
|
|
|
|
if(WITH_JPEG8)
|
|
set(JPEG_LIB_VERSION 80)
|
|
elseif(WITH_JPEG7)
|
|
set(JPEG_LIB_VERSION 70)
|
|
else()
|
|
set(JPEG_LIB_VERSION 62)
|
|
endif()
|
|
|
|
math(EXPR JPEG_LIB_VERSION_DIV10 "${JPEG_LIB_VERSION} / 10")
|
|
math(EXPR JPEG_LIB_VERSION_MOD10 "${JPEG_LIB_VERSION} % 10")
|
|
if(JPEG_LIB_VERSION STREQUAL "62")
|
|
set(DEFAULT_SO_MAJOR_VERSION ${JPEG_LIB_VERSION})
|
|
else()
|
|
set(DEFAULT_SO_MAJOR_VERSION ${JPEG_LIB_VERSION_DIV10})
|
|
endif()
|
|
if(JPEG_LIB_VERSION STREQUAL "80")
|
|
set(DEFAULT_SO_MINOR_VERSION 2)
|
|
else()
|
|
set(DEFAULT_SO_MINOR_VERSION 0)
|
|
endif()
|
|
|
|
# This causes SO_MAJOR_VERSION/SO_MINOR_VERSION to reset to defaults if
|
|
# WITH_JPEG7 or WITH_JPEG8 has changed.
|
|
if((DEFINED WITH_JPEG7_INT AND NOT WITH_JPEG7 EQUAL WITH_JPEG7_INT) OR
|
|
(DEFINED WITH_JPEG8_INT AND NOT WITH_JPEG8 EQUAL WITH_JPEG8_INT))
|
|
set(FORCE_SO_VERSION "FORCE")
|
|
endif()
|
|
set(WITH_JPEG7_INT ${WITH_JPEG7} CACHE INTERNAL "")
|
|
set(WITH_JPEG8_INT ${WITH_JPEG8} CACHE INTERNAL "")
|
|
|
|
set(SO_MAJOR_VERSION ${DEFAULT_SO_MAJOR_VERSION} CACHE STRING
|
|
"Major version of the libjpeg API shared library (default: ${DEFAULT_SO_MAJOR_VERSION})"
|
|
${FORCE_SO_VERSION})
|
|
set(SO_MINOR_VERSION ${DEFAULT_SO_MINOR_VERSION} CACHE STRING
|
|
"Minor version of the libjpeg API shared library (default: ${DEFAULT_SO_MINOR_VERSION})"
|
|
${FORCE_SO_VERSION})
|
|
|
|
set(JPEG_LIB_VERSION_DECIMAL "${JPEG_LIB_VERSION_DIV10}.${JPEG_LIB_VERSION_MOD10}")
|
|
message(STATUS "Emulating libjpeg API/ABI v${JPEG_LIB_VERSION_DECIMAL} (WITH_JPEG7 = ${WITH_JPEG7}, WITH_JPEG8 = ${WITH_JPEG8})")
|
|
message(STATUS "libjpeg API shared library version = ${SO_MAJOR_VERSION}.${SO_AGE}.${SO_MINOR_VERSION}")
|
|
|
|
# Because the TurboJPEG API library uses versioned symbols and changes the
|
|
# names of functions whenever they are modified in a backward-incompatible
|
|
# manner, it is always backward-ABI-compatible with itself, so the major and
|
|
# minor SO versions don't change. However, we increase the middle number (the
|
|
# SO "age") whenever functions are added to the API.
|
|
set(TURBOJPEG_SO_MAJOR_VERSION 0)
|
|
set(TURBOJPEG_SO_AGE 2)
|
|
set(TURBOJPEG_SO_VERSION 0.${TURBOJPEG_SO_AGE}.0)
|
|
|
|
|
|
###############################################################################
|
|
# COMPILER SETTINGS
|
|
###############################################################################
|
|
|
|
if(MSVC)
|
|
option(WITH_CRT_DLL
|
|
"Link all ${CMAKE_PROJECT_NAME} libraries and executables with the C run-time DLL (msvcr*.dll) instead of the static C run-time library (libcmt*.lib.) The default is to use the C run-time DLL only with the libraries and executables that need it."
|
|
FALSE)
|
|
if(NOT WITH_CRT_DLL)
|
|
# Use the static C library for all build types
|
|
foreach(var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
|
|
CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
|
|
if(${var} MATCHES "/MD")
|
|
string(REGEX REPLACE "/MD" "/MT" ${var} "${${var}}")
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
add_definitions(-D_CRT_NONSTDC_NO_WARNINGS)
|
|
endif()
|
|
|
|
if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
|
|
# Use the maximum optimization level for release builds
|
|
foreach(var CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
|
|
if(${var} MATCHES "-O2")
|
|
string(REGEX REPLACE "-O2" "-O3" ${var} "${${var}}")
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
|
|
if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
|
|
if(CMAKE_C_COMPILER_ID MATCHES "SunPro")
|
|
# Use the maximum optimization level for release builds
|
|
foreach(var CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
|
|
if(${var} MATCHES "-xO3")
|
|
string(REGEX REPLACE "-xO3" "-xO5" ${var} "${${var}}")
|
|
endif()
|
|
if(${var} MATCHES "-xO2")
|
|
string(REGEX REPLACE "-xO2" "-xO5" ${var} "${${var}}")
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
endif()
|
|
|
|
string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UC)
|
|
|
|
set(EFFECTIVE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
|
|
message(STATUS "Compiler flags = ${EFFECTIVE_C_FLAGS}")
|
|
|
|
set(EFFECTIVE_LD_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
|
|
message(STATUS "Linker flags = ${EFFECTIVE_LD_FLAGS}")
|
|
|
|
include(CheckCSourceCompiles)
|
|
include(CheckIncludeFiles)
|
|
include(CheckTypeSize)
|
|
|
|
check_type_size("size_t" SIZE_T)
|
|
check_type_size("unsigned long" UNSIGNED_LONG)
|
|
|
|
if(SIZE_T EQUAL UNSIGNED_LONG)
|
|
check_c_source_compiles("int main(int argc, char **argv) { unsigned long a = argc; return __builtin_ctzl(a); }"
|
|
HAVE_BUILTIN_CTZL)
|
|
endif()
|
|
if(MSVC)
|
|
check_include_files("intrin.h" HAVE_INTRIN_H)
|
|
endif()
|
|
|
|
if(UNIX)
|
|
if(CMAKE_CROSSCOMPILING)
|
|
set(RIGHT_SHIFT_IS_UNSIGNED 0)
|
|
else()
|
|
include(CheckCSourceRuns)
|
|
check_c_source_runs("
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
int is_shifting_signed (long arg) {
|
|
long res = arg >> 4;
|
|
if (res == -0x7F7E80CL)
|
|
return 1; /* right shift is signed */
|
|
/* see if unsigned-shift hack will fix it. */
|
|
/* we can't just test exact value since it depends on width of long... */
|
|
res |= (~0L) << (32-4);
|
|
if (res == -0x7F7E80CL)
|
|
return 0; /* right shift is unsigned */
|
|
printf(\"Right shift isn't acting as I expect it to.\\\\n\");
|
|
printf(\"I fear the JPEG software will not work at all.\\\\n\\\\n\");
|
|
return 0; /* try it with unsigned anyway */
|
|
}
|
|
int main (void) {
|
|
exit(is_shifting_signed(-0x7F7E80B1L));
|
|
}" RIGHT_SHIFT_IS_UNSIGNED)
|
|
endif()
|
|
endif()
|
|
|
|
if(MSVC)
|
|
set(INLINE_OPTIONS "__inline;inline")
|
|
else()
|
|
set(INLINE_OPTIONS "__inline__;inline")
|
|
endif()
|
|
option(FORCE_INLINE "Force function inlining" TRUE)
|
|
boolean_number(FORCE_INLINE)
|
|
if(FORCE_INLINE)
|
|
if(MSVC)
|
|
list(INSERT INLINE_OPTIONS 0 "__forceinline")
|
|
else()
|
|
list(INSERT INLINE_OPTIONS 0 "inline __attribute__((always_inline))")
|
|
list(INSERT INLINE_OPTIONS 0 "__inline__ __attribute__((always_inline))")
|
|
endif()
|
|
endif()
|
|
foreach(inline ${INLINE_OPTIONS})
|
|
check_c_source_compiles("${inline} static int foo(void) { return 0; } int main(void) { return foo(); }"
|
|
INLINE_WORKS)
|
|
if(INLINE_WORKS)
|
|
set(INLINE ${inline})
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
if(NOT INLINE_WORKS)
|
|
message(FATAL_ERROR "Could not determine how to inline functions.")
|
|
endif()
|
|
message(STATUS "INLINE = ${INLINE} (FORCE_INLINE = ${FORCE_INLINE})")
|
|
|
|
if(WITH_TURBOJPEG)
|
|
if(MSVC)
|
|
set(THREAD_LOCAL "__declspec(thread)")
|
|
else()
|
|
set(THREAD_LOCAL "__thread")
|
|
endif()
|
|
check_c_source_compiles("${THREAD_LOCAL} int i; int main(void) { i = 0; return i; }" HAVE_THREAD_LOCAL)
|
|
if(HAVE_THREAD_LOCAL)
|
|
message(STATUS "THREAD_LOCAL = ${THREAD_LOCAL}")
|
|
else()
|
|
message(WARNING "Thread-local storage is not available. The TurboJPEG API library's global error handler will not be thread-safe.")
|
|
unset(THREAD_LOCAL)
|
|
endif()
|
|
endif()
|
|
|
|
if(UNIX AND NOT APPLE)
|
|
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map "VERS_1 { global: *; };")
|
|
set(CMAKE_REQUIRED_FLAGS
|
|
"-Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
|
|
check_c_source_compiles("int main(void) { return 0; }" HAVE_VERSION_SCRIPT)
|
|
set(CMAKE_REQUIRED_FLAGS)
|
|
file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map)
|
|
if(HAVE_VERSION_SCRIPT)
|
|
message(STATUS "Linker supports GNU-style version scripts")
|
|
set(MAPFLAG "-Wl,--version-script,")
|
|
set(TJMAPFLAG "-Wl,--version-script,")
|
|
else()
|
|
message(STATUS "Linker does not support GNU-style version scripts")
|
|
if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
|
|
# The Solaris linker doesn't like our version script for the libjpeg API
|
|
# library, but the version script for the TurboJPEG API library should
|
|
# still work.
|
|
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map
|
|
"VERS_1 { global: foo; local: *; }; VERS_2 { global: foo2; } VERS_1;")
|
|
set(CMAKE_REQUIRED_FLAGS "-Wl,-M,${CMAKE_CURRENT_BINARY_DIR}/conftest.map -shared")
|
|
check_c_source_compiles("int foo() { return 0; } int foo2() { return 2; }"
|
|
HAVE_MAPFILE)
|
|
set(CMAKE_REQUIRED_FLAGS)
|
|
file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/conftest.map)
|
|
if(HAVE_MAPFILE)
|
|
message(STATUS "Linker supports mapfiles")
|
|
set(TJMAPFLAG "-Wl,-M,")
|
|
else()
|
|
message(STATUS "Linker does not support mapfiles")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# Generate files
|
|
if(WIN32)
|
|
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/win/jconfig.h.in jconfig.h)
|
|
else()
|
|
configure_file(jconfig.h.in jconfig.h)
|
|
endif()
|
|
configure_file(jconfigint.h.in jconfigint.h)
|
|
configure_file(jversion.h.in jversion.h)
|
|
if(UNIX)
|
|
configure_file(libjpeg.map.in libjpeg.map)
|
|
endif()
|
|
|
|
# Include directories and compiler definitions
|
|
include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
|
|
|
|
|
|
###############################################################################
|
|
# TARGETS
|
|
###############################################################################
|
|
|
|
if(CMAKE_EXECUTABLE_SUFFIX_TMP)
|
|
set(CMAKE_EXECUTABLE_SUFFIX ${CMAKE_EXECUTABLE_SUFFIX_TMP})
|
|
endif()
|
|
message(STATUS "CMAKE_EXECUTABLE_SUFFIX = ${CMAKE_EXECUTABLE_SUFFIX}")
|
|
|
|
set(JPEG_SOURCES jcapimin.c jcapistd.c jccoefct.c jccolor.c jcdctmgr.c jchuff.c
|
|
jcicc.c jcinit.c jcmainct.c jcmarker.c jcmaster.c jcomapi.c jcparam.c
|
|
jcphuff.c jcprepct.c jcsample.c jctrans.c jdapimin.c jdapistd.c jdatadst.c
|
|
jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c jdicc.c jdinput.c
|
|
jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c jdpostct.c jdsample.c
|
|
jdtrans.c jerror.c jfdctflt.c jfdctfst.c jfdctint.c jidctflt.c jidctfst.c
|
|
jidctint.c jidctred.c jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c)
|
|
|
|
if(WITH_ARITH_ENC OR WITH_ARITH_DEC)
|
|
set(JPEG_SOURCES ${JPEG_SOURCES} jaricom.c)
|
|
endif()
|
|
|
|
if(WITH_ARITH_ENC)
|
|
set(JPEG_SOURCES ${JPEG_SOURCES} jcarith.c)
|
|
endif()
|
|
|
|
if(WITH_ARITH_DEC)
|
|
set(JPEG_SOURCES ${JPEG_SOURCES} jdarith.c)
|
|
endif()
|
|
|
|
if(WITH_SIMD)
|
|
add_subdirectory(simd)
|
|
if(NEON_INTRINSICS)
|
|
add_definitions(-DNEON_INTRINSICS)
|
|
endif()
|
|
elseif(NOT WITH_12BIT)
|
|
message(STATUS "SIMD extensions: None (WITH_SIMD = ${WITH_SIMD})")
|
|
endif()
|
|
if(WITH_SIMD)
|
|
message(STATUS "SIMD extensions: ${CPU_TYPE} (WITH_SIMD = ${WITH_SIMD})")
|
|
if(MSVC_IDE OR XCODE)
|
|
set_source_files_properties(${SIMD_OBJS} PROPERTIES GENERATED 1)
|
|
endif()
|
|
else()
|
|
add_library(simd OBJECT jsimd_none.c)
|
|
if(NOT WIN32 AND (CMAKE_POSITION_INDEPENDENT_CODE OR ENABLE_SHARED))
|
|
set_target_properties(simd PROPERTIES POSITION_INDEPENDENT_CODE 1)
|
|
endif()
|
|
endif()
|
|
|
|
if(WITH_JAVA)
|
|
add_subdirectory(java)
|
|
endif()
|
|
|
|
if(ENABLE_SHARED)
|
|
add_subdirectory(sharedlib)
|
|
endif()
|
|
|
|
if(ENABLE_STATIC)
|
|
add_library(jpeg-static STATIC ${JPEG_SOURCES} $<TARGET_OBJECTS:simd>
|
|
${SIMD_OBJS})
|
|
if(NOT MSVC)
|
|
set_target_properties(jpeg-static PROPERTIES OUTPUT_NAME jpeg)
|
|
endif()
|
|
endif()
|
|
|
|
if(WITH_TURBOJPEG)
|
|
if(ENABLE_SHARED)
|
|
set(TURBOJPEG_SOURCES ${JPEG_SOURCES} $<TARGET_OBJECTS:simd> ${SIMD_OBJS}
|
|
turbojpeg.c transupp.c jdatadst-tj.c jdatasrc-tj.c rdbmp.c rdppm.c
|
|
wrbmp.c wrppm.c)
|
|
set(TJMAPFILE ${CMAKE_CURRENT_SOURCE_DIR}/turbojpeg-mapfile)
|
|
if(WITH_JAVA)
|
|
set(TURBOJPEG_SOURCES ${TURBOJPEG_SOURCES} turbojpeg-jni.c)
|
|
include_directories(${JAVA_INCLUDE_PATH} ${JAVA_INCLUDE_PATH2})
|
|
set(TJMAPFILE ${CMAKE_CURRENT_SOURCE_DIR}/turbojpeg-mapfile.jni)
|
|
endif()
|
|
if(MSVC)
|
|
configure_file(${CMAKE_SOURCE_DIR}/win/turbojpeg.rc.in
|
|
${CMAKE_BINARY_DIR}/win/turbojpeg.rc)
|
|
set(TURBOJPEG_SOURCES ${TURBOJPEG_SOURCES}
|
|
${CMAKE_BINARY_DIR}/win/turbojpeg.rc)
|
|
endif()
|
|
add_library(turbojpeg SHARED ${TURBOJPEG_SOURCES})
|
|
set_property(TARGET turbojpeg PROPERTY COMPILE_FLAGS
|
|
"-DBMP_SUPPORTED -DPPM_SUPPORTED")
|
|
if(WIN32)
|
|
set_target_properties(turbojpeg PROPERTIES DEFINE_SYMBOL DLLDEFINE)
|
|
endif()
|
|
if(MINGW)
|
|
set_target_properties(turbojpeg PROPERTIES LINK_FLAGS -Wl,--kill-at)
|
|
endif()
|
|
if(APPLE AND (NOT CMAKE_OSX_DEPLOYMENT_TARGET OR
|
|
CMAKE_OSX_DEPLOYMENT_TARGET VERSION_GREATER 10.4))
|
|
if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
|
|
set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,")
|
|
endif()
|
|
set_target_properties(turbojpeg PROPERTIES MACOSX_RPATH 1)
|
|
endif()
|
|
set_target_properties(turbojpeg PROPERTIES
|
|
SOVERSION ${TURBOJPEG_SO_MAJOR_VERSION} VERSION ${TURBOJPEG_SO_VERSION})
|
|
if(TJMAPFLAG)
|
|
set_target_properties(turbojpeg PROPERTIES
|
|
LINK_FLAGS "${TJMAPFLAG}${TJMAPFILE}")
|
|
endif()
|
|
endif()
|
|
|
|
if(ENABLE_STATIC)
|
|
add_library(turbojpeg-static STATIC ${JPEG_SOURCES} $<TARGET_OBJECTS:simd>
|
|
${SIMD_OBJS} turbojpeg.c transupp.c jdatadst-tj.c jdatasrc-tj.c rdbmp.c
|
|
rdppm.c wrbmp.c wrppm.c)
|
|
set_property(TARGET turbojpeg-static PROPERTY COMPILE_FLAGS
|
|
"-DBMP_SUPPORTED -DPPM_SUPPORTED")
|
|
if(NOT MSVC)
|
|
set_target_properties(turbojpeg-static PROPERTIES OUTPUT_NAME turbojpeg)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(WIN32)
|
|
set(USE_SETMODE "-DUSE_SETMODE")
|
|
endif()
|
|
if(WITH_12BIT)
|
|
set(COMPILE_FLAGS "-DGIF_SUPPORTED -DPPM_SUPPORTED ${USE_SETMODE}")
|
|
else()
|
|
set(COMPILE_FLAGS "-DBMP_SUPPORTED -DGIF_SUPPORTED -DPPM_SUPPORTED -DTARGA_SUPPORTED ${USE_SETMODE}")
|
|
set(CJPEG_BMP_SOURCES rdbmp.c rdtarga.c)
|
|
set(DJPEG_BMP_SOURCES wrbmp.c wrtarga.c)
|
|
endif() |