e8b40f3c2b
The Gordian knot that 7fec5074f9 attempted
to unravel was caused by the fact that there are several
data-precision-dependent (JSAMPLE-dependent) fields and methods in the
exposed libjpeg API structures, and if you change the exposed libjpeg
API structures, then you have to change the whole API. If you change
the whole API, then you have to provide a whole new library to support
the new API, and that makes it difficult to support multiple data
precisions in the same application. (It is not impossible, as example.c
demonstrated, but using data-precision-dependent libjpeg API structures
would have made the cjpeg, djpeg, and jpegtran source code hard to read,
so it made more sense to build, install, and package 12-bit-specific
versions of those applications.)
Unfortunately, the result of that initial integration effort was an
unreadable and unmaintainable mess, which is a problem for a library
that is an ISO/ITU-T reference implementation. Also, as I dug into the
problem of lossless JPEG support, I realized that 16-bit lossless JPEG
images are a thing, and supporting yet another version of the libjpeg
API just for those images is untenable.
In fact, however, the touch points for JSAMPLE in the exposed libjpeg
API structures are minimal:
- The colormap and sample_range_limit fields in jpeg_decompress_struct
- The alloc_sarray() and access_virt_sarray() methods in
jpeg_memory_mgr
- jpeg_write_scanlines() and jpeg_write_raw_data()
- jpeg_read_scanlines() and jpeg_read_raw_data()
- jpeg_skip_scanlines() and jpeg_crop_scanline()
(This is subtle, but both of those functions use JSAMPLE-dependent
opaque structures behind the scenes.)
It is much more readable and maintainable to provide 12-bit-specific
versions of those six top-level API functions and to document that the
aforementioned methods and fields must be type-cast when using 12-bit
samples. Since that eliminates the need to provide a 12-bit-specific
version of the exposed libjpeg API structures, we can:
- Compile only the precision-dependent libjpeg modules (the
coefficient buffer controllers, the colorspace converters, the
DCT/IDCT managers, the main buffer controllers, the preprocessing
and postprocessing controller, the downsampler and upsamplers, the
quantizers, the integer DCT methods, and the IDCT methods) for
multiple data precisions.
- Introduce 12-bit-specific methods into the various internal
structures defined in jpegint.h.
- Create precision-independent data type, macro, method, field, and
function names that are prefixed by an underscore, and use an
internal header to convert those into precision-dependent data
type, macro, method, field, and function names, based on the value
of BITS_IN_JSAMPLE, when compiling the precision-dependent libjpeg
modules.
- Expose precision-dependent jinit*() functions for each of the
precision-dependent libjpeg modules.
- Abstract the precision-dependent libjpeg modules by calling the
appropriate precision-dependent jinit*() function, based on the
value of cinfo->data_precision, from top-level libjpeg API
functions.
117 lines
4.5 KiB
CMake
117 lines
4.5 KiB
CMake
# Anything that must be linked against the shared C library on Windows must
|
|
# be built in this subdirectory, because CMake doesn't allow us to override
|
|
# the compiler flags for each build type except at directory scope. Note
|
|
# to CMake developers: Add a COMPILE_FLAGS_<CONFIG> target property, or
|
|
# better yet, provide a friendly way of configuring a Windows target to use the
|
|
# static C library.
|
|
|
|
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
|
|
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
|
|
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/..)
|
|
|
|
if(MSVC)
|
|
# Build all configurations against shared C library
|
|
foreach(var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
|
|
CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
|
|
if(${var} MATCHES "/MT")
|
|
string(REGEX REPLACE "/MT" "/MD" ${var} "${${var}}")
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
|
|
foreach(src ${JPEG_SOURCES})
|
|
set(JPEG_SRCS ${JPEG_SRCS} ../${src})
|
|
endforeach()
|
|
|
|
if(WITH_SIMD AND (MSVC_IDE OR XCODE))
|
|
# This tells CMake that the "source" files haven't been generated yet
|
|
set_source_files_properties(${SIMD_OBJS} PROPERTIES GENERATED 1)
|
|
endif()
|
|
|
|
if(WIN32)
|
|
set(DEFFILE ../win/jpeg${SO_MAJOR_VERSION}.def)
|
|
endif()
|
|
if(MSVC)
|
|
configure_file(${CMAKE_SOURCE_DIR}/win/jpeg.rc.in
|
|
${CMAKE_BINARY_DIR}/win/jpeg.rc)
|
|
set(JPEG_SRCS ${JPEG_SRCS} ${CMAKE_BINARY_DIR}/win/jpeg.rc)
|
|
endif()
|
|
add_library(jpeg SHARED ${JPEG_SRCS} ${DEFFILE} $<TARGET_OBJECTS:simd>
|
|
${SIMD_OBJS} ${JPEG12_OBJS})
|
|
|
|
set_target_properties(jpeg PROPERTIES SOVERSION ${SO_MAJOR_VERSION}
|
|
VERSION ${SO_MAJOR_VERSION}.${SO_AGE}.${SO_MINOR_VERSION})
|
|
if(APPLE AND (NOT CMAKE_OSX_DEPLOYMENT_TARGET OR
|
|
CMAKE_OSX_DEPLOYMENT_TARGET VERSION_GREATER 10.4))
|
|
if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
|
|
set(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-rpath,")
|
|
endif()
|
|
set_target_properties(jpeg PROPERTIES MACOSX_RPATH 1)
|
|
endif()
|
|
if(MAPFLAG)
|
|
set_target_properties(jpeg PROPERTIES
|
|
LINK_FLAGS "${MAPFLAG}${CMAKE_CURRENT_BINARY_DIR}/../libjpeg.map")
|
|
endif()
|
|
if(MSVC)
|
|
set_target_properties(jpeg PROPERTIES
|
|
RUNTIME_OUTPUT_NAME jpeg${SO_MAJOR_VERSION})
|
|
# The jsimd_*.c file is built using /MT, so this prevents a linker warning.
|
|
set_target_properties(jpeg PROPERTIES LINK_FLAGS
|
|
"/NODEFAULTLIB:LIBCMT /NODEFAULTLIB:LIBCMTD")
|
|
elseif(MINGW)
|
|
set_target_properties(jpeg PROPERTIES SUFFIX -${SO_MAJOR_VERSION}.dll)
|
|
endif()
|
|
|
|
if(WIN32)
|
|
set(USE_SETMODE "-DUSE_SETMODE")
|
|
endif()
|
|
set(CDJPEG_COMPILE_FLAGS
|
|
"-DBMP_SUPPORTED -DGIF_SUPPORTED -DPPM_SUPPORTED -DTARGA_SUPPORTED ${USE_SETMODE}")
|
|
|
|
# Compile a separate version of these source files with 12-bit data precision.
|
|
if(WITH_12BIT)
|
|
add_library(cjpeg12 OBJECT ../rdgif.c ../rdppm.c)
|
|
set_property(TARGET cjpeg12 PROPERTY COMPILE_FLAGS
|
|
"-DBITS_IN_JSAMPLE=12 -DGIF_SUPPORTED -DPPM_SUPPORTED")
|
|
set(CJPEG12_OBJS $<TARGET_OBJECTS:cjpeg12>)
|
|
endif()
|
|
add_executable(cjpeg ../cjpeg.c ../cdjpeg.c ../rdbmp.c ../rdgif.c ../rdppm.c
|
|
../rdswitch.c ../rdtarga.c ${CJPEG12_OBJS})
|
|
set_property(TARGET cjpeg PROPERTY COMPILE_FLAGS ${CDJPEG_COMPILE_FLAGS})
|
|
target_link_libraries(cjpeg jpeg)
|
|
|
|
# Compile a separate version of these source files with 12-bit data precision.
|
|
if(WITH_12BIT)
|
|
add_library(djpeg12 OBJECT ../rdcolmap.c ../wrgif.c ../wrppm.c)
|
|
set_property(TARGET djpeg12 PROPERTY COMPILE_FLAGS
|
|
"-DBITS_IN_JSAMPLE=12 -DGIF_SUPPORTED -DPPM_SUPPORTED")
|
|
set(DJPEG12_OBJS $<TARGET_OBJECTS:djpeg12>)
|
|
endif()
|
|
add_executable(djpeg ../djpeg.c ../cdjpeg.c ../rdcolmap.c ../rdswitch.c
|
|
../wrbmp.c ../wrgif.c ../wrppm.c ../wrtarga.c ${DJPEG12_OBJS})
|
|
set_property(TARGET djpeg PROPERTY COMPILE_FLAGS ${CDJPEG_COMPILE_FLAGS})
|
|
target_link_libraries(djpeg jpeg)
|
|
|
|
add_executable(jpegtran ../jpegtran.c ../cdjpeg.c ../rdswitch.c ../transupp.c)
|
|
target_link_libraries(jpegtran jpeg)
|
|
set_property(TARGET jpegtran PROPERTY COMPILE_FLAGS "${USE_SETMODE}")
|
|
|
|
add_executable(example ../example.c)
|
|
target_link_libraries(example jpeg)
|
|
|
|
add_executable(jcstest ../jcstest.c)
|
|
target_link_libraries(jcstest jpeg)
|
|
|
|
install(TARGETS jpeg EXPORT ${CMAKE_PROJECT_NAME}Targets
|
|
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
|
|
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
|
|
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
|
|
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
|
|
install(TARGETS cjpeg djpeg jpegtran
|
|
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
|
|
if(NOT CMAKE_VERSION VERSION_LESS "3.1" AND MSVC AND
|
|
CMAKE_C_LINKER_SUPPORTS_PDB)
|
|
install(FILES "$<TARGET_PDB_FILE:jpeg>"
|
|
DESTINATION ${CMAKE_INSTALL_BINDIR} OPTIONAL)
|
|
endif()
|