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