| # |
| # Copyright (C) 2023 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| # use this file except in compliance with the License. You may obtain a copy of |
| # the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations under |
| # the License. |
| # |
| |
| cmake_minimum_required(VERSION 3.15) |
| |
| # CMP0091: MSVC runtime library flags are selected by an abstraction. |
| # New in CMake 3.15. https://cmake.org/cmake/help/latest/policy/CMP0091.html |
| if(POLICY CMP0091) |
| cmake_policy(SET CMP0091 OLD) |
| endif() |
| |
| set(UHDR_MAJOR_VERSION 1) |
| set(UHDR_MINOR_VERSION 2) |
| set(UHDR_PATCH_VERSION 0) |
| project(libuhdr |
| VERSION ${UHDR_MAJOR_VERSION}.${UHDR_MINOR_VERSION}.${UHDR_PATCH_VERSION} |
| LANGUAGES C CXX |
| DESCRIPTION "Library for encoding and decoding ultrahdr images") |
| |
| ########################################################### |
| # Detect system |
| ########################################################### |
| if(${CMAKE_SYSTEM_NAME} MATCHES "Linux") |
| elseif(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten") |
| elseif(${CMAKE_SYSTEM_NAME} MATCHES "Android") |
| elseif(WIN32) |
| elseif(APPLE) |
| else() |
| message(FATAL_ERROR "Platform ${CMAKE_SYSTEM_NAME} not recognized") |
| endif() |
| |
| if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*") |
| if(CMAKE_SIZEOF_VOID_P EQUAL 8) |
| set(ARCH "amd64") |
| else() |
| set(ARCH "i386") |
| endif() |
| elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*") |
| set(ARCH "i386") |
| elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|arm64.*|ARM64.*)") |
| if(CMAKE_SIZEOF_VOID_P EQUAL 8) |
| set(ARCH "aarch64") |
| else() |
| set(ARCH "arm") |
| endif() |
| elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)") |
| set(ARCH "arm") |
| elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^riscv64") |
| set(ARCH "riscv64") |
| elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^loongarch64") |
| set(ARCH "loong64") |
| else() |
| message(FATAL_ERROR "Architecture: ${CMAKE_SYSTEM_PROCESSOR} not recognized") |
| endif() |
| |
| ########################################################### |
| # Directories |
| ########################################################### |
| set(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/lib) |
| set(THIRD_PARTY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third_party) |
| set(JAVA_DIR ${CMAKE_CURRENT_SOURCE_DIR}/java) |
| set(TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/tests) |
| set(BENCHMARK_DIR ${CMAKE_CURRENT_SOURCE_DIR}/benchmark) |
| set(FUZZERS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/fuzzer) |
| set(EXAMPLES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/examples) |
| set(EXPORT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) |
| |
| if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR) |
| message(WARNING "Selected in-source build. Preferably, create a build/ directory and build from there.") |
| endif() |
| |
| ########################################################### |
| # Options |
| ########################################################### |
| get_cmake_property(IS_MULTI GENERATOR_IS_MULTI_CONFIG) |
| if(NOT IS_MULTI) |
| if(NOT CMAKE_BUILD_TYPE) |
| message(STATUS "No build type chosen, selecting Release") |
| set(CMAKE_BUILD_TYPE "Release" CACHE STRING "The type of build: Debug Release MinSizeRel RelWithDebInfo." FORCE) |
| endif() |
| endif() |
| |
| if(EMSCRIPTEN) |
| # platform does not support dynamic linking? |
| message(STATUS "For wasm targets, selecting static only builds") |
| option(BUILD_SHARED_LIBS "Build shared libraries" FALSE) |
| elseif(NOT DEFINED BUILD_SHARED_LIBS) |
| message(STATUS "No target type chosen, selecting Shared") |
| option(BUILD_SHARED_LIBS "Build shared libraries" TRUE) |
| endif() |
| |
| function(option_if_not_defined name description default) |
| if(NOT DEFINED ${name}) |
| option(${name} ${description} ${default}) |
| endif() |
| endfunction() |
| |
| option_if_not_defined(UHDR_BUILD_EXAMPLES "Build sample application " TRUE) |
| option_if_not_defined(UHDR_BUILD_TESTS "Build unit tests " FALSE) |
| option_if_not_defined(UHDR_BUILD_BENCHMARK "Build benchmark tests " FALSE) |
| option_if_not_defined(UHDR_BUILD_FUZZERS "Build fuzz test applications " FALSE) |
| option_if_not_defined(UHDR_BUILD_DEPS "Build deps and not use pre-installed packages " FALSE) |
| option_if_not_defined(UHDR_BUILD_JAVA "Build JNI wrapper and Java front-end classes " FALSE) |
| option_if_not_defined(UHDR_BUILD_PACKAGING "Build distribution packages using CPack " FALSE) |
| |
| option_if_not_defined(UHDR_ENABLE_LOGS "Build with verbose logging " FALSE) |
| option_if_not_defined(UHDR_ENABLE_INSTALL "Enable install and uninstall targets for libuhdr package " TRUE) |
| option_if_not_defined(UHDR_ENABLE_INTRINSICS "Build with SIMD acceleration " TRUE) |
| option_if_not_defined(UHDR_ENABLE_GLES "Build with GPU acceleration " FALSE) |
| option_if_not_defined(UHDR_ENABLE_WERROR "Build with -Werror" FALSE) |
| |
| # pre-requisites |
| if(UHDR_BUILD_TESTS AND EMSCRIPTEN) |
| message(FATAL_ERROR "Building tests not supported for wasm targets") |
| endif() |
| |
| if(UHDR_BUILD_BENCHMARK AND WIN32) |
| message(FATAL_ERROR "Building benchmarks not supported in Windows") |
| endif() |
| |
| if(UHDR_BUILD_BENCHMARK AND EMSCRIPTEN) |
| message(FATAL_ERROR "Building benchmarks not supported for wasm targets") |
| endif() |
| |
| # side effects |
| if(CMAKE_CROSSCOMPILING AND UHDR_ENABLE_INSTALL) |
| set(UHDR_ENABLE_INSTALL FALSE) # disable install and uninstall targets during cross compilation. |
| message(STATUS "Install and uninstall targets - Disabled") |
| endif() |
| |
| if(UHDR_BUILD_FUZZERS AND NOT UHDR_BUILD_DEPS) |
| set(UHDR_BUILD_DEPS TRUE) # For fuzz testing its best to build all dependencies from source. |
| # This is to instrument dependency libs as well. |
| message(STATUS "Building dependencies from source - Enabled") |
| endif() |
| |
| if(DEFINED UHDR_SANITIZE_OPTIONS AND NOT UHDR_BUILD_DEPS) |
| set(UHDR_BUILD_DEPS TRUE) # If sanitize options are enabled, its best to build all dependencies from source. |
| # This is to instrument dependency libs as well. |
| message(STATUS "Building dependencies from source - Enabled") |
| endif() |
| |
| if(UHDR_BUILD_DEPS AND UHDR_ENABLE_INSTALL) |
| set(UHDR_ENABLE_INSTALL FALSE) # If dependencies are not chosen from installed packages but are built |
| # from source, its best to disallow system wide installation of |
| # uhdr to avoid possible abi/api conflicts. |
| message(STATUS "Install and uninstall targets - Disabled") |
| endif() |
| |
| ########################################################### |
| # Compile flags |
| ########################################################### |
| set(CMAKE_CXX_STANDARD 17) |
| set(CMAKE_CXX_STANDARD_REQUIRED ON) |
| set(CMAKE_CXX_EXTENSIONS OFF) |
| if(BUILD_SHARED_LIBS) |
| set(CMAKE_POSITION_INDEPENDENT_CODE ON) |
| set(CMAKE_CXX_VISIBILITY_PRESET hidden) |
| set(CMAKE_VISIBILITY_INLINES_HIDDEN YES) |
| set(UHDR_ENABLE_STATIC_LINKING OFF) |
| add_compile_options(-DUHDR_BUILDING_SHARED_LIBRARY) |
| else() |
| if(WIN32) |
| set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a) |
| else() |
| set(CMAKE_FIND_LIBRARY_SUFFIXES .a) |
| endif() |
| if(APPLE) |
| message(STATUS "Apple does not support statically linking an entire executable, disabling '-static' option") |
| set(UHDR_ENABLE_STATIC_LINKING OFF) |
| elseif(DEFINED UHDR_SANITIZE_OPTIONS OR UHDR_BUILD_FUZZERS) |
| message(STATUS "Possible that sanitizer libraries are only DSO's, disabling '-static' option") |
| set(UHDR_ENABLE_STATIC_LINKING OFF) |
| elseif(MSVC) |
| message(STATUS "Disabling '-static' option in MSVC platforms") |
| set(UHDR_ENABLE_STATIC_LINKING OFF) |
| else() |
| set(UHDR_ENABLE_STATIC_LINKING ON) |
| endif() |
| endif() |
| if(UHDR_ENABLE_LOGS) |
| add_compile_options(-DLOG_NDEBUG) |
| endif() |
| if(UHDR_ENABLE_INTRINSICS) |
| add_compile_options(-DUHDR_ENABLE_INTRINSICS) |
| endif() |
| |
| include(CheckCXXCompilerFlag) |
| function(CheckCompilerOption opt res) |
| set(CMAKE_REQUIRED_FLAGS ${opt}) |
| check_cxx_compiler_flag(${opt} ${res}) |
| unset(CMAKE_REQUIRED_FLAGS) |
| if(NOT ${res}) |
| message(FATAL_ERROR "Unsupported compiler option(s) ${opt}") |
| endif() |
| endfunction(CheckCompilerOption) |
| |
| if(DEFINED UHDR_SANITIZE_OPTIONS) |
| CheckCompilerOption("-fsanitize=${UHDR_SANITIZE_OPTIONS}" SUPPORTS_SAN_OPTIONS) |
| add_compile_options(-fsanitize=${UHDR_SANITIZE_OPTIONS}) |
| add_link_options(-fsanitize=${UHDR_SANITIZE_OPTIONS}) |
| endif() |
| |
| if(UHDR_BUILD_FUZZERS) |
| CheckCompilerOption("-fsanitize=fuzzer-no-link" fuzz) |
| add_compile_options(-fsanitize=fuzzer-no-link) |
| endif() |
| |
| set(UHDR_WERROR_FLAGS "") |
| if(MSVC) |
| add_definitions(-D_CRT_SECURE_NO_WARNINGS) |
| # Disable specific warnings |
| # TODO: None of these should be disabled, but for now, for a warning-free msvc build these are |
| # added. fix the warnings and remove these filters |
| add_compile_options(/wd4244) # conversion from 'type1' to 'type2', possible loss of data |
| add_compile_options(/wd4267) # conversion from 'size_t' to 'type' possible loss of data |
| add_compile_options(/wd4305) # truncation from 'double' to 'float' |
| add_compile_options(/wd4838) # conversion from 'type1' to 'type2' requires a narrowing conversion |
| add_compile_options(/wd26812) # Prefer enum class over enum |
| elseif(EMSCRIPTEN) |
| if(NOT UHDR_BUILD_DEPS) |
| include(CheckCSourceCompiles) |
| set(CMAKE_REQUIRED_FLAGS "--use-port=libjpeg") |
| set(CMAKE_REQUIRED_LINK_OPTIONS "--use-port=libjpeg") |
| check_c_source_compiles([=[ |
| #include <stdio.h> |
| #include <jpeglib.h> |
| int main(void) { |
| struct jpeg_compress_struct cinfo; |
| struct jpeg_error_mgr jerr; |
| cinfo.err=jpeg_std_error(&jerr); |
| jpeg_create_compress(&cinfo); |
| jpeg_destroy_compress(&cinfo); |
| return 0; |
| } |
| ]=] HAVE_JPEG) |
| if(NOT HAVE_JPEG) |
| message(FATAL_ERROR "Could NOT compile with --use-port=libjpeg, resolve this \ |
| or try 'cmake -DUHDR_BUILD_DEPS=1'") |
| endif() |
| endif() |
| else() |
| add_compile_options(-ffunction-sections) |
| add_compile_options(-fdata-sections) |
| add_compile_options(-fomit-frame-pointer) |
| add_compile_options(-ffp-contract=fast) |
| if(ARCH STREQUAL "i386") |
| add_compile_options(-m32) |
| add_compile_options(-march=i386) |
| add_compile_options(-mtune=generic) |
| elseif(ARCH STREQUAL "amd64") |
| add_compile_options(-m64) |
| add_compile_options(-march=x86-64) |
| add_compile_options(-mtune=generic) |
| elseif(ARCH STREQUAL "arm") |
| add_compile_options(-march=armv7-a) |
| add_compile_options(-marm) |
| if(NOT ANDROID_ABI) |
| add_compile_options(-mfloat-abi=hard) |
| endif() |
| add_compile_options(-mfpu=neon-vfpv3) |
| add_compile_options(-fno-lax-vector-conversions) |
| elseif(ARCH STREQUAL "aarch64") |
| add_compile_options(-march=armv8-a) |
| add_compile_options(-fno-lax-vector-conversions) |
| elseif(ARCH STREQUAL "riscv64") |
| add_compile_options(-march=rv64gc) |
| add_compile_options(-mabi=lp64d) |
| elseif(ARCH STREQUAL "loong64") |
| add_compile_options(-march=loongarch64) |
| add_compile_options(-mabi=lp64d) |
| endif() |
| |
| if(UHDR_ENABLE_WERROR) |
| CheckCompilerOption("-Werror" SUPPORTS_WERROR) |
| set(UHDR_WERROR_FLAGS "-Werror") |
| endif() |
| endif() |
| |
| ########################################################### |
| # Utils |
| ########################################################### |
| # copied from https://github.com/google/shaderc/blob/main/cmake/utils.cmake |
| macro(get_transitive_static_libs target out_list) |
| if(TARGET ${target}) |
| get_target_property(target_type ${target} TYPE) |
| if(target_type STREQUAL "STATIC_LIBRARY") |
| list(INSERT ${out_list} 0 ${target}) |
| get_target_property(libs ${target} LINK_LIBRARIES) |
| if(libs) |
| foreach(lib ${libs}) |
| get_transitive_static_libs(${lib} ${out_list}) |
| endforeach() |
| endif() |
| endif() |
| endif() |
| endmacro() |
| |
| # combine a list of static libraries in to a single library |
| function(combine_static_libs target output_target) |
| set(all_libs_list "") |
| get_transitive_static_libs(${target} all_libs_list) |
| foreach(lib IN LISTS all_libs_list) |
| target_sources(${output_target} PRIVATE $<TARGET_OBJECTS:${lib}>) |
| endforeach() |
| endfunction() |
| |
| ########################################################### |
| # Dependencies |
| ########################################################### |
| list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") |
| |
| if(${CMAKE_SYSTEM_NAME} MATCHES "Android") |
| if (UHDR_ENABLE_LOGS) |
| find_library(log-lib log QUIET) |
| if(NOT log-lib) |
| message(FATAL_ERROR "Could NOT find log library, retry after installing \ |
| log library at sysroot or try 'cmake -DUHDR_ENABLE_LOGS=0'") |
| else() |
| message(STATUS "Found log-lib: ${log-lib}") |
| endif() |
| endif() |
| endif() |
| |
| # Threads |
| set(CMAKE_THREAD_PREFER_PTHREAD ON) |
| set(THREADS_PREFER_PTHREAD_FLAG ON) |
| find_package(Threads REQUIRED) |
| |
| include(ExternalProject) |
| |
| get_directory_property(UHDR_COMPILE_FLAGS COMPILE_OPTIONS) |
| string (REPLACE ";" " " UHDR_COMPILE_FLAGS_STR "${UHDR_COMPILE_FLAGS}") |
| set(UHDR_CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${UHDR_COMPILE_FLAGS_STR}") |
| set(UHDR_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${UHDR_COMPILE_FLAGS_STR}") |
| set(UHDR_CMAKE_ARGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_C_FLAGS=${UHDR_CMAKE_C_FLAGS}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_CXX_FLAGS=${UHDR_CMAKE_CXX_FLAGS}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_CXX_FLAGS_MINSIZEREL=${CMAKE_CXX_FLAGS_MINSIZEREL}) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_CXX_FLAGS_RELWITHDEBINFO=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}) |
| if(BUILD_SHARED_LIBS) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_POSITION_INDEPENDENT_CODE=ON) |
| endif() |
| if(MSVC AND UHDR_BUILD_TESTS) |
| list(APPEND UHDR_CMAKE_ARGS "-Dgtest_force_shared_crt=ON") |
| endif() |
| if(DEFINED CMAKE_TOOLCHAIN_FILE) |
| list(APPEND UHDR_CMAKE_ARGS -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${CMAKE_TOOLCHAIN_FILE}) |
| endif() |
| if(DEFINED ANDROID_PLATFORM) |
| list(APPEND UHDR_CMAKE_ARGS -DANDROID_PLATFORM=${ANDROID_PLATFORM}) |
| endif() |
| if(DEFINED ANDROID_ABI) |
| list(APPEND UHDR_CMAKE_ARGS -DANDROID_ABI=${ANDROID_ABI}) |
| endif() |
| if(DEFINED UHDR_ANDROID_NDK_PATH) |
| list(APPEND UHDR_CMAKE_ARGS -DUHDR_ANDROID_NDK_PATH=${UHDR_ANDROID_NDK_PATH}) |
| endif() |
| |
| # opengl es libraries |
| if(UHDR_ENABLE_GLES) |
| find_package(EGL QUIET) |
| if(EGL_FOUND) |
| message(STATUS "Found EGL: ${EGL_LIBRARIES}") |
| find_package(OpenGLES3 QUIET) |
| if(OpenGLES3_FOUND) |
| message(STATUS "Found GLESv3: ${OPENGLES3_LIBRARIES} (API version \"${OpenGLES3_API_VERSION}\")") |
| else() |
| message(STATUS "Could NOT find GLESv3") |
| endif() |
| else() |
| message(STATUS "Could NOT find EGL") |
| endif() |
| if(EGL_FOUND AND OpenGLES3_FOUND) |
| add_compile_options(-DUHDR_ENABLE_GLES) |
| string(FIND "${OPENGLES3_LIBRARIES}" "GLESv3" result) |
| if(result GREATER -1) |
| set(UHDR_GL_DEPS "-lEGL -lGLESv3") |
| else() |
| set(UHDR_GL_DEPS "-lEGL -lGLESv2") |
| endif() |
| else() |
| set(UHDR_ENABLE_GLES FALSE) |
| endif() |
| endif() |
| |
| # libjpeg-turbo |
| if(NOT UHDR_BUILD_DEPS) |
| find_package(JPEG QUIET) |
| if(NOT JPEG_FOUND) |
| message(FATAL_ERROR "Could NOT find JPEG (missing: JPEG_LIBRARIES JPEG_INCLUDE_DIRS),\ |
| retry after installing JPEG library at sysroot or try 'cmake -DUHDR_BUILD_DEPS=1'") |
| else() |
| message(STATUS "Found JPEG: ${JPEG_LIBRARIES} (found version \"${JPEG_VERSION}\")") |
| endif() |
| endif() |
| |
| if(NOT JPEG_FOUND) |
| set(JPEGTURBO_TARGET_NAME turbojpeg) |
| set(JPEGTURBO_PREFIX_DIR ${CMAKE_CURRENT_BINARY_DIR}/${JPEGTURBO_TARGET_NAME}) |
| set(JPEGTURBO_SOURCE_DIR ${THIRD_PARTY_DIR}/${JPEGTURBO_TARGET_NAME}) |
| set(JPEGTURBO_BINARY_DIR ${JPEGTURBO_PREFIX_DIR}/src/${JPEGTURBO_TARGET_NAME}-build) |
| set(JPEG_INCLUDE_DIRS ${JPEGTURBO_SOURCE_DIR} ${JPEGTURBO_BINARY_DIR}) |
| if(MSVC) |
| set(JPEG_LIB ${CMAKE_STATIC_LIBRARY_PREFIX}jpeg-static${CMAKE_STATIC_LIBRARY_SUFFIX}) |
| else() |
| set(JPEG_LIB ${CMAKE_STATIC_LIBRARY_PREFIX}jpeg${CMAKE_STATIC_LIBRARY_SUFFIX}) |
| endif() |
| if(IS_MULTI) |
| set(JPEG_LIB_PREFIX ${JPEGTURBO_BINARY_DIR}/$<CONFIG>/) |
| else() |
| set(JPEG_LIB_PREFIX ${JPEGTURBO_BINARY_DIR}/) |
| endif() |
| set(JPEG_LIBRARIES ${JPEG_LIB_PREFIX}${JPEG_LIB}) |
| if(EMSCRIPTEN) |
| ExternalProject_Add(${JPEGTURBO_TARGET_NAME} |
| GIT_REPOSITORY https://github.com/libjpeg-turbo/libjpeg-turbo.git |
| GIT_TAG 3.0.1 |
| PREFIX ${JPEGTURBO_PREFIX_DIR} |
| SOURCE_DIR ${JPEGTURBO_SOURCE_DIR} |
| BINARY_DIR ${JPEGTURBO_BINARY_DIR} |
| CONFIGURE_COMMAND emcmake cmake ${JPEGTURBO_SOURCE_DIR} |
| -DENABLE_SHARED=0 -DWITH_SIMD=0 |
| BUILD_COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --config $<CONFIG> --target jpeg-static |
| BUILD_BYPRODUCTS ${JPEG_LIBRARIES} |
| INSTALL_COMMAND "" |
| ) |
| else() |
| ExternalProject_Add(${JPEGTURBO_TARGET_NAME} |
| GIT_REPOSITORY https://github.com/libjpeg-turbo/libjpeg-turbo.git |
| GIT_TAG 3.0.1 |
| PREFIX ${JPEGTURBO_PREFIX_DIR} |
| SOURCE_DIR ${JPEGTURBO_SOURCE_DIR} |
| BINARY_DIR ${JPEGTURBO_BINARY_DIR} |
| BUILD_COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --config $<CONFIG> --target jpeg-static |
| CMAKE_ARGS ${UHDR_CMAKE_ARGS} -DENABLE_SHARED=0 |
| BUILD_BYPRODUCTS ${JPEG_LIBRARIES} |
| INSTALL_COMMAND "" |
| ) |
| endif() |
| endif() |
| |
| if(UHDR_BUILD_JAVA) |
| # build jni and java util classes |
| find_package(Java REQUIRED) |
| if(${CMAKE_SYSTEM_NAME} MATCHES "Android") |
| find_package(JNI QUIET) |
| if(NOT JAVA_INCLUDE_PATH) |
| message(FATAL_ERROR "Could NOT find JNI Component") |
| else() |
| message(STATUS "Found JNI Component") |
| endif() |
| set(UHDR_JNI_INCLUDE_PATH ${JAVA_INCLUDE_PATH}) |
| else() |
| find_package(JNI REQUIRED) |
| set(UHDR_JNI_INCLUDE_PATH ${JNI_INCLUDE_DIRS}) |
| endif() |
| endif() |
| |
| if(UHDR_BUILD_TESTS) |
| # gtest and gmock |
| set(GTEST_TARGET_NAME googletest) |
| set(GTEST_PREFIX_DIR ${CMAKE_CURRENT_BINARY_DIR}/${GTEST_TARGET_NAME}) |
| set(GTEST_SOURCE_DIR ${THIRD_PARTY_DIR}/${GTEST_TARGET_NAME}) |
| set(GTEST_BINARY_DIR ${GTEST_PREFIX_DIR}/src/${GTEST_TARGET_NAME}-build) |
| set(GTEST_INCLUDE_DIRS |
| ${GTEST_SOURCE_DIR}/googletest/include |
| ${GTEST_SOURCE_DIR}/googlemock/include) |
| set(GTEST_LIB ${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}) |
| set(GTEST_LIB_MAIN ${CMAKE_STATIC_LIBRARY_PREFIX}gtest_main${CMAKE_STATIC_LIBRARY_SUFFIX}) |
| if(IS_MULTI) |
| set(GTEST_LIB_PREFIX ${GTEST_BINARY_DIR}/lib/$<CONFIG>/) |
| else() |
| set(GTEST_LIB_PREFIX ${GTEST_BINARY_DIR}/lib/) |
| endif() |
| set(GTEST_BOTH_LIBRARIES ${GTEST_LIB_PREFIX}${GTEST_LIB} ${GTEST_LIB_PREFIX}${GTEST_LIB_MAIN}) |
| ExternalProject_Add(${GTEST_TARGET_NAME} |
| GIT_REPOSITORY https://github.com/google/googletest |
| GIT_TAG v1.14.0 |
| PREFIX ${GTEST_PREFIX_DIR} |
| SOURCE_DIR ${GTEST_SOURCE_DIR} |
| BINARY_DIR ${GTEST_BINARY_DIR} |
| CMAKE_ARGS ${UHDR_CMAKE_ARGS} |
| BUILD_BYPRODUCTS ${GTEST_BOTH_LIBRARIES} |
| INSTALL_COMMAND "" |
| ) |
| endif() |
| |
| if(UHDR_BUILD_BENCHMARK) |
| # benchmark |
| set(BM_TARGET_NAME benchmark) |
| set(BM_PREFIX_DIR ${CMAKE_CURRENT_BINARY_DIR}/${BM_TARGET_NAME}) |
| set(BM_SOURCE_DIR ${THIRD_PARTY_DIR}/${BM_TARGET_NAME}) |
| set(BM_BINARY_DIR ${BM_PREFIX_DIR}/src/${BM_TARGET_NAME}-build) |
| set(BENCHMARK_INCLUDE_DIR ${BM_SOURCE_DIR}/include) |
| set(BM_LIB ${CMAKE_STATIC_LIBRARY_PREFIX}benchmark${CMAKE_STATIC_LIBRARY_SUFFIX}) |
| set(BM_LIB_MAIN ${CMAKE_STATIC_LIBRARY_PREFIX}benchmark_main${CMAKE_STATIC_LIBRARY_SUFFIX}) |
| if(IS_MULTI) |
| set(BM_LIB_PREFIX ${BM_BINARY_DIR}/src/$<CONFIG>/) |
| else() |
| set(BM_LIB_PREFIX ${BM_BINARY_DIR}/src/) |
| endif() |
| set(BENCHMARK_LIBRARIES ${BM_LIB_PREFIX}${BM_LIB} ${BM_LIB_PREFIX}${BM_LIB_MAIN}) |
| ExternalProject_Add(${BM_TARGET_NAME} |
| GIT_REPOSITORY https://github.com/google/benchmark.git |
| GIT_TAG v1.8.3 |
| PREFIX ${BM_PREFIX_DIR} |
| SOURCE_DIR ${BM_SOURCE_DIR} |
| BINARY_DIR ${BM_BINARY_DIR} |
| CMAKE_ARGS ${UHDR_CMAKE_ARGS} |
| -DBENCHMARK_ENABLE_TESTING=OFF |
| -DBENCHMARK_DOWNLOAD_DEPENDENCIES=OFF |
| BUILD_BYPRODUCTS ${BENCHMARK_LIBRARIES} |
| INSTALL_COMMAND "" |
| ) |
| endif() |
| |
| set_property(DIRECTORY PROPERTY ADDITIONAL_MAKE_CLEAN_FILES |
| ${JPEGTURBO_BINARY_DIR} ${GTEST_BINARY_DIR} ${BM_BINARY_DIR}) |
| |
| ########################################################### |
| # File Lists |
| ########################################################### |
| file(GLOB UHDR_CORE_SRCS_LIST "${SOURCE_DIR}/src/*.cpp") |
| if(UHDR_ENABLE_INTRINSICS) |
| if(ARCH STREQUAL "arm" OR ARCH STREQUAL "aarch64") |
| file(GLOB UHDR_CORE_NEON_SRCS_LIST "${SOURCE_DIR}/src/dsp/arm/*.cpp") |
| list(APPEND UHDR_CORE_SRCS_LIST ${UHDR_CORE_NEON_SRCS_LIST}) |
| endif() |
| endif() |
| if(UHDR_ENABLE_GLES) |
| file(GLOB UHDR_CORE_GLES_SRCS_LIST "${SOURCE_DIR}/src/gpu/*.cpp") |
| list(APPEND UHDR_CORE_SRCS_LIST ${UHDR_CORE_GLES_SRCS_LIST}) |
| endif() |
| if(UHDR_BUILD_JAVA) |
| file(GLOB UHDR_JNI_SRCS_LIST "${JAVA_DIR}/jni/*.cpp") |
| file(GLOB UHDR_JAVA_SRCS_LIST "${JAVA_DIR}/com/google/media/codecs/ultrahdr/*.java") |
| file(GLOB UHDR_APP_SRC "${JAVA_DIR}/UltraHdrApp.java") |
| endif() |
| file(GLOB UHDR_TEST_SRCS_LIST "${TESTS_DIR}/*.cpp") |
| file(GLOB UHDR_BM_SRCS_LIST "${BENCHMARK_DIR}/*.cpp") |
| file(GLOB IMAGE_IO_SRCS_LIST "${THIRD_PARTY_DIR}/image_io/src/**/*.cc") |
| |
| set(PRIVATE_INCLUDE_DIR ${SOURCE_DIR}/include/ ${JPEG_INCLUDE_DIRS}) |
| set(COMMON_LIBS_LIST ${JPEG_LIBRARIES} Threads::Threads) |
| |
| ########################################################### |
| # Targets |
| ########################################################### |
| set(IMAGEIO_TARGET_NAME image_io) |
| add_library(${IMAGEIO_TARGET_NAME} STATIC ${IMAGE_IO_SRCS_LIST}) |
| target_include_directories(${IMAGEIO_TARGET_NAME} PRIVATE |
| "${THIRD_PARTY_DIR}/image_io/includes" |
| "${THIRD_PARTY_DIR}/image_io/src/modp_b64" |
| "${THIRD_PARTY_DIR}/image_io/src/modp_b64/modp_b64") |
| |
| set(UHDR_CORE_LIB_NAME core) |
| add_library(${UHDR_CORE_LIB_NAME} STATIC ${UHDR_CORE_SRCS_LIST}) |
| target_compile_options(${UHDR_CORE_LIB_NAME} PRIVATE ${UHDR_WERROR_FLAGS}) |
| if(NOT JPEG_FOUND) |
| add_dependencies(${UHDR_CORE_LIB_NAME} ${JPEGTURBO_TARGET_NAME}) |
| endif() |
| if(NOT MSVC) |
| target_compile_options(${UHDR_CORE_LIB_NAME} PRIVATE -Wall -Wextra -Wshadow) |
| endif() |
| if(DEFINED UHDR_MAX_DIMENSION) |
| target_compile_options(${UHDR_CORE_LIB_NAME} PRIVATE -DUHDR_MAX_DIMENSION=${UHDR_MAX_DIMENSION}) |
| endif() |
| target_include_directories(${UHDR_CORE_LIB_NAME} PRIVATE |
| ${PRIVATE_INCLUDE_DIR} |
| "${THIRD_PARTY_DIR}/image_io/includes/" |
| ) |
| target_include_directories(${UHDR_CORE_LIB_NAME} PUBLIC ${EXPORT_INCLUDE_DIR}) |
| if(${CMAKE_SYSTEM_NAME} MATCHES "Android") |
| target_link_libraries(${UHDR_CORE_LIB_NAME} PUBLIC ${log-lib}) |
| endif() |
| if(UHDR_ENABLE_GLES) |
| target_link_libraries(${UHDR_CORE_LIB_NAME} PRIVATE ${EGL_LIBRARIES} ${OPENGLES3_LIBRARIES}) |
| endif() |
| target_link_libraries(${UHDR_CORE_LIB_NAME} PRIVATE ${COMMON_LIBS_LIST} ${IMAGEIO_TARGET_NAME}) |
| |
| if(UHDR_BUILD_EXAMPLES) |
| set(UHDR_SAMPLE_APP ultrahdr_app) |
| add_executable(${UHDR_SAMPLE_APP} "${EXAMPLES_DIR}/ultrahdr_app.cpp") |
| add_dependencies(${UHDR_SAMPLE_APP} ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(${UHDR_SAMPLE_APP} PRIVATE ${UHDR_WERROR_FLAGS}) |
| if(UHDR_BUILD_FUZZERS) |
| target_link_options(${UHDR_SAMPLE_APP} PRIVATE -fsanitize=fuzzer-no-link) |
| endif() |
| if(UHDR_ENABLE_STATIC_LINKING) |
| target_link_options(${UHDR_SAMPLE_APP} PRIVATE -static) |
| endif() |
| target_link_libraries(${UHDR_SAMPLE_APP} PRIVATE ${UHDR_CORE_LIB_NAME}) |
| endif() |
| |
| if(UHDR_BUILD_TESTS OR UHDR_BUILD_BENCHMARK) |
| include(CTest) |
| if(WIN32) |
| file(COPY "${TESTS_DIR}/data/" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/data") |
| else() |
| execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink |
| "${TESTS_DIR}/data/" "${CMAKE_CURRENT_BINARY_DIR}/data" |
| RESULT_VARIABLE result |
| ERROR_VARIABLE errorinfo) |
| string(FIND "${errorinfo}" "error" errorstatus) |
| if(result GREATER 0 OR errorstatus GREATER -1) |
| message(FATAL_ERROR "Creating sym link failed with info ${errorinfo}") |
| endif() |
| endif() |
| endif() |
| |
| if(UHDR_BUILD_TESTS) |
| add_executable(ultrahdr_unit_test ${UHDR_TEST_SRCS_LIST}) |
| add_dependencies(ultrahdr_unit_test ${GTEST_TARGET_NAME} ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(ultrahdr_unit_test PRIVATE ${UHDR_WERROR_FLAGS}) |
| target_include_directories(ultrahdr_unit_test PRIVATE |
| ${PRIVATE_INCLUDE_DIR} |
| ${GTEST_INCLUDE_DIRS} |
| ) |
| if(UHDR_BUILD_FUZZERS) |
| target_link_options(ultrahdr_unit_test PRIVATE -fsanitize=fuzzer-no-link) |
| endif() |
| target_link_libraries(ultrahdr_unit_test ${UHDR_CORE_LIB_NAME} ${GTEST_BOTH_LIBRARIES}) |
| add_test(NAME UHDRUnitTests, COMMAND ultrahdr_unit_test) |
| endif() |
| |
| if(UHDR_BUILD_BENCHMARK) |
| add_executable(ultrahdr_bm ${UHDR_BM_SRCS_LIST}) |
| add_dependencies(ultrahdr_bm ${BM_TARGET_NAME} ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(ultrahdr_bm PRIVATE ${UHDR_WERROR_FLAGS}) |
| target_include_directories(ultrahdr_bm PRIVATE |
| ${PRIVATE_INCLUDE_DIR} |
| ${BENCHMARK_INCLUDE_DIR} |
| ) |
| if(UHDR_BUILD_FUZZERS) |
| target_link_options(ultrahdr_bm PRIVATE -fsanitize=fuzzer-no-link) |
| endif() |
| target_link_libraries(ultrahdr_bm ${UHDR_CORE_LIB_NAME} ${BENCHMARK_LIBRARIES}) |
| |
| set(RES_FILE "${TESTS_DIR}/data/UltrahdrBenchmarkTestRes-1.2.zip") |
| set(RES_FILE_MD5SUM "31fc352444f95bc1ab4b9d6e397de6c1") |
| set(GET_RES_FILE TRUE) |
| if(EXISTS ${RES_FILE}) |
| file(MD5 ${RES_FILE} CURR_MD5_SUM) |
| if(CURR_MD5_SUM STREQUAL RES_FILE_MD5SUM) |
| message("Zip File already exists: " ${RES_FILE}) |
| set(GET_RES_FILE FALSE) |
| else() |
| file(REMOVE "${RES_FILE}") |
| endif() |
| endif() |
| |
| if(GET_RES_FILE) |
| message("-- Downloading benchmark test resources") |
| set(RES_URL "https://storage.googleapis.com/android_media/external/libultrahdr/benchmark/UltrahdrBenchmarkTestRes-1.2.zip") |
| file(DOWNLOAD ${RES_URL} ${RES_FILE} STATUS result EXPECTED_MD5 ${RES_FILE_MD5SUM}) |
| list(GET result 0 retval) |
| if(retval) |
| file(REMOVE "${RES_FILE}") |
| list(GET result 0 errcode) |
| list(GET result 1 info) |
| message(FATAL_ERROR "Error downloading ${RES_URL}: ${info} (${errcode})") |
| endif() |
| endif() |
| message("-- Extracting benchmark test resources") |
| execute_process(COMMAND "${CMAKE_COMMAND}" -E tar xf "${RES_FILE}" |
| WORKING_DIRECTORY "${TESTS_DIR}/data/" |
| RESULT_VARIABLE result |
| ERROR_VARIABLE errorinfo) |
| string(FIND "${errorinfo}" "error" errorstatus) |
| if(result GREATER 0 OR errorstatus GREATER -1) |
| message(FATAL_ERROR "Extracting benchmark test resources failed with info ${errorinfo}") |
| endif() |
| endif() |
| |
| if(UHDR_BUILD_FUZZERS) |
| add_executable(ultrahdr_enc_fuzzer ${FUZZERS_DIR}/ultrahdr_enc_fuzzer.cpp) |
| add_dependencies(ultrahdr_enc_fuzzer ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(ultrahdr_enc_fuzzer PRIVATE ${UHDR_WERROR_FLAGS}) |
| target_include_directories(ultrahdr_enc_fuzzer PRIVATE ${PRIVATE_INCLUDE_DIR}) |
| if(DEFINED ENV{LIB_FUZZING_ENGINE}) |
| target_link_options(ultrahdr_enc_fuzzer PRIVATE $ENV{LIB_FUZZING_ENGINE}) |
| else() |
| target_link_options(ultrahdr_enc_fuzzer PRIVATE -fsanitize=fuzzer) |
| endif() |
| target_link_libraries(ultrahdr_enc_fuzzer ${UHDR_CORE_LIB_NAME}) |
| |
| add_executable(ultrahdr_dec_fuzzer ${FUZZERS_DIR}/ultrahdr_dec_fuzzer.cpp) |
| add_dependencies(ultrahdr_dec_fuzzer ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(ultrahdr_dec_fuzzer PRIVATE ${UHDR_WERROR_FLAGS}) |
| target_include_directories(ultrahdr_dec_fuzzer PRIVATE ${PRIVATE_INCLUDE_DIR}) |
| if(DEFINED ENV{LIB_FUZZING_ENGINE}) |
| target_link_options(ultrahdr_dec_fuzzer PRIVATE $ENV{LIB_FUZZING_ENGINE}) |
| else() |
| target_link_options(ultrahdr_dec_fuzzer PRIVATE -fsanitize=fuzzer) |
| endif() |
| target_link_libraries(ultrahdr_dec_fuzzer ${UHDR_CORE_LIB_NAME}) |
| |
| add_executable(ultrahdr_legacy_fuzzer ${FUZZERS_DIR}/ultrahdr_legacy_fuzzer.cpp) |
| add_dependencies(ultrahdr_legacy_fuzzer ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(ultrahdr_legacy_fuzzer PRIVATE ${UHDR_WERROR_FLAGS}) |
| target_include_directories(ultrahdr_legacy_fuzzer PRIVATE ${PRIVATE_INCLUDE_DIR}) |
| if(DEFINED ENV{LIB_FUZZING_ENGINE}) |
| target_link_options(ultrahdr_legacy_fuzzer PRIVATE $ENV{LIB_FUZZING_ENGINE}) |
| else() |
| target_link_options(ultrahdr_legacy_fuzzer PRIVATE -fsanitize=fuzzer) |
| endif() |
| target_link_libraries(ultrahdr_legacy_fuzzer ${UHDR_CORE_LIB_NAME}) |
| endif() |
| |
| set(UHDR_TARGET_NAME uhdr) |
| add_library(${UHDR_TARGET_NAME}) |
| add_dependencies(${UHDR_TARGET_NAME} ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(${UHDR_TARGET_NAME} PRIVATE ${UHDR_WERROR_FLAGS}) |
| if(UHDR_ENABLE_GLES) |
| target_link_libraries(${UHDR_TARGET_NAME} PRIVATE ${EGL_LIBRARIES} ${OPENGLES3_LIBRARIES}) |
| endif() |
| if(${CMAKE_SYSTEM_NAME} MATCHES "Android") |
| target_link_libraries(${UHDR_TARGET_NAME} PRIVATE ${log-lib}) |
| endif() |
| target_link_libraries(${UHDR_TARGET_NAME} PRIVATE ${JPEG_LIBRARIES}) |
| set_target_properties(${UHDR_TARGET_NAME} |
| PROPERTIES PUBLIC_HEADER ultrahdr_api.h) |
| if(BUILD_SHARED_LIBS) |
| # If target is STATIC no need to set VERSION and SOVERSION |
| set_target_properties(${UHDR_TARGET_NAME} |
| PROPERTIES VERSION ${PROJECT_VERSION} |
| SOVERSION ${PROJECT_VERSION_MAJOR}) |
| endif() |
| combine_static_libs(${UHDR_CORE_LIB_NAME} ${UHDR_TARGET_NAME}) |
| |
| # Build static library as well |
| if(BUILD_SHARED_LIBS) |
| set(UHDR_TARGET_NAME_STATIC uhdr-static) |
| add_library(${UHDR_TARGET_NAME_STATIC} STATIC) |
| add_dependencies(${UHDR_TARGET_NAME_STATIC} ${UHDR_CORE_LIB_NAME}) |
| target_compile_options(${UHDR_TARGET_NAME_STATIC} PRIVATE ${UHDR_WERROR_FLAGS}) |
| if(UHDR_ENABLE_GLES) |
| target_link_libraries(${UHDR_TARGET_NAME_STATIC} PRIVATE ${EGL_LIBRARIES} ${OPENGLES3_LIBRARIES}) |
| endif() |
| if(${CMAKE_SYSTEM_NAME} MATCHES "Android") |
| target_link_libraries(${UHDR_TARGET_NAME_STATIC} PRIVATE ${log-lib}) |
| endif() |
| target_link_libraries(${UHDR_TARGET_NAME_STATIC} PRIVATE ${JPEG_LIBRARIES}) |
| combine_static_libs(${UHDR_CORE_LIB_NAME} ${UHDR_TARGET_NAME_STATIC}) |
| if(NOT MSVC) |
| set_target_properties(${UHDR_TARGET_NAME_STATIC} |
| PROPERTIES OUTPUT_NAME ${UHDR_TARGET_NAME}) |
| endif() |
| endif() |
| |
| if(UHDR_BUILD_JAVA) |
| include(UseJava) |
| |
| set(UHDR_JNI_TARGET_NAME uhdrjni) |
| add_library(${UHDR_JNI_TARGET_NAME} SHARED ${UHDR_JNI_SRCS_LIST}) |
| add_dependencies(${UHDR_JNI_TARGET_NAME} ${UHDR_TARGET_NAME}) |
| target_include_directories(${UHDR_JNI_TARGET_NAME} PRIVATE ${UHDR_JNI_INCLUDE_PATH} ${EXPORT_INCLUDE_DIR}) |
| target_compile_options(${UHDR_JNI_TARGET_NAME} PRIVATE ${UHDR_WERROR_FLAGS}) |
| target_link_libraries(${UHDR_JNI_TARGET_NAME} PRIVATE ${UHDR_TARGET_NAME}) |
| |
| add_jar(uhdr-java SOURCES ${UHDR_JAVA_SRCS_LIST} ${UHDR_APP_SRC} ENTRY_POINT UltraHdrApp) |
| endif() |
| |
| if(UHDR_ENABLE_INSTALL) |
| if(NOT(MSVC OR XCODE)) |
| include(GNUInstallDirs) |
| |
| # pkg-config: libuhdr.pc |
| configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/libuhdr.pc.in" |
| "${CMAKE_CURRENT_BINARY_DIR}/libuhdr.pc" @ONLY NEWLINE_STYLE UNIX) |
| install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libuhdr.pc" |
| DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") |
| install(TARGETS ${UHDR_TARGET_NAME} ${UHDR_TARGET_NAME_STATIC} ${UHDR_SAMPLE_APP} |
| RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" |
| LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" |
| ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" |
| PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") |
| if(BUILD_SHARED_LIBS) |
| if(APPLE) |
| install(CODE "message(STATUS \"You may need to add path \" |
| \"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/ \" |
| \"to DYLD_FALLBACK_LIBRARY_PATH if binaries are unable to load uhdr library \n\" |
| \"e.g. export DYLD_FALLBACK_LIBRARY_PATH=$DYLD_FALLBACK_LIBRARY_PATH:${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/ \")") |
| elseif(UNIX) |
| install(CODE "message(STATUS \"You may need to add path \" |
| \"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/ \" |
| \"to LD_LIBRARY_PATH if binaries are unable to load uhdr library \n\" |
| \"e.g. export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/ \")") |
| endif() |
| endif() |
| |
| configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" |
| "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) |
| add_custom_target(uninstall |
| COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) |
| |
| # packaging |
| if(UHDR_BUILD_PACKAGING) |
| include(cmake/package.cmake) |
| include(CPack) |
| endif() |
| |
| endif() |
| endif() |
