Conan/conan-build
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[DO-983][DO-985] add tiff and zstd packages (!14)

Browse Source 
Co-authored-by: aleksandr.vodyanov <aleksandr.vodyanov@avroid.tech>
Reviewed-on: https://git.avroid.tech/Conan/conan_build/pulls/14
This commit is contained in:
Aleksandr Vodyanov
2024-12-26 16:03:17 +03:00
parent 70e3dea3f3
commit 60445ac09e
55 changed files with 1662 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
recipes/libtiff/all/conandata.yml Normal file
View File

@@ -0,0 +1,44 @@
sources:
"4.7.0":
url: "https://nexus.avroid.tech/repository/all-raw-proxy-download_osgeo_org/libtiff/tiff-4.7.0.tar.xz"
sha256: "273a0a73b1f0bed640afee4a5df0337357ced5b53d3d5d1c405b936501f71017"
"4.6.0":
url: "https://nexus.avroid.tech/repository/all-raw-proxy-download_osgeo_org/libtiff/tiff-4.6.0.tar.gz"
sha256: "88b3979e6d5c7e32b50d7ec72fb15af724f6ab2cbf7e10880c360a77e4b5d99a"
"4.5.1":
url: "https://nexus.avroid.tech/repository/all-raw-proxy-download_osgeo_org/libtiff/tiff-4.5.1.tar.gz"
sha256: "d7f38b6788e4a8f5da7940c5ac9424f494d8a79eba53d555f4a507167dca5e2b"
"4.5.0":
url: "https://nexus.avroid.tech/repository/all-raw-proxy-download_osgeo_org/libtiff/tiff-4.5.0.tar.gz"
sha256: "c7a1d9296649233979fa3eacffef3fa024d73d05d589cb622727b5b08c423464"
"4.4.0":
url: "https://nexus.avroid.tech/repository/all-raw-proxy-download_osgeo_org/libtiff/tiff-4.4.0.tar.gz"
sha256: "917223b37538959aca3b790d2d73aa6e626b688e02dcda272aec24c2f498abed"
"4.3.0":
url: "https://nexus.avroid.tech/repository/all-raw-proxy-download_osgeo_org/libtiff/tiff-4.3.0.tar.gz"
sha256: "0e46e5acb087ce7d1ac53cf4f56a09b221537fc86dfc5daaad1c2e89e1b37ac8"
patches:
"4.7.0":
- patch_file: "patches/4.5.1-0001-cmake-dependencies.patch"
patch_description: "CMake: robust handling of dependencies"
patch_type: "conan"
"4.6.0":
- patch_file: "patches/4.5.1-0001-cmake-dependencies.patch"
patch_description: "CMake: robust handling of dependencies"
patch_type: "conan"
"4.5.1":
- patch_file: "patches/4.5.1-0001-cmake-dependencies.patch"
patch_description: "CMake: robust handling of dependencies"
patch_type: "conan"
"4.5.0":
- patch_file: "patches/4.5.0-0001-cmake-dependencies.patch"
patch_description: "CMake: robust handling of dependencies"
patch_type: "conan"
"4.4.0":
- patch_file: "patches/4.4.0-0001-cmake-dependencies.patch"
patch_description: "CMake: robust handling of dependencies"
patch_type: "conan"
"4.3.0":
- patch_file: "patches/4.3.0-0001-cmake-dependencies.patch"
patch_description: "CMake: robust handling of dependencies"
patch_type: "conan"

192
recipes/libtiff/all/conanfile.py Normal file
View File

@@ -0,0 +1,192 @@
from conan import ConanFile
from conan.errors import ConanInvalidConfiguration
from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
from conan.tools.files import apply_conandata_patches, copy, export_conandata_patches, get, replace_in_file, rm, rmdir
from conan.tools.microsoft import is_msvc
from conan.tools.scm import Version
import os
required_conan_version = ">=1.53.0"
class LibtiffConan(ConanFile):
name = "libtiff"
description = "Library for Tag Image File Format (TIFF)"
url = "https://github.com/conan-io/conan-center-index"
license = "libtiff"
homepage = "http://www.simplesystems.org/libtiff"
topics = ("tiff", "image", "bigtiff", "tagged-image-file-format")
package_type = "library"
settings = "os", "arch", "compiler", "build_type"
options = {
"shared": [True, False],
"fPIC": [True, False],
"lzma": [True, False],
"jpeg": [False, "libjpeg", "libjpeg-turbo", "mozjpeg"],
"zlib": [True, False],
"libdeflate": [True, False],
"zstd": [True, False],
"jbig": [True, False],
"webp": [True, False],
"cxx": [True, False],
}
default_options = {
"shared": False,
"fPIC": True,
"lzma": True,
"jpeg": "libjpeg",
"zlib": True,
"libdeflate": True,
"zstd": True,
"jbig": True,
"webp": True,
"cxx": True,
}
def export_sources(self):
export_conandata_patches(self)
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def configure(self):
if self.options.shared:
self.options.rm_safe("fPIC")
if not self.options.cxx:
self.settings.rm_safe("compiler.cppstd")
self.settings.rm_safe("compiler.libcxx")
def layout(self):
cmake_layout(self, src_folder="src")
def requirements(self):
if self.options.zlib:
self.requires("zlib/[>=1.2.11 <2]")
if self.options.libdeflate:
self.requires("libdeflate/1.19")
if self.options.lzma:
self.requires("xz_utils/[>=5.4.5 <6]")
if self.options.jpeg == "libjpeg":
self.requires("libjpeg/9e")
elif self.options.jpeg == "libjpeg-turbo":
self.requires("libjpeg-turbo/[>=3.0.2]")
elif self.options.jpeg == "mozjpeg":
self.requires("mozjpeg/4.1.5")
if self.options.jbig:
self.requires("jbig/20160605")
if self.options.zstd:
self.requires("zstd/[>=1.5.5]")
if self.options.webp:
self.requires("libwebp/1.3.2")
def validate(self):
if self.options.libdeflate and not self.options.zlib:
raise ConanInvalidConfiguration("libtiff:libdeflate=True requires libtiff:zlib=True")
# def build_requirements(self):
# if Version(self.version) >= "4.5.1":
# # https://github.com/conan-io/conan/issues/3482#issuecomment-662284561
# self.tool_requires("cmake/[>=3.18 <4]")
def source(self):
get(self, **self.conan_data["sources"][self.version], strip_root=True)
def generate(self):
tc = CMakeToolchain(self)
tc.variables["lzma"] = self.options.lzma
tc.variables["jpeg"] = bool(self.options.jpeg)
tc.variables["jpeg12"] = False
tc.variables["jbig"] = self.options.jbig
tc.variables["zlib"] = self.options.zlib
tc.variables["libdeflate"] = self.options.libdeflate
tc.variables["zstd"] = self.options.zstd
tc.variables["webp"] = self.options.webp
tc.variables["lerc"] = False # TODO: add lerc support for libtiff versions >= 4.3.0
if Version(self.version) >= "4.5.0":
# Disable tools, test, contrib, man & html generation
tc.variables["tiff-tools"] = False
tc.variables["tiff-tests"] = False
tc.variables["tiff-contrib"] = False
tc.variables["tiff-docs"] = False
tc.variables["cxx"] = self.options.cxx
# BUILD_SHARED_LIBS must be set in command line because defined upstream before project()
tc.cache_variables["BUILD_SHARED_LIBS"] = bool(self.options.shared)
tc.cache_variables["CMAKE_FIND_PACKAGE_PREFER_CONFIG"] = True
tc.generate()
deps = CMakeDeps(self)
if Version(self.version) >= "4.5.1":
deps.set_property("jbig", "cmake_target_name", "JBIG::JBIG")
deps.set_property("xz_utils", "cmake_target_name", "liblzma::liblzma")
deps.set_property("libdeflate", "cmake_file_name", "Deflate")
deps.set_property("libdeflate", "cmake_target_name", "Deflate::Deflate")
deps.generate()
def _patch_sources(self):
apply_conandata_patches(self)
# remove FindXXXX for conan dependencies
for module in ["Deflate", "JBIG", "JPEG", "LERC", "WebP", "ZSTD", "liblzma", "LibLZMA"]:
rm(self, f"Find{module}.cmake", os.path.join(self.source_folder, "cmake"))
# Export symbols of tiffxx for msvc shared
replace_in_file(self, os.path.join(self.source_folder, "libtiff", "CMakeLists.txt"),
"set_target_properties(tiffxx PROPERTIES SOVERSION ${SO_COMPATVERSION})",
"set_target_properties(tiffxx PROPERTIES SOVERSION ${SO_COMPATVERSION} WINDOWS_EXPORT_ALL_SYMBOLS ON)")
# Disable tools, test, contrib, man & html generation
if Version(self.version) < "4.5.0":
replace_in_file(self, os.path.join(self.source_folder, "CMakeLists.txt"),
"add_subdirectory(tools)\nadd_subdirectory(test)\nadd_subdirectory(contrib)\nadd_subdirectory(build)\n"
"add_subdirectory(man)\nadd_subdirectory(html)", "")
def build(self):
self._patch_sources()
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
license_file = "COPYRIGHT" if Version(self.version) < "4.5.0" else "LICENSE.md"
copy(self, license_file, src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"), ignore_case=True, keep_path=False)
cmake = CMake(self)
cmake.install()
rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
def package_info(self):
self.cpp_info.set_property("cmake_find_mode", "both")
self.cpp_info.set_property("cmake_file_name", "TIFF")
self.cpp_info.set_property("cmake_target_name", "TIFF::TIFF")
self.cpp_info.set_property("pkg_config_name", f"libtiff-{Version(self.version).major}")
suffix = "d" if is_msvc(self) and self.settings.build_type == "Debug" else ""
if self.options.cxx:
self.cpp_info.libs.append(f"tiffxx{suffix}")
self.cpp_info.libs.append(f"tiff{suffix}")
if self.settings.os in ["Linux", "Android", "FreeBSD", "SunOS", "AIX"]:
self.cpp_info.system_libs.append("m")
self.cpp_info.requires = []
if self.options.zlib:
self.cpp_info.requires.append("zlib::zlib")
if self.options.libdeflate:
self.cpp_info.requires.append("libdeflate::libdeflate")
if self.options.lzma:
self.cpp_info.requires.append("xz_utils::xz_utils")
if self.options.jpeg == "libjpeg":
self.cpp_info.requires.append("libjpeg::libjpeg")
elif self.options.jpeg == "libjpeg-turbo":
self.cpp_info.requires.append("libjpeg-turbo::jpeg")
elif self.options.jpeg == "mozjpeg":
self.cpp_info.requires.append("mozjpeg::libjpeg")
if self.options.jbig:
self.cpp_info.requires.append("jbig::jbig")
if self.options.zstd:
self.cpp_info.requires.append("zstd::zstd")
if self.options.webp:
self.cpp_info.requires.append("libwebp::libwebp")
# TODO: to remove in conan v2 once cmake_find_package* & pkg_config generators removed
self.cpp_info.names["cmake_find_package"] = "TIFF"
self.cpp_info.names["cmake_find_package_multi"] = "TIFF"

91
recipes/libtiff/all/patches/4.3.0-0001-cmake-dependencies.patch Normal file
View File

@@ -0,0 +1,91 @@
--- a/cmake/DeflateCodec.cmake
+++ b/cmake/DeflateCodec.cmake
@@ -35,7 +35,10 @@ set(ZIP_SUPPORT ${ZLIB_SUPPORT})
# libdeflate
set(LIBDEFLATE_SUPPORT FALSE)
-find_package(Deflate)
+find_package(libdeflate CONFIG)
+if(libdeflate_FOUND)
+ set(Deflate_FOUND TRUE)
+endif()
option(libdeflate "use libdeflate (optional for faster Deflate support, still requires zlib)" ${Deflate_FOUND})
if (libdeflate AND Deflate_FOUND AND ZIP_SUPPORT)
set(LIBDEFLATE_SUPPORT TRUE)
--- a/cmake/JBIGCodec.cmake
+++ b/cmake/JBIGCodec.cmake
@@ -27,14 +27,17 @@
# JBIG-KIT
set(JBIG_SUPPORT FALSE)
-find_package(JBIG)
+find_package(jbig CONFIG)
+if(jbig_FOUND)
+ set(JBIG_FOUND TRUE)
+endif()
if(JBIG_FOUND)
set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${JBIG_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${JBIG_LIBRARIES})
- check_symbol_exists(jbg_newlen "jbig.h" HAVE_JBG_NEWLEN)
+ set(HAVE_JBG_NEWLEN TRUE)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
endif()
--- a/cmake/ZSTDCodec.cmake
+++ b/cmake/ZSTDCodec.cmake
@@ -28,14 +28,17 @@
set(ZSTD_SUPPORT FALSE)
set(ZSTD_USABLE FALSE)
-find_package(ZSTD)
+find_package(zstd CONFIG)
+if(zstd_FOUND)
+ set(ZSTD_FOUND TRUE)
+endif()
if(ZSTD_FOUND)
set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${ZSTD_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${ZSTD_LIBRARIES})
- check_symbol_exists(ZSTD_decompressStream "zstd.h" ZSTD_RECENT_ENOUGH)
+ set(ZSTD_RECENT_ENOUGH TRUE)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
--- a/libtiff/CMakeLists.txt
+++ b/libtiff/CMakeLists.txt
@@ -110,7 +110,7 @@ if(ZIP_SUPPORT)
target_link_libraries(tiff PRIVATE ZLIB::ZLIB)
endif()
if(ZIP_SUPPORT AND LIBDEFLATE_SUPPORT)
- target_link_libraries(tiff PRIVATE Deflate::Deflate)
+ target_link_libraries(tiff PRIVATE $<IF:$<TARGET_EXISTS:libdeflate::libdeflate>,libdeflate::libdeflate,libdeflate::libdeflate_static>)
endif()
if(JPEG_SUPPORT)
target_link_libraries(tiff PRIVATE JPEG::JPEG)
@@ -120,7 +120,7 @@ if(JPEG_SUPPORT)
endif()
endif()
if(JBIG_SUPPORT)
- target_link_libraries(tiff PRIVATE JBIG::JBIG)
+ target_link_libraries(tiff PRIVATE jbig::jbig)
endif()
if(LERC_SUPPORT)
target_link_libraries(tiff PRIVATE LERC::LERC)
@@ -129,10 +129,10 @@ if(LZMA_SUPPORT)
target_link_libraries(tiff PRIVATE LibLZMA::LibLZMA)
endif()
if(ZSTD_SUPPORT)
- target_link_libraries(tiff PRIVATE ZSTD::ZSTD)
+ target_link_libraries(tiff PRIVATE $<IF:$<TARGET_EXISTS:zstd::libzstd_shared>,zstd::libzstd_shared,zstd::libzstd_static>)
endif()
if(WEBP_SUPPORT)
- target_link_libraries(tiff PRIVATE WebP::WebP)
+ target_link_libraries(tiff PRIVATE WebP::webp)
endif()
target_link_libraries(tiff PRIVATE CMath::CMath)

92
recipes/libtiff/all/patches/4.4.0-0001-cmake-dependencies.patch Normal file
View File

@@ -0,0 +1,92 @@
--- a/cmake/DeflateCodec.cmake
+++ b/cmake/DeflateCodec.cmake
@@ -35,7 +35,10 @@ set(ZIP_SUPPORT ${ZLIB_SUPPORT})
# libdeflate
set(LIBDEFLATE_SUPPORT FALSE)
-find_package(Deflate)
+find_package(libdeflate CONFIG)
+if(libdeflate_FOUND)
+ set(Deflate_FOUND TRUE)
+endif()
option(libdeflate "use libdeflate (optional for faster Deflate support, still requires zlib)" ${Deflate_FOUND})
if (libdeflate AND Deflate_FOUND AND ZIP_SUPPORT)
set(LIBDEFLATE_SUPPORT TRUE)
--- a/cmake/JBIGCodec.cmake
+++ b/cmake/JBIGCodec.cmake
@@ -27,14 +27,17 @@
# JBIG-KIT
set(JBIG_SUPPORT FALSE)
-find_package(JBIG)
+find_package(jbig CONFIG)
+if(jbig_FOUND)
+ set(JBIG_FOUND TRUE)
+endif()
if(JBIG_FOUND)
set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${JBIG_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${JBIG_LIBRARIES})
- check_symbol_exists(jbg_newlen "jbig.h" HAVE_JBG_NEWLEN)
+ set(HAVE_JBG_NEWLEN TRUE)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
endif()
--- a/cmake/ZSTDCodec.cmake
+++ b/cmake/ZSTDCodec.cmake
@@ -28,14 +28,17 @@
set(ZSTD_SUPPORT FALSE)
set(ZSTD_USABLE FALSE)
-find_package(ZSTD)
+find_package(zstd CONFIG)
+if(zstd_FOUND)
+ set(ZSTD_FOUND TRUE)
+endif()
if(ZSTD_FOUND)
set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${ZSTD_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${ZSTD_LIBRARIES})
- check_symbol_exists(ZSTD_decompressStream "zstd.h" ZSTD_RECENT_ENOUGH)
+ set(ZSTD_RECENT_ENOUGH TRUE)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
--- a/libtiff/CMakeLists.txt
+++ b/libtiff/CMakeLists.txt
@@ -114,7 +114,7 @@ if(ZIP_SUPPORT)
string(APPEND tiff_requires_private " zlib")
endif()
if(ZIP_SUPPORT AND LIBDEFLATE_SUPPORT)
- target_link_libraries(tiff PRIVATE Deflate::Deflate)
+ target_link_libraries(tiff PRIVATE $<IF:$<TARGET_EXISTS:libdeflate::libdeflate>,libdeflate::libdeflate,libdeflate::libdeflate_static>)
list(APPEND tiff_libs_private_list "${Deflate_LIBRARY}")
endif()
if(JPEG_SUPPORT)
@@ -126,7 +126,7 @@ if(JPEG_SUPPORT)
endif()
endif()
if(JBIG_SUPPORT)
- target_link_libraries(tiff PRIVATE JBIG::JBIG)
+ target_link_libraries(tiff PRIVATE jbig::jbig)
list(APPEND tiff_libs_private_list "${JBIG_LIBRARY}")
endif()
if(LERC_SUPPORT)
@@ -141,11 +141,11 @@ if(LZMA_SUPPORT)
string(APPEND tiff_requires_private " liblzma")
endif()
if(ZSTD_SUPPORT)
- target_link_libraries(tiff PRIVATE ZSTD::ZSTD)
+ target_link_libraries(tiff PRIVATE $<IF:$<TARGET_EXISTS:zstd::libzstd_shared>,zstd::libzstd_shared,zstd::libzstd_static>)
string(APPEND tiff_requires_private " libzstd")
endif()
if(WEBP_SUPPORT)
- target_link_libraries(tiff PRIVATE WebP::WebP)
+ target_link_libraries(tiff PRIVATE WebP::webp)
string(APPEND tiff_requires_private " libwebp")
endif()
target_link_libraries(tiff PRIVATE CMath::CMath)

116
recipes/libtiff/all/patches/4.5.0-0001-cmake-dependencies.patch Normal file
View File

@@ -0,0 +1,116 @@
--- a/cmake/DeflateCodec.cmake
+++ b/cmake/DeflateCodec.cmake
@@ -35,7 +35,10 @@ set(LIBDEFLATE_SUPPORT FALSE)
# libdeflate
set(LIBDEFLATE_SUPPORT FALSE)
-find_package(Deflate)
+find_package(libdeflate CONFIG)
+if(libdeflate_FOUND)
+ set(Deflate_FOUND TRUE)
+endif()
option(libdeflate "use libdeflate (optional for faster Deflate support, still requires zlib)" ${Deflate_FOUND})
if (libdeflate AND Deflate_FOUND AND ZIP_SUPPORT)
set(LIBDEFLATE_SUPPORT TRUE)
--- a/cmake/JBIGCodec.cmake
+++ b/cmake/JBIGCodec.cmake
@@ -27,14 +27,17 @@ set(JBIG_SUPPORT FALSE)
# JBIG-KIT
set(JBIG_SUPPORT FALSE)
-find_package(JBIG)
+find_package(jbig CONFIG)
+if(jbig_FOUND)
+ set(JBIG_FOUND TRUE)
+endif()
if(JBIG_FOUND)
set(CMAKE_REQUIRED_INCLUDES_SAVE ${CMAKE_REQUIRED_INCLUDES})
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${JBIG_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${JBIG_LIBRARIES})
- check_symbol_exists(jbg_newlen "jbig.h" HAVE_JBG_NEWLEN)
+ set(HAVE_JBG_NEWLEN TRUE)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
endif()
--- a/cmake/JPEGCodec.cmake
+++ b/cmake/JPEGCodec.cmake
@@ -47,19 +47,7 @@
cmake_push_check_state(RESET)
set(CMAKE_REQUIRED_INCLUDES "${JPEG_INCLUDE_DIRS}")
set(CMAKE_REQUIRED_LIBRARIES "${JPEG_LIBRARIES}")
- check_c_source_compiles(
- "
- #include <stddef.h>
- #include <stdio.h>
- #include \"jpeglib.h\"
- int main()
- {
- jpeg_read_scanlines(0,0,0);
- jpeg12_read_scanlines(0,0,0);
- return 0;
- }
- "
- HAVE_JPEGTURBO_DUAL_MODE_8_12)
+ set(HAVE_JPEGTURBO_DUAL_MODE_8_12 FALSE)
cmake_pop_check_state()
endif()
--- a/cmake/ZSTDCodec.cmake
+++ b/cmake/ZSTDCodec.cmake
@@ -28,7 +28,10 @@ set(ZSTD_USABLE FALSE)
set(ZSTD_SUPPORT FALSE)
set(ZSTD_USABLE FALSE)
-find_package(ZSTD)
+find_package(zstd CONFIG)
+if(zstd_FOUND)
+ set(ZSTD_FOUND TRUE)
+endif()
if(ZSTD_FOUND)
if(NOT DEFINED ZSTD_HAVE_DECOMPRESS_STREAM)
@@ -36,7 +39,7 @@ if(ZSTD_FOUND)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${ZSTD_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES_SAVE ${CMAKE_REQUIRED_LIBRARIES})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${ZSTD_LIBRARIES})
- check_symbol_exists(ZSTD_decompressStream "zstd.h" ZSTD_HAVE_DECOMPRESS_STREAM)
+ set(ZSTD_HAVE_DECOMPRESS_STREAM TRUE)
set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES_SAVE})
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES_SAVE})
endif()
--- a/libtiff/CMakeLists.txt
+++ b/libtiff/CMakeLists.txt
@@ -116,7 +116,7 @@ if(ZIP_SUPPORT AND LIBDEFLATE_SUPPORT)
string(APPEND tiff_requires_private " zlib")
endif()
if(ZIP_SUPPORT AND LIBDEFLATE_SUPPORT)
- target_link_libraries(tiff PRIVATE Deflate::Deflate)
+ target_link_libraries(tiff PRIVATE $<IF:$<TARGET_EXISTS:libdeflate::libdeflate>,libdeflate::libdeflate,libdeflate::libdeflate_static>)
list(APPEND tiff_libs_private_list "${Deflate_LIBRARY}")
endif()
if(JPEG_SUPPORT)
@@ -130,7 +130,7 @@ if(JBIG_SUPPORT)
endif()
endif()
if(JBIG_SUPPORT)
- target_link_libraries(tiff PRIVATE JBIG::JBIG)
+ target_link_libraries(tiff PRIVATE jbig::jbig)
list(APPEND tiff_libs_private_list "${JBIG_LIBRARY}")
endif()
if(LERC_SUPPORT)
@@ -145,11 +145,11 @@ if(ZSTD_SUPPORT)
string(APPEND tiff_requires_private " liblzma")
endif()
if(ZSTD_SUPPORT)
- target_link_libraries(tiff PRIVATE ZSTD::ZSTD)
+ target_link_libraries(tiff PRIVATE $<IF:$<TARGET_EXISTS:zstd::libzstd_shared>,zstd::libzstd_shared,zstd::libzstd_static>)
string(APPEND tiff_requires_private " libzstd")
endif()
if(WEBP_SUPPORT)
- target_link_libraries(tiff PRIVATE WebP::WebP)
+ target_link_libraries(tiff PRIVATE WebP::webp)
string(APPEND tiff_requires_private " libwebp")
endif()
if(CMath_LIBRARY)

31
recipes/libtiff/all/patches/4.5.1-0001-cmake-dependencies.patch Normal file
View File

@@ -0,0 +1,31 @@
diff --git a/cmake/JPEGCodec.cmake b/cmake/JPEGCodec.cmake
index 8455a3ec..09fe975a 100644
--- a/cmake/JPEGCodec.cmake
+++ b/cmake/JPEGCodec.cmake
@@ -42,25 +42,7 @@ endif()
if (JPEG_SUPPORT)
# Check for jpeg12_read_scanlines() which has been added in libjpeg-turbo 2.2
# for dual 8/12 bit mode.
- include(CheckCSourceCompiles)
- include(CMakePushCheckState)
- cmake_push_check_state(RESET)
- set(CMAKE_REQUIRED_INCLUDES "${JPEG_INCLUDE_DIRS}")
- set(CMAKE_REQUIRED_LIBRARIES "${JPEG_LIBRARIES}")
- check_c_source_compiles(
- "
- #include <stddef.h>
- #include <stdio.h>
- #include \"jpeglib.h\"
- int main()
- {
- jpeg_read_scanlines(0,0,0);
- jpeg12_read_scanlines(0,0,0);
- return 0;
- }
- "
- HAVE_JPEGTURBO_DUAL_MODE_8_12)
- cmake_pop_check_state()
+ set(HAVE_JPEGTURBO_DUAL_MODE_8_12 FALSE)
endif()
if (NOT HAVE_JPEGTURBO_DUAL_MODE_8_12)

7
recipes/libtiff/all/test_package/CMakeLists.txt Normal file
View File

@@ -0,0 +1,7 @@
cmake_minimum_required(VERSION 3.1)
project(test_package LANGUAGES C)
find_package(TIFF REQUIRED)
add_executable(${PROJECT_NAME} test_package.c)
target_link_libraries(${PROJECT_NAME} PRIVATE TIFF::TIFF)

26
recipes/libtiff/all/test_package/conanfile.py Normal file
View File

@@ -0,0 +1,26 @@
from conan import ConanFile
from conan.tools.build import can_run
from conan.tools.cmake import CMake, cmake_layout
import os
class TestPackageConan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
generators = "CMakeToolchain", "CMakeDeps", "VirtualRunEnv"
test_type = "explicit"
def layout(self):
cmake_layout(self)
def requirements(self):
self.requires(self.tested_reference_str)
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def test(self):
if can_run(self):
bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
self.run(bin_path, env="conanrun")

8
recipes/libtiff/all/test_package/test_package.c Normal file
View File

@@ -0,0 +1,8 @@
#include <tiffio.h>
int main()
{
TIFF* tif = TIFFOpen("foo.tif", "w");
TIFFClose(tif);
return 0;
}

8
recipes/libtiff/all/test_v1_package/CMakeLists.txt Normal file
View File

@@ -0,0 +1,8 @@
cmake_minimum_required(VERSION 3.1)
project(test_package)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup(TARGETS)
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../test_package
${CMAKE_CURRENT_BINARY_DIR}/test_package)

17
recipes/libtiff/all/test_v1_package/conanfile.py Normal file
View File

@@ -0,0 +1,17 @@
from conans import ConanFile, CMake, tools
import os
class TestPackageConan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
generators = "cmake", "cmake_find_package"
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def test(self):
if not tools.cross_building(self):
bin_path = os.path.join("bin", "test_package")
self.run(bin_path, run_environment=True)