CMakeLists.txt (17140B)
1 # Copyright (c) the JPEG XL Project Authors. All rights reserved. 2 # 3 # Use of this source code is governed by a BSD-style 4 # license that can be found in the LICENSE file. 5 6 # ICC detection library used by the comparison and viewer tools. 7 if(JPEGXL_ENABLE_VIEWERS) 8 if(WIN32) 9 find_package(Qt6 QUIET COMPONENTS Widgets) 10 if (NOT Qt6_FOUND) 11 message(WARNING "Qt6 was not found.") 12 else() 13 add_library(icc_detect STATIC EXCLUDE_FROM_ALL 14 icc_detect/icc_detect_win32.cc 15 icc_detect/icc_detect.h 16 ) 17 target_include_directories(icc_detect PRIVATE "${PROJECT_SOURCE_DIR}") 18 target_link_libraries(icc_detect PUBLIC Qt6::Widgets) 19 if(JPEGXL_DEP_LICENSE_DIR) 20 configure_file("${JPEGXL_DEP_LICENSE_DIR}/libqt6widgets6/copyright" 21 ${PROJECT_BINARY_DIR}/LICENSE.libqt6widgets6 COPYONLY) 22 endif() # JPEGXL_DEP_LICENSE_DIR 23 endif() 24 elseif(APPLE) 25 find_package(Qt6 QUIET COMPONENTS Widgets) 26 if (Qt6_FOUND) 27 add_library(icc_detect STATIC EXCLUDE_FROM_ALL 28 icc_detect/icc_detect_empty.cc 29 icc_detect/icc_detect.h 30 ) 31 target_include_directories(icc_detect PRIVATE "${PROJECT_SOURCE_DIR}") 32 target_link_libraries(icc_detect PUBLIC Qt6::Widgets) 33 else() 34 message(WARNING "APPLE: Qt6 was not found.") 35 endif() 36 else() 37 find_package(Qt6 QUIET COMPONENTS Widgets) 38 find_package(ECM QUIET NO_MODULE) 39 if (NOT Qt6_FOUND OR NOT ECM_FOUND) 40 if (NOT Qt6_FOUND) 41 message(WARNING "Qt6 was not found.") 42 else() 43 message(WARNING "extra-cmake-modules were not found.") 44 endif() 45 else() 46 set(CMAKE_MODULE_PATH ${ECM_FIND_MODULE_DIR}) 47 find_package(XCB COMPONENTS XCB) 48 if (XCB_FOUND) 49 add_library(icc_detect STATIC EXCLUDE_FROM_ALL 50 icc_detect/icc_detect_x11.cc 51 icc_detect/icc_detect.h 52 ) 53 target_link_libraries(icc_detect PUBLIC jxl-internal Qt6::Widgets XCB::XCB) 54 endif () 55 endif() 56 endif() 57 endif() # JPEGXL_ENABLE_VIEWERS 58 59 # Tools are added conditionally below. 60 set(TOOL_BINARIES) 61 # Tools that depend on jxl internal functions. 62 set(INTERNAL_TOOL_BINARIES) 63 set(FUZZER_CORPUS_BINARIES) 64 65 add_library(jxl_tool STATIC EXCLUDE_FROM_ALL 66 cmdline.cc 67 codec_config.cc 68 speed_stats.cc 69 tool_version.cc 70 ${JXL_CMS_OBJECTS} 71 ) 72 target_compile_options(jxl_tool PUBLIC "${JPEGXL_INTERNAL_FLAGS}") 73 target_include_directories(jxl_tool PUBLIC "${PROJECT_SOURCE_DIR}") 74 target_link_libraries(jxl_tool PUBLIC hwy) 75 76 # The JPEGXL_VERSION is set from the builders. 77 if(NOT DEFINED JPEGXL_VERSION OR JPEGXL_VERSION STREQUAL "") 78 find_package(Git QUIET) 79 execute_process( 80 COMMAND "${GIT_EXECUTABLE}" rev-parse --short HEAD 81 OUTPUT_VARIABLE GIT_REV 82 WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" 83 ERROR_QUIET) 84 string(STRIP "${GIT_REV}" GIT_REV) 85 if(GIT_REV STREQUAL "") 86 set(JPEGXL_VERSION "(unknown)") 87 endif() 88 endif() 89 90 if(NOT DEFINED JPEGXL_VERSION OR JPEGXL_VERSION STREQUAL "") 91 # We are building from a git environment and the user didn't set 92 # JPEGXL_VERSION. Make a target that computes the GIT_REV at build-time always 93 # but only updates the file if it changed. This allows rebuilds without 94 # modifying cmake files to update the JPEGXL_VERSION. 95 message(STATUS "Building with JPEGXL_VERSION=${GIT_REV} (auto-updated)") 96 add_custom_target( 97 tool_version_git 98 ${CMAKE_COMMAND} 99 -D JPEGXL_ROOT_DIR=${CMAKE_SOURCE_DIR} 100 -D DST=${CMAKE_CURRENT_BINARY_DIR}/tool_version_git.h 101 -P ${CMAKE_CURRENT_SOURCE_DIR}/git_version.cmake 102 BYPRODUCTS "${CMAKE_CURRENT_BINARY_DIR}/tool_version_git.h" 103 ) 104 add_dependencies(jxl_tool tool_version_git) 105 106 set_source_files_properties(tool_version.cc PROPERTIES 107 COMPILE_DEFINITIONS JPEGXL_VERSION_FROM_GIT=1) 108 target_include_directories(jxl_tool PRIVATE "${CMAKE_CURRENT_BINARY_DIR}") 109 # Note: Ninja looks for dependencies on the jxl_tool target before running 110 # the tool_version_git targets, so when updating the tool_version_git.h the 111 # jxl_tool target is not rebuilt. This forces to generate it at configure time 112 # if needed. 113 execute_process( 114 COMMAND ${CMAKE_COMMAND} 115 -D JPEGXL_ROOT_DIR=${CMAKE_SOURCE_DIR} 116 -D DST=${CMAKE_CURRENT_BINARY_DIR}/tool_version_git.h 117 -P ${CMAKE_CURRENT_SOURCE_DIR}/git_version.cmake) 118 else() 119 message(STATUS "Building with JPEGXL_VERSION=${JPEGXL_VERSION}") 120 set_source_files_properties(tool_version.cc PROPERTIES 121 COMPILE_DEFINITIONS JPEGXL_VERSION=\"${JPEGXL_VERSION}\") 122 endif() 123 124 add_library(jxl_gauss_blur STATIC #EXCLUDE_FROM_ALL 125 gauss_blur.cc 126 ) 127 target_compile_options(jxl_gauss_blur PUBLIC "${JPEGXL_INTERNAL_FLAGS}") 128 target_include_directories(jxl_gauss_blur PUBLIC "${PROJECT_SOURCE_DIR}") 129 target_link_libraries(jxl_gauss_blur PUBLIC jxl) 130 target_link_libraries(jxl_gauss_blur PUBLIC hwy) 131 132 if(JPEGXL_ENABLE_TOOLS) 133 # Main compressor. 134 add_executable(cjxl cjxl_main.cc) 135 target_link_libraries(cjxl 136 jxl 137 jxl_extras_codec 138 jxl_threads 139 jxl_tool 140 ) 141 list(APPEND TOOL_BINARIES cjxl) 142 143 # Main decompressor. 144 add_executable(djxl djxl_main.cc) 145 target_link_libraries(djxl 146 jxl 147 jxl_extras_codec 148 jxl_threads 149 jxl_tool 150 ) 151 list(APPEND TOOL_BINARIES djxl) 152 153 if(JPEGXL_ENABLE_JPEGLI) 154 # Depends on parts of jxl_extras that are only built if libjpeg is found and 155 # jpegli is enabled. 156 add_executable(cjpegli cjpegli.cc) 157 add_executable(djpegli djpegli.cc) 158 list(APPEND INTERNAL_TOOL_BINARIES cjpegli djpegli) 159 endif() 160 161 add_executable(jxlinfo jxlinfo.c) 162 target_link_libraries(jxlinfo jxl) 163 list(APPEND TOOL_BINARIES jxlinfo) 164 165 if(NOT SANITIZER STREQUAL "none") 166 # Linking a C test binary with the C++ JPEG XL implementation when using 167 # address sanitizer is not well supported by clang 9, so force using clang++ 168 # for linking this test if a sanitizer is used. 169 set_target_properties(jxlinfo PROPERTIES LINKER_LANGUAGE CXX) 170 endif() # SANITIZER != "none" 171 172 endif() # JPEGXL_ENABLE_TOOLS 173 174 # Other developer tools. 175 if(JPEGXL_ENABLE_DEVTOOLS) 176 list(APPEND INTERNAL_TOOL_BINARIES 177 butteraugli_main 178 decode_and_encode 179 display_to_hlg 180 exr_to_pq 181 pq_to_hlg 182 render_hlg 183 local_tone_map 184 tone_map 185 texture_to_cube 186 generate_lut_template 187 ssimulacra_main 188 ssimulacra2 189 xyb_range 190 jxl_from_tree 191 ) 192 193 add_executable(ssimulacra_main ssimulacra_main.cc ssimulacra.cc) 194 target_link_libraries(ssimulacra_main jxl_gauss_blur) 195 196 add_executable(ssimulacra2 ssimulacra2_main.cc ssimulacra2.cc) 197 target_link_libraries(ssimulacra2 jxl_gauss_blur) 198 199 add_executable(butteraugli_main butteraugli_main.cc) 200 add_executable(decode_and_encode decode_and_encode.cc) 201 add_executable(display_to_hlg hdr/display_to_hlg.cc) 202 add_executable(exr_to_pq hdr/exr_to_pq.cc) 203 add_executable(pq_to_hlg hdr/pq_to_hlg.cc) 204 add_executable(render_hlg hdr/render_hlg.cc) 205 add_executable(local_tone_map hdr/local_tone_map.cc) 206 add_executable(tone_map hdr/tone_map.cc) 207 add_executable(texture_to_cube hdr/texture_to_cube.cc) 208 add_executable(generate_lut_template hdr/generate_lut_template.cc) 209 add_executable(xyb_range xyb_range.cc) 210 add_executable(jxl_from_tree jxl_from_tree.cc) 211 212 list(APPEND FUZZER_CORPUS_BINARIES djxl_fuzzer_corpus) 213 add_executable(djxl_fuzzer_corpus djxl_fuzzer_corpus.cc) 214 target_link_libraries(djxl_fuzzer_corpus 215 jxl_testlib-internal 216 jxl_extras-internal 217 jxl_tool 218 ) 219 if(JPEGXL_ENABLE_JPEGLI) 220 list(APPEND FUZZER_CORPUS_BINARIES jpegli_dec_fuzzer_corpus) 221 add_executable(jpegli_dec_fuzzer_corpus jpegli_dec_fuzzer_corpus.cc) 222 target_link_libraries(jpegli_dec_fuzzer_corpus 223 jpegli-static 224 jxl_tool 225 jxl_threads 226 ) 227 endif() 228 endif() # JPEGXL_ENABLE_DEVTOOLS 229 230 # Benchmark tools. 231 if(JPEGXL_ENABLE_BENCHMARK AND JPEGXL_ENABLE_TOOLS) 232 list(APPEND INTERNAL_TOOL_BINARIES 233 benchmark_xl 234 ) 235 236 add_executable(benchmark_xl 237 benchmark/benchmark_xl.cc 238 benchmark/benchmark_args.cc 239 benchmark/benchmark_codec.cc 240 benchmark/benchmark_file_io.cc 241 benchmark/benchmark_stats.cc 242 benchmark/benchmark_utils.cc 243 benchmark/benchmark_utils.h 244 benchmark/benchmark_codec_custom.cc 245 benchmark/benchmark_codec_custom.h 246 benchmark/benchmark_codec_jpeg.cc 247 benchmark/benchmark_codec_jpeg.h 248 benchmark/benchmark_codec_jxl.cc 249 benchmark/benchmark_codec_jxl.h 250 ssimulacra2.cc 251 ../third_party/dirent.cc 252 ) 253 target_link_libraries(benchmark_xl Threads::Threads) 254 target_link_libraries(benchmark_xl jxl_gauss_blur) # for ssimulacra 255 if(MINGW) 256 # MINGW doesn't support glob.h. 257 target_compile_definitions(benchmark_xl PRIVATE "-DHAS_GLOB=0") 258 endif() # MINGW 259 260 if(NOT JPEGXL_BUNDLE_LIBPNG) 261 find_package(PNG) 262 endif() 263 if(PNG_FOUND) 264 target_sources(benchmark_xl PRIVATE 265 "${CMAKE_CURRENT_LIST_DIR}/benchmark/benchmark_codec_png.cc" 266 "${CMAKE_CURRENT_LIST_DIR}/benchmark/benchmark_codec_png.h" 267 ) 268 target_compile_definitions(benchmark_xl PRIVATE -DBENCHMARK_PNG) 269 endif() 270 271 find_package(PkgConfig) 272 pkg_check_modules(WebP IMPORTED_TARGET libwebp) 273 if(WebP_FOUND) 274 target_sources(benchmark_xl PRIVATE 275 "${CMAKE_CURRENT_LIST_DIR}/benchmark/benchmark_codec_webp.cc" 276 "${CMAKE_CURRENT_LIST_DIR}/benchmark/benchmark_codec_webp.h" 277 ) 278 target_compile_definitions(benchmark_xl PRIVATE -DBENCHMARK_WEBP) 279 280 # Use the static version of webp if available. 281 find_library(WebP_STATIC_LINK_LIBRARY NAMES libwebp.a 282 PATHS "${WebP_LIBDIR}") 283 find_library(SharpYuv_STATIC_LINK_LIBRARY NAMES libsharpyuv.a 284 PATHS "${WebP_LIBDIR}") 285 if(NOT WebP_STATIC_LINK_LIBRARY) 286 message(WARNING "Using dynamic libwebp") 287 target_link_libraries(benchmark_xl PkgConfig::WebP) 288 else() 289 target_link_libraries(benchmark_xl "${WebP_STATIC_LINK_LIBRARY}") 290 if(SharpYuv_STATIC_LINK_LIBRARY) 291 target_link_libraries(benchmark_xl "${SharpYuv_STATIC_LINK_LIBRARY}") 292 endif() 293 target_include_directories(benchmark_xl 294 PRIVATE ${WebP_STATIC_INCLUDE_DIRS}) 295 target_compile_options(benchmark_xl PRIVATE ${WebP_STATIC_CFLAGS_OTHER}) 296 endif() # NOT WebP_STATIC_LINK_LIBRARY 297 endif() 298 299 pkg_check_modules(AVIF IMPORTED_TARGET libavif) 300 if(AVIF_FOUND) 301 target_sources(benchmark_xl PRIVATE 302 "${CMAKE_CURRENT_LIST_DIR}/benchmark/benchmark_codec_avif.cc" 303 "${CMAKE_CURRENT_LIST_DIR}/benchmark/benchmark_codec_avif.h" 304 ) 305 target_compile_definitions(benchmark_xl PRIVATE -DBENCHMARK_AVIF) 306 target_link_libraries(benchmark_xl PkgConfig::AVIF) 307 endif() 308 endif() # JPEGXL_ENABLE_BENCHMARK 309 310 # All tool binaries depend on "jxl" library and the tool helpers. 311 foreach(BINARY IN LISTS INTERNAL_TOOL_BINARIES) 312 target_link_libraries("${BINARY}" 313 jxl_extras-internal 314 jxl_threads 315 jxl_tool 316 ) 317 endforeach() 318 319 list(APPEND TOOL_BINARIES ${INTERNAL_TOOL_BINARIES} ${FUZZER_CORPUS_BINARIES}) 320 321 foreach(BINARY IN LISTS TOOL_BINARIES) 322 if(EMSCRIPTEN) 323 set(JXL_WASM_TOOLS_LINK_FLAGS "\ 324 -s USE_LIBPNG=1 \ 325 -s ALLOW_MEMORY_GROWTH=1 \ 326 ") 327 if (JPEGXL_ENABLE_WASM_TRHEADS) 328 set(JXL_WASM_TOOLS_LINK_FLAGS "${JXL_WASM_TOOLS_LINK_FLAGS} \ 329 -s USE_PTHREADS=1 \ 330 -s PTHREAD_POOL_SIZE=16 \ 331 ") 332 endif() 333 set_target_properties(${BINARY} PROPERTIES LINK_FLAGS "${JXL_WASM_TOOLS_LINK_FLAGS}") 334 endif() 335 endforeach() 336 337 install(TARGETS ${TOOL_BINARIES} RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}") 338 message(STATUS "Building tools: ${TOOL_BINARIES}") 339 340 # djxl_fuzzer builds even when not JPEGXL_ENABLE_TOOLS 341 set(FUZZER_BINARIES djxl_fuzzer) 342 if(JPEGXL_ENABLE_TOOLS) 343 list(APPEND FUZZER_BINARIES 344 color_encoding_fuzzer 345 decode_basic_info_fuzzer 346 cjxl_fuzzer 347 streaming_fuzzer 348 icc_codec_fuzzer 349 fields_fuzzer 350 rans_fuzzer 351 set_from_bytes_fuzzer 352 transforms_fuzzer 353 ) 354 if(JPEGXL_ENABLE_JPEGLI) 355 list(APPEND FUZZER_BINARIES jpegli_dec_fuzzer) 356 endif() 357 endif() 358 359 # Fuzzers. 360 foreach(FUZZER IN LISTS FUZZER_BINARIES) 361 if(JPEGXL_ENABLE_FUZZERS) 362 set(BINARY "${FUZZER}") 363 add_executable("${BINARY}" "${BINARY}.cc") 364 target_link_libraries("${BINARY}" ${JPEGXL_FUZZER_LINK_FLAGS}) 365 else() 366 # When not enabled we want a lightweight alternative for regular fuzzers 367 # that just run the target. 368 set(BINARY "${FUZZER}_runner") 369 add_executable("${BINARY}" EXCLUDE_FROM_ALL 370 "fuzzer_stub.cc" "${FUZZER}.cc") 371 endif() # JPEGXL_ENABLE_FUZZERS 372 target_include_directories("${BINARY}" PRIVATE "${CMAKE_SOURCE_DIR}") 373 if(FUZZER STREQUAL djxl_fuzzer) 374 target_link_libraries("${BINARY}" 375 jxl_dec-internal 376 jxl_threads 377 ) 378 elseif(FUZZER STREQUAL jpegli_dec_fuzzer) 379 target_link_libraries("${BINARY}" jpegli-static) 380 else() 381 target_link_libraries("${BINARY}" 382 jxl_testlib-internal 383 jxl_extras_nocodec-internal 384 jxl_tool 385 ) 386 endif() 387 endforeach() 388 389 # EMSCRIPTEN doesn't support dynamic libraries so testing for linkage there 390 # doesn't make much sense. 391 if(BUILD_TESTING AND TARGET jxl AND NOT JPEGXL_EMSCRIPTEN) 392 # Library API test. This test is only to check that we can link against the 393 # shared library from C99 file and don't need to use internal symbols. 394 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/tests) 395 add_executable(libjxl_test libjxl_test.c) 396 set_property(TARGET libjxl_test PROPERTY C_STANDARD 99) 397 if(NOT SANITIZER STREQUAL "none") 398 # Linking a C test binary with the C++ JPEG XL implementation when using 399 # address sanitizer is not well supported by clang 9, so force using clang++ 400 # for linking this test if a sanitizer is used. 401 set_target_properties(libjxl_test PROPERTIES LINKER_LANGUAGE CXX) 402 endif() # SANITIZER != "none" 403 set_target_properties(libjxl_test PROPERTIES PREFIX "tests/") 404 target_link_libraries(libjxl_test jxl) 405 if (NOT MSVC) 406 target_compile_options(libjxl_test PRIVATE -Wall -Wextra -Werror) 407 if(NOT WIN32) 408 target_compile_options(libjxl_test PRIVATE -pedantic) 409 endif() # NOT WIN32 410 endif() # NOT MSVC 411 412 add_test( 413 NAME LibraryCLinkageTest 414 COMMAND libjxl_test 415 WORKING_DIRECTORY $<TARGET_FILE_DIR:jxl> 416 ) 417 # if user decide to set CMAKE_SKIP_RPATH:BOOL=ON make sure libjxl.so.0.7 can 418 # still be found: 419 if(UNIX AND CMAKE_SKIP_RPATH) 420 set_property(TEST LibraryCLinkageTest PROPERTY ENVIRONMENT 421 LD_LIBRARY_PATH=${CMAKE_CURRENT_BINARY_DIR}/.. 422 ) 423 endif() 424 425 endif() # BUILD_TESTING AND TARGET jxl AND NOT JPEGXL_EMSCRIPTEN 426 427 # Tools defined in subdirectories. 428 if(JPEGXL_ENABLE_VIEWERS) 429 add_subdirectory(viewer) 430 add_subdirectory(comparison_viewer) 431 add_subdirectory(flicker_test) 432 endif() 433 434 add_subdirectory(conformance) 435 add_subdirectory(wasm_demo) 436 437 if(JPEGXL_ENABLE_JNI) 438 find_package(JNI QUIET) 439 find_package(Java QUIET) 440 441 if (JNI_FOUND AND Java_FOUND) 442 include(UseJava) 443 444 # decoder_jni_onload.cc might be necessary for Android; not used yet. 445 add_library(jxl_jni SHARED jni/org/jpeg/jpegxl/wrapper/decoder_jni.cc) 446 target_include_directories(jxl_jni PRIVATE "${JNI_INCLUDE_DIRS}" "${PROJECT_SOURCE_DIR}") 447 target_link_libraries(jxl_jni PUBLIC jxl_dec-internal jxl_threads) 448 if(NOT DEFINED JPEGXL_INSTALL_JNIDIR) 449 set(JPEGXL_INSTALL_JNIDIR ${CMAKE_INSTALL_LIBDIR}) 450 endif() 451 install(TARGETS jxl_jni DESTINATION ${JPEGXL_INSTALL_JNIDIR}) 452 453 add_jar(jxl_jni_wrapper SOURCES 454 jni/org/jpeg/jpegxl/wrapper/Decoder.java 455 jni/org/jpeg/jpegxl/wrapper/DecoderJni.java 456 jni/org/jpeg/jpegxl/wrapper/ImageData.java 457 jni/org/jpeg/jpegxl/wrapper/PixelFormat.java 458 jni/org/jpeg/jpegxl/wrapper/Status.java 459 jni/org/jpeg/jpegxl/wrapper/StreamInfo.java 460 OUTPUT_NAME org.jpeg.jpegxl 461 ) 462 get_target_property(JXL_JNI_WRAPPER_JAR jxl_jni_wrapper JAR_FILE) 463 if(NOT DEFINED JPEGXL_INSTALL_JARDIR) 464 set(JPEGXL_INSTALL_JARDIR ${CMAKE_INSTALL_LIBDIR}) 465 endif() 466 install_jar(jxl_jni_wrapper DESTINATION ${JPEGXL_INSTALL_JARDIR}) 467 468 add_jar(jxl_jni_wrapper_test 469 SOURCES jni/org/jpeg/jpegxl/wrapper/DecoderTest.java 470 INCLUDE_JARS jxl_jni_wrapper 471 ) 472 get_target_property(JXL_JNI_WRAPPER_TEST_JAR jxl_jni_wrapper_test JAR_FILE) 473 474 if(NOT SANITIZER MATCHES ".san") 475 # NB: Vanilla OpenJDK 8 / 11 are known to work well (i.e. either 476 # "which java" or JAVA_HOME environment variable point to the path like 477 # "/usr/lib/jvm/java-xx-openjdk-yyy" on Debian Linux). 478 add_test( 479 NAME test_jxl_jni_wrapper 480 COMMAND ${Java_JAVA_EXECUTABLE} 481 -cp "${JXL_JNI_WRAPPER_JAR}:${JXL_JNI_WRAPPER_TEST_JAR}" 482 -Dorg.jpeg.jpegxl.wrapper.lib=$<TARGET_FILE:jxl_jni> 483 org.jpeg.jpegxl.wrapper.DecoderTest 484 ) 485 endif() # JPEGXL_ENABLE_FUZZERS 486 endif() # JNI_FOUND & Java_FOUND 487 endif() # JPEGXL_ENABLE_JNI 488 489 # End-to-end tests for the tools 490 if(JPEGXL_TEST_TOOLS) 491 find_program (BASH_PROGRAM bash) 492 if (BASH_PROGRAM) 493 set(TEST_SCRIPTS) 494 find_package(JPEG) 495 if (JPEG_FOUND AND JPEGXL_ENABLE_TRANSCODE_JPEG) 496 list(APPEND TEST_SCRIPTS roundtrip_test) 497 endif() 498 if (JPEG_FOUND AND JPEGXL_ENABLE_JPEGLI) 499 list(APPEND TEST_SCRIPTS jpegli_tools_test) 500 endif() 501 foreach(SCRIPT IN LISTS TEST_SCRIPTS) 502 add_test(NAME ${SCRIPT} 503 COMMAND ${BASH_PROGRAM} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/${SCRIPT}.sh 504 ${CMAKE_BINARY_DIR}) 505 endforeach() 506 endif() # BASH_PROGRAM 507 endif() # JPEGXL_TEST_TOOLS