Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case.
This also changes all the key words to lower case. The primary reason for changing key words is that all documentation for CMakeLists.txt now shows the key words as lower case. Even the printed “Mastering CMake v5” uses lower case.
Thanks to Hans Johnson
#
#----------------------------------------------------------------------
-SET(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE 1000000)
-SET(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS 50)
-SET(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS 2000)
+set(CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE 1000000)
+set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS 50)
+set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS 2000)
-SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
+set(CTEST_CUSTOM_COVERAGE_EXCLUDE
${CTEST_CUSTOM_COVERAGE_EXCLUDE}
# Exclude files from the Testing directories
".*/thirdparty/.*"
)
-SET(CTEST_CUSTOM_WARNING_EXCEPTION
+set(CTEST_CUSTOM_WARNING_EXCEPTION
${CTEST_CUSTOM_WARNING_EXCEPTION}
# Suppress warning caused by intentional messages about deprecation
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
#
-FIND_PROGRAM(CPPCHECK_EXECUTABLE
+find_program(CPPCHECK_EXECUTABLE
cppcheck
)
-MARK_AS_ADVANCED(
+mark_as_advanced(
CPPCHECK_EXECUTABLE
)
# Look for the header file.
-FIND_PATH(FCGI_INCLUDE_DIR NAMES fastcgi.h)
+find_path(FCGI_INCLUDE_DIR NAMES fastcgi.h)
# Look for the library.
-FIND_LIBRARY(FCGI_LIBRARY NAMES fcgi)
+find_library(FCGI_LIBRARY NAMES fcgi)
# Handle the QUIETLY and REQUIRED arguments and set FCGI_FOUND to TRUE if all listed variables are TRUE.
-INCLUDE(FindPackageHandleStandardArgs)
+include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(FCGI DEFAULT_MSG FCGI_LIBRARY FCGI_INCLUDE_DIR)
# Copy the results to the output variables.
-IF(FCGI_FOUND)
- SET(FCGI_LIBRARIES ${FCGI_LIBRARY})
- SET(FCGI_INCLUDE_DIRS ${FCGI_INCLUDE_DIR})
-ELSE(FCGI_FOUND)
- SET(FCGI_LIBRARIES)
- SET(FCGI_INCLUDE_DIRS)
-ENDIF(FCGI_FOUND)
+if(FCGI_FOUND)
+ set(FCGI_LIBRARIES ${FCGI_LIBRARY})
+ set(FCGI_INCLUDE_DIRS ${FCGI_INCLUDE_DIR})
+else(FCGI_FOUND)
+ set(FCGI_LIBRARIES)
+ set(FCGI_INCLUDE_DIRS)
+endif(FCGI_FOUND)
-MARK_AS_ADVANCED(FCGI_INCLUDE_DIR FCGI_LIBRARY)
+mark_as_advanced(FCGI_INCLUDE_DIR FCGI_LIBRARY)
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
#
-FIND_PROGRAM(KDU_EXPAND_EXECUTABLE
+find_program(KDU_EXPAND_EXECUTABLE
kdu_expand
)
-MARK_AS_ADVANCED(
+mark_as_advanced(
KDU_EXPAND_EXECUTABLE
)
#=============================================================================
#=============================================================================
-FIND_PATH(LCMS_INCLUDE_DIR lcms.h PATHS /usr/include /usr/local/include /opt/include /opt/local/include)
+find_path(LCMS_INCLUDE_DIR lcms.h PATHS /usr/include /usr/local/include /opt/include /opt/local/include)
-SET(LCMS_NAMES ${LCMS_NAMES} lcms liblcms liblcms_static)
+set(LCMS_NAMES ${LCMS_NAMES} lcms liblcms liblcms_static)
-FIND_LIBRARY(LCMS_LIBRARY NAMES ${LCMS_NAMES} )
+find_library(LCMS_LIBRARY NAMES ${LCMS_NAMES} )
-MARK_AS_ADVANCED(LCMS_INCLUDE_DIR LCMS_LIBRARY)
+mark_as_advanced(LCMS_INCLUDE_DIR LCMS_LIBRARY)
# handle the QUIETLY and REQUIRED arguments and set LCMS_FOUND to TRUE if
# all listed variables are TRUE
-INCLUDE(FindPackageHandleStandardArgs)
+include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(LCMS DEFAULT_MSG LCMS_LIBRARY LCMS_INCLUDE_DIR)
-IF(LCMS_FOUND)
- SET( LCMS_INCLUDE_DIRS ${LCMS_INCLUDE_DIR})
- SET( LCMS_LIBRARIES ${LCMS_LIBRARY} )
-ENDIF(LCMS_FOUND)
+if(LCMS_FOUND)
+ set( LCMS_INCLUDE_DIRS ${LCMS_INCLUDE_DIR})
+ set( LCMS_LIBRARIES ${LCMS_LIBRARY} )
+endif(LCMS_FOUND)
#=============================================================================
#=============================================================================
-FIND_PATH(LCMS2_INCLUDE_DIR lcms2.h PATHS /usr/include /usr/local/include /opt/include /opt/local/include)
+find_path(LCMS2_INCLUDE_DIR lcms2.h PATHS /usr/include /usr/local/include /opt/include /opt/local/include)
-SET(LCMS2_NAMES ${LCMS2_NAMES} lcms2 liblcms2 liblcms2_static)
+set(LCMS2_NAMES ${LCMS2_NAMES} lcms2 liblcms2 liblcms2_static)
-FIND_LIBRARY(LCMS2_LIBRARY NAMES ${LCMS2_NAMES} )
+find_library(LCMS2_LIBRARY NAMES ${LCMS2_NAMES} )
-MARK_AS_ADVANCED(LCMS2_INCLUDE_DIR LCMS2_LIBRARY)
+mark_as_advanced(LCMS2_INCLUDE_DIR LCMS2_LIBRARY)
# handle the QUIETLY and REQUIRED arguments and set LCMS2_FOUND to TRUE if
# all listed variables are TRUE
-INCLUDE(FindPackageHandleStandardArgs)
+include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(LCMS2 DEFAULT_MSG LCMS2_LIBRARY LCMS2_INCLUDE_DIR)
-IF(LCMS2_FOUND)
- SET( LCMS2_INCLUDE_DIRS ${LCMS2_INCLUDE_DIR})
- SET( LCMS2_LIBRARIES ${LCMS2_LIBRARY} )
-ENDIF(LCMS2_FOUND)
+if(LCMS2_FOUND)
+ set( LCMS2_INCLUDE_DIRS ${LCMS2_INCLUDE_DIR})
+ set( LCMS2_LIBRARIES ${LCMS2_LIBRARY} )
+endif(LCMS2_FOUND)
# Make this explicit here, rather than accepting the CPack default value,
# so we can refer to it:
- SET(CPACK_PACKAGE_NAME "${OPENJPEG_LIBRARY_NAME}")
+ set(CPACK_PACKAGE_NAME "${OPENJPEG_LIBRARY_NAME}")
- IF(NOT DEFINED CPACK_SYSTEM_NAME)
+ if(NOT DEFINED CPACK_SYSTEM_NAME)
# make sure package is not Cygwin-unknown, for Cygwin just
# cygwin is good for the system name
- IF("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
- SET(CPACK_SYSTEM_NAME Cygwin)
- ELSE("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
- SET(CPACK_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR})
- ENDIF("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
- ENDIF(NOT DEFINED CPACK_SYSTEM_NAME)
- IF(${CPACK_SYSTEM_NAME} MATCHES Windows)
- IF(CMAKE_CL_64)
- SET(CPACK_SYSTEM_NAME win64-x64)
- ELSE(CMAKE_CL_64)
- SET(CPACK_SYSTEM_NAME win32-x86)
- ENDIF(CMAKE_CL_64)
- ENDIF(${CPACK_SYSTEM_NAME} MATCHES Windows)
+ if("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+ set(CPACK_SYSTEM_NAME Cygwin)
+ else("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+ set(CPACK_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR})
+ endif("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+ endif(NOT DEFINED CPACK_SYSTEM_NAME)
+ if(${CPACK_SYSTEM_NAME} MATCHES Windows)
+ if(CMAKE_CL_64)
+ set(CPACK_SYSTEM_NAME win64-x64)
+ else(CMAKE_CL_64)
+ set(CPACK_SYSTEM_NAME win32-x86)
+ endif(CMAKE_CL_64)
+ endif(${CPACK_SYSTEM_NAME} MATCHES Windows)
- IF(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
+ if(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
# if the CPACK_PACKAGE_FILE_NAME is not defined by the cache
# default to source package - system, on cygwin system is not
# needed
- IF(CYGWIN)
- SET(CPACK_PACKAGE_FILE_NAME "${CPACK_SOURCE_PACKAGE_FILE_NAME}")
- ELSE(CYGWIN)
- SET(CPACK_PACKAGE_FILE_NAME
+ if(CYGWIN)
+ set(CPACK_PACKAGE_FILE_NAME "${CPACK_SOURCE_PACKAGE_FILE_NAME}")
+ else(CYGWIN)
+ set(CPACK_PACKAGE_FILE_NAME
"${CPACK_SOURCE_PACKAGE_FILE_NAME}-${CPACK_SYSTEM_NAME}")
- ENDIF(CYGWIN)
- ENDIF(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
+ endif(CYGWIN)
+ endif(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
set(CPACK_BUNDLE_NAME "OpenJPEG ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
configure_file(${CMAKE_ROOT}/Templates/AppleInfo.plist
${CMAKE_CURRENT_BINARY_DIR}/opj.plist)
- SET(CPACK_BUNDLE_PLIST
+ set(CPACK_BUNDLE_PLIST
${CMAKE_CURRENT_BINARY_DIR}/opj.plist)
#include(BundleUtilities)
# module to load OPENJPEG's settings for an external project.
@OPENJPEG_CONFIG_INSTALL_ONLY@
# The OPENJPEG version number.
-SET(OPENJPEG_MAJOR_VERSION "@OPENJPEG_VERSION_MAJOR@")
-SET(OPENJPEG_MINOR_VERSION "@OPENJPEG_VERSION_MINOR@")
-SET(OPENJPEG_BUILD_VERSION "@OPENJPEG_VERSION_BUILD@")
+set(OPENJPEG_MAJOR_VERSION "@OPENJPEG_VERSION_MAJOR@")
+set(OPENJPEG_MINOR_VERSION "@OPENJPEG_VERSION_MINOR@")
+set(OPENJPEG_BUILD_VERSION "@OPENJPEG_VERSION_BUILD@")
# The libraries.
-SET(OPENJPEG_LIBRARIES "@OPENJPEG_LIBRARY_NAME@")
+set(OPENJPEG_LIBRARIES "@OPENJPEG_LIBRARY_NAME@")
# The CMake macros dir.
-SET(OPENJPEG_CMAKE_DIR "@OPENJPEG_INSTALL_PACKAGE_DIR@")
+set(OPENJPEG_CMAKE_DIR "@OPENJPEG_INSTALL_PACKAGE_DIR@")
# The configuration options.
-SET(OPENJPEG_BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@")
+set(OPENJPEG_BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@")
# The "use" file.
-SET(OPENJPEG_USE_FILE "@OPENJPEG_USE_FILE_CONFIG@")
+set(OPENJPEG_USE_FILE "@OPENJPEG_USE_FILE_CONFIG@")
get_filename_component(SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
if(EXISTS ${SELF_DIR}/OpenJPEGTargets.cmake)
else(EXISTS ${SELF_DIR}/OpenJPEGTargets.cmake)
if(EXISTS ${SELF_DIR}/OpenJPEGExports.cmake)
# This is a build tree
- SET( OPENJPEG_INCLUDE_DIRS @OPENJPEG_INCLUDE_PATH@)
+ set( OPENJPEG_INCLUDE_DIRS @OPENJPEG_INCLUDE_PATH@)
include(${SELF_DIR}/OpenJPEGExports.cmake)
set(OPENJPEG_USE_FILE ${SELF_DIR}/UseOPENJPEG.cmake)
# Backward compatible part:
-SET(OPENJPEG_FOUND TRUE)
+set(OPENJPEG_FOUND TRUE)
# by Julien Malik
#
-MACRO(OPJ_TEST_LARGE_FILES VARIABLE)
- IF("${VARIABLE}" MATCHES "^${VARIABLE}$")
+macro(OPJ_TEST_LARGE_FILES VARIABLE)
+ if("${VARIABLE}" MATCHES "^${VARIABLE}$")
# On most platforms it is probably overkill to first test the flags for 64-bit off_t,
# and then separately fseeko. However, in the future we might have 128-bit filesystems
# (ZFS), so it might be dangerous to indiscriminately set e.g. _FILE_OFFSET_BITS=64.
- MESSAGE(STATUS "Checking for 64-bit off_t")
+ message(STATUS "Checking for 64-bit off_t")
# First check without any special flags
- TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+ try_compile(FILE64_OK "${PROJECT_BINARY_DIR}"
"${PROJECT_SOURCE_DIR}/CMake/TestFileOffsetBits.c")
if(FILE64_OK)
- MESSAGE(STATUS "Checking for 64-bit off_t - present")
+ message(STATUS "Checking for 64-bit off_t - present")
endif(FILE64_OK)
if(NOT FILE64_OK)
# Test with _FILE_OFFSET_BITS=64
- TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+ try_compile(FILE64_OK "${PROJECT_BINARY_DIR}"
"${PROJECT_SOURCE_DIR}/CMake/TestFileOffsetBits.c"
COMPILE_DEFINITIONS "-D_FILE_OFFSET_BITS=64" )
if(FILE64_OK)
- MESSAGE(STATUS "Checking for 64-bit off_t - present with _FILE_OFFSET_BITS=64")
+ message(STATUS "Checking for 64-bit off_t - present with _FILE_OFFSET_BITS=64")
set(_FILE_OFFSET_BITS 64)
endif(FILE64_OK)
endif(NOT FILE64_OK)
if(NOT FILE64_OK)
# Test with _LARGE_FILES
- TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+ try_compile(FILE64_OK "${PROJECT_BINARY_DIR}"
"${PROJECT_SOURCE_DIR}/CMake/TestFileOffsetBits.c"
COMPILE_DEFINITIONS "-D_LARGE_FILES" )
if(FILE64_OK)
- MESSAGE(STATUS "Checking for 64-bit off_t - present with _LARGE_FILES")
+ message(STATUS "Checking for 64-bit off_t - present with _LARGE_FILES")
set(_LARGE_FILES 1)
endif(FILE64_OK)
endif(NOT FILE64_OK)
if(NOT FILE64_OK)
# Test with _LARGEFILE_SOURCE
- TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+ try_compile(FILE64_OK "${PROJECT_BINARY_DIR}"
"${PROJECT_SOURCE_DIR}/CMake/TestFileOffsetBits.c"
COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
if(FILE64_OK)
- MESSAGE(STATUS "Checking for 64-bit off_t - present with _LARGEFILE_SOURCE")
+ message(STATUS "Checking for 64-bit off_t - present with _LARGEFILE_SOURCE")
set(_LARGEFILE_SOURCE 1)
endif(FILE64_OK)
endif(NOT FILE64_OK)
#if(NOT FILE64_OK)
# # now check for Windows stuff
- # TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+ # try_compile(FILE64_OK "${PROJECT_BINARY_DIR}"
# "${PROJECT_SOURCE_DIR}/CMake/TestWindowsFSeek.c")
# if(FILE64_OK)
- # MESSAGE(STATUS "Checking for 64-bit off_t - present with _fseeki64")
+ # message(STATUS "Checking for 64-bit off_t - present with _fseeki64")
# set(HAVE__FSEEKI64 1)
# endif(FILE64_OK)
#endif(NOT FILE64_OK)
if(NOT FILE64_OK)
- MESSAGE(STATUS "Checking for 64-bit off_t - not present")
+ message(STATUS "Checking for 64-bit off_t - not present")
endif(NOT FILE64_OK)
- SET(_FILE_OFFSET_BITS ${_FILE_OFFSET_BITS} CACHE INTERNAL "Result of test for needed _FILE_OFFSET_BITS=64")
- SET(_LARGE_FILES ${_LARGE_FILES} CACHE INTERNAL "Result of test for needed _LARGE_FILES")
- SET(_LARGEFILE_SOURCE ${_LARGEFILE_SOURCE} CACHE INTERNAL "Result of test for needed _LARGEFILE_SOURCE")
+ set(_FILE_OFFSET_BITS ${_FILE_OFFSET_BITS} CACHE INTERNAL "Result of test for needed _FILE_OFFSET_BITS=64")
+ set(_LARGE_FILES ${_LARGE_FILES} CACHE INTERNAL "Result of test for needed _LARGE_FILES")
+ set(_LARGEFILE_SOURCE ${_LARGEFILE_SOURCE} CACHE INTERNAL "Result of test for needed _LARGEFILE_SOURCE")
# Set the flags we might have determined to be required above
- CONFIGURE_FILE("${PROJECT_SOURCE_DIR}/CMake/TestLargeFiles.c.cmake.in"
+ configure_file("${PROJECT_SOURCE_DIR}/CMake/TestLargeFiles.c.cmake.in"
"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
- MESSAGE(STATUS "Checking for fseeko/ftello")
+ message(STATUS "Checking for fseeko/ftello")
# Test if ftello/fseeko are available
- TRY_COMPILE(FSEEKO_COMPILE_OK
+ try_compile(FSEEKO_COMPILE_OK
"${PROJECT_BINARY_DIR}"
"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
- IF(FSEEKO_COMPILE_OK)
- MESSAGE(STATUS "Checking for fseeko/ftello - present")
- ENDIF(FSEEKO_COMPILE_OK)
+ if(FSEEKO_COMPILE_OK)
+ message(STATUS "Checking for fseeko/ftello - present")
+ endif(FSEEKO_COMPILE_OK)
- IF(NOT FSEEKO_COMPILE_OK)
+ if(NOT FSEEKO_COMPILE_OK)
# glibc 2.2 needs _LARGEFILE_SOURCE for fseeko (but not for 64-bit off_t...)
- TRY_COMPILE(FSEEKO_COMPILE_OK
+ try_compile(FSEEKO_COMPILE_OK
"${PROJECT_BINARY_DIR}"
"${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c"
COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
- IF(FSEEKO_COMPILE_OK)
- MESSAGE(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
- SET(_LARGEFILE_SOURCE ${_LARGEFILE_SOURCE} CACHE INTERNAL "Result of test for needed _LARGEFILE_SOURCE")
- ENDIF(FSEEKO_COMPILE_OK)
- ENDIF(NOT FSEEKO_COMPILE_OK)
+ if(FSEEKO_COMPILE_OK)
+ message(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
+ set(_LARGEFILE_SOURCE ${_LARGEFILE_SOURCE} CACHE INTERNAL "Result of test for needed _LARGEFILE_SOURCE")
+ endif(FSEEKO_COMPILE_OK)
+ endif(NOT FSEEKO_COMPILE_OK)
if(FSEEKO_COMPILE_OK)
- SET(HAVE_FSEEKO ON CACHE INTERNAL "Result of test for fseeko/ftello")
+ set(HAVE_FSEEKO ON CACHE INTERNAL "Result of test for fseeko/ftello")
else(FSEEKO_COMPILE_OK)
- MESSAGE(STATUS "Checking for fseeko/ftello - not found")
- SET(HAVE_FSEEKO OFF CACHE INTERNAL "Result of test for fseeko/ftello")
+ message(STATUS "Checking for fseeko/ftello - not found")
+ set(HAVE_FSEEKO OFF CACHE INTERNAL "Result of test for fseeko/ftello")
endif(FSEEKO_COMPILE_OK)
if(FILE64_OK AND FSEEKO_COMPILE_OK)
- MESSAGE(STATUS "Large File support - found")
- SET(${VARIABLE} ON CACHE INTERNAL "Result of test for large file support")
+ message(STATUS "Large File support - found")
+ set(${VARIABLE} ON CACHE INTERNAL "Result of test for large file support")
else(FILE64_OK AND FSEEKO_COMPILE_OK)
- MESSAGE(STATUS "Large File support - not found")
- SET(${VARIABLE} OFF CACHE INTERNAL "Result of test for large file support")
+ message(STATUS "Large File support - not found")
+ set(${VARIABLE} OFF CACHE INTERNAL "Result of test for large file support")
endif(FILE64_OK AND FSEEKO_COMPILE_OK)
- ENDIF("${VARIABLE}" MATCHES "^${VARIABLE}$")
-ENDMACRO(OPJ_TEST_LARGE_FILES VARIABLE)
+ endif("${VARIABLE}" MATCHES "^${VARIABLE}$")
+endmacro(OPJ_TEST_LARGE_FILES VARIABLE)
# you will eventually like to prefix the library to avoid linking confusion
# For this purpose you can define a CMake var: OPENJPEG_NAMESPACE to whatever you like
# e.g.:
-# SET(OPENJPEG_NAMESPACE "GDCMOPENJPEG")
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+# set(OPENJPEG_NAMESPACE "GDCMOPENJPEG")
+cmake_minimum_required(VERSION 2.6)
-IF(COMMAND CMAKE_POLICY)
- CMAKE_POLICY(SET CMP0003 NEW)
-ENDIF(COMMAND CMAKE_POLICY)
+if(COMMAND CMAKE_POLICY)
+ cmake_policy(SET CMP0003 NEW)
+endif(COMMAND CMAKE_POLICY)
-IF(NOT OPENJPEG_NAMESPACE)
- SET(OPENJPEG_NAMESPACE "OPENJPEG")
- SET(OPENJPEG_STANDALONE 1)
-ENDIF(NOT OPENJPEG_NAMESPACE)
+if(NOT OPENJPEG_NAMESPACE)
+ set(OPENJPEG_NAMESPACE "OPENJPEG")
+ set(OPENJPEG_STANDALONE 1)
+endif(NOT OPENJPEG_NAMESPACE)
# In all cases:
-STRING(TOLOWER ${OPENJPEG_NAMESPACE} OPENJPEG_LIBRARY_NAME)
+string(TOLOWER ${OPENJPEG_NAMESPACE} OPENJPEG_LIBRARY_NAME)
-PROJECT(${OPENJPEG_NAMESPACE} C)
+project(${OPENJPEG_NAMESPACE} C)
# Do full dependency headers.
-INCLUDE_REGULAR_EXPRESSION("^.*$")
+include_regular_expression("^.*$")
#-----------------------------------------------------------------------------
# OPENJPEG version number, useful for packaging and doxygen doc:
-SET(OPENJPEG_VERSION_MAJOR 1)
-SET(OPENJPEG_VERSION_MINOR 99)
-SET(OPENJPEG_VERSION_BUILD 0)
-SET(OPENJPEG_VERSION
+set(OPENJPEG_VERSION_MAJOR 1)
+set(OPENJPEG_VERSION_MINOR 99)
+set(OPENJPEG_VERSION_BUILD 0)
+set(OPENJPEG_VERSION
"${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}")
-SET(PACKAGE_VERSION
+set(PACKAGE_VERSION
"${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}")
-SET(OPENJPEG_LIBRARY_PROPERTIES
+set(OPENJPEG_LIBRARY_PROPERTIES
VERSION "${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}"
SOVERSION "${OPENJPEG_VERSION_MAJOR}"
)
# --------------------------------------------------------------------------
# Path to additional CMake modules
-SET(CMAKE_MODULE_PATH
+set(CMAKE_MODULE_PATH
${CMAKE_SOURCE_DIR}/CMake
${CMAKE_MODULE_PATH})
# --------------------------------------------------------------------------
# On Visual Studio 8 MS deprecated C. This removes all 1.276E1265 security
# warnings
-IF(WIN32)
- IF(NOT BORLAND)
- IF(NOT CYGWIN)
- IF(NOT MINGW)
- IF(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
- ADD_DEFINITIONS(
+if(WIN32)
+ if(NOT BORLAND)
+ if(NOT CYGWIN)
+ if(NOT MINGW)
+ if(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
+ add_definitions(
-D_CRT_FAR_MAPPINGS_NO_DEPRECATE
-D_CRT_IS_WCTYPE_NO_DEPRECATE
-D_CRT_MANAGED_FP_NO_DEPRECATE
-D_CRT_VCCLRIT_NO_DEPRECATE
-D_SCL_SECURE_NO_DEPRECATE
)
- ENDIF(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
- ENDIF(NOT MINGW)
- ENDIF(NOT CYGWIN)
- ENDIF(NOT BORLAND)
-ENDIF(WIN32)
+ endif(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
+ endif(NOT MINGW)
+ endif(NOT CYGWIN)
+ endif(NOT BORLAND)
+endif(WIN32)
# --------------------------------------------------------------------------
# Install directories
-STRING(TOLOWER ${PROJECT_NAME} projectname)
-SET(OPENJPEG_INSTALL_SUBDIR "${projectname}-${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}")
+string(TOLOWER ${PROJECT_NAME} projectname)
+set(OPENJPEG_INSTALL_SUBDIR "${projectname}-${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}")
-IF(NOT OPENJPEG_INSTALL_BIN_DIR)
- SET(OPENJPEG_INSTALL_BIN_DIR "bin")
-ENDIF(NOT OPENJPEG_INSTALL_BIN_DIR)
+if(NOT OPENJPEG_INSTALL_BIN_DIR)
+ set(OPENJPEG_INSTALL_BIN_DIR "bin")
+endif(NOT OPENJPEG_INSTALL_BIN_DIR)
-IF(NOT OPENJPEG_INSTALL_LIB_DIR)
- SET(OPENJPEG_INSTALL_LIB_DIR "lib")
-ENDIF(NOT OPENJPEG_INSTALL_LIB_DIR)
+if(NOT OPENJPEG_INSTALL_LIB_DIR)
+ set(OPENJPEG_INSTALL_LIB_DIR "lib")
+endif(NOT OPENJPEG_INSTALL_LIB_DIR)
-IF(NOT OPENJPEG_INSTALL_SHARE_DIR)
- SET(OPENJPEG_INSTALL_SHARE_DIR "share")
-ENDIF(NOT OPENJPEG_INSTALL_SHARE_DIR)
+if(NOT OPENJPEG_INSTALL_SHARE_DIR)
+ set(OPENJPEG_INSTALL_SHARE_DIR "share")
+endif(NOT OPENJPEG_INSTALL_SHARE_DIR)
-IF(NOT OPENJPEG_INSTALL_DATA_DIR)
- SET(OPENJPEG_INSTALL_DATA_DIR "${OPENJPEG_INSTALL_SHARE_DIR}/${OPENJPEG_INSTALL_SUBDIR}")
-ENDIF(NOT OPENJPEG_INSTALL_DATA_DIR)
+if(NOT OPENJPEG_INSTALL_DATA_DIR)
+ set(OPENJPEG_INSTALL_DATA_DIR "${OPENJPEG_INSTALL_SHARE_DIR}/${OPENJPEG_INSTALL_SUBDIR}")
+endif(NOT OPENJPEG_INSTALL_DATA_DIR)
-IF(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
- SET(OPENJPEG_INSTALL_INCLUDE_DIR "include/${OPENJPEG_INSTALL_SUBDIR}")
-ENDIF(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
+if(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
+ set(OPENJPEG_INSTALL_INCLUDE_DIR "include/${OPENJPEG_INSTALL_SUBDIR}")
+endif(NOT OPENJPEG_INSTALL_INCLUDE_DIR)
-IF(NOT OPENJPEG_INSTALL_MAN_DIR)
- SET(OPENJPEG_INSTALL_MAN_DIR "share/man/")
-ENDIF(NOT OPENJPEG_INSTALL_MAN_DIR)
+if(NOT OPENJPEG_INSTALL_MAN_DIR)
+ set(OPENJPEG_INSTALL_MAN_DIR "share/man/")
+endif(NOT OPENJPEG_INSTALL_MAN_DIR)
-IF(NOT OPENJPEG_INSTALL_DOC_DIR)
- SET(OPENJPEG_INSTALL_DOC_DIR "share/doc/${OPENJPEG_INSTALL_SUBDIR}")
-ENDIF(NOT OPENJPEG_INSTALL_DOC_DIR)
+if(NOT OPENJPEG_INSTALL_DOC_DIR)
+ set(OPENJPEG_INSTALL_DOC_DIR "share/doc/${OPENJPEG_INSTALL_SUBDIR}")
+endif(NOT OPENJPEG_INSTALL_DOC_DIR)
-IF(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
+if(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
# We could install *.cmake files in share/ however those files contains
# hardcoded path to libraries on a multi-arch system (fedora/debian) those
# path will be different (lib/i386-linux-gnu vs lib/x86_64-linux-gnu)
- SET(OPENJPEG_INSTALL_PACKAGE_DIR "${OPENJPEG_INSTALL_LIB_DIR}/${OPENJPEG_INSTALL_SUBDIR}")
-ENDIF(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
+ set(OPENJPEG_INSTALL_PACKAGE_DIR "${OPENJPEG_INSTALL_LIB_DIR}/${OPENJPEG_INSTALL_SUBDIR}")
+endif(NOT OPENJPEG_INSTALL_PACKAGE_DIR)
#-----------------------------------------------------------------------------
# Big endian test:
-INCLUDE (${CMAKE_ROOT}/Modules/TestBigEndian.cmake)
+include (${CMAKE_ROOT}/Modules/TestBigEndian.cmake)
TEST_BIG_ENDIAN(OPJ_BIG_ENDIAN)
#-----------------------------------------------------------------------------
# Setup file for setting custom ctest vars
-CONFIGURE_FILE(
+configure_file(
${CMAKE_SOURCE_DIR}/CMake/CTestCustom.cmake.in
${CMAKE_BINARY_DIR}/CTestCustom.cmake
@ONLY
#-----------------------------------------------------------------------------
# OpenJPEG build configuration options.
-OPTION(BUILD_SHARED_LIBS "Build OpenJPEG shared library and link executables against it." ON)
-SET (EXECUTABLE_OUTPUT_PATH ${OPENJPEG_BINARY_DIR}/bin CACHE PATH "Single output directory for building all executables.")
-SET (LIBRARY_OUTPUT_PATH ${OPENJPEG_BINARY_DIR}/bin CACHE PATH "Single output directory for building all libraries.")
-MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
+option(BUILD_SHARED_LIBS "Build OpenJPEG shared library and link executables against it." ON)
+set (EXECUTABLE_OUTPUT_PATH ${OPENJPEG_BINARY_DIR}/bin CACHE PATH "Single output directory for building all executables.")
+set (LIBRARY_OUTPUT_PATH ${OPENJPEG_BINARY_DIR}/bin CACHE PATH "Single output directory for building all libraries.")
+mark_as_advanced(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
#-----------------------------------------------------------------------------
# configure name mangling to allow multiple libraries to coexist
# peacefully
-IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in)
-SET(MANGLE_PREFIX ${OPENJPEG_LIBRARY_NAME})
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in)
+set(MANGLE_PREFIX ${OPENJPEG_LIBRARY_NAME})
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in
${CMAKE_CURRENT_BINARY_DIR}/openjpeg_mangle.h
@ONLY)
-ENDIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in)
+endif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/openjpeg_mangle.h.in)
#-----------------------------------------------------------------------------
# pkgconfig support
-IF(UNIX)
+if(UNIX)
# install in lib and not share (see multi-arch note above)
- CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/libopenjpeg1.pc.cmake
+ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libopenjpeg1.pc.cmake
${CMAKE_CURRENT_BINARY_DIR}/libopenjpeg1.pc @ONLY)
- INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjpeg1.pc DESTINATION
+ install( FILES ${CMAKE_CURRENT_BINARY_DIR}/libopenjpeg1.pc DESTINATION
${OPENJPEG_INSTALL_LIB_DIR}/pkgconfig )
- INSTALL( CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} -E create_symlink
+ install( CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink
\"libopenjpeg1.pc\"
\"\$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/${OPENJPEG_INSTALL_SHARE_DIR}/pkgconfig/libopenjpeg.pc\")")
-ENDIF(UNIX)
+endif(UNIX)
#-----------------------------------------------------------------------------
# Compiler specific flags:
-IF(CMAKE_COMPILER_IS_GNUCC)
+if(CMAKE_COMPILER_IS_GNUCC)
# For all builds, make sure openjpeg is std99 compliant:
- # SET(CMAKE_C_FLAGS "-Wall -std=c99 ${CMAKE_C_FLAGS}") # FIXME: this setting prevented us from setting a coverage build.
+ # set(CMAKE_C_FLAGS "-Wall -std=c99 ${CMAKE_C_FLAGS}") # FIXME: this setting prevented us from setting a coverage build.
# Do not use ffast-math for all build, it would produce incorrect results, only set for release:
- SET(CMAKE_C_FLAGS_RELEASE "-ffast-math ${CMAKE_C_FLAGS_RELEASE}")
-ENDIF(CMAKE_COMPILER_IS_GNUCC)
+ set(CMAKE_C_FLAGS_RELEASE "-ffast-math ${CMAKE_C_FLAGS_RELEASE}")
+endif(CMAKE_COMPILER_IS_GNUCC)
#-----------------------------------------------------------------------------
# opj_config.h generation (1/2)
-INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
+include (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)
CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H)
CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H)
CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H)
# Enable Large file support
-INCLUDE(TestLargeFiles)
+include(TestLargeFiles)
OPJ_TEST_LARGE_FILES(OPJ_HAVE_LARGEFILES)
#-----------------------------------------------------------------------------
# Build Library
-INCLUDE_DIRECTORIES(BEFORE ${OPENJPEG_BINARY_DIR})
-ADD_SUBDIRECTORY(libopenjpeg)
+include_directories(BEFORE ${OPENJPEG_BINARY_DIR})
+add_subdirectory(libopenjpeg)
#-----------------------------------------------------------------------------
# Build Applications
-OPTION(BUILD_CODEC "Build the CODEC executables" ON)
-OPTION(BUILD_MJ2 "Build the MJ2 executables." OFF)
-OPTION(BUILD_JPWL "Build the JPWL library and executables" OFF)
-OPTION(BUILD_JPIP "Build the JPIP library and executables." OFF)
-IF(BUILD_JPIP)
- OPTION(BUILD_JPIP_SERVER "Build the JPIP server." OFF)
-ENDIF(BUILD_JPIP)
-OPTION(BUILD_VIEWER "Build the OPJViewer executable (C++)" OFF)
-OPTION(BUILD_JAVA "Build the openjpeg jar (Java)" OFF)
-MARK_AS_ADVANCED(BUILD_VIEWER)
-MARK_AS_ADVANCED(BUILD_JAVA)
-
-IF(BUILD_CODEC OR BUILD_MJ2)
+option(BUILD_CODEC "Build the CODEC executables" ON)
+option(BUILD_MJ2 "Build the MJ2 executables." OFF)
+option(BUILD_JPWL "Build the JPWL library and executables" OFF)
+option(BUILD_JPIP "Build the JPIP library and executables." OFF)
+if(BUILD_JPIP)
+ option(BUILD_JPIP_SERVER "Build the JPIP server." OFF)
+endif(BUILD_JPIP)
+option(BUILD_VIEWER "Build the OPJViewer executable (C++)" OFF)
+option(BUILD_JAVA "Build the openjpeg jar (Java)" OFF)
+mark_as_advanced(BUILD_VIEWER)
+mark_as_advanced(BUILD_JAVA)
+
+if(BUILD_CODEC OR BUILD_MJ2)
# OFF: It will only build 3rd party libs if they are not found on the system
# ON: 3rd party libs will ALWAYS be build, and used
- OPTION(BUILD_THIRDPARTY "Build the thirdparty executables if it is needed" OFF)
- ADD_SUBDIRECTORY(thirdparty)
- ADD_SUBDIRECTORY(applications)
-ENDIF (BUILD_CODEC OR BUILD_MJ2)
+ option(BUILD_THIRDPARTY "Build the thirdparty executables if it is needed" OFF)
+ add_subdirectory(thirdparty)
+ add_subdirectory(applications)
+endif (BUILD_CODEC OR BUILD_MJ2)
include(CheckTypeSize)
CHECK_TYPE_SIZE(ssize_t SSIZE_T)
#-----------------------------------------------------------------------------
# opj_config.h generation (2/2)
-CONFIGURE_FILE("${OPENJPEG_SOURCE_DIR}/opj_config.h.cmake.in"
+configure_file("${OPENJPEG_SOURCE_DIR}/opj_config.h.cmake.in"
"${OPENJPEG_BINARY_DIR}/opj_config.h"
@ONLY
)
#
-INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/opj_config.h
+install( FILES ${CMAKE_CURRENT_BINARY_DIR}/opj_config.h
DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR} COMPONENT Headers)
#-----------------------------------------------------------------------------
# Build DOCUMENTATION (not in ALL target and only if Doxygen is found)
-OPTION(BUILD_DOC "Build the HTML documentation (with doxygen if available)." OFF)
-IF(BUILD_DOC)
- ADD_SUBDIRECTORY(doc)
-ENDIF(BUILD_DOC)
+option(BUILD_DOC "Build the HTML documentation (with doxygen if available)." OFF)
+if(BUILD_DOC)
+ add_subdirectory(doc)
+endif(BUILD_DOC)
#-----------------------------------------------------------------------------
# Buld Testing
-OPTION(BUILD_TESTING "Build the tests." OFF)
-IF(BUILD_TESTING)
- IF(BUILD_CODEC)
- ENABLE_TESTING()
- INCLUDE(CTest)
+option(BUILD_TESTING "Build the tests." OFF)
+if(BUILD_TESTING)
+ if(BUILD_CODEC)
+ enable_testing()
+ include(CTest)
# Search openjpeg data needed for the tests
# They could be found via svn on the OpenJPEG google code project
# svn checkout http://openjpeg.googlecode.com/svn/data (about 70 Mo)
- FIND_PATH(OPJ_DATA_ROOT README-OPJ-Data
+ find_path(OPJ_DATA_ROOT README-OPJ-Data
PATHS
$ENV{OPJ_DATA_ROOT}
${CMAKE_SOURCE_DIR}/../data
)
# Add repository where to find tests
- ADD_SUBDIRECTORY(tests)
+ add_subdirectory(tests)
- ELSE(BUILD_CODEC)
+ else(BUILD_CODEC)
message(FATAL_ERROR "You need build codec to run the tests")
- ENDIF(BUILD_CODEC)
-ENDIF(BUILD_TESTING)
+ endif(BUILD_CODEC)
+endif(BUILD_TESTING)
#-----------------------------------------------------------------------------
# install all targets referenced as OPENJPEGTargets
-INSTALL(EXPORT OpenJPEGTargets DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR})
-CONFIGURE_FILE( ${OPENJPEG_SOURCE_DIR}/CMake/OpenJPEGConfig.cmake.in
+install(EXPORT OpenJPEGTargets DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR})
+configure_file( ${OPENJPEG_SOURCE_DIR}/CMake/OpenJPEGConfig.cmake.in
${OPENJPEG_BINARY_DIR}/OpenJPEGConfig.cmake
@ONLY
)
-INSTALL( FILES ${OPENJPEG_BINARY_DIR}/OpenJPEGConfig.cmake
+install( FILES ${OPENJPEG_BINARY_DIR}/OpenJPEGConfig.cmake
DESTINATION ${OPENJPEG_INSTALL_PACKAGE_DIR}
)
#-----------------------------------------------------------------------------
# install CHANGES and LICENSE
-IF(EXISTS ${OPENJPEG_SOURCE_DIR}/CHANGES)
- INSTALL(FILES CHANGES DESTINATION ${OPENJPEG_INSTALL_DOC_DIR})
-ENDIF(EXISTS ${OPENJPEG_SOURCE_DIR}/CHANGES)
-INSTALL(FILES LICENSE DESTINATION ${OPENJPEG_INSTALL_DOC_DIR})
+if(EXISTS ${OPENJPEG_SOURCE_DIR}/CHANGES)
+ install(FILES CHANGES DESTINATION ${OPENJPEG_INSTALL_DOC_DIR})
+endif(EXISTS ${OPENJPEG_SOURCE_DIR}/CHANGES)
+install(FILES LICENSE DESTINATION ${OPENJPEG_INSTALL_DOC_DIR})
-INCLUDE (CMake/OpenJPEGCPack.cmake)
+include (CMake/OpenJPEGCPack.cmake)
# Build the each application if it needed
-IF(BUILD_CODEC)
- ADD_SUBDIRECTORY(codec)
-ENDIF(BUILD_CODEC)
+if(BUILD_CODEC)
+ add_subdirectory(codec)
+endif(BUILD_CODEC)
-IF(BUILD_MJ2)
- ADD_SUBDIRECTORY(mj2)
-ENDIF(BUILD_MJ2)
+if(BUILD_MJ2)
+ add_subdirectory(mj2)
+endif(BUILD_MJ2)
# Client & Server:
-IF(BUILD_JPIP)
- ADD_SUBDIRECTORY(jpip)
-ENDIF(BUILD_JPIP)
+if(BUILD_JPIP)
+ add_subdirectory(jpip)
+endif(BUILD_JPIP)
-IF(BUILD_VIEWER)
- ADD_SUBDIRECTORY(OPJViewer)
-ENDIF(BUILD_VIEWER)
+if(BUILD_VIEWER)
+ add_subdirectory(OPJViewer)
+endif(BUILD_VIEWER)
-IF(BUILD_JAVA)
- ADD_SUBDIRECTORY(JavaOpenJPEG)
-ENDIF(BUILD_JAVA)
+if(BUILD_JAVA)
+ add_subdirectory(JavaOpenJPEG)
+endif(BUILD_JAVA)
#JavaOpenJPEG/CMakeLists.txt
# First thing define the common source:
-SET(openjpegjni_SRCS
+set(openjpegjni_SRCS
JavaOpenJPEGDecoder.c
JavaOpenJPEG.c
)
)
# build jar:
-FIND_PACKAGE(Java 1.5 REQUIRED) # javac, jar
+find_package(Java 1.5 REQUIRED) # javac, jar
# build dep list:
file(GLOB java_srcs "java-sources/org/openJpeg/*.java")
# make sure target javac dir exists:
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/classes)
# Build java
-ADD_CUSTOM_COMMAND(
+add_custom_command(
OUTPUT ${LIBRARY_OUTPUT_PATH}/openjpeg.jar
COMMAND ${Java_JAVAC_EXECUTABLE} -sourcepath "${CMAKE_CURRENT_SOURCE_DIR}/java-sources"
${java_srcs} -d ${CMAKE_CURRENT_BINARY_DIR}/classes
)
# name the target
-ADD_CUSTOM_TARGET(OpenJPEGJavaJar ALL
+add_custom_target(OpenJPEGJavaJar ALL
DEPENDS ${LIBRARY_OUTPUT_PATH}/openjpeg.jar
COMMENT "building openjpeg.jar"
)
-PROJECT(viewer CXX)
+project(viewer CXX)
-FIND_PACKAGE(wxWidgets REQUIRED)
-INCLUDE(${wxWidgets_USE_FILE})
+find_package(wxWidgets REQUIRED)
+include(${wxWidgets_USE_FILE})
-INCLUDE_DIRECTORIES(
+include_directories(
${CMAKE_CURRENT_SOURCE_DIR}/../..
${CMAKE_CURRENT_SOURCE_DIR}/..
)
# original flags:
# -DUSE_JPWL -DwxUSE_LIBOPENJPEG -DwxUSE_GUI=1 -DOPJ_STATIC -DOPJ_HTMLABOUT -DOPJ_INICONFIG -DUSE_JPSEC -DOPJ_MANYFORMATS
-ADD_DEFINITIONS(-DwxUSE_LIBOPENJPEG -DOPENJPEG_VERSION="1.5.0")
-SET(OPJV_SRCS
+add_definitions(-DwxUSE_LIBOPENJPEG -DOPENJPEG_VERSION="1.5.0")
+set(OPJV_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/source/imagjpeg2000.cpp
${CMAKE_CURRENT_SOURCE_DIR}/source/wxj2kparser.cpp
${CMAKE_CURRENT_SOURCE_DIR}/source/OPJViewer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/source/OPJAbout.cpp
${CMAKE_CURRENT_SOURCE_DIR}/../codec/index.c
)
-ADD_EXECUTABLE(opjviewer ${OPJV_SRCS})
-TARGET_LINK_LIBRARIES(opjviewer ${wxWidgets_LIBRARIES} openjpeg)
+add_executable(opjviewer ${OPJV_SRCS})
+target_link_libraries(opjviewer ${wxWidgets_LIBRARIES} openjpeg)
# Build the demo app, small examples
# First thing define the common source:
-SET(common_SRCS
+set(common_SRCS
convert.c
index.c
${OPENJPEG_SOURCE_DIR}/applications/common/color.c
)
# Headers file are located here:
-INCLUDE_DIRECTORIES(
+include_directories(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
${LCMS_INCLUDE_DIRNAME}
${OPENJPEG_SOURCE_DIR}/applications/common
${TIFF_INCLUDE_DIRNAME}
)
-IF(WIN32)
- IF(BUILD_SHARED_LIBS)
- ADD_DEFINITIONS(-DOPJ_EXPORTS)
- ELSE(BUILD_SHARED_LIBS)
- ADD_DEFINITIONS(-DOPJ_STATIC)
- ENDIF(BUILD_SHARED_LIBS)
-ENDIF(WIN32)
+if(WIN32)
+ if(BUILD_SHARED_LIBS)
+ add_definitions(-DOPJ_EXPORTS)
+ else(BUILD_SHARED_LIBS)
+ add_definitions(-DOPJ_STATIC)
+ endif(BUILD_SHARED_LIBS)
+endif(WIN32)
# Loop over all executables:
-FOREACH(exe j2k_to_image image_to_j2k j2k_dump)
- ADD_EXECUTABLE(${exe} ${exe}.c ${common_SRCS})
- TARGET_LINK_LIBRARIES(${exe} ${OPENJPEG_LIBRARY_NAME}
+foreach(exe j2k_to_image image_to_j2k j2k_dump)
+ add_executable(${exe} ${exe}.c ${common_SRCS})
+ target_link_libraries(${exe} ${OPENJPEG_LIBRARY_NAME}
${PNG_LIBNAME} ${TIFF_LIBNAME} ${LCMS_LIBNAME}
)
# To support universal exe:
- IF(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(${exe} z)
+ if(ZLIB_FOUND AND APPLE)
+ target_link_libraries(${exe} z)
ELSe(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(${exe} ${Z_LIBNAME})
- ENDIF(ZLIB_FOUND AND APPLE)
+ target_link_libraries(${exe} ${Z_LIBNAME})
+ endif(ZLIB_FOUND AND APPLE)
# On unix you need to link to the math library:
- IF(UNIX)
- TARGET_LINK_LIBRARIES(${exe} m)
- ENDIF(UNIX)
+ if(UNIX)
+ target_link_libraries(${exe} m)
+ endif(UNIX)
# Install exe
- INSTALL(TARGETS ${exe}
+ install(TARGETS ${exe}
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
-ENDFOREACH(exe)
+endforeach(exe)
# Install man pages
-INSTALL(
+install(
FILES ${OPENJPEG_SOURCE_DIR}/doc/man/man1/image_to_j2k.1
${OPENJPEG_SOURCE_DIR}/doc/man/man1/j2k_dump.1
${OPENJPEG_SOURCE_DIR}/doc/man/man1/j2k_to_image.1
DESTINATION ${OPENJPEG_INSTALL_MAN_DIR}/man1)
#
-IF(BUILD_JPWL)
- ADD_EXECUTABLE(JPWL_j2k_to_image
+if(BUILD_JPWL)
+ add_executable(JPWL_j2k_to_image
j2k_to_image.c
${common_SRCS}
)
- SET_PROPERTY(
+ set_property(
TARGET JPWL_j2k_to_image
APPEND PROPERTY COMPILE_DEFINITIONS USE_JPWL
)
- TARGET_LINK_LIBRARIES(JPWL_j2k_to_image ${OPENJPEG_LIBRARY_NAME}_JPWL
+ target_link_libraries(JPWL_j2k_to_image ${OPENJPEG_LIBRARY_NAME}_JPWL
${LCMS_LIBNAME} ${PNG_LIBNAME} ${TIFF_LIBNAME})
# To support universal exe:
- IF(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(JPWL_j2k_to_image z)
+ if(ZLIB_FOUND AND APPLE)
+ target_link_libraries(JPWL_j2k_to_image z)
ELSe(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(JPWL_j2k_to_image ${Z_LIBNAME})
- ENDIF(ZLIB_FOUND AND APPLE)
+ target_link_libraries(JPWL_j2k_to_image ${Z_LIBNAME})
+ endif(ZLIB_FOUND AND APPLE)
- IF(UNIX)
- TARGET_LINK_LIBRARIES(JPWL_j2k_to_image m)
- ENDIF(UNIX)
+ if(UNIX)
+ target_link_libraries(JPWL_j2k_to_image m)
+ endif(UNIX)
- ADD_EXECUTABLE(JPWL_image_to_j2k
+ add_executable(JPWL_image_to_j2k
image_to_j2k.c
${common_SRCS}
)
- SET_PROPERTY(
+ set_property(
TARGET JPWL_image_to_j2k
APPEND PROPERTY COMPILE_DEFINITIONS USE_JPWL
)
- TARGET_LINK_LIBRARIES(JPWL_image_to_j2k ${OPENJPEG_LIBRARY_NAME}_JPWL
+ target_link_libraries(JPWL_image_to_j2k ${OPENJPEG_LIBRARY_NAME}_JPWL
${LCMS_LIBNAME} ${PNG_LIBNAME} ${TIFF_LIBNAME})
# To support universal exe:
- IF(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(JPWL_image_to_j2k z)
+ if(ZLIB_FOUND AND APPLE)
+ target_link_libraries(JPWL_image_to_j2k z)
ELSe(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(JPWL_image_to_j2k ${Z_LIBNAME})
- ENDIF(ZLIB_FOUND AND APPLE)
+ target_link_libraries(JPWL_image_to_j2k ${Z_LIBNAME})
+ endif(ZLIB_FOUND AND APPLE)
- IF(UNIX)
- TARGET_LINK_LIBRARIES(JPWL_image_to_j2k m)
- ENDIF(UNIX)
+ if(UNIX)
+ target_link_libraries(JPWL_image_to_j2k m)
+ endif(UNIX)
- INSTALL(TARGETS JPWL_image_to_j2k JPWL_j2k_to_image
+ install(TARGETS JPWL_image_to_j2k JPWL_j2k_to_image
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
-ENDIF(BUILD_JPWL)
+endif(BUILD_JPWL)
# required dep for server:
-IF(BUILD_JPIP_SERVER)
- FIND_PACKAGE(CURL REQUIRED)
- FIND_PACKAGE(FCGI REQUIRED)
- FIND_PACKAGE(Threads REQUIRED)
- IF(NOT CMAKE_USE_PTHREADS_INIT)
- MESSAGE(FATAL_ERROR "Only pthread are supported")
- ENDIF(NOT CMAKE_USE_PTHREADS_INIT)
-ENDIF(BUILD_JPIP_SERVER)
+if(BUILD_JPIP_SERVER)
+ find_package(CURL REQUIRED)
+ find_package(FCGI REQUIRED)
+ find_package(Threads REQUIRED)
+ if(NOT CMAKE_USE_PTHREADS_INIT)
+ message(FATAL_ERROR "Only pthread are supported")
+ endif(NOT CMAKE_USE_PTHREADS_INIT)
+endif(BUILD_JPIP_SERVER)
# JPIP library:
-ADD_SUBDIRECTORY(libopenjpip)
+add_subdirectory(libopenjpip)
# JPIP binaries:
-ADD_SUBDIRECTORY(util)
+add_subdirectory(util)
-INCLUDE_REGULAR_EXPRESSION("^.*$")
+include_regular_expression("^.*$")
-INCLUDE_DIRECTORIES(
+include_directories(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
${FCGI_INCLUDE_DIRS}
${CURL_INCLUDE_DIRS}
)
# Defines the source code for the library
-SET(OPENJPIP_SRCS
+set(OPENJPIP_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/boxheader_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/codestream_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/imgreg_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/sock_manager.c
)
-SET(SERVER_SRCS
+set(SERVER_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/auxtrans_manager.c
)
-SET(LOCAL_SRCS
+set(LOCAL_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/jp2k_decoder.c
${CMAKE_CURRENT_SOURCE_DIR}/imgsock_manager.c
${CMAKE_CURRENT_SOURCE_DIR}/jpipstream_manager.c
)
# Build the library
-ADD_LIBRARY(openjpip_local STATIC ${OPENJPIP_SRCS} ${LOCAL_SRCS})
-TARGET_LINK_LIBRARIES(openjpip_local ${OPENJPEG_LIBRARY_NAME})
-IF(WIN32)
+add_library(openjpip_local STATIC ${OPENJPIP_SRCS} ${LOCAL_SRCS})
+target_link_libraries(openjpip_local ${OPENJPEG_LIBRARY_NAME})
+if(WIN32)
# add Winsock on windows+mingw
- TARGET_LINK_LIBRARIES(openjpip_local ws2_32)
-ENDIF(WIN32)
+ target_link_libraries(openjpip_local ws2_32)
+endif(WIN32)
# Install library
-INSTALL(TARGETS openjpip_local
+install(TARGETS openjpip_local
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
)
-IF(BUILD_JPIP_SERVER)
- ADD_LIBRARY(openjpip_server STATIC ${OPENJPIP_SRCS} ${SERVER_SRCS})
- TARGET_LINK_LIBRARIES(openjpip_server ${FCGI_LIBRARIES} ${CURL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
- SET_TARGET_PROPERTIES(openjpip_server
+if(BUILD_JPIP_SERVER)
+ add_library(openjpip_server STATIC ${OPENJPIP_SRCS} ${SERVER_SRCS})
+ target_link_libraries(openjpip_server ${FCGI_LIBRARIES} ${CURL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+ set_target_properties(openjpip_server
PROPERTIES COMPILE_FLAGS "-DSERVER")
- INSTALL(TARGETS openjpip_server
+ install(TARGETS openjpip_server
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
)
-ENDIF(BUILD_JPIP_SERVER)
+endif(BUILD_JPIP_SERVER)
# Headers file are located here:
-INCLUDE_DIRECTORIES(
+include_directories(
${OPENJPEG_SOURCE_DIR}/libopenjpeg # opj_stdint.h
${OPENJPEG_SOURCE_DIR}/applications/jpip/libopenjpip
${FCGI_INCLUDE_DIRS}
)
# Tool to embed metadata into JP2 file
-ADD_EXECUTABLE(addXMLinJP2 addXMLinJP2.c)
+add_executable(addXMLinJP2 addXMLinJP2.c)
# Install exe
-INSTALL(TARGETS addXMLinJP2
+install(TARGETS addXMLinJP2
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
-IF(BUILD_JPIP_SERVER)
+if(BUILD_JPIP_SERVER)
- SET(OPJ_SERVER_SRCS
+ set(OPJ_SERVER_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/opj_server.c
)
# Build executable
- ADD_EXECUTABLE(opj_server ${OPJ_SERVER_SRCS})
- TARGET_LINK_LIBRARIES(opj_server openjpip_server)
- SET_PROPERTY(
+ add_executable(opj_server ${OPJ_SERVER_SRCS})
+ target_link_libraries(opj_server openjpip_server)
+ set_property(
TARGET opj_server
APPEND PROPERTY
COMPILE_DEFINITIONS SERVER QUIT_SIGNAL="quitJPIP"
)
# On unix you need to link to the math library:
- IF(UNIX)
- TARGET_LINK_LIBRARIES(opj_server m)
- ENDIF(UNIX)
+ if(UNIX)
+ target_link_libraries(opj_server m)
+ endif(UNIX)
# Install exe
- INSTALL(TARGETS opj_server
+ install(TARGETS opj_server
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
-ENDIF(BUILD_JPIP_SERVER)
+endif(BUILD_JPIP_SERVER)
-SET(EXES
+set(EXES
opj_dec_server
jpip_to_jp2
jpip_to_j2k
test_index
)
-FOREACH(exe ${EXES})
- ADD_EXECUTABLE(${exe} ${exe}.c)
- TARGET_LINK_LIBRARIES(${exe} openjpip_local)
- INSTALL(TARGETS ${exe}
+foreach(exe ${EXES})
+ add_executable(${exe} ${exe}.c)
+ target_link_libraries(${exe} openjpip_local)
+ install(TARGETS ${exe}
EXPORT OpenJPEGTargets
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
)
-ENDFOREACH(exe)
+endforeach(exe)
# Build the two java clients:
-FIND_PACKAGE(Java 1.5 COMPONENTS Development) # javac, jar
+find_package(Java 1.5 COMPONENTS Development) # javac, jar
# Only build the java viewer if dev is found:
if(Java_Development_FOUND AND Java_JAVAC_EXECUTABLE)
# make sure target javac dir exists:
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/classes1)
# Build java
- ADD_CUSTOM_COMMAND(
+ add_custom_command(
OUTPUT ${LIBRARY_OUTPUT_PATH}/opj_viewer.jar
COMMAND ${Java_JAVAC_EXECUTABLE} ${jflags}
${java1_srcs} -d ${CMAKE_CURRENT_BINARY_DIR}/classes1
)
# name the target
- ADD_CUSTOM_TARGET(OPJViewerJar ALL
+ add_custom_target(OPJViewerJar ALL
DEPENDS ${LIBRARY_OUTPUT_PATH}/opj_viewer.jar
COMMENT "building opj_viewer.jar"
)
- INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/opj_viewer.jar
+ install(FILES ${LIBRARY_OUTPUT_PATH}/opj_viewer.jar
DESTINATION ${OPENJPEG_INSTALL_SHARE_DIR} COMPONENT JavaModule
)
# make sure target javac dir exists:
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/classes2)
# Build java
- ADD_CUSTOM_COMMAND(
+ add_custom_command(
OUTPUT ${LIBRARY_OUTPUT_PATH}/opj_viewer_xerces.jar
COMMAND ${Java_JAVAC_EXECUTABLE} ${jflags}
-classpath ${APACHE_XERCES_JAR}
)
# name the target
- ADD_CUSTOM_TARGET(OPJViewerXercesJar ALL
+ add_custom_target(OPJViewerXercesJar ALL
DEPENDS ${LIBRARY_OUTPUT_PATH}/opj_viewer_xerces.jar
COMMENT "building opj_viewer_xerces.jar"
)
- INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/opj_viewer_xerces.jar
+ install(FILES ${LIBRARY_OUTPUT_PATH}/opj_viewer_xerces.jar
DESTINATION ${OPENJPEG_INSTALL_SHARE_DIR} COMPONENT JavaModule
)
endif()
# Makefile for the MJ2 codecs of the OpenJPEG library: frames_to_mj2, mj2_to_frames, extract_j2k_from_mj2 and wrap_j2k_in_mj2
-SET(common_SRCS ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c)
+set(common_SRCS ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c)
# While mj2 executables do not use the API correctly, we do not link with the library but rather compile the sources files.
-SET(OPJ_SRCS
+set(OPJ_SRCS
${OPENJPEG_SOURCE_DIR}/libopenjpeg/bio.c
${OPENJPEG_SOURCE_DIR}/libopenjpeg/cio.c
${OPENJPEG_SOURCE_DIR}/libopenjpeg/dwt.c
${OPENJPEG_SOURCE_DIR}/libopenjpeg/function_list.c
)
-SET(MJ2_SRCS mj2.c mj2_convert.c)
+set(MJ2_SRCS mj2.c mj2_convert.c)
-IF(WIN32)
- ADD_DEFINITIONS(-DOPJ_STATIC)
-ENDIF(WIN32)
+if(WIN32)
+ add_definitions(-DOPJ_STATIC)
+endif(WIN32)
# Headers file are located here:
-INCLUDE_DIRECTORIES(
+include_directories(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
${OPENJPEG_SOURCE_DIR}/applications/common
${LCMS_INCLUDE_DIRNAME}
)
-ADD_EXECUTABLE(frames_to_mj2
+add_executable(frames_to_mj2
frames_to_mj2.c
${common_SRCS}
${OPJ_SRCS}
${MJ2_SRCS}
)
-TARGET_LINK_LIBRARIES(frames_to_mj2 ${LCMS_LIBNAME})
+target_link_libraries(frames_to_mj2 ${LCMS_LIBNAME})
-IF(UNIX)
- TARGET_LINK_LIBRARIES(frames_to_mj2 m)
-ENDIF(UNIX)
+if(UNIX)
+ target_link_libraries(frames_to_mj2 m)
+endif(UNIX)
-ADD_EXECUTABLE(mj2_to_frames
+add_executable(mj2_to_frames
mj2_to_frames.c
${common_SRCS}
${OPJ_SRCS}
${MJ2_SRCS}
${OPENJPEG_SOURCE_DIR}/applications/common/color.c
)
-TARGET_LINK_LIBRARIES(mj2_to_frames ${LCMS_LIBNAME})
+target_link_libraries(mj2_to_frames ${LCMS_LIBNAME})
-IF(UNIX)
- TARGET_LINK_LIBRARIES(mj2_to_frames m)
-ENDIF(UNIX)
+if(UNIX)
+ target_link_libraries(mj2_to_frames m)
+endif(UNIX)
-ADD_EXECUTABLE(extract_j2k_from_mj2
+add_executable(extract_j2k_from_mj2
extract_j2k_from_mj2.c
${OPJ_SRCS}
${MJ2_SRCS}
)
-TARGET_LINK_LIBRARIES(extract_j2k_from_mj2 ${LCMS_LIBNAME})
+target_link_libraries(extract_j2k_from_mj2 ${LCMS_LIBNAME})
-IF(UNIX)
- TARGET_LINK_LIBRARIES(extract_j2k_from_mj2 m)
-ENDIF(UNIX)
+if(UNIX)
+ target_link_libraries(extract_j2k_from_mj2 m)
+endif(UNIX)
-ADD_EXECUTABLE(wrap_j2k_in_mj2
+add_executable(wrap_j2k_in_mj2
wrap_j2k_in_mj2.c
${OPJ_SRCS}
${MJ2_SRCS}
)
-TARGET_LINK_LIBRARIES(wrap_j2k_in_mj2 ${LCMS_LIBNAME})
+target_link_libraries(wrap_j2k_in_mj2 ${LCMS_LIBNAME})
-IF(UNIX)
- TARGET_LINK_LIBRARIES(wrap_j2k_in_mj2 m)
-ENDIF(UNIX)
+if(UNIX)
+ target_link_libraries(wrap_j2k_in_mj2 m)
+endif(UNIX)
-INSTALL(TARGETS frames_to_mj2 mj2_to_frames extract_j2k_from_mj2 wrap_j2k_in_mj2
+install(TARGETS frames_to_mj2 mj2_to_frames extract_j2k_from_mj2 wrap_j2k_in_mj2
DESTINATION ${OPENJPEG_INSTALL_BIN_DIR})
# to generate the html documentation in the doc/html repository of the build folder.
# Try to find the doxygen tool
-FIND_PACKAGE(Doxygen)
+find_package(Doxygen)
-IF(DOXYGEN_FOUND)
+if(DOXYGEN_FOUND)
# Configure the doxygen config file with variable from CMake and move it
- CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.dox.cmake.in
+ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.dox.cmake.in
${CMAKE_BINARY_DIR}/doc/Doxyfile-html.dox @ONLY)
# Configure the html mainpage file of the doxygen documentation with variable
# from CMake and move it
- CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/mainpage.dox.cmake
+ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/mainpage.dox.cmake
${CMAKE_BINARY_DIR}/doc/mainpage.dox @ONLY)
# Generate new target to build the html documentation
- ADD_CUSTOM_TARGET(doc ALL
+ add_custom_target(doc ALL
${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/doc/Doxyfile-html.dox)
-ELSE(DOXYGEN_FOUND)
+else(DOXYGEN_FOUND)
- MESSAGE(STATUS "Doxygen not found, we cannot generate the documentation")
+ message(STATUS "Doxygen not found, we cannot generate the documentation")
-ENDIF(DOXYGEN_FOUND)
+endif(DOXYGEN_FOUND)
-INCLUDE_REGULAR_EXPRESSION("^.*$")
+include_regular_expression("^.*$")
# Defines the source code for the library
-SET(OPENJPEG_SRCS
+set(OPENJPEG_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/bio.c
${CMAKE_CURRENT_SOURCE_DIR}/cio.c
${CMAKE_CURRENT_SOURCE_DIR}/dwt.c
)
# Build the library
-IF(WIN32)
- IF(BUILD_SHARED_LIBS)
- ADD_DEFINITIONS(-DOPJ_EXPORTS)
- ELSE(BUILD_SHARED_LIBS)
- ADD_DEFINITIONS(-DOPJ_STATIC)
- ENDIF(BUILD_SHARED_LIBS)
-ENDIF(WIN32)
-ADD_LIBRARY(${OPENJPEG_LIBRARY_NAME} ${OPENJPEG_SRCS})
-IF(UNIX)
- TARGET_LINK_LIBRARIES(${OPENJPEG_LIBRARY_NAME} m)
-ENDIF(UNIX)
-SET_TARGET_PROPERTIES(${OPENJPEG_LIBRARY_NAME} PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
+if(WIN32)
+ if(BUILD_SHARED_LIBS)
+ add_definitions(-DOPJ_EXPORTS)
+ else(BUILD_SHARED_LIBS)
+ add_definitions(-DOPJ_STATIC)
+ endif(BUILD_SHARED_LIBS)
+endif(WIN32)
+add_library(${OPENJPEG_LIBRARY_NAME} ${OPENJPEG_SRCS})
+if(UNIX)
+ target_link_libraries(${OPENJPEG_LIBRARY_NAME} m)
+endif(UNIX)
+set_target_properties(${OPENJPEG_LIBRARY_NAME} PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
# Build the JPWL library ?
-IF(BUILD_JPWL)
- ADD_SUBDIRECTORY(jpwl)
-ENDIF(BUILD_JPWL)
+if(BUILD_JPWL)
+ add_subdirectory(jpwl)
+endif(BUILD_JPWL)
# Install library
-INSTALL(TARGETS ${OPENJPEG_LIBRARY_NAME}
+install(TARGETS ${OPENJPEG_LIBRARY_NAME}
EXPORT OpenJPEGTargets
RUNTIME DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
LIBRARY DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
)
# Install includes files
-INSTALL(FILES openjpeg.h opj_stdint.h
+install(FILES openjpeg.h opj_stdint.h
DESTINATION ${OPENJPEG_INSTALL_INCLUDE_DIR} COMPONENT Headers
)
# install man page of the library
-INSTALL(
+install(
FILES ${OPENJPEG_SOURCE_DIR}/doc/man/man3/libopenjpeg.3
DESTINATION ${OPENJPEG_INSTALL_MAN_DIR}/man3)
# Makefile for the main JPWL OpenJPEG codecs: JPWL_ j2k_to_image and JPWL_image_to_j2k
-ADD_DEFINITIONS(-DUSE_JPWL)
+add_definitions(-DUSE_JPWL)
-SET(JPWL_SRCS crc.c jpwl.c jpwl_lib.c rs.c)
-IF(APPLE)
- SET_SOURCE_FILES_PROPERTIES(
+set(JPWL_SRCS crc.c jpwl.c jpwl_lib.c rs.c)
+if(APPLE)
+ set_source_files_properties(
rs.c
PROPERTIES
COMPILE_FLAGS -fno-common)
-ENDIF(APPLE)
+endif(APPLE)
-INCLUDE_DIRECTORIES(
+include_directories(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
)
# Build the library
-IF(WIN32)
- IF(BUILD_SHARED_LIBS)
- ADD_DEFINITIONS(-DOPJ_EXPORTS)
- ELSE(BUILD_SHARED_LIBS)
- ADD_DEFINITIONS(-DOPJ_STATIC)
- ENDIF(BUILD_SHARED_LIBS)
-ENDIF(WIN32)
-ADD_LIBRARY(${OPENJPEG_LIBRARY_NAME}_JPWL ${JPWL_SRCS} ${OPENJPEG_SRCS})
-SET_TARGET_PROPERTIES(${OPENJPEG_LIBRARY_NAME}_JPWL
+if(WIN32)
+ if(BUILD_SHARED_LIBS)
+ add_definitions(-DOPJ_EXPORTS)
+ else(BUILD_SHARED_LIBS)
+ add_definitions(-DOPJ_STATIC)
+ endif(BUILD_SHARED_LIBS)
+endif(WIN32)
+add_library(${OPENJPEG_LIBRARY_NAME}_JPWL ${JPWL_SRCS} ${OPENJPEG_SRCS})
+set_target_properties(${OPENJPEG_LIBRARY_NAME}_JPWL
PROPERTIES ${OPENJPEG_LIBRARY_PROPERTIES})
# Install library
-INSTALL(TARGETS ${OPENJPEG_LIBRARY_NAME}_JPWL
+install(TARGETS ${OPENJPEG_LIBRARY_NAME}_JPWL
EXPORT OpenJPEGTargets
RUNTIME DESTINATION ${OPENJPEG_INSTALL_BIN_DIR} COMPONENT Applications
LIBRARY DESTINATION ${OPENJPEG_INSTALL_LIB_DIR} COMPONENT Libraries
# Tests
-INCLUDE_DIRECTORIES(
+include_directories(
${OPENJPEG_SOURCE_DIR}/libopenjpeg
${OPENJPEG_SOURCE_DIR}/applications/codec
${OPENJPEG_SOURCE_DIR}/applications/common
)
# First thing define the common source:
-SET(comparePGXimages_SRCS comparePGXimages.c
+set(comparePGXimages_SRCS comparePGXimages.c
${OPENJPEG_SOURCE_DIR}/applications/codec/convert.c
${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c
)
-SET(compare_dump_files_SRCS compare_dump_files.c
+set(compare_dump_files_SRCS compare_dump_files.c
${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c)
-SET(compareRAWimages_SRCS compareRAWimages.c
+set(compareRAWimages_SRCS compareRAWimages.c
${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c)
-ADD_EXECUTABLE(comparePGXimages ${comparePGXimages_SRCS})
-TARGET_LINK_LIBRARIES(comparePGXimages
+add_executable(comparePGXimages ${comparePGXimages_SRCS})
+target_link_libraries(comparePGXimages
${OPENJPEG_LIBRARY_NAME}
${PNG_LIBNAME} ${TIFF_LIBNAME}
)
# To support universal exe:
-IF(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(comparePGXimages z)
+if(ZLIB_FOUND AND APPLE)
+ target_link_libraries(comparePGXimages z)
ELSe(ZLIB_FOUND AND APPLE)
- TARGET_LINK_LIBRARIES(comparePGXimages ${Z_LIBNAME})
-ENDIF(ZLIB_FOUND AND APPLE)
+ target_link_libraries(comparePGXimages ${Z_LIBNAME})
+endif(ZLIB_FOUND AND APPLE)
-ADD_EXECUTABLE(compare_dump_files ${compare_dump_files_SRCS})
+add_executable(compare_dump_files ${compare_dump_files_SRCS})
-ADD_EXECUTABLE(j2k_random_tile_access j2k_random_tile_access.c)
-TARGET_LINK_LIBRARIES(j2k_random_tile_access ${OPENJPEG_LIBRARY_NAME})
+add_executable(j2k_random_tile_access j2k_random_tile_access.c)
+target_link_libraries(j2k_random_tile_access ${OPENJPEG_LIBRARY_NAME})
-ADD_EXECUTABLE(compareRAWimages ${compareRAWimages_SRCS})
+add_executable(compareRAWimages ${compareRAWimages_SRCS})
-ADD_EXECUTABLE(test_tile_encoder test_tile_encoder.c)
-TARGET_LINK_LIBRARIES(test_tile_encoder ${OPENJPEG_LIBRARY_NAME})
+add_executable(test_tile_encoder test_tile_encoder.c)
+target_link_libraries(test_tile_encoder ${OPENJPEG_LIBRARY_NAME})
# Let's try a couple of possibilities:
-ADD_TEST(tte0 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder)
-ADD_TEST(tte1 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 3 2048 2048 1024 1024 8 1 tte1.j2k)
-ADD_TEST(tte2 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 3 2048 2048 1024 1024 8 1 tte2.jp2)
-ADD_TEST(tte3 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 1 2048 2048 1024 1024 8 1 tte3.j2k)
-ADD_TEST(tte4 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 1 256 256 128 128 8 0 tte4.j2k)
-ADD_TEST(tte5 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 1 512 512 256 256 8 0 tte5.j2k)
+add_test(tte0 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder)
+add_test(tte1 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 3 2048 2048 1024 1024 8 1 tte1.j2k)
+add_test(tte2 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 3 2048 2048 1024 1024 8 1 tte2.jp2)
+add_test(tte3 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 1 2048 2048 1024 1024 8 1 tte3.j2k)
+add_test(tte4 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 1 256 256 128 128 8 0 tte4.j2k)
+add_test(tte5 ${EXECUTABLE_OUTPUT_PATH}/test_tile_encoder 1 512 512 256 256 8 0 tte5.j2k)
-ADD_EXECUTABLE(test_tile_decoder test_tile_decoder.c)
-TARGET_LINK_LIBRARIES(test_tile_decoder ${OPENJPEG_LIBRARY_NAME})
+add_executable(test_tile_decoder test_tile_decoder.c)
+target_link_libraries(test_tile_decoder ${OPENJPEG_LIBRARY_NAME})
-ADD_TEST(ttd0 ${EXECUTABLE_OUTPUT_PATH}/test_tile_decoder)
+add_test(ttd0 ${EXECUTABLE_OUTPUT_PATH}/test_tile_decoder)
set_property(TEST ttd0 APPEND PROPERTY DEPENDS tte0)
-ADD_TEST(ttd1 ${EXECUTABLE_OUTPUT_PATH}/test_tile_decoder 0 0 1024 1024 tte1.j2k)
+add_test(ttd1 ${EXECUTABLE_OUTPUT_PATH}/test_tile_decoder 0 0 1024 1024 tte1.j2k)
set_property(TEST ttd1 APPEND PROPERTY DEPENDS tte1)
-ADD_TEST(ttd2 ${EXECUTABLE_OUTPUT_PATH}/test_tile_decoder 0 0 1024 1024 tte2.jp2)
+add_test(ttd2 ${EXECUTABLE_OUTPUT_PATH}/test_tile_decoder 0 0 1024 1024 tte2.jp2)
set_property(TEST ttd2 APPEND PROPERTY DEPENDS tte2)
# No image send to the dashboard if lib PNG is not available.
-IF(NOT HAVE_LIBPNG)
- MESSAGE(WARNING "Lib PNG seems to be not available: if you want run the non-regression tests with images reported to the dashboard, you need it (try BUILD_THIRDPARTY)")
-ENDIF(NOT HAVE_LIBPNG)
+if(NOT HAVE_LIBPNG)
+ message(WARNING "Lib PNG seems to be not available: if you want run the non-regression tests with images reported to the dashboard, you need it (try BUILD_THIRDPARTY)")
+endif(NOT HAVE_LIBPNG)
-ADD_SUBDIRECTORY(conformance)
-ADD_SUBDIRECTORY(nonregression)
+add_subdirectory(conformance)
+add_subdirectory(nonregression)
-IF(BUILD_JPIP)
- IF(JPIP_SERVER)
- #SET(s "http://jpip.example.com/myFCGI?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream")
- SET(s "${JPIP_SERVER}?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream")
- SET(p "${CMAKE_CURRENT_BINARY_DIR}/jpip.dat")
- SET(md5 "62b00c620fb0a600c5ffd413cada4674")
- ADD_TEST(TestJPIP1 ${CMAKE_COMMAND} -DD_URL:STRING=${s} -DD_FILE:PATH=${p}
+if(BUILD_JPIP)
+ if(JPIP_SERVER)
+ #set(s "http://jpip.example.com/myFCGI?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream")
+ set(s "${JPIP_SERVER}?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream")
+ set(p "${CMAKE_CURRENT_BINARY_DIR}/jpip.dat")
+ set(md5 "62b00c620fb0a600c5ffd413cada4674")
+ add_test(TestJPIP1 ${CMAKE_COMMAND} -DD_URL:STRING=${s} -DD_FILE:PATH=${p}
-DEXPECTED_MD5=${md5} -P ${PROJECT_SOURCE_DIR}/CMake/JPIPTestDriver.cmake)
- ENDIF(JPIP_SERVER)
-ENDIF(BUILD_JPIP)
+ endif(JPIP_SERVER)
+endif(BUILD_JPIP)
# CONFORMANCE TESTS AND NON-REGRESSION ON THIS DATASET
-FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
-SET(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
-SET(BASELINE_CONF ${OPJ_DATA_ROOT}/baseline/conformance)
-SET(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression)
-SET(INPUT_CONF ${OPJ_DATA_ROOT}/input/conformance)
+set(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
+set(BASELINE_CONF ${OPJ_DATA_ROOT}/baseline/conformance)
+set(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression)
+set(INPUT_CONF ${OPJ_DATA_ROOT}/input/conformance)
# List of components by file (normaly p0_13.j2k have 257 components but for this
#set of test we consider only 4)
-SET( CP0_nbC_list "not_used;1;1;1;3;4;4;3;3;1;3;1;1;4;3;1;1")
-SET( CP1_nbC_list "not_used;1;3;4;1;3;3;2")
+set( CP0_nbC_list "not_used;1;1;1;3;4;4;3;3;1;3;1;1;4;3;1;1")
+set( CP1_nbC_list "not_used;1;3;4;1;3;3;2")
-SET(COMMENTCODEVAR FALSE)
+set(COMMENTCODEVAR FALSE)
#--------------------------------------------------------------------------
# non regression comparison
# Parameters and tolerances given by Table C.1
-SET( C0P0_ResFactor_list "not_used;0;0;0;3;3;3;0;5;2;0;0;0;0;2;0;0")
-SET( C0P0_PEAK_list "not_used;0;0;0;33;54;109;10;7;4;10;0;0;0;0;0;0")
-SET( C0P0_MSE_list "not_used;0;0;0;55.8;68;743;0.34;6.72;1.47;2.84;0;0;0;0;0;0")
+set( C0P0_ResFactor_list "not_used;0;0;0;3;3;3;0;5;2;0;0;0;0;2;0;0")
+set( C0P0_PEAK_list "not_used;0;0;0;33;54;109;10;7;4;10;0;0;0;0;0;0")
+set( C0P0_MSE_list "not_used;0;0;0;55.8;68;743;0.34;6.72;1.47;2.84;0;0;0;0;0;0")
-FOREACH(numFileC0P0 RANGE 1 16)
+foreach(numFileC0P0 RANGE 1 16)
# Build filenames
- IF(${numFileC0P0} LESS 10)
- SET( filenameInput p0_0${numFileC0P0}.j2k )
- SET( filenameRef c0p0_0${numFileC0P0}.pgx )
- ELSE(${numFileC0P0} LESS 10)
- SET( filenameInput p0_${numFileC0P0}.j2k )
- SET( filenameRef c0p0_${numFileC0P0}.pgx )
- ENDIF(${numFileC0P0} LESS 10)
+ if(${numFileC0P0} LESS 10)
+ set( filenameInput p0_0${numFileC0P0}.j2k )
+ set( filenameRef c0p0_0${numFileC0P0}.pgx )
+ else(${numFileC0P0} LESS 10)
+ set( filenameInput p0_${numFileC0P0}.j2k )
+ set( filenameRef c0p0_${numFileC0P0}.pgx )
+ endif(${numFileC0P0} LESS 10)
# Get corresponding tests parameters
list(GET C0P0_ResFactor_list ${numFileC0P0} ResFactor)
list(GET C0P0_MSE_list ${numFileC0P0} MSE_limit)
# Manage cases which need to try different resolution reduction
- IF (numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
+ if (numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
get_filename_component(filenameRefSub ${filenameRef} NAME_WE)
#r = 0
- ADD_TEST(ETS-C0P0-${filenameInput}-r0-decode
+ add_test(ETS-C0P0-${filenameInput}-r0-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c0${filenameInput}-r0.pgx
-r 0
)
- ADD_TEST(ETS-C0P0-${filenameInput}-r0-compare2ref
+ add_test(ETS-C0P0-${filenameInput}-r0-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRefSub}r0.pgx
-t ${TEMP}/c0${filenameInput}-r0.pgx
-s t_
)
- SET_TESTS_PROPERTIES(ETS-C0P0-${filenameInput}-r0-compare2ref
+ set_tests_properties(ETS-C0P0-${filenameInput}-r0-compare2ref
PROPERTIES DEPENDS
ETS-C0P0-${filenameInput}-r0-decode)
- ADD_TEST(NR-C0P0-${filenameInput}-r0-compare2base
+ add_test(NR-C0P0-${filenameInput}-r0-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx
-t ${TEMP}/c0${filenameInput}-r0.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C0P0-${filenameInput}-r0-compare2base
+ set_tests_properties(NR-C0P0-${filenameInput}-r0-compare2base
PROPERTIES DEPENDS
ETS-C0P0-${filenameInput}-r0-decode)
#r = 1
- ADD_TEST(ETS-C0P0-${filenameInput}-r1-decode
+ add_test(ETS-C0P0-${filenameInput}-r1-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c0${filenameInput}-r1.pgx
-r 1
)
- ADD_TEST(ETS-C0P0-${filenameInput}-r1-compare2ref
+ add_test(ETS-C0P0-${filenameInput}-r1-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRefSub}r1.pgx
-t ${TEMP}/c0${filenameInput}-r1.pgx
-s t_
)
- SET_TESTS_PROPERTIES(ETS-C0P0-${filenameInput}-r1-compare2ref
+ set_tests_properties(ETS-C0P0-${filenameInput}-r1-compare2ref
PROPERTIES DEPENDS
ETS-C0P0-${filenameInput}-r1-decode)
- ADD_TEST(NR-C0P0-${filenameInput}-r1-compare2base
+ add_test(NR-C0P0-${filenameInput}-r1-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRefSub}-r1.pgx
-t ${TEMP}/c0${filenameInput}-r1.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C0P0-${filenameInput}-r1-compare2base
+ set_tests_properties(NR-C0P0-${filenameInput}-r1-compare2base
PROPERTIES DEPENDS
ETS-C0P0-${filenameInput}-r1-decode)
- ELSE(numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
+ else(numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
- ADD_TEST(ETS-C0P0-${filenameInput}-decode
+ add_test(ETS-C0P0-${filenameInput}-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c0${filenameInput}.pgx
-r ${ResFactor}
)
- ADD_TEST(ETS-C0P0-${filenameInput}-compare2ref
+ add_test(ETS-C0P0-${filenameInput}-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRef}
-t ${TEMP}/c0${filenameInput}.pgx
-s t_
)
- SET_TESTS_PROPERTIES(ETS-C0P0-${filenameInput}-compare2ref
+ set_tests_properties(ETS-C0P0-${filenameInput}-compare2ref
PROPERTIES DEPENDS
ETS-C0P0-${filenameInput}-decode)
- ADD_TEST(NR-C0P0-${filenameInput}-compare2base
+ add_test(NR-C0P0-${filenameInput}-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRef}
-t ${TEMP}/c0${filenameInput}.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C0P0-${filenameInput}-compare2base
+ set_tests_properties(NR-C0P0-${filenameInput}-compare2base
PROPERTIES DEPENDS
ETS-C0P0-${filenameInput}-decode)
- ENDIF(numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
+ endif(numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15)
-ENDFOREACH(numFileC0P0)
+endforeach(numFileC0P0)
#--------------------------------------------------------------------------
# Tests about class 0 profile 1
# non regression comparison
# Parameters and tolerances given by Table C.4
-SET( C0P1_ResFactor_list "not_used;0;3;3;0;4;1;0")
-SET( C0P1_PEAK_list "not_used;0;35;28;2;128;128;0")
-SET( C0P1_MSE_list "not_used;0;74;18.8;0.550;16384;16384;0")
+set( C0P1_ResFactor_list "not_used;0;3;3;0;4;1;0")
+set( C0P1_PEAK_list "not_used;0;35;28;2;128;128;0")
+set( C0P1_MSE_list "not_used;0;74;18.8;0.550;16384;16384;0")
-FOREACH(numFileC0P1 RANGE 1 7)
+foreach(numFileC0P1 RANGE 1 7)
# Build filenames
- SET( filenameInput p1_0${numFileC0P1}.j2k )
- SET( filenameRef c0p1_0${numFileC0P1}.pgx )
+ set( filenameInput p1_0${numFileC0P1}.j2k )
+ set( filenameRef c0p1_0${numFileC0P1}.pgx )
# Get corresponding tests parameters
list(GET C0P1_ResFactor_list ${numFileC0P1} ResFactor)
list(GET C0P1_MSE_list ${numFileC0P1} MSE_limit)
# Manage cases which need to try different resolution reduction
- IF (numFileC0P1 EQUAL 4 )
+ if (numFileC0P1 EQUAL 4 )
get_filename_component(filenameRefSub ${filenameRef} NAME_WE)
#r = 0
- ADD_TEST(ETS-C0P1-${filenameInput}-r0-decode
+ add_test(ETS-C0P1-${filenameInput}-r0-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c0${filenameInput}-r0.pgx
-r 0
)
- ADD_TEST(ETS-C0P1-${filenameInput}-r0-compare2ref
+ add_test(ETS-C0P1-${filenameInput}-r0-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRefSub}r0.pgx
-t ${TEMP}/c0${filenameInput}-r0.pgx
-s t_
)
- SET_TESTS_PROPERTIES(ETS-C0P1-${filenameInput}-r0-compare2ref
+ set_tests_properties(ETS-C0P1-${filenameInput}-r0-compare2ref
PROPERTIES DEPENDS
ETS-C0P1-${filenameInput}-r0-decode)
- ADD_TEST(NR-C0P1-${filenameInput}-r0-compare2base
+ add_test(NR-C0P1-${filenameInput}-r0-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx
-t ${TEMP}/c0${filenameInput}-r0.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C0P1-${filenameInput}-r0-compare2base
+ set_tests_properties(NR-C0P1-${filenameInput}-r0-compare2base
PROPERTIES DEPENDS
ETS-C0P1-${filenameInput}-r0-decode)
#r = 3
- ADD_TEST(ETS-C0P1-${filenameInput}-r3-decode
+ add_test(ETS-C0P1-${filenameInput}-r3-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c0${filenameInput}-r3.pgx
-r 3
)
- ADD_TEST(ETS-C0P1-${filenameInput}-r3-compare2ref
+ add_test(ETS-C0P1-${filenameInput}-r3-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRefSub}r3.pgx
-t ${TEMP}/c0${filenameInput}-r3.pgx
-s t_
)
- SET_TESTS_PROPERTIES(ETS-C0P1-${filenameInput}-r3-compare2ref
+ set_tests_properties(ETS-C0P1-${filenameInput}-r3-compare2ref
PROPERTIES DEPENDS
ETS-C0P1-${filenameInput}-r3-decode)
- ADD_TEST(NR-C0P1-${filenameInput}-r3-compare2base
+ add_test(NR-C0P1-${filenameInput}-r3-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRefSub}-r3.pgx
-t ${TEMP}/c0${filenameInput}-r3.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C0P1-${filenameInput}-r3-compare2base
+ set_tests_properties(NR-C0P1-${filenameInput}-r3-compare2base
PROPERTIES DEPENDS
ETS-C0P1-${filenameInput}-r3-decode)
- ELSE(numFileC0P1 EQUAL 4)
+ else(numFileC0P1 EQUAL 4)
- ADD_TEST(ETS-C0P1-${filenameInput}-decode
+ add_test(ETS-C0P1-${filenameInput}-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c0${filenameInput}.pgx
-r ${ResFactor}
)
- ADD_TEST(ETS-C0P1-${filenameInput}-compare2ref
+ add_test(ETS-C0P1-${filenameInput}-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRef}
-t ${TEMP}/c0${filenameInput}.pgx
-s t_
)
- SET_TESTS_PROPERTIES(ETS-C0P1-${filenameInput}-compare2ref
+ set_tests_properties(ETS-C0P1-${filenameInput}-compare2ref
PROPERTIES DEPENDS
ETS-C0P1-${filenameInput}-decode)
- ADD_TEST(NR-C0P1-${filenameInput}-compare2base
+ add_test(NR-C0P1-${filenameInput}-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRef}
-t ${TEMP}/c0${filenameInput}.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C0P1-${filenameInput}-compare2base
+ set_tests_properties(NR-C0P1-${filenameInput}-compare2base
PROPERTIES DEPENDS
ETS-C0P1-${filenameInput}-decode)
- ENDIF(numFileC0P1 EQUAL 4)
+ endif(numFileC0P1 EQUAL 4)
-ENDFOREACH(numFileC0P1)
+endforeach(numFileC0P1)
#--------------------------------------------------------------------------
# Tests about class 1 profile 0
# non regression comparison
# Parameters and tolerances given by Table C.6
-SET( C1P0_ResFactor_list "not_used;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0")
-SET( C1P0_PEAK_list "not_used;0;0;0;5:4:6;2:2:2:0;635:403:378:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0")
-SET( C1P0_MSE_list "not_used;0;0;0;0.776:0.626:1.070;0.302:0.307:0.269:0;11287:6124:3968:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0")
+set( C1P0_ResFactor_list "not_used;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0")
+set( C1P0_PEAK_list "not_used;0;0;0;5:4:6;2:2:2:0;635:403:378:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0")
+set( C1P0_MSE_list "not_used;0;0;0;0.776:0.626:1.070;0.302:0.307:0.269:0;11287:6124:3968:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0")
-FOREACH(numFileC1P0 RANGE 1 16)
+foreach(numFileC1P0 RANGE 1 16)
# Build filenames
- IF(${numFileC1P0} LESS 10)
- SET( filenameInput p0_0${numFileC1P0}.j2k )
- SET( filenameRef c1p0_0${numFileC1P0}.pgx )
- ELSE(${numFileC1P0} LESS 10)
- SET( filenameInput p0_${numFileC1P0}.j2k )
- SET( filenameRef c1p0_${numFileC1P0}.pgx )
- ENDIF(${numFileC1P0} LESS 10)
+ if(${numFileC1P0} LESS 10)
+ set( filenameInput p0_0${numFileC1P0}.j2k )
+ set( filenameRef c1p0_0${numFileC1P0}.pgx )
+ else(${numFileC1P0} LESS 10)
+ set( filenameInput p0_${numFileC1P0}.j2k )
+ set( filenameRef c1p0_${numFileC1P0}.pgx )
+ endif(${numFileC1P0} LESS 10)
# Get corresponding tests parameters
list(GET CP0_nbC_list ${numFileC1P0} nbComponents)
list(GET C1P0_PEAK_list ${numFileC1P0} PEAK_limit)
list(GET C1P0_MSE_list ${numFileC1P0} MSE_limit)
- ADD_TEST(ETS-C1P0-${filenameInput}-decode
+ add_test(ETS-C1P0-${filenameInput}-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c1${filenameInput}.pgx
-r ${ResFactor}
)
- ADD_TEST(ETS-C1P0-${filenameInput}-compare2ref
+ add_test(ETS-C1P0-${filenameInput}-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRef}
-t ${TEMP}/c1${filenameInput}.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(ETS-C1P0-${filenameInput}-compare2ref
+ set_tests_properties(ETS-C1P0-${filenameInput}-compare2ref
PROPERTIES DEPENDS
ETS-C1P0-${filenameInput}-decode)
- ADD_TEST(NR-C1P0-${filenameInput}-compare2base
+ add_test(NR-C1P0-${filenameInput}-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRef}
-t ${TEMP}/c1${filenameInput}.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C1P0-${filenameInput}-compare2base
+ set_tests_properties(NR-C1P0-${filenameInput}-compare2base
PROPERTIES DEPENDS
ETS-C1P0-${filenameInput}-decode)
-ENDFOREACH(numFileC1P0)
+endforeach(numFileC1P0)
#--------------------------------------------------------------------------
# Tests about class 1 profile 1
# non regression comparison
# Parameters and tolerances given by Table C.7
-SET( C1P1_PEAK_list "not_used;0;5:4:6;2:2:1:0;624;40:40:40;2:2:2;0:0")
-SET( C1P1_MSE_list "not_used;0;0.765:0.616:1.051;0.3:0.210:0.200:0;3080;8.458:9.816:10.154;0.6:0.6:0.6;0:0")
+set( C1P1_PEAK_list "not_used;0;5:4:6;2:2:1:0;624;40:40:40;2:2:2;0:0")
+set( C1P1_MSE_list "not_used;0;0.765:0.616:1.051;0.3:0.210:0.200:0;3080;8.458:9.816:10.154;0.6:0.6:0.6;0:0")
-FOREACH(numFileC1P1 RANGE 1 7)
+foreach(numFileC1P1 RANGE 1 7)
# Build filenames
- SET( filenameInput p1_0${numFileC1P1}.j2k )
- SET( filenameRef c1p1_0${numFileC1P1}.pgx )
+ set( filenameInput p1_0${numFileC1P1}.j2k )
+ set( filenameRef c1p1_0${numFileC1P1}.pgx )
# Get corresponding tests parameters
list(GET CP1_nbC_list ${numFileC1P1} nbComponents)
list(GET C1P1_PEAK_list ${numFileC1P1} PEAK_limit)
list(GET C1P1_MSE_list ${numFileC1P1} MSE_limit)
- ADD_TEST(ETS-C1P1-${filenameInput}-decode
+ add_test(ETS-C1P1-${filenameInput}-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/c1${filenameInput}.pgx
-r 0
)
- ADD_TEST(ETS-C1P1-${filenameInput}-compare2ref
+ add_test(ETS-C1P1-${filenameInput}-compare2ref
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_CONF}/${filenameRef}
-t ${TEMP}/c1${filenameInput}.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(ETS-C1P1-${filenameInput}-compare2ref
+ set_tests_properties(ETS-C1P1-${filenameInput}-compare2ref
PROPERTIES DEPENDS
ETS-C1P1-${filenameInput}-decode)
- ADD_TEST(NR-C1P1-${filenameInput}-compare2base
+ add_test(NR-C1P1-${filenameInput}-compare2base
${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
-b ${BASELINE_NR}/opj_${filenameRef}
-t ${TEMP}/c1${filenameInput}.pgx
-s b_t_
)
- SET_TESTS_PROPERTIES(NR-C1P1-${filenameInput}-compare2base
+ set_tests_properties(NR-C1P1-${filenameInput}-compare2base
PROPERTIES DEPENDS
ETS-C1P1-${filenameInput}-decode)
-ENDFOREACH(numFileC1P1)
+endforeach(numFileC1P1)
#--------------------------------------------------------------------------
# Tests about JP2 file
# Tolerances given by Table G.1
-FOREACH(numFileJP2 RANGE 1 9)
+foreach(numFileJP2 RANGE 1 9)
# Build filenames
- SET( filenameInput "file${numFileJP2}.jp2" )
- SET( filenameRef jp2_${numFileJP2}.tif )
+ set( filenameInput "file${numFileJP2}.jp2" )
+ set( filenameRef jp2_${numFileJP2}.tif )
# Get corresponding tests parameters
list(GET JP2_PEAK_list ${numFileJP2} PEAK_limit)
- ADD_TEST(ETS-JP2-${filenameInput}-decode
+ add_test(ETS-JP2-${filenameInput}-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/${filenameInput}.tif
#
# FIXME: Need to implement a compare tif images function
#
-# ADD_TEST(ETS-JP2-${filenameInput}-compare2ref
+# add_test(ETS-JP2-${filenameInput}-compare2ref
# ${EXECUTABLE_OUTPUT_PATH}/compareTIFimages
# -b ${BASELINE_CONF}/${filenameRef_tif}
# -t ${TEMP}/${filenameInput}.pgx
# -p 4
# )
#
-# SET_TESTS_PROPERTIES(ETS-JP2-${filenameInput}-compare2ref
+# set_tests_properties(ETS-JP2-${filenameInput}-compare2ref
# PROPERTIES DEPENDS
# ETS-JP2-${filenameInput}-decode)
#
-# ADD_TEST(NR-JP2-${filenameInput}-compare2base
+# add_test(NR-JP2-${filenameInput}-compare2base
# ${EXECUTABLE_OUTPUT_PATH}/compareTIFimages
# -b ${BASELINE_NR}/opj_${filenameRef}
# -t ${TEMP}/${filenameInput}.tif
# -d
# )
#
-# SET_TESTS_PROPERTIES(NR-JP2-${filenameInput}-compare2base
+# set_tests_properties(NR-JP2-${filenameInput}-compare2base
# PROPERTIES DEPENDS
# ETS-JP2-${filenameInput}-decode)
-ENDFOREACH(numFileJP2)
+endforeach(numFileJP2)
#--------------------------------------------------------------------------#
#--------------------------------------------------------------------------#
# try to dump image and codestream informations into a file
# non regression comparison this file to the baseline
-FOREACH(numFileP0 RANGE 1 16)
+foreach(numFileP0 RANGE 1 16)
# Build filenames
- IF(${numFileP0} LESS 10)
- SET( filenameInput p0_0${numFileP0}.j2k )
- ELSE(${numFileP0} LESS 10)
- SET( filenameInput p0_${numFileP0}.j2k )
- ENDIF(${numFileP0} LESS 10)
+ if(${numFileP0} LESS 10)
+ set( filenameInput p0_0${numFileP0}.j2k )
+ else(${numFileP0} LESS 10)
+ set( filenameInput p0_${numFileP0}.j2k )
+ endif(${numFileP0} LESS 10)
get_filename_component(filenameRefSub ${filenameInput} NAME_WE)
- ADD_TEST(NR-${filenameInput}-dump
+ add_test(NR-${filenameInput}-dump
${EXECUTABLE_OUTPUT_PATH}/j2k_dump
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/${filenameInput}.txt
)
- ADD_TEST(NR-${filenameInput}-compare_dump2base
+ add_test(NR-${filenameInput}-compare_dump2base
${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
-b ${BASELINE_NR}/opj_v2_${filenameRefSub}.txt
-t ${TEMP}/${filenameInput}.txt
)
- SET_TESTS_PROPERTIES(NR-${filenameInput}-compare_dump2base
+ set_tests_properties(NR-${filenameInput}-compare_dump2base
PROPERTIES DEPENDS
NR-${filenameInput}-dump)
-ENDFOREACH(numFileP0)
+endforeach(numFileP0)
#--------------------------------------------------------------------------
# Tests about dump of profile 1 file
# try to dump image and codestream informations into a file
# non regression comparison this file to the baseline
-FOREACH(numFileP1 RANGE 1 7)
+foreach(numFileP1 RANGE 1 7)
# Build filenames
- SET( filenameInput p1_0${numFileP1}.j2k )
+ set( filenameInput p1_0${numFileP1}.j2k )
get_filename_component(filenameInputSub ${filenameInput} NAME_WE)
- ADD_TEST(NR-${filenameInput}-dump
+ add_test(NR-${filenameInput}-dump
${EXECUTABLE_OUTPUT_PATH}/j2k_dump
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/${filenameInput}.txt
)
- ADD_TEST(NR-${filenameInput}-compare_dump2base
+ add_test(NR-${filenameInput}-compare_dump2base
${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
-b ${BASELINE_NR}/opj_v2_${filenameInputSub}.txt
-t ${TEMP}/${filenameInput}.txt
)
- SET_TESTS_PROPERTIES(NR-${filenameInput}-compare_dump2base
+ set_tests_properties(NR-${filenameInput}-compare_dump2base
PROPERTIES DEPENDS
NR-${filenameInput}-dump)
-ENDFOREACH(numFileP1)
+endforeach(numFileP1)
#--------------------------------------------------------------------------
# Tests about dump of JP2 file
# try to dump image and codestream informations into a file
# non regression comparison this file to the baseline
-FOREACH(numFileJP2 RANGE 1 9)
+foreach(numFileJP2 RANGE 1 9)
# Build filenames
- SET( filenameInput "file${numFileJP2}.jp2" )
+ set( filenameInput "file${numFileJP2}.jp2" )
get_filename_component(filenameInputSub ${filenameInput} NAME_WE)
- ADD_TEST(NR-${filenameInput}-dump
+ add_test(NR-${filenameInput}-dump
${EXECUTABLE_OUTPUT_PATH}/j2k_dump
-i ${INPUT_CONF}/${filenameInput}
-o ${TEMP}/${filenameInput}.txt
)
- ADD_TEST(NR-${filenameInput}-compare_dump2base
+ add_test(NR-${filenameInput}-compare_dump2base
${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
-b ${BASELINE_NR}/opj_v2_${filenameInputSub}.txt
-t ${TEMP}/${filenameInput}.txt
)
- SET_TESTS_PROPERTIES(NR-${filenameInput}-compare_dump2base
+ set_tests_properties(NR-${filenameInput}-compare_dump2base
PROPERTIES DEPENDS
NR-${filenameInput}-dump)
-ENDFOREACH(numFileJP2)
\ No newline at end of file
+endforeach(numFileJP2)
\ No newline at end of file
# NON-REGRESSION TESTS ON THIS DATASET LOCATED ${OPJ_DATA_ROOT}/input/nonregression
-FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
-SET(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
-SET(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression)
-SET(INPUT_NR ${OPJ_DATA_ROOT}/input/nonregression)
+set(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary)
+set(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression)
+set(INPUT_NR ${OPJ_DATA_ROOT}/input/nonregression)
-SET(INPUT_NR_PATH ${INPUT_NR})
-SET(TEMP_PATH ${TEMP})
-SET(INPUT_CONF_PATH ${OPJ_DATA_ROOT}/input/conformance)
+set(INPUT_NR_PATH ${INPUT_NR})
+set(TEMP_PATH ${TEMP})
+set(INPUT_CONF_PATH ${OPJ_DATA_ROOT}/input/conformance)
# need kdu_expand if possible
find_package(KAKADU)
# Dump all files with the selected extension inside the input directory
# Define a list of file which should be gracefully rejected:
-SET(BLACKLIST_JPEG2000
+set(BLACKLIST_JPEG2000
empty
)
-FILE(GLOB_RECURSE OPJ_DATA_NR_LIST
+file(GLOB_RECURSE OPJ_DATA_NR_LIST
"${INPUT_NR}/*.j2k"
"${INPUT_NR}/*.j2c"
"${INPUT_NR}/*.jp2"
#"${INPUT_NR}/*.jpx"
)
-FOREACH(INPUT_FILENAME ${OPJ_DATA_NR_LIST})
- GET_FILENAME_COMPONENT(INPUT_FILENAME_NAME ${INPUT_FILENAME} NAME)
- GET_FILENAME_COMPONENT(INPUT_FILENAME_NAME_WE ${INPUT_FILENAME_NAME} NAME_WE)
- STRING(REGEX MATCH ${INPUT_FILENAME_NAME} bad_jpeg2000 ${BLACKLIST_JPEG2000})
+foreach(INPUT_FILENAME ${OPJ_DATA_NR_LIST})
+ get_filename_component(INPUT_FILENAME_NAME ${INPUT_FILENAME} NAME)
+ get_filename_component(INPUT_FILENAME_NAME_WE ${INPUT_FILENAME_NAME} NAME_WE)
+ string(REGEX MATCH ${INPUT_FILENAME_NAME} bad_jpeg2000 ${BLACKLIST_JPEG2000})
# Dump the input image
- ADD_TEST(NR-${INPUT_FILENAME_NAME}-dump
+ add_test(NR-${INPUT_FILENAME_NAME}-dump
${EXECUTABLE_OUTPUT_PATH}/j2k_dump
-i ${INPUT_FILENAME}
-o ${TEMP}/${INPUT_FILENAME_NAME}.txt
-v
)
- IF(bad_jpeg2000)
- SET_TESTS_PROPERTIES(NR-${INPUT_FILENAME_NAME}-dump
+ if(bad_jpeg2000)
+ set_tests_properties(NR-${INPUT_FILENAME_NAME}-dump
PROPERTIES WILL_FAIL TRUE)
- ELSE(bad_jpeg2000)
+ else(bad_jpeg2000)
# Compare the dump output with the baseline
- ADD_TEST(NR-${INPUT_FILENAME_NAME}-compare_dump2base
+ add_test(NR-${INPUT_FILENAME_NAME}-compare_dump2base
${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
-b ${BASELINE_NR}/opj_v2_${INPUT_FILENAME_NAME_WE}.txt
-t ${TEMP}/${INPUT_FILENAME_NAME}.txt
)
- SET_TESTS_PROPERTIES(NR-${INPUT_FILENAME_NAME}-compare_dump2base
+ set_tests_properties(NR-${INPUT_FILENAME_NAME}-compare_dump2base
PROPERTIES DEPENDS
NR-${INPUT_FILENAME_NAME}-dump)
- ENDIF(bad_jpeg2000)
+ endif(bad_jpeg2000)
-ENDFOREACH(INPUT_FILENAME)
+endforeach(INPUT_FILENAME)
#########################################################################
# to know which files processed and with which options.
# Configure the test suite file:
-CONFIGURE_FILE("test_suite.ctest.in"
+configure_file("test_suite.ctest.in"
"${CMAKE_CURRENT_BINARY_DIR}/test_suite.ctest"
@ONLY)
# Read the file into a list
-FILE(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/test_suite.ctest OPJ_TEST_CMD_LINE_LIST)
+file(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/test_suite.ctest OPJ_TEST_CMD_LINE_LIST)
# Try to find and configure and read another test suite file
-FILE(GLOB TEST_SUITE_FILES *.ctest.in)
-IF (TEST_SUITE_FILES)
- FOREACH(TEST_SUITE_FILE ${TEST_SUITE_FILES})
+file(GLOB TEST_SUITE_FILES *.ctest.in)
+if (TEST_SUITE_FILES)
+ foreach(TEST_SUITE_FILE ${TEST_SUITE_FILES})
# Avoid to process the official test suite
- SET(FILE_ALREADY_READ 0)
- GET_FILENAME_COMPONENT(TEST_SUITE_FILENAME ${TEST_SUITE_FILE} NAME)
- STRING(REGEX MATCH "^test_suite.ctest.in$" FILE_ALREADY_READ ${TEST_SUITE_FILENAME})
+ set(FILE_ALREADY_READ 0)
+ get_filename_component(TEST_SUITE_FILENAME ${TEST_SUITE_FILE} NAME)
+ string(REGEX MATCH "^test_suite.ctest.in$" FILE_ALREADY_READ ${TEST_SUITE_FILENAME})
- IF(NOT FILE_ALREADY_READ)
+ if(NOT FILE_ALREADY_READ)
# Configure the additional test suite file:
- GET_FILENAME_COMPONENT(TEST_SUITE_FILE_SUB ${TEST_SUITE_FILE} NAME_WE)
- CONFIGURE_FILE("${TEST_SUITE_FILE}"
+ get_filename_component(TEST_SUITE_FILE_SUB ${TEST_SUITE_FILE} NAME_WE)
+ configure_file("${TEST_SUITE_FILE}"
"${CMAKE_CURRENT_BINARY_DIR}/${TEST_SUITE_FILE_SUB}.ctest"
@ONLY)
# Read the additional file into a list
- FILE(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/${TEST_SUITE_FILE_SUB}.ctest OPJ_TEST_CMD_LINE_LIST_TEMP)
+ file(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/${TEST_SUITE_FILE_SUB}.ctest OPJ_TEST_CMD_LINE_LIST_TEMP)
# Append the list of command
- SET(OPJ_TEST_CMD_LINE_LIST ${OPJ_TEST_CMD_LINE_LIST} ${OPJ_TEST_CMD_LINE_LIST_TEMP})
+ set(OPJ_TEST_CMD_LINE_LIST ${OPJ_TEST_CMD_LINE_LIST} ${OPJ_TEST_CMD_LINE_LIST_TEMP})
- ENDIF(NOT FILE_ALREADY_READ)
+ endif(NOT FILE_ALREADY_READ)
- ENDFOREACH(TEST_SUITE_FILE)
+ endforeach(TEST_SUITE_FILE)
-ELSE(TEST_SUITE_FILES)
+else(TEST_SUITE_FILES)
- MESSAGE(FATAL_ERROR "One test suite should be available (test_suite.ctest.in) !!!")
+ message(FATAL_ERROR "One test suite should be available (test_suite.ctest.in) !!!")
-ENDIF(TEST_SUITE_FILES)
+endif(TEST_SUITE_FILES)
# Parse the command line found in the file(s)
-SET(IT_TEST_ENC 0)
-SET(IT_TEST_DEC 0)
-FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST})
+set(IT_TEST_ENC 0)
+set(IT_TEST_DEC 0)
+foreach(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST})
- SET(IGNORE_LINE_FOUND 0)
+ set(IGNORE_LINE_FOUND 0)
# Replace space by ; to generate a list
- STRING(REPLACE " " ";" CMD_ARG_LIST ${OPJ_TEST_CMD_LINE})
+ string(REPLACE " " ";" CMD_ARG_LIST ${OPJ_TEST_CMD_LINE})
# Check if the first argument begin by the comment sign
- LIST(GET CMD_ARG_LIST 0 EXE_NAME)
+ list(GET CMD_ARG_LIST 0 EXE_NAME)
- IF(EXE_NAME)
- STRING(REGEX MATCH "^#" IGNORE_LINE_FOUND ${EXE_NAME})
- ENDIF(EXE_NAME)
+ if(EXE_NAME)
+ string(REGEX MATCH "^#" IGNORE_LINE_FOUND ${EXE_NAME})
+ endif(EXE_NAME)
- IF(IGNORE_LINE_FOUND OR NOT EXE_NAME)
+ if(IGNORE_LINE_FOUND OR NOT EXE_NAME)
- #MESSAGE( STATUS "Current line is ignored: ${OPJ_TEST_CMD_LINE}")
+ #message( STATUS "Current line is ignored: ${OPJ_TEST_CMD_LINE}")
- ELSE(IGNORE_LINE_FOUND OR NOT EXE_NAME)
+ else(IGNORE_LINE_FOUND OR NOT EXE_NAME)
# Check if the first argument begin by the failed sign
- SET(FAILED_TEST_FOUND 0)
- STRING(REGEX MATCH "^!" FAILED_TEST_FOUND ${EXE_NAME})
+ set(FAILED_TEST_FOUND 0)
+ string(REGEX MATCH "^!" FAILED_TEST_FOUND ${EXE_NAME})
- IF (FAILED_TEST_FOUND)
+ if (FAILED_TEST_FOUND)
# Manage the different cases with the failed sign to remove the first argument which must be image_to_j2k
- SET(FAILED_TEST_FOUND_1 0)
- STRING(REGEX MATCH "^!image_to_j2k$|^!j2k_to_image$" FAILED_TEST_FOUND_1 ${EXE_NAME})
+ set(FAILED_TEST_FOUND_1 0)
+ string(REGEX MATCH "^!image_to_j2k$|^!j2k_to_image$" FAILED_TEST_FOUND_1 ${EXE_NAME})
- IF (FAILED_TEST_FOUND_1)
+ if (FAILED_TEST_FOUND_1)
- LIST(REMOVE_AT CMD_ARG_LIST 0)
+ list(REMOVE_AT CMD_ARG_LIST 0)
- ELSE (FAILED_TEST_FOUND_1)
+ else (FAILED_TEST_FOUND_1)
- SET(FAILED_TEST_FOUND_2 0)
- LIST(GET CMD_ARG_LIST 1 EXE_NAME)
- STRING(REGEX MATCH "^image_to_j2k$|^j2k_to_image$" FAILED_TEST_FOUND_2 ${EXE_NAME})
+ set(FAILED_TEST_FOUND_2 0)
+ list(GET CMD_ARG_LIST 1 EXE_NAME)
+ string(REGEX MATCH "^image_to_j2k$|^j2k_to_image$" FAILED_TEST_FOUND_2 ${EXE_NAME})
- IF (FAILED_TEST_FOUND_2)
+ if (FAILED_TEST_FOUND_2)
- LIST(REMOVE_AT CMD_ARG_LIST 0)
- LIST(REMOVE_AT CMD_ARG_LIST 0)
+ list(REMOVE_AT CMD_ARG_LIST 0)
+ list(REMOVE_AT CMD_ARG_LIST 0)
- ELSE (FAILED_TEST_FOUND_2)
+ else (FAILED_TEST_FOUND_2)
- MESSAGE( FATAL_ERROR "${EXE_NAME} is not the right executable name to encode file (try to use image_to_j2k or j2k_to_image)")
+ message( FATAL_ERROR "${EXE_NAME} is not the right executable name to encode file (try to use image_to_j2k or j2k_to_image)")
- ENDIF (FAILED_TEST_FOUND_2)
- ENDIF (FAILED_TEST_FOUND_1)
+ endif (FAILED_TEST_FOUND_2)
+ endif (FAILED_TEST_FOUND_1)
- ELSE (FAILED_TEST_FOUND)
+ else (FAILED_TEST_FOUND)
# Check if the first argument is equal to image_to_j2k
- STRING(REGEX MATCH "^image_to_j2k$|^j2k_to_image$" EXE_NAME_FOUND ${EXE_NAME})
+ string(REGEX MATCH "^image_to_j2k$|^j2k_to_image$" EXE_NAME_FOUND ${EXE_NAME})
- IF(EXE_NAME_FOUND)
+ if(EXE_NAME_FOUND)
- STRING(REGEX MATCH "image_to_j2k" ENC_TEST_FOUND ${EXE_NAME})
+ string(REGEX MATCH "image_to_j2k" ENC_TEST_FOUND ${EXE_NAME})
- ELSE(EXE_NAME_FOUND)
+ else(EXE_NAME_FOUND)
- MESSAGE( FATAL_ERROR "${EXE_NAME} is not the right executable name to encode file (try to use image_to_j2k)")
+ message( FATAL_ERROR "${EXE_NAME} is not the right executable name to encode file (try to use image_to_j2k)")
- ENDIF(EXE_NAME_FOUND)
+ endif(EXE_NAME_FOUND)
- LIST(REMOVE_AT CMD_ARG_LIST 0)
+ list(REMOVE_AT CMD_ARG_LIST 0)
- ENDIF (FAILED_TEST_FOUND)
+ endif (FAILED_TEST_FOUND)
# Parse the argument list to find the input filename and output filename
- SET(CMD_ARG_LIST_2 "")
- SET(ARG_POS 0)
- SET(INPUT_ARG_POS 0)
- SET(OUTPUT_ARG_POS 0)
+ set(CMD_ARG_LIST_2 "")
+ set(ARG_POS 0)
+ set(INPUT_ARG_POS 0)
+ set(OUTPUT_ARG_POS 0)
- FOREACH(CMD_ARG_ELT ${CMD_ARG_LIST})
+ foreach(CMD_ARG_ELT ${CMD_ARG_LIST})
math(EXPR ARG_POS "${ARG_POS}+1" )
- STRING(COMPARE EQUAL ${CMD_ARG_ELT} "-i" INPUT_ARG_FOUND)
- IF(INPUT_ARG_FOUND)
- SET(INPUT_ARG_POS ${ARG_POS})
- SET(INPUT_ARG_FOUND 0)
- ENDIF(INPUT_ARG_FOUND)
+ string(COMPARE EQUAL ${CMD_ARG_ELT} "-i" INPUT_ARG_FOUND)
+ if(INPUT_ARG_FOUND)
+ set(INPUT_ARG_POS ${ARG_POS})
+ set(INPUT_ARG_FOUND 0)
+ endif(INPUT_ARG_FOUND)
- STRING(COMPARE EQUAL ${CMD_ARG_ELT} "-o" OUTPUT_ARG_FOUND)
- IF(OUTPUT_ARG_FOUND)
- SET(OUTPUT_ARG_POS ${ARG_POS})
- SET(OUTPUT_ARG_FOUND 0)
- ENDIF(OUTPUT_ARG_FOUND)
+ string(COMPARE EQUAL ${CMD_ARG_ELT} "-o" OUTPUT_ARG_FOUND)
+ if(OUTPUT_ARG_FOUND)
+ set(OUTPUT_ARG_POS ${ARG_POS})
+ set(OUTPUT_ARG_FOUND 0)
+ endif(OUTPUT_ARG_FOUND)
- LIST (APPEND CMD_ARG_LIST_2 ${CMD_ARG_ELT})
+ list (APPEND CMD_ARG_LIST_2 ${CMD_ARG_ELT})
- ENDFOREACH(CMD_ARG_ELT)
+ endforeach(CMD_ARG_ELT)
- LIST(GET CMD_ARG_LIST_2 ${INPUT_ARG_POS} INPUT_FILENAME)
- GET_FILENAME_COMPONENT(INPUT_FILENAME_NAME ${INPUT_FILENAME} NAME)
- GET_FILENAME_COMPONENT(INPUT_FILENAME_NAME_WE ${INPUT_FILENAME_NAME} NAME_WE)
- LIST(GET CMD_ARG_LIST_2 ${OUTPUT_ARG_POS} OUTPUT_FILENAME)
- GET_FILENAME_COMPONENT(OUTPUT_FILENAME_NAME_WE ${OUTPUT_FILENAME} NAME_WE)
+ list(GET CMD_ARG_LIST_2 ${INPUT_ARG_POS} INPUT_FILENAME)
+ get_filename_component(INPUT_FILENAME_NAME ${INPUT_FILENAME} NAME)
+ get_filename_component(INPUT_FILENAME_NAME_WE ${INPUT_FILENAME_NAME} NAME_WE)
+ list(GET CMD_ARG_LIST_2 ${OUTPUT_ARG_POS} OUTPUT_FILENAME)
+ get_filename_component(OUTPUT_FILENAME_NAME_WE ${OUTPUT_FILENAME} NAME_WE)
#-----
# Now we can add the test suite corresponding to a line command in the file
#-----
# ENCODER TEST SUITE
- IF(ENC_TEST_FOUND)
+ if(ENC_TEST_FOUND)
math(EXPR IT_TEST_ENC "${IT_TEST_ENC}+1" )
# Encode an image into the jpeg2000 format
- ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode
+ add_test(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode
${EXECUTABLE_OUTPUT_PATH}/image_to_j2k
${CMD_ARG_LIST_2}
)
- IF(FAILED_TEST_FOUND)
- SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode PROPERTIES WILL_FAIL TRUE)
- ELSE(FAILED_TEST_FOUND)
+ if(FAILED_TEST_FOUND)
+ set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode PROPERTIES WILL_FAIL TRUE)
+ else(FAILED_TEST_FOUND)
# Dump the encoding file
- ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump
+ add_test(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump
${EXECUTABLE_OUTPUT_PATH}/j2k_dump
-i ${OUTPUT_FILENAME}
-o ${OUTPUT_FILENAME}-ENC-${IT_TEST_ENC}.txt
)
- SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump
+ set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump
PROPERTIES DEPENDS
NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode)
# Compare the dump file with the baseline
- ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dump2base
+ add_test(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dump2base
${EXECUTABLE_OUTPUT_PATH}/compare_dump_files
-b ${BASELINE_NR}/opj_v2_${OUTPUT_FILENAME_NAME_WE}-ENC-${IT_TEST_ENC}.txt
-t ${OUTPUT_FILENAME}-ENC-${IT_TEST_ENC}.txt
)
- SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dump2base
+ set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dump2base
PROPERTIES DEPENDS
NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-dump)
# Decode the encoding file with kakadu expand command
- IF (KDU_EXPAND_EXECUTABLE)
- ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
+ if (KDU_EXPAND_EXECUTABLE)
+ add_test(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
${KDU_EXPAND_EXECUTABLE}
-i ${OUTPUT_FILENAME}
-o ${OUTPUT_FILENAME}.raw
)
- SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
+ set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref
PROPERTIES DEPENDS
NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode)
# Compare the decoding file with baseline generated from the kdu_expand and baseline.j2k
- ADD_TEST(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base
+ add_test(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base
${EXECUTABLE_OUTPUT_PATH}/compareRAWimages
-b ${BASELINE_NR}/opj_${OUTPUT_FILENAME_NAME_WE}-ENC-${IT_TEST_ENC}.raw
-t ${OUTPUT_FILENAME}.raw
)
- SET_TESTS_PROPERTIES(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base
+ set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base
PROPERTIES DEPENDS
NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-decode-ref)
- ENDIF()
- ENDIF(FAILED_TEST_FOUND)
+ endif()
+ endif(FAILED_TEST_FOUND)
# DECODER TEST SUITE
- ELSE(ENC_TEST_FOUND)
+ else(ENC_TEST_FOUND)
math(EXPR IT_TEST_DEC "${IT_TEST_DEC}+1" )
# Decode the input image
- ADD_TEST(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode
+ add_test(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode
${EXECUTABLE_OUTPUT_PATH}/j2k_to_image
${CMD_ARG_LIST_2}
)
- IF(FAILED_TEST_FOUND)
+ if(FAILED_TEST_FOUND)
- SET_TESTS_PROPERTIES(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode PROPERTIES WILL_FAIL TRUE)
+ set_tests_properties(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode PROPERTIES WILL_FAIL TRUE)
- ELSE(FAILED_TEST_FOUND)
+ else(FAILED_TEST_FOUND)
# FIXME: add a compare2base function base on raw which
# can output png diff files if necesary
-# ADD_TEST(NR-${filename}-compare2base
+# add_test(NR-${filename}-compare2base
# ${EXECUTABLE_OUTPUT_PATH}/comparePGXimages
# -b ${BASELINE_NR}/opj_${filenameRef}
# -t ${TEMP}/${filename}.pgx
# -s b_t_
# )
#
-# SET_TESTS_PROPERTIES(NR-${filename}-compare2base
+# set_tests_properties(NR-${filename}-compare2base
# PROPERTIES DEPENDS
# NR-${filename}-decode)
- ENDIF(FAILED_TEST_FOUND)
+ endif(FAILED_TEST_FOUND)
- ENDIF(ENC_TEST_FOUND)
+ endif(ENC_TEST_FOUND)
- ENDIF(IGNORE_LINE_FOUND OR NOT EXE_NAME)
+ endif(IGNORE_LINE_FOUND OR NOT EXE_NAME)
-ENDFOREACH(OPJ_TEST_CMD_LINE)
+endforeach(OPJ_TEST_CMD_LINE)
projects / openjpeg / commitdiff