mirror of
https://github.com/opencv/opencv.git
synced 2026-09-11 12:52:33 -05:00
a859f3feff
When a user disables a bundled image-codec dependency (e.g. BUILD_ZLIB=OFF) to supply an external build but find_package() cannot locate it, OpenCVFindLibsGrfmt.cmake silently falls back to compiling the bundled 3rdparty version. As reported in the issue, this is misleading: the editable ZLIB_LIBRARY_DEBUG/RELEASE cache entries have no effect after the fallback and nothing points the user at the real knob (ZLIB_ROOT / ZLIB_DIR). Emit a message(WARNING) in each fallback branch, guarded by NOT BUILD_<lib>, so the built-in fallback is no longer silent when the user explicitly opted out of the bundled build. The warning names the correct search variables for that library and points to the CMake find_package / Find<lib> documentation. Applied consistently to the zlib, libjpeg, libtiff, libpng and libwebp fallback branches. The existing fallback behavior is intentionally left unchanged, so configurations that rely on the built-in fallback continue to build. Fixes #26746
492 lines
18 KiB
CMake
492 lines
18 KiB
CMake
# ----------------------------------------------------------------------------
|
|
# Detect 3rd-party image IO libraries
|
|
# ----------------------------------------------------------------------------
|
|
|
|
# --- zlib (required) ---
|
|
if(WITH_ZLIB_NG)
|
|
ocv_clear_vars(ZLIB_LIBRARY ZLIB_LIBRARIES ZLIB_INCLUDE_DIR)
|
|
set(ZLIB_LIBRARY zlib CACHE INTERNAL "")
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/zlib-ng")
|
|
set(ZLIB_INCLUDE_DIR "${${ZLIB_LIBRARY}_BINARY_DIR}" CACHE INTERNAL "")
|
|
set(ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR})
|
|
set(ZLIB_LIBRARIES ${ZLIB_LIBRARY})
|
|
|
|
ocv_parse_header_version(ZLIB "${${ZLIB_LIBRARY}_SOURCE_DIR}/zlib.h.in" ZLIB_VERSION)
|
|
ocv_parse_header_version(ZLIBNG "${${ZLIB_LIBRARY}_SOURCE_DIR}/zlib.h.in" ZLIBNG_VERSION)
|
|
|
|
set(HAVE_ZLIB_NG YES)
|
|
else()
|
|
if(BUILD_ZLIB)
|
|
ocv_clear_vars(ZLIB_FOUND)
|
|
else()
|
|
ocv_clear_internal_cache_vars(ZLIB_LIBRARY ZLIB_INCLUDE_DIR)
|
|
if(ANDROID)
|
|
set(_zlib_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .so)
|
|
endif()
|
|
if(QNX)
|
|
set(ZLIB_FOUND TRUE)
|
|
set(ZLIB_LIBRARY z)
|
|
set(ZLIB_LIBRARIES z)
|
|
else()
|
|
find_package(ZLIB "${MIN_VER_ZLIB}")
|
|
endif()
|
|
if(ANDROID)
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_zlib_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
unset(_zlib_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES)
|
|
endif()
|
|
if(ZLIB_FOUND AND ANDROID)
|
|
if(ZLIB_LIBRARY MATCHES "/usr/lib.*/libz.so$")
|
|
set(ZLIB_LIBRARY z)
|
|
set(ZLIB_LIBRARIES z)
|
|
set(ZLIB_LIBRARY_RELEASE z)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(NOT ZLIB_FOUND)
|
|
if(NOT BUILD_ZLIB)
|
|
message(WARNING "ZLIB library has not been found, falling back to built-in version. "
|
|
"Set ZLIB_ROOT or ZLIB_DIR variable so that find_package(ZLIB) would be able to find it. "
|
|
"See find_package and FindZLIB cmake documentation for details.")
|
|
endif()
|
|
ocv_clear_vars(ZLIB_LIBRARY ZLIB_LIBRARIES ZLIB_INCLUDE_DIR)
|
|
|
|
set(ZLIB_LIBRARY zlib CACHE INTERNAL "")
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/zlib")
|
|
set(ZLIB_INCLUDE_DIR "${${ZLIB_LIBRARY}_SOURCE_DIR}" "${${ZLIB_LIBRARY}_BINARY_DIR}" CACHE INTERNAL "")
|
|
set(ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR})
|
|
set(ZLIB_LIBRARIES ${ZLIB_LIBRARY})
|
|
|
|
ocv_parse_header_version(ZLIB "${${ZLIB_LIBRARY}_SOURCE_DIR}/zlib.h" ZLIB_VERSION)
|
|
endif()
|
|
endif()
|
|
|
|
# --- libavif (optional) ---
|
|
|
|
if(WITH_AVIF)
|
|
ocv_clear_internal_cache_vars(AVIF_LIBRARY AVIF_INCLUDE_DIR)
|
|
include(cmake/OpenCVFindAVIF.cmake)
|
|
if(AVIF_FOUND)
|
|
set(HAVE_AVIF 1)
|
|
endif()
|
|
endif()
|
|
|
|
# --- libjpeg (optional) ---
|
|
if(WITH_JPEG)
|
|
if(BUILD_JPEG)
|
|
ocv_clear_vars(JPEG_FOUND)
|
|
else()
|
|
ocv_clear_internal_cache_vars(JPEG_LIBRARY JPEG_INCLUDE_DIR)
|
|
if(QNX)
|
|
set(JPEG_LIBRARY jpeg)
|
|
set(JPEG_LIBRARIES jpeg)
|
|
set(JPEG_FOUND TRUE)
|
|
else()
|
|
include(FindJPEG)
|
|
endif()
|
|
endif()
|
|
|
|
if(NOT JPEG_FOUND)
|
|
if(NOT BUILD_JPEG)
|
|
message(WARNING "JPEG library has not been found, falling back to built-in version. "
|
|
"Add the external installation prefix to CMAKE_PREFIX_PATH, or set JPEG_INCLUDE_DIR "
|
|
"and JPEG_LIBRARY, so that FindJPEG can locate it. "
|
|
"See FindJPEG cmake documentation for details.")
|
|
endif()
|
|
ocv_clear_vars(JPEG_LIBRARY JPEG_INCLUDE_DIR)
|
|
|
|
if(NOT BUILD_JPEG_TURBO_DISABLE)
|
|
set(JPEG_LIBRARY libjpeg-turbo CACHE INTERNAL "")
|
|
set(JPEG_LIBRARIES ${JPEG_LIBRARY})
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libjpeg-turbo")
|
|
set(JPEG_INCLUDE_DIR "${${JPEG_LIBRARY}_SOURCE_DIR}/src" CACHE INTERNAL "")
|
|
else()
|
|
set(JPEG_LIBRARY libjpeg CACHE INTERNAL "")
|
|
set(JPEG_LIBRARIES ${JPEG_LIBRARY})
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libjpeg")
|
|
set(JPEG_INCLUDE_DIR "${${JPEG_LIBRARY}_SOURCE_DIR}" CACHE INTERNAL "")
|
|
endif()
|
|
set(JPEG_INCLUDE_DIRS "${JPEG_INCLUDE_DIR}")
|
|
endif()
|
|
|
|
macro(ocv_detect_jpeg_version header_file)
|
|
if(NOT DEFINED JPEG_LIB_VERSION AND EXISTS "${header_file}")
|
|
ocv_parse_header("${header_file}" JPEG_VERSION_LINES JPEG_LIB_VERSION)
|
|
|
|
if(DEFINED JPEG_LIB_VERSION)
|
|
# Extract libjpeg-turbo version from the header file if JPEG_LIB_VERSION is found.
|
|
file(STRINGS "${header_file}" JPEG_TURBO_VERSION_LINE REGEX "^#define[\t ]+LIBJPEG_TURBO_VERSION[\t ]")
|
|
|
|
if(JPEG_TURBO_VERSION_LINE)
|
|
# Support both raw values (e.g., 3.1.2) and quoted strings (e.g., "3.1.2").
|
|
string(REGEX REPLACE "^#define[\t ]+LIBJPEG_TURBO_VERSION[\t ]+\"?([^\"]+)\"?.*" "\\1" JPEG_TURBO_VERSION_STRING "${JPEG_TURBO_VERSION_LINE}")
|
|
if(JPEG_TURBO_VERSION_STRING)
|
|
string(STRIP "${JPEG_TURBO_VERSION_STRING}" JPEG_TURBO_VERSION_STRING)
|
|
set(JPEG_LIB_VERSION "${JPEG_TURBO_VERSION_STRING}-${JPEG_LIB_VERSION}")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endmacro()
|
|
|
|
ocv_detect_jpeg_version("${JPEG_INCLUDE_DIR}/jpeglib.h")
|
|
if(DEFINED CMAKE_CXX_LIBRARY_ARCHITECTURE)
|
|
ocv_detect_jpeg_version("${JPEG_INCLUDE_DIR}/${CMAKE_CXX_LIBRARY_ARCHITECTURE}/jconfig.h")
|
|
endif()
|
|
# no needed for strict platform check here, both files 64/32 should contain the same version
|
|
ocv_detect_jpeg_version("${JPEG_INCLUDE_DIR}/jconfig-64.h")
|
|
ocv_detect_jpeg_version("${JPEG_INCLUDE_DIR}/jconfig-32.h")
|
|
ocv_detect_jpeg_version("${JPEG_INCLUDE_DIR}/jconfig.h")
|
|
ocv_detect_jpeg_version("${${JPEG_LIBRARY}_BINARY_DIR}/jconfig.h")
|
|
if(NOT DEFINED JPEG_LIB_VERSION)
|
|
set(JPEG_LIB_VERSION "unknown")
|
|
endif()
|
|
set(HAVE_JPEG YES)
|
|
endif()
|
|
|
|
# --- libtiff (optional, should be searched after zlib and libjpeg) ---
|
|
if(WITH_TIFF)
|
|
if(BUILD_TIFF)
|
|
ocv_clear_vars(TIFF_FOUND)
|
|
else()
|
|
ocv_clear_internal_cache_vars(TIFF_LIBRARY TIFF_INCLUDE_DIR)
|
|
if(QNX)
|
|
set(TIFF_LIBRARY tiff)
|
|
set(TIFF_LIBRARIES tiff)
|
|
set(TIFF_FOUND TRUE)
|
|
else()
|
|
include(FindTIFF)
|
|
endif()
|
|
if(TIFF_FOUND)
|
|
ocv_parse_header("${TIFF_INCLUDE_DIR}/tiff.h" TIFF_VERSION_LINES TIFF_VERSION_CLASSIC TIFF_VERSION_BIG TIFF_VERSION TIFF_BIGTIFF_VERSION)
|
|
endif()
|
|
endif()
|
|
|
|
if(NOT TIFF_FOUND)
|
|
if(NOT BUILD_TIFF)
|
|
message(WARNING "TIFF library has not been found, falling back to built-in version. "
|
|
"Add the external installation prefix to CMAKE_PREFIX_PATH, or set TIFF_INCLUDE_DIR "
|
|
"and TIFF_LIBRARY, so that FindTIFF can locate it. "
|
|
"See FindTIFF cmake documentation for details.")
|
|
endif()
|
|
ocv_clear_vars(TIFF_LIBRARY TIFF_LIBRARIES TIFF_INCLUDE_DIR)
|
|
|
|
set(TIFF_LIBRARY libtiff CACHE INTERNAL "")
|
|
set(TIFF_LIBRARIES ${TIFF_LIBRARY})
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libtiff")
|
|
set(TIFF_INCLUDE_DIR "${${TIFF_LIBRARY}_SOURCE_DIR}" "${${TIFF_LIBRARY}_BINARY_DIR}" CACHE INTERNAL "")
|
|
ocv_parse_header("${${TIFF_LIBRARY}_SOURCE_DIR}/tiff.h" TIFF_VERSION_LINES TIFF_VERSION_CLASSIC TIFF_VERSION_BIG TIFF_VERSION TIFF_BIGTIFF_VERSION)
|
|
endif()
|
|
|
|
if(TIFF_VERSION_CLASSIC AND NOT TIFF_VERSION)
|
|
set(TIFF_VERSION ${TIFF_VERSION_CLASSIC})
|
|
endif()
|
|
|
|
if(TIFF_BIGTIFF_VERSION AND NOT TIFF_VERSION_BIG)
|
|
set(TIFF_VERSION_BIG ${TIFF_BIGTIFF_VERSION})
|
|
endif()
|
|
|
|
if(NOT TIFF_VERSION_STRING AND TIFF_INCLUDE_DIR)
|
|
foreach(_TIFF_INCLUDE_DIR IN LISTS TIFF_INCLUDE_DIR)
|
|
if(EXISTS "${_TIFF_INCLUDE_DIR}/tiffvers.h")
|
|
file(STRINGS "${_TIFF_INCLUDE_DIR}/tiffvers.h" tiff_version_str REGEX "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version .*")
|
|
string(REGEX REPLACE "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version +([^ \\n]*).*" "\\1" TIFF_VERSION_STRING "${tiff_version_str}")
|
|
unset(tiff_version_str)
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
|
|
set(HAVE_TIFF YES)
|
|
endif()
|
|
|
|
# --- libwebp (optional) ---
|
|
|
|
if(WITH_WEBP)
|
|
if(BUILD_WEBP)
|
|
ocv_clear_vars(WEBP_FOUND WEBP_LIBRARY WEBP_LIBRARIES WEBP_INCLUDE_DIR)
|
|
else()
|
|
ocv_clear_internal_cache_vars(WEBP_LIBRARY WEBP_INCLUDE_DIR)
|
|
include(cmake/OpenCVFindWebP.cmake)
|
|
if(WEBP_FOUND)
|
|
set(HAVE_WEBP 1)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# --- Add libwebp to 3rdparty/libwebp and compile it if not available ---
|
|
if(WITH_WEBP AND NOT WEBP_FOUND
|
|
AND (NOT ANDROID OR HAVE_CPUFEATURES)
|
|
)
|
|
if(NOT BUILD_WEBP)
|
|
message(WARNING "WebP library has not been found, falling back to built-in version. "
|
|
"Set WEBP_INCLUDE_DIR and WEBP_LIBRARY, or add the external installation prefix to "
|
|
"CMAKE_PREFIX_PATH, so that the external WebP can be located.")
|
|
endif()
|
|
ocv_clear_vars(WEBP_LIBRARY WEBP_INCLUDE_DIR)
|
|
set(WEBP_LIBRARY libwebp CACHE INTERNAL "")
|
|
set(WEBP_LIBRARIES ${WEBP_LIBRARY})
|
|
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libwebp")
|
|
set(WEBP_INCLUDE_DIR "${${WEBP_LIBRARY}_SOURCE_DIR}/src" CACHE INTERNAL "")
|
|
set(HAVE_WEBP 1)
|
|
endif()
|
|
|
|
if(NOT WEBP_VERSION AND WEBP_INCLUDE_DIR)
|
|
if(EXISTS "${WEBP_INCLUDE_DIR}/webp/encode.h")
|
|
file(STRINGS "${WEBP_INCLUDE_DIR}/webp/encode.h" WEBP_ENCODER_ABI_VERSION REGEX "#define[ \t]+WEBP_ENCODER_ABI_VERSION[ \t]+([x0-9a-f]+)" )
|
|
if(WEBP_ENCODER_ABI_VERSION MATCHES "#define[ \t]+WEBP_ENCODER_ABI_VERSION[ \t]+([x0-9a-f]+)")
|
|
set(WEBP_ENCODER_ABI_VERSION "${CMAKE_MATCH_1}")
|
|
else()
|
|
unset(WEBP_ENCODER_ABI_VERSION)
|
|
endif()
|
|
endif()
|
|
|
|
if(EXISTS "${WEBP_INCLUDE_DIR}/webp/decode.h")
|
|
file(STRINGS "${WEBP_INCLUDE_DIR}/webp/decode.h" WEBP_DECODER_ABI_VERSION REGEX "#define[ \t]+WEBP_DECODER_ABI_VERSION[ \t]+([x0-9a-f]+)" )
|
|
if(WEBP_DECODER_ABI_VERSION MATCHES "#define[ \t]+WEBP_DECODER_ABI_VERSION[ \t]+([x0-9a-f]+)")
|
|
set(WEBP_DECODER_ABI_VERSION "${CMAKE_MATCH_1}")
|
|
else()
|
|
unset(WEBP_DECODER_ABI_VERSION)
|
|
endif()
|
|
endif()
|
|
|
|
if(EXISTS "${WEBP_INCLUDE_DIR}/webp/demux.h")
|
|
file(STRINGS "${WEBP_INCLUDE_DIR}/webp/demux.h" WEBP_DEMUX_ABI_VERSION REGEX "#define[ \t]+WEBP_DEMUX_ABI_VERSION[ \t]+([x0-9a-f]+)" )
|
|
if(WEBP_DEMUX_ABI_VERSION MATCHES "#define[ \t]+WEBP_DEMUX_ABI_VERSION[ \t]+([x0-9a-f]+)")
|
|
set(WEBP_DEMUX_ABI_VERSION "${CMAKE_MATCH_1}")
|
|
else()
|
|
unset(WEBP_DEMUX_ABI_VERSION)
|
|
endif()
|
|
endif()
|
|
|
|
set(WEBP_VERSION "decoder: ${WEBP_DECODER_ABI_VERSION}, encoder: ${WEBP_ENCODER_ABI_VERSION}, demux: ${WEBP_DEMUX_ABI_VERSION}")
|
|
endif()
|
|
|
|
# --- libjxl (optional) ---
|
|
if(WITH_JPEGXL)
|
|
ocv_clear_vars(HAVE_JPEGXL)
|
|
ocv_clear_internal_cache_vars(JPEGXL_INCLUDE_PATHS JPEGXL_LIBRARIES JPEGXL_VERSION)
|
|
include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindJPEGXL.cmake")
|
|
if(JPEGXL_FOUND)
|
|
set(HAVE_JPEGXL YES)
|
|
message(STATUS "Found system JPEG-XL: ver ${JPEGXL_VERSION}")
|
|
endif()
|
|
endif()
|
|
|
|
# --- libopenjp2 (optional, check before libjasper) ---
|
|
if(WITH_OPENJPEG)
|
|
if(BUILD_OPENJPEG)
|
|
ocv_clear_vars(OpenJPEG_FOUND)
|
|
else()
|
|
find_package(OpenJPEG QUIET)
|
|
endif()
|
|
|
|
if(NOT OpenJPEG_FOUND OR OPENJPEG_MAJOR_VERSION LESS 2)
|
|
ocv_clear_vars(OPENJPEG_MAJOR_VERSION OPENJPEG_MINOR_VERSION OPENJPEG_BUILD_VERSION OPENJPEG_LIBRARIES OPENJPEG_INCLUDE_DIRS)
|
|
message(STATUS "Could NOT find OpenJPEG (minimal suitable version: 2.0, "
|
|
"recommended version >= 2.3.1). OpenJPEG will be built from sources")
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/openjpeg")
|
|
if(OCV_CAN_BUILD_OPENJPEG)
|
|
set(HAVE_OPENJPEG YES)
|
|
message(STATUS "OpenJPEG libraries will be built from sources: ${OPENJPEG_LIBRARIES} "
|
|
"(version \"${OPENJPEG_VERSION}\")")
|
|
else()
|
|
set(HAVE_OPENJPEG NO)
|
|
message(STATUS "OpenJPEG libraries can't be built from sources. System requirements are not fulfilled.")
|
|
endif()
|
|
else()
|
|
set(HAVE_OPENJPEG YES)
|
|
set(OPENJPEG_VERSION "${OPENJPEG_MAJOR_VERSION}.${OPENJPEG_MINOR_VERSION}.${OPENJPEG_BUILD_VERSION}")
|
|
message(STATUS "Found system OpenJPEG: ${OPENJPEG_LIBRARIES} "
|
|
"(found version \"${OPENJPEG_VERSION}\")")
|
|
endif()
|
|
endif()
|
|
|
|
# --- libjasper (optional, should be searched after libjpeg) ---
|
|
if(WITH_JASPER AND NOT HAVE_OPENJPEG)
|
|
if(BUILD_JASPER)
|
|
ocv_clear_vars(JASPER_FOUND)
|
|
else()
|
|
include(FindJasper)
|
|
endif()
|
|
|
|
if(NOT JASPER_FOUND)
|
|
ocv_clear_vars(JASPER_LIBRARY JASPER_LIBRARIES JASPER_INCLUDE_DIR)
|
|
|
|
set(JASPER_LIBRARY libjasper CACHE INTERNAL "")
|
|
set(JASPER_LIBRARIES ${JASPER_LIBRARY})
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libjasper")
|
|
set(JASPER_INCLUDE_DIR "${${JASPER_LIBRARY}_SOURCE_DIR}" CACHE INTERNAL "")
|
|
endif()
|
|
|
|
set(HAVE_JASPER YES)
|
|
|
|
if(NOT JASPER_VERSION_STRING)
|
|
ocv_parse_header2(JASPER "${JASPER_INCLUDE_DIR}/jasper/jas_config.h" JAS_VERSION "")
|
|
endif()
|
|
endif()
|
|
|
|
if(WITH_SPNG)
|
|
if(BUILD_SPNG)
|
|
ocv_clear_vars(PNG_FOUND)
|
|
else()
|
|
# CMakeConfig bug in SPNG, include is missing there in version 0.7.4 and older
|
|
# See https://github.com/randy408/libspng/pull/264
|
|
include(CMakeFindDependencyMacro)
|
|
find_package(SPNG QUIET)
|
|
if(SPNG_FOUND)
|
|
set(SPNG_LIBRARY "spng::spng" CACHE INTERNAL "")
|
|
set(SPNG_LIBRARIES ${SPNG_LIBRARY})
|
|
else()
|
|
if(PkgConfig_FOUND)
|
|
pkg_check_modules(SPNG QUIET spng)
|
|
if(SPNG_FOUND)
|
|
set(SPNG_LIBRARY ${SPNG_LIBRARIES} CACHE INTERNAL "")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
if(SPNG_FOUND)
|
|
set(HAVE_SPNG YES)
|
|
message(STATUS "imgcodecs: PNG codec will use SPNG, version: ${SPNG_VERSION}")
|
|
endif()
|
|
endif()
|
|
if(NOT SPNG_FOUND)
|
|
set(SPNG_LIBRARY libspng CACHE INTERNAL "")
|
|
set(SPNG_LIBRARIES ${SPNG_LIBRARY})
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libspng")
|
|
set(SPNG_INCLUDE_DIR "${${SPNG_LIBRARY}_SOURCE_DIR}" CACHE INTERNAL "")
|
|
set(SPNG_DEFINITIONS "")
|
|
ocv_parse_header("${SPNG_INCLUDE_DIR}/spng.h" SPNG_VERSION_LINES SPNG_VERSION_MAJOR SPNG_VERSION_MINOR SPNG_VERSION_PATCH)
|
|
|
|
set(HAVE_SPNG YES)
|
|
set(SPNG_VERSION "${SPNG_VERSION_MAJOR}.${SPNG_VERSION_MINOR}.${SPNG_VERSION_PATCH}")
|
|
message(STATUS "imgcodecs: PNG codec will use SPNG, version: ${SPNG_VERSION} ")
|
|
endif()
|
|
endif()
|
|
|
|
# --- libpng (optional, should be searched after zlib) ---
|
|
if(NOT HAVE_SPNG AND WITH_PNG)
|
|
if(BUILD_PNG)
|
|
ocv_clear_vars(PNG_FOUND)
|
|
else()
|
|
ocv_clear_internal_cache_vars(PNG_LIBRARY PNG_INCLUDE_DIR PNG_PNG_INCLUDE_DIR)
|
|
find_package(PNG QUIET)
|
|
endif()
|
|
|
|
if(NOT PNG_FOUND)
|
|
if(NOT BUILD_PNG)
|
|
message(WARNING "PNG library has not been found, falling back to built-in version. "
|
|
"Set PNG_ROOT or PNG_DIR variable so that find_package(PNG) would be able to find it. "
|
|
"See find_package and FindPNG cmake documentation for details.")
|
|
endif()
|
|
ocv_clear_vars(PNG_LIBRARY PNG_LIBRARIES PNG_INCLUDE_DIR PNG_DEFINITIONS)
|
|
|
|
set(PNG_LIBRARY libpng CACHE INTERNAL "")
|
|
set(PNG_LIBRARIES ${PNG_LIBRARY})
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libpng")
|
|
set(PNG_INCLUDE_DIR "${${PNG_LIBRARY}_SOURCE_DIR}" CACHE INTERNAL "")
|
|
set(PNG_DEFINITIONS "")
|
|
ocv_parse_header_version(PNG "${PNG_INCLUDE_DIR}/png.h" PNG_LIBPNG_VER_STRING)
|
|
endif()
|
|
|
|
if(BUILD_PNG)
|
|
# Downstream find_package(PNG) calls from transitive dependencies
|
|
# (included via include() in the same scope) may overwrite PNG_FOUND
|
|
# and related variables. PNG_LIBRARY is naturally protected by
|
|
# FindPNG's "if(NOT PNG_LIBRARY)" guard, but PNG_PNG_INCLUDE_DIR
|
|
# (searched via find_path without a guard) and its derived variables
|
|
# (PNG_INCLUDE_DIR, PNG_LIBRARIES, PNG_VERSION_STRING) are not.
|
|
# Lock PNG_PNG_INCLUDE_DIR so that find_path() respects the cached
|
|
# bundled path and skips the system search.
|
|
set(PNG_PNG_INCLUDE_DIR "${PNG_INCLUDE_DIR}" CACHE INTERNAL "PNG include dir (bundled)")
|
|
endif()
|
|
|
|
set(HAVE_PNG YES)
|
|
endif()
|
|
|
|
|
|
# --- OpenEXR (optional) ---
|
|
if(WITH_OPENEXR)
|
|
ocv_clear_vars(HAVE_OPENEXR)
|
|
if(NOT BUILD_OPENEXR)
|
|
ocv_clear_internal_cache_vars(OPENEXR_INCLUDE_PATHS OPENEXR_LIBRARIES OPENEXR_ILMIMF_LIBRARY OPENEXR_VERSION)
|
|
include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindOpenEXR.cmake")
|
|
endif()
|
|
|
|
if(OPENEXR_FOUND)
|
|
set(HAVE_OPENEXR YES)
|
|
else()
|
|
ocv_clear_vars(OPENEXR_INCLUDE_PATHS OPENEXR_LIBRARIES OPENEXR_ILMIMF_LIBRARY OPENEXR_VERSION)
|
|
|
|
set(OPENEXR_LIBRARIES IlmImf)
|
|
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/openexr")
|
|
if(OPENEXR_VERSION) # check via TARGET doesn't work
|
|
set(BUILD_OPENEXR ON)
|
|
set(HAVE_OPENEXR YES)
|
|
set(BUILD_OPENEXR ON)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
# --- GDAL (optional) ---
|
|
if(WITH_GDAL)
|
|
find_package(GDAL QUIET)
|
|
|
|
if(NOT GDAL_FOUND)
|
|
set(HAVE_GDAL NO)
|
|
ocv_clear_vars(GDAL_VERSION GDAL_LIBRARIES)
|
|
else()
|
|
set(HAVE_GDAL YES)
|
|
ocv_include_directories(${GDAL_INCLUDE_DIR})
|
|
|
|
# GDAL_VERSION requires CMake 3.14 or later, if not found, GDAL_RELEASE_NAME is used instead.
|
|
# See https://cmake.org/cmake/help/latest/module/FindGDAL.html
|
|
if(NOT GDAL_VERSION)
|
|
if(EXISTS "${GDAL_INCLUDE_DIR}/gdal_version.h")
|
|
file(STRINGS "${GDAL_INCLUDE_DIR}/gdal_version.h" gdal_version_str REGEX "^#[\t ]+define[\t ]+GDAL_RELEASE_NAME[\t ]*")
|
|
string(REGEX REPLACE "^#\[\t ]+define[\t ]+GDAL_RELEASE_NAME[\t ]+\"([^ \\n]*)\"" "\\1" GDAL_VERSION "${gdal_version_str}")
|
|
unset(gdal_version_str)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(WITH_GDCM)
|
|
find_package(GDCM QUIET)
|
|
if(NOT GDCM_FOUND)
|
|
set(HAVE_GDCM NO)
|
|
ocv_clear_vars(GDCM_VERSION GDCM_LIBRARIES)
|
|
else()
|
|
set(HAVE_GDCM YES)
|
|
# include(${GDCM_USE_FILE})
|
|
set(GDCM_LIBRARIES gdcmMSFF) # GDCM does not set this variable for some reason
|
|
endif()
|
|
endif()
|
|
|
|
if(WITH_IMGCODEC_GIF)
|
|
set(HAVE_IMGCODEC_GIF ON)
|
|
elseif(DEFINED WITH_IMGCODEC_GIF)
|
|
set(HAVE_IMGCODEC_GIF OFF)
|
|
endif()
|
|
if(WITH_IMGCODEC_HDR)
|
|
set(HAVE_IMGCODEC_HDR ON)
|
|
elseif(DEFINED WITH_IMGCODEC_HDR)
|
|
set(HAVE_IMGCODEC_HDR OFF)
|
|
endif()
|
|
if(WITH_IMGCODEC_SUNRASTER)
|
|
set(HAVE_IMGCODEC_SUNRASTER ON)
|
|
elseif(DEFINED WITH_IMGCODEC_SUNRASTER)
|
|
set(HAVE_IMGCODEC_SUNRASTER OFF)
|
|
endif()
|
|
if(WITH_IMGCODEC_PXM)
|
|
set(HAVE_IMGCODEC_PXM ON)
|
|
elseif(DEFINED WITH_IMGCODEC_PXM)
|
|
set(HAVE_IMGCODEC_PXM OFF)
|
|
endif()
|
|
if(WITH_IMGCODEC_PFM)
|
|
set(HAVE_IMGCODEC_PFM ON)
|
|
elseif(DEFINED WITH_IMGCODEC_PFM)
|
|
set(HAVE_IMGCODEC_PFM OFF)
|
|
endif()
|