jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

deps: Update CMakeLists.txt for dependencies

master
PatTheMav 2021-11-29 22:02:23 +01:00
parent b667fb3eff
commit dba1041034
No known key found for this signature in database
GPG Key ID: CEFD5D83C12A66B3
13 changed files with 809 additions and 941 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
deps/CMakeLists.txt vendored
View File

@ -1,39 +1,27 @@
if(OS_WINDOWS)
if(NOT MINGW)
add_subdirectory(w32-pthreads)
endif()
add_subdirectory(ipc-util)
if(NOT MINGW)
add_subdirectory(w32-pthreads)
endif()
add_subdirectory(glad)
add_subdirectory(ipc-util)
if(BUILD_LIBFF)
add_subdirectory(libff)
endif()
add_subdirectory(media-playback)
add_subdirectory(file-updater)
add_subdirectory(obs-scripting)
add_subdirectory(opts-parser)
if(WIN32)
add_subdirectory(blake2)
add_subdirectory(lzma)
endif()
add_subdirectory(glad)
add_subdirectory(media-playback)
add_subdirectory(file-updater)
add_subdirectory(obs-scripting)
add_subdirectory(opts-parser)
add_subdirectory(libcaption)
# Use bundled jansson version as fallback
find_package(Jansson 2.5 QUIET)
if(NOT JANSSON_FOUND)
message(STATUS "Jansson >=2.5 not found, building bundled version")
if(NOT TARGET Jansson::Jansson)
message(STATUS "OBS: Jansson >=2.5 not found, building bundled version")
add_subdirectory(jansson)
set(OBS_JANSSON_IMPORT "jansson" CACHE INTERNAL "Internal var")
set(OBS_JANSSON_INCLUDE_DIRS "" CACHE INTERNAL "Internal var")
add_library(Jansson::Jansson ALIAS jansson)
else()
message(STATUS "Using system Jansson library")
set(OBS_JANSSON_IMPORT "${JANSSON_LIBRARIES}" CACHE INTERNAL "Internal var")
set(OBS_JANSSON_INCLUDE_DIRS "${JANSSON_INCLUDE_DIRS}" CACHE INTERNAL "Internal var")
message(STATUS "OBS: OBS-Studio - Using system Jansson library")
endif()

33
deps/blake2/CMakeLists.txt vendored
View File

@ -1,33 +1,18 @@
cmake_minimum_required(VERSION 3.2)
project(blake2)
set(BLAKE2_INCLUDE_DIR
"${CMAKE_CURRENT_SOURCE_DIR}/src"
CACHE PATH "blake2 include path")
add_library(blake2 STATIC)
add_library(OBS::blake2 ALIAS blake2)
include_directories(
${LIBblake2_INCLUDE_DIRS}
src
)
target_sources(blake2 PRIVATE src/blake2b-ref.c src/blake2.h src/blake2-impl.h)
if(WIN32)
target_include_directories(blake2 PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src)
if(OS_WINDOWS)
if(MSVC)
add_compile_options($<IF:$<CONFIG:Debug>,/MTd,/MT> /Zl)
target_compile_options(blake2 PRIVATE "$<IF:$<CONFIG:Debug>,/MTd,/MT>" /Zl)
endif()
add_definitions(
-Dinline=_inline
-Drestrict=__restrict)
target_compile_definitions(blake2 PRIVATE inline=_inline restrict=__restrict)
endif()
set(blake2_SOURCES
src/blake2b-ref.c)
set(blake2_HEADERS
src/blake2.h
src/blake2-impl.h)
add_library(blake2 STATIC
${blake2_SOURCES}
${blake2_HEADERS})
set_target_properties(blake2 PROPERTIES FOLDER "deps")

32
deps/file-updater/CMakeLists.txt vendored
View File

@ -1,31 +1,17 @@
project(file-updater)
find_package(Libcurl REQUIRED)
find_package(CURL REQUIRED)
include_directories(${LIBCURL_INCLUDE_DIRS})
add_library(file-updater INTERFACE)
add_library(OBS::file-updater ALIAS file-updater)
if(WIN32 AND NOT MINGW)
include_directories(../w32-pthreads)
set(file-updater_PLATFORM_DEPS
w32-pthreads)
endif()
set(file-updater_HEADERS
target_sources(file-updater INTERFACE file-updater/file-updater.c
file-updater/file-updater.h)
set(file-updater_SOURCES
file-updater/file-updater.c)
add_library(file-updater STATIC
${file-updater_SOURCES}
${file-updater_HEADERS})
target_link_libraries(file-updater INTERFACE CURL::libcurl)
target_include_directories(file-updater
PUBLIC .)
target_include_directories(file-updater INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(file-updater
${LIBCURL_LIBRARIES}
${file-updater_PLATFORM_DEPS}
libobs)
set_target_properties(file-updater PROPERTIES
FOLDER "deps"
POSITION_INDEPENDENT_CODE ON)
if(OS_WINDOWS AND NOT MINGW)
target_link_libraries(file-updater INTERFACE OBS::w32-pthreads)
endif()

101
deps/glad/CMakeLists.txt vendored
View File

@ -1,76 +1,51 @@
project(glad)
find_package(OpenGL)
find_package(OpenGL REQUIRED)
if(NOT WIN32 AND NOT APPLE)
find_package(X11 REQUIRED)
find_package(EGL REQUIRED)
endif()
add_library(glad SHARED)
add_library(OBS::obsglad ALIAS glad)
set(glad_SOURCES
src/glad.c
include/glad/glad.h)
target_sources(glad PRIVATE src/glad.c include/glad/glad.h)
if(WIN32)
set(MODULE_DESCRIPTION "Glad OpenGL Loading Library")
configure_file(${CMAKE_SOURCE_DIR}/cmake/winrc/obs-module.rc.in obsglad.rc)
set(glad_PLATFORM_SOURCES
src/glad_wgl.c
include/glad/glad_wgl.h
obsglad.rc)
elseif(NOT APPLE)
set(glad_PLATFORM_SOURCES
src/glad_egl.c
src/glad_glx.c
include/glad/glad_egl.h
include/glad/glad_glx.h)
endif()
target_include_directories(glad PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
set(glad_include_dirs
PRIVATE ${OPENGL_INCLUDE_DIR})
target_compile_definitions(glad PRIVATE GLAD_GLAPI_EXPORT_BUILD)
if (UNIX AND NOT APPLE)
list (APPEND glad_include_dirs
PRIVATE
${X11_X11_INCLUDE_PATH}
${EGL_INCLUDE_DIRS})
endif()
target_link_libraries(glad PUBLIC OpenGL::GL)
add_library(glad SHARED
${glad_SOURCES}
${glad_PLATFORM_SOURCES})
set_target_properties(glad PROPERTIES
set_target_properties(
glad
PROPERTIES OUTPUT_NAME obsglad
FOLDER "deps"
OUTPUT_NAME obsglad
VERSION "0"
SOVERSION "0"
POSITION_INDEPENDENT_CODE ON)
target_include_directories(glad
PUBLIC include
${glad_include_dirs})
target_compile_definitions(glad
PRIVATE GLAD_GLAPI_EXPORT_BUILD)
VERSION "${OBS_VERSION_MAJOR}"
SOVERSION "1")
if(OS_WINDOWS)
set(MODULE_DESCRIPTION "Glad OpenGL Loading Library")
configure_file(${CMAKE_SOURCE_DIR}/cmake/bundle/windows/obs-module.rc.in
obsglad.rc)
target_sources(glad PRIVATE src/glad_wgl.c include/glad/glad_wgl.h obsglad.rc)
elseif(OS_POSIX AND NOT OS_MACOS)
find_package(OpenGL REQUIRED)
find_package(X11 REQUIRED)
target_link_libraries(glad PRIVATE X11::X11)
target_sources(glad PRIVATE src/glad_glx.c include/glad/glad_glx.h)
if(TARGET OpenGL::EGL)
target_sources(glad PRIVATE src/glad_egl.c include/glad/glad_egl.h)
target_link_libraries(glad PRIVATE OpenGL::EGL)
endif()
endif()
if(NOT MSVC)
target_compile_options(glad
PRIVATE -DPIC -fvisibility=hidden)
target_compile_options(glad PRIVATE -fvisibility=hidden)
endif()
if(NOT WIN32 AND NOT APPLE)
set(glad_PLATFORM_DEPS
${X11_X11_LIB}
${EGL_LIBRARIES})
# only link to libdl on linux
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
set(glad_PLATFORM_DEPS
${glad_PLATFORM_DEPS}
-ldl)
endif()
endif()
target_link_libraries(glad
${glad_PLATFORM_DEPS}
${OPENGL_gl_LIBRARY})
install_obs_core(glad)
setup_binary_target(glad)

50
deps/ipc-util/CMakeLists.txt vendored
View File

@ -1,37 +1,23 @@
# TODO: Add posix support
if(NOT WIN32)
return()
endif()
project(ipc-util)
set(ipc-util_HEADERS
ipc-util/pipe.h)
add_library(ipc-util STATIC)
add_library(OBS::ipc-util ALIAS ipc-util)
if(WIN32)
set(ipc-util_HEADERS
${ipc-util_HEADERS}
ipc-util/pipe-windows.h)
set(ipc-util_SOURCES
ipc-util/pipe-windows.c)
else()
set(ipc-util_HEADERS
${ipc-util_HEADERS}
ipc-util/pipe-posix.h)
set(ipc-util_SOURCES
ipc-util/pipe-posix.c)
endif()
target_sources(ipc-util PRIVATE ipc-util/pipe.h)
if(MSVC)
add_compile_options($<IF:$<CONFIG:Debug>,/MTd,/MT> /Zl)
endif()
add_library(ipc-util STATIC
${ipc-util_SOURCES}
${ipc-util_HEADERS})
set_target_properties(ipc-util PROPERTIES
FOLDER "deps"
set_target_properties(ipc-util PROPERTIES FOLDER "deps"
POSITION_INDEPENDENT_CODE ON)
target_include_directories(ipc-util
PUBLIC .)
target_link_libraries(ipc-util)
target_include_directories(ipc-util PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
if(OS_WINDOWS)
if(MSVC)
target_compile_options(ipc-util PRIVATE "$<IF:$<CONFIG:Debug>,/MTd,/MT>"
/Zl)
endif()
target_sources(ipc-util PRIVATE ipc-util/pipe-windows.c
ipc-util/pipe-windows.h)
else()
target_sources(ipc-util PRIVATE ipc-util/pipe-posix.c ipc-util/pipe-posic.h)
endif()

679
deps/jansson/CMakeLists.txt vendored
View File

@ -1,12 +1,10 @@
# Notes:
#
# Author: Paul Harris, June 2012
# Additions: Joakim Soderberg, Febuary 2013
# Author: Paul Harris, June 2012 Additions: Joakim Soderberg, Febuary 2013
#
# Supports: building static/shared, release/debug/etc, can also build html docs
# and some of the tests.
# Note that its designed for out-of-tree builds, so it will not pollute your
# source tree.
# and some of the tests. Note that its designed for out-of-tree builds, so it
# will not pollute your source tree.
#
# TODO 1: Finish implementing tests. api tests are working, but the valgrind
# variants are not flagging problems.
@ -15,60 +13,53 @@
#
# TODO 3: Consolidate version numbers, currently the version number is written
# into: * cmake (here) * autotools (the configure) * source code header files.
# Should not be written directly into header files, autotools/cmake can do
# that job.
# Should not be written directly into header files, autotools/cmake can do that
# job.
#
# Brief intro on how to use cmake:
# > mkdir build (somewhere - we do out-of-tree builds)
# > use cmake, ccmake, or cmake-gui to configure the project. for linux, you
# can only choose one variant: release,debug,etc... and static or shared.
# >> example:
# >> cd build
# >> ccmake -i ../path_to_jansson_dir
# >> inside, configure your options. press C until there are no lines
# with * next to them.
# >> note, I like to configure the 'install' path to ../install, so I get
# self-contained clean installs I can point other projects to.
# >> press G to 'generate' the project files.
# >> make (to build the project)
# >> make install
# >> make test (to run the tests, if you enabled them)
# Brief intro on how to use cmake: > mkdir build (somewhere - we do out-of-tree
# builds) > use cmake, ccmake, or cmake-gui to configure the project. for linux,
# you can only choose one variant: release,debug,etc... and static or shared. >>
# example: >> cd build >> ccmake -i ../path_to_jansson_dir >> inside, configure
# your options. press C until there are no lines with * next to them. >> note,
# I like to configure the 'install' path to ../install, so I get self-contained
# clean installs I can point other projects to. >> press G to 'generate' the
# project files. >> make (to build the project) >> make install >> make test (to
# run the tests, if you enabled them)
#
# Brief description on how it works:
# There is a small heirachy of CMakeLists.txt files which define how the
# project is built.
# Header file detection etc is done, and the results are written into config.h
# and jansson_config.h, which are generated from the corresponding
# config.h.cmake and jansson_config.h.cmake template files.
# The generated header files end up in the build directory - not in
# the source directory.
# The rest is down to the usual make process.
# Brief description on how it works: There is a small heirachy of CMakeLists.txt
# files which define how the project is built. Header file detection etc is
# done, and the results are written into config.h and jansson_config.h, which
# are generated from the corresponding config.h.cmake and jansson_config.h.cmake
# template files. The generated header files end up in the build directory - not
# in the source directory. The rest is down to the usual make process.
cmake_minimum_required (VERSION 2.8.12)
cmake_minimum_required(VERSION 2.8.12)
# required for exports? cmake_minimum_required (VERSION 2.8.6)
project (jansson C)
project(jansson C)
# Options
option(JANSSON_BUILD_SHARED_LIBS "Build shared libraries." OFF)
option(USE_URANDOM "Use /dev/urandom to seed the hash function." ON)
option(USE_WINDOWS_CRYPTOAPI "Use CryptGenRandom to seed the hash function." ON)
if (MSVC)
# This option must match the settings used in your program, in particular if you
# are linking statically
option(JANSSON_STATIC_CRT "Link the static CRT libraries" ON )
endif ()
if(MSVC)
# This option must match the settings used in your program, in particular if
# you are linking statically
option(JANSSON_STATIC_CRT "Link the static CRT libraries" ON)
endif()
# Disabled by OBS
option(JANSSON_EXAMPLES "Compile example applications" OFF)
if (UNIX)
option(JANSSON_COVERAGE "(GCC Only! Requires gcov/lcov to be installed). Include target for doing coverage analysis for the test suite. Note that -DCMAKE_BUILD_TYPE=Debug must be set" OFF)
if(UNIX)
option(
JANSSON_COVERAGE
"(GCC Only! Requires gcov/lcov to be installed). Include target for doing coverage analysis for the test suite. Note that -DCMAKE_BUILD_TYPE=Debug must be set"
OFF)
option(JANSSON_COVERALLS "Generate coverage info for Coveralls" OFF)
option(JANSSON_COVERALLS_UPLOAD "Upload coverage info to Coveralls (Only works via Travis)" ON)
endif ()
option(JANSSON_COVERALLS_UPLOAD
"Upload coverage info to Coveralls (Only works via Travis)" ON)
endif()
# Set some nicer output dirs.
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
@ -76,16 +67,14 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
set(JANSSON_TEMP_DIR ${PROJECT_BINARY_DIR}/tmp)
# Give the debug version a different postfix for windows,
# so both the debug and release version can be built in the
# same build-tree on Windows (MSVC).
if (WIN32)
# Give the debug version a different postfix for windows, so both the debug and
# release version can be built in the same build-tree on Windows (MSVC).
if(WIN32)
set(CMAKE_DEBUG_POSTFIX "_d")
endif (WIN32)
endif(WIN32)
# This is how I thought it should go
# set (JANSSON_VERSION "2.3.1")
# set (JANSSON_SOVERSION 2)
# This is how I thought it should go set (JANSSON_VERSION "2.3.1") set
# (JANSSON_SOVERSION 2)
set(JANSSON_DISPLAY_VERSION "2.9")
@ -96,19 +85,19 @@ set(JANSSON_SOVERSION 4)
# for CheckFunctionKeywords
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
include (CheckCSourceCompiles)
include (CheckFunctionExists)
include (CheckFunctionKeywords)
include (CheckIncludeFiles)
include (CheckTypeSize)
include(CheckCSourceCompiles)
include(CheckFunctionExists)
include(CheckFunctionKeywords)
include(CheckIncludeFiles)
include(CheckTypeSize)
if (MSVC)
if(MSVC)
# Turn off Microsofts "security" warnings.
add_definitions( "/W3 /D_CRT_SECURE_NO_WARNINGS /wd4005 /wd4996 /nologo" )
add_definitions("/W3 /D_CRT_SECURE_NO_WARNINGS /wd4005 /wd4996 /nologo")
# Disabled by OBS, options already set by top level CMakeLists
if (FALSE)
if (JANSSON_STATIC_CRT)
if(FALSE)
if(JANSSON_STATIC_CRT)
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
endif()
@ -116,18 +105,18 @@ if (MSVC)
endif()
if (NOT WIN32 AND NOT APPLE)
if(NOT WIN32 AND NOT APPLE)
add_definitions("-fPIC")
endif()
message("C compiler: ${CMAKE_C_COMPILER_ID}")
# Coverage only works with GCC for a debug build.
if (JANSSON_COVERALLS)
if(JANSSON_COVERALLS)
set(JANSSON_COVERAGE ON)
endif()
if (JANSSON_COVERAGE)
if(JANSSON_COVERAGE)
include(CodeCoverage)
include(Coveralls)
@ -135,88 +124,88 @@ if (JANSSON_COVERAGE)
coveralls_turn_on_coverage()
endif()
check_include_files (endian.h HAVE_ENDIAN_H)
check_include_files (fcntl.h HAVE_FCNTL_H)
check_include_files (sched.h HAVE_SCHED_H)
check_include_files (unistd.h HAVE_UNISTD_H)
check_include_files (sys/param.h HAVE_SYS_PARAM_H)
check_include_files (sys/stat.h HAVE_SYS_STAT_H)
check_include_files (sys/time.h HAVE_SYS_TIME_H)
check_include_files (sys/time.h HAVE_SYS_TYPES_H)
check_include_files(endian.h HAVE_ENDIAN_H)
check_include_files(fcntl.h HAVE_FCNTL_H)
check_include_files(sched.h HAVE_SCHED_H)
check_include_files(unistd.h HAVE_UNISTD_H)
check_include_files(sys/param.h HAVE_SYS_PARAM_H)
check_include_files(sys/stat.h HAVE_SYS_STAT_H)
check_include_files(sys/time.h HAVE_SYS_TIME_H)
check_include_files(sys/time.h HAVE_SYS_TYPES_H)
check_function_exists (close HAVE_CLOSE)
check_function_exists (getpid HAVE_GETPID)
check_function_exists (gettimeofday HAVE_GETTIMEOFDAY)
check_function_exists (open HAVE_OPEN)
check_function_exists (read HAVE_READ)
check_function_exists (sched_yield HAVE_SCHED_YIELD)
check_function_exists(close HAVE_CLOSE)
check_function_exists(getpid HAVE_GETPID)
check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
check_function_exists(open HAVE_OPEN)
check_function_exists(read HAVE_READ)
check_function_exists(sched_yield HAVE_SCHED_YIELD)
# Check for the int-type includes
check_include_files (stdint.h HAVE_STDINT_H)
check_include_files(stdint.h HAVE_STDINT_H)
# Check our 64 bit integer sizes
check_type_size (__int64 __INT64)
check_type_size (int64_t INT64_T)
check_type_size ("long long" LONG_LONG_INT)
check_type_size(__int64 __INT64)
check_type_size(int64_t INT64_T)
check_type_size("long long" LONG_LONG_INT)
# Check our 32 bit integer sizes
check_type_size (int32_t INT32_T)
check_type_size (__int32 __INT32)
check_type_size ("long" LONG_INT)
check_type_size ("int" INT)
if (HAVE_INT32_T)
set (JSON_INT32 int32_t)
elseif (HAVE___INT32)
set (JSON_INT32 __int32)
elseif (HAVE_LONG_INT AND (${LONG_INT} EQUAL 4))
set (JSON_INT32 long)
elseif (HAVE_INT AND (${INT} EQUAL 4))
set (JSON_INT32 int)
else ()
message (FATAL_ERROR "Could not detect a valid 32-bit integer type")
endif ()
check_type_size(int32_t INT32_T)
check_type_size(__int32 __INT32)
check_type_size("long" LONG_INT)
check_type_size("int" INT)
if(HAVE_INT32_T)
set(JSON_INT32 int32_t)
elseif(HAVE___INT32)
set(JSON_INT32 __int32)
elseif(HAVE_LONG_INT AND (${LONG_INT} EQUAL 4))
set(JSON_INT32 long)
elseif(HAVE_INT AND (${INT} EQUAL 4))
set(JSON_INT32 int)
else()
message(FATAL_ERROR "Could not detect a valid 32-bit integer type")
endif()
check_type_size ("unsigned long" UNSIGNED_LONG_INT)
check_type_size ("unsigned int" UNSIGNED_INT)
check_type_size ("unsigned short" UNSIGNED_SHORT)
check_type_size("unsigned long" UNSIGNED_LONG_INT)
check_type_size("unsigned int" UNSIGNED_INT)
check_type_size("unsigned short" UNSIGNED_SHORT)
check_type_size (uint32_t UINT32_T)
check_type_size (__uint32 __UINT32)
if (HAVE_UINT32_T)
set (JSON_UINT32 uint32_t)
elseif (HAVE___UINT32)
set (JSON_UINT32 __uint32)
elseif (HAVE_UNSIGNED_LONG_INT AND (${UNSIGNED_LONG_INT} EQUAL 4))
set (JSON_UINT32 "unsigned long")
elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 4))
set (JSON_UINT32 "unsigned int")
else ()
message (FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
endif ()
check_type_size(uint32_t UINT32_T)
check_type_size(__uint32 __UINT32)
if(HAVE_UINT32_T)
set(JSON_UINT32 uint32_t)
elseif(HAVE___UINT32)
set(JSON_UINT32 __uint32)
elseif(HAVE_UNSIGNED_LONG_INT AND (${UNSIGNED_LONG_INT} EQUAL 4))
set(JSON_UINT32 "unsigned long")
elseif(HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 4))
set(JSON_UINT32 "unsigned int")
else()
message(FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
endif()
check_type_size (uint16_t UINT16_T)
check_type_size (__uint16 __UINT16)
if (HAVE_UINT16_T)
set (JSON_UINT16 uint16_t)
elseif (HAVE___UINT16)
set (JSON_UINT16 __uint16)
elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 2))
set (JSON_UINT16 "unsigned int")
elseif (HAVE_UNSIGNED_SHORT AND (${UNSIGNED_SHORT} EQUAL 2))
set (JSON_UINT16 "unsigned short")
else ()
message (FATAL_ERROR "Could not detect a valid unsigned 16-bit integer type")
endif ()
check_type_size(uint16_t UINT16_T)
check_type_size(__uint16 __UINT16)
if(HAVE_UINT16_T)
set(JSON_UINT16 uint16_t)
elseif(HAVE___UINT16)
set(JSON_UINT16 __uint16)
elseif(HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 2))
set(JSON_UINT16 "unsigned int")
elseif(HAVE_UNSIGNED_SHORT AND (${UNSIGNED_SHORT} EQUAL 2))
set(JSON_UINT16 "unsigned short")
else()
message(FATAL_ERROR "Could not detect a valid unsigned 16-bit integer type")
endif()
check_type_size (uint8_t UINT8_T)
check_type_size (__uint8 __UINT8)
if (HAVE_UINT8_T)
set (JSON_UINT8 uint8_t)
elseif (HAVE___UINT8)
set (JSON_UINT8 __uint8)
else ()
set (JSON_UINT8 "unsigned char")
endif ()
check_type_size(uint8_t UINT8_T)
check_type_size(__uint8 __UINT8)
if(HAVE_UINT8_T)
set(JSON_UINT8 uint8_t)
elseif(HAVE___UINT8)
set(JSON_UINT8 __uint8)
else()
set(JSON_UINT8 "unsigned char")
endif()
# Check for ssize_t and SSIZE_T existance.
check_type_size(ssize_t SSIZE_T)
@ -231,106 +220,116 @@ endif()
set(CMAKE_EXTRA_INCLUDE_FILES "")
# Check for all the variants of strtoll
check_function_exists (strtoll HAVE_STRTOLL)
check_function_exists (strtoq HAVE_STRTOQ)
check_function_exists (_strtoi64 HAVE__STRTOI64)
check_function_exists(strtoll HAVE_STRTOLL)
check_function_exists(strtoq HAVE_STRTOQ)
check_function_exists(_strtoi64 HAVE__STRTOI64)
# Figure out what variant we should use
if (HAVE_STRTOLL)
set (JSON_STRTOINT strtoll)
elseif (HAVE_STRTOQ)
set (JSON_STRTOINT strtoq)
elseif (HAVE__STRTOI64)
set (JSON_STRTOINT _strtoi64)
else ()
# fallback to strtol (32 bit)
# this will set all the required variables
set (JSON_STRTOINT strtol)
set (JSON_INT_T long)
set (JSON_INTEGER_FORMAT "\"ld\"")
endif ()
if(HAVE_STRTOLL)
set(JSON_STRTOINT strtoll)
elseif(HAVE_STRTOQ)
set(JSON_STRTOINT strtoq)
elseif(HAVE__STRTOI64)
set(JSON_STRTOINT _strtoi64)
else()
# fallback to strtol (32 bit) this will set all the required variables
set(JSON_STRTOINT strtol)
set(JSON_INT_T long)
set(JSON_INTEGER_FORMAT "\"ld\"")
endif()
# if we haven't defined JSON_INT_T, then we have a 64 bit conversion function.
# detect what to use for the 64 bit type.
# Note: I will prefer long long if I can get it, as that is what the automake system aimed for.
if (NOT DEFINED JSON_INT_T)
if (HAVE_LONG_LONG_INT AND ((${LONG_LONG_INT}) EQUAL 8))
set (JSON_INT_T "long long")
elseif (HAVE_INT64_T)
set (JSON_INT_T int64_t)
elseif (HAVE___INT64)
set (JSON_INT_T __int64)
else ()
message (FATAL_ERROR "Could not detect 64 bit type, although I detected the strtoll equivalent")
endif ()
# detect what to use for the 64 bit type. Note: I will prefer long long if I can
# get it, as that is what the automake system aimed for.
if(NOT DEFINED JSON_INT_T)
if(HAVE_LONG_LONG_INT AND ((${LONG_LONG_INT}) EQUAL 8))
set(JSON_INT_T "long long")
elseif(HAVE_INT64_T)
set(JSON_INT_T int64_t)
elseif(HAVE___INT64)
set(JSON_INT_T __int64)
else()
message(
FATAL_ERROR
"Could not detect 64 bit type, although I detected the strtoll equivalent"
)
endif()
# Apparently, Borland BCC and MSVC wants I64d,
# Borland BCC could also accept LD
# and gcc wants ldd,
# I am not sure what cygwin will want, so I will assume I64d
if (WIN32) # matches both msvc and cygwin
set (JSON_INTEGER_FORMAT "\"I64d\"")
else ()
set (JSON_INTEGER_FORMAT "\"lld\"")
endif ()
endif ()
# Apparently, Borland BCC and MSVC wants I64d, Borland BCC could also accept
# LD and gcc wants ldd, I am not sure what cygwin will want, so I will assume
# I64d
if(WIN32) # matches both msvc and cygwin
set(JSON_INTEGER_FORMAT "\"I64d\"")
else()
set(JSON_INTEGER_FORMAT "\"lld\"")
endif()
endif()
# If locale.h and localeconv() are available, define to 1, otherwise to 0.
check_include_files (locale.h HAVE_LOCALE_H)
check_function_exists (localeconv HAVE_LOCALECONV)
check_include_files(locale.h HAVE_LOCALE_H)
check_function_exists(localeconv HAVE_LOCALECONV)
if (HAVE_LOCALECONV AND HAVE_LOCALE_H)
set (JSON_HAVE_LOCALECONV 1)
else ()
set (JSON_HAVE_LOCALECONV 0)
if(HAVE_LOCALECONV AND HAVE_LOCALE_H)
set(JSON_HAVE_LOCALECONV 1)
else()
set(JSON_HAVE_LOCALECONV 0)
endif()
# check if we have setlocale
check_function_exists(setlocale HAVE_SETLOCALE)
# Check what the inline keyword is.
# Note that the original JSON_INLINE was always set to just 'inline', so this goes further.
# Check what the inline keyword is. Note that the original JSON_INLINE was
# always set to just 'inline', so this goes further.
check_function_keywords("inline")
check_function_keywords("__inline")
check_function_keywords("__inline__")
if (HAVE_INLINE)
if(HAVE_INLINE)
set(JSON_INLINE inline)
elseif (HAVE___INLINE)
elseif(HAVE___INLINE)
set(JSON_INLINE __inline)
elseif (HAVE___INLINE__)
elseif(HAVE___INLINE__)
set(JSON_INLINE __inline__)
else()
# no inline on this platform
set (JSON_INLINE)
set(JSON_INLINE)
endif()
check_c_source_compiles ("int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); return 0; } " HAVE_SYNC_BUILTINS)
check_c_source_compiles ("int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); return 0; }" HAVE_ATOMIC_BUILTINS)
check_c_source_compiles(
"int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); return 0; } "
HAVE_SYNC_BUILTINS)
check_c_source_compiles(
"int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); return 0; }"
HAVE_ATOMIC_BUILTINS)
set (JANSSON_INITIAL_HASHTABLE_ORDER 3 CACHE STRING "Number of buckets new object hashtables contain is 2 raised to this power. The default is 3, so empty hashtables contain 2^3 = 8 buckets.")
set(JANSSON_INITIAL_HASHTABLE_ORDER
3
CACHE
STRING
"Number of buckets new object hashtables contain is 2 raised to this power. The default is 3, so empty hashtables contain 2^3 = 8 buckets."
)
# configure the public config file
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_config.h.cmake
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_config.h.cmake
${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h)
# Copy the jansson.h file to the public include folder
file (COPY ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h
file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h
DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
add_definitions(-DJANSSON_USING_CMAKE)
# configure the private config file
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_private_config.h.cmake
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_private_config.h.cmake
${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h)
# and tell the source code to include it
add_definitions(-DHAVE_CONFIG_H)
include_directories (${CMAKE_CURRENT_BINARY_DIR}/include)
include_directories (${CMAKE_CURRENT_BINARY_DIR}/private_include)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/private_include)
# Add the lib sources.
file(GLOB JANSSON_SRC src/*.c)
@ -342,8 +341,7 @@ set(JANSSON_HDR_PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/src/utf.h
${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h)
set(JANSSON_HDR_PUBLIC
${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h
set(JANSSON_HDR_PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h
${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h)
source_group("Library Sources" FILES ${JANSSON_SRC})
@ -351,40 +349,35 @@ source_group("Library Private Headers" FILES ${JANSSON_HDR_PRIVATE})
source_group("Library Public Headers" FILES ${JANSSON_HDR_PUBLIC})
if(JANSSON_BUILD_SHARED_LIBS)
add_library(jansson SHARED
${JANSSON_SRC}
${JANSSON_HDR_PRIVATE}
${JANSSON_HDR_PUBLIC}
src/jansson.def)
add_library(jansson SHARED ${JANSSON_SRC} ${JANSSON_HDR_PRIVATE}
${JANSSON_HDR_PUBLIC} src/jansson.def)
set_target_properties(jansson PROPERTIES
VERSION ${JANSSON_VERSION}
set_target_properties(jansson PROPERTIES VERSION ${JANSSON_VERSION}
SOVERSION ${JANSSON_SOVERSION})
else()
add_library(jansson
${JANSSON_SRC}
${JANSSON_HDR_PRIVATE}
add_library(jansson ${JANSSON_SRC} ${JANSSON_HDR_PRIVATE}
${JANSSON_HDR_PUBLIC})
endif()
set_target_properties(jansson PROPERTIES FOLDER "deps")
if (JANSSON_EXAMPLES)
if(JANSSON_EXAMPLES)
add_executable(simple_parse "${PROJECT_SOURCE_DIR}/examples/simple_parse.c")
target_link_libraries(simple_parse jansson)
endif()
# For building Documentation (uses Sphinx)
# Disabled by OBS
# For building Documentation (uses Sphinx) Disabled by OBS
option(JANSSON_BUILD_DOCS "Build documentation (uses python-sphinx)." OFF)
if (JANSSON_BUILD_DOCS)
if(JANSSON_BUILD_DOCS)
find_package(Sphinx)
if (NOT SPHINX_FOUND)
if(NOT SPHINX_FOUND)
message(WARNING "Sphinx not found. Cannot generate documentation!
Set -DJANSSON_BUILD_DOCS=OFF to get rid of this message.")
else()
if (Sphinx_VERSION_STRING VERSION_LESS 1.0)
message(WARNING "Your Sphinx version is too old!
if(Sphinx_VERSION_STRING VERSION_LESS 1.0)
message(
WARNING
"Your Sphinx version is too old!
This project requires Sphinx v1.0 or above to produce
proper documentation (you have v${Sphinx_VERSION_STRING}).
You will get output but it will have errors.")
@ -396,45 +389,46 @@ if (JANSSON_BUILD_DOCS)
# Sphinx cache with pickled ReST documents
set(SPHINX_CACHE_DIR "${CMAKE_CURRENT_BINARY_DIR}/_doctrees")
# CMake could be used to build the conf.py file too,
# eg it could automatically write the version of the program or change the theme.
# if(NOT DEFINED SPHINX_THEME)
# set(SPHINX_THEME default)
# endif()
# CMake could be used to build the conf.py file too, eg it could
# automatically write the version of the program or change the theme. if(NOT
# DEFINED SPHINX_THEME) set(SPHINX_THEME default) endif()
#
# if(NOT DEFINED SPHINX_THEME_DIR)
# set(SPHINX_THEME_DIR)
# endif()
# if(NOT DEFINED SPHINX_THEME_DIR) set(SPHINX_THEME_DIR) endif()
#
# configure_file(
# "${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in"
# "${BINARY_BUILD_DIR}/conf.py"
# @ONLY)
# configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in"
# "${BINARY_BUILD_DIR}/conf.py" @ONLY)
# TODO: Add support for all sphinx builders: http://sphinx-doc.org/builders.html
# TODO: Add support for all sphinx builders:
# http://sphinx-doc.org/builders.html
# Add documentation targets.
set(DOC_TARGETS html)
option(JANSSON_BUILD_MAN "Create a target for building man pages." ON)
if (JANSSON_BUILD_MAN)
if (Sphinx_VERSION_STRING VERSION_LESS 1.0)
message(WARNING "Sphinx version 1.0 > is required to build man pages. You have v${Sphinx_VERSION_STRING}.")
if(JANSSON_BUILD_MAN)
if(Sphinx_VERSION_STRING VERSION_LESS 1.0)
message(
WARNING
"Sphinx version 1.0 > is required to build man pages. You have v${Sphinx_VERSION_STRING}."
)
else()
list(APPEND DOC_TARGETS man)
endif()
endif()
option(JANSSON_BUILD_LATEX "Create a target for building latex docs (to create PDF)." OFF)
option(JANSSON_BUILD_LATEX
"Create a target for building latex docs (to create PDF)." OFF)
if (JANSSON_BUILD_LATEX)
if(JANSSON_BUILD_LATEX)
find_package(LATEX)
if (NOT LATEX_COMPILER)
if(NOT LATEX_COMPILER)
message("Couldn't find Latex, can't build latex docs using Sphinx")
else()
message("Latex found! If you have problems building, see Sphinx documentation for required Latex packages.")
message(
"Latex found! If you have problems building, see Sphinx documentation for required Latex packages."
)
list(APPEND DOC_TARGETS latex)
endif()
endif()
@ -442,12 +436,15 @@ if (JANSSON_BUILD_DOCS)
# The doc target will build all documentation targets.
add_custom_target(doc)
foreach (DOC_TARGET ${DOC_TARGETS})
add_custom_target(${DOC_TARGET}
foreach(DOC_TARGET ${DOC_TARGETS})
add_custom_target(
${DOC_TARGET}
${SPHINX_EXECUTABLE}
# -q # Enable for quiet mode
-b ${DOC_TARGET}
-d "${SPHINX_CACHE_DIR}"
-b
${DOC_TARGET}
-d
"${SPHINX_CACHE_DIR}"
# -c "${BINARY_BUILD_DIR}" # enable if using cmake-generated conf.py
"${CMAKE_CURRENT_SOURCE_DIR}/doc"
"${CMAKE_CURRENT_BINARY_DIR}/doc/${DOC_TARGET}"
@ -458,17 +455,18 @@ if (JANSSON_BUILD_DOCS)
message("Building documentation enabled for: ${DOC_TARGETS}")
endif()
endif ()
endif()
# Disabled by OBS
option(JANSSON_WITHOUT_TESTS "Don't build tests ('make test' to execute tests)" ON)
option(JANSSON_WITHOUT_TESTS "Don't build tests ('make test' to execute tests)"
ON)
if (NOT JANSSON_WITHOUT_TESTS)
if(NOT JANSSON_WITHOUT_TESTS)
option(JANSSON_TEST_WITH_VALGRIND "Enable valgrind tests." OFF)
ENABLE_TESTING()
enable_testing()
if (JANSSON_TEST_WITH_VALGRIND)
if(JANSSON_TEST_WITH_VALGRIND)
# TODO: Add FindValgrind.cmake instead of having a hardcoded path.
add_definitions(-DVALGRIND)
@ -476,19 +474,20 @@ if (NOT JANSSON_WITHOUT_TESTS)
# enable valgrind
set(CMAKE_MEMORYCHECK_COMMAND valgrind)
set(CMAKE_MEMORYCHECK_COMMAND_OPTIONS
"--error-exitcode=1 --leak-check=full --show-reachable=yes --track-origins=yes -q")
"--error-exitcode=1 --leak-check=full --show-reachable=yes --track-origins=yes -q"
)
set(MEMCHECK_COMMAND
"${CMAKE_MEMORYCHECK_COMMAND} ${CMAKE_MEMORYCHECK_COMMAND_OPTIONS}")
separate_arguments(MEMCHECK_COMMAND)
endif ()
endif()
#
# Test suites.
#
if (CMAKE_COMPILER_IS_GNUCC)
if(CMAKE_COMPILER_IS_GNUCC)
add_definitions(-Wall -Wextra -Wdeclaration-after-statement)
endif ()
endif()
set(api_tests
test_array
@ -504,9 +503,9 @@ if (NOT JANSSON_WITHOUT_TESTS)
test_simple
test_unpack)
# Doing arithmetic on void pointers is not allowed by Microsofts compiler
# such as secure_malloc and secure_free is doing, so exclude it for now.
if (NOT MSVC)
# Doing arithmetic on void pointers is not allowed by Microsofts compiler such
# as secure_malloc and secure_free is doing, so exclude it for now.
if(NOT MSVC)
list(APPEND api_tests test_memory_funcs)
endif()
@ -518,80 +517,87 @@ if (NOT JANSSON_WITHOUT_TESTS)
endmacro(build_testprog)
# Create executables and tests/valgrind tests for API tests.
foreach (test ${api_tests})
foreach(test ${api_tests})
build_testprog(${test} ${PROJECT_SOURCE_DIR}/test/suites/api)
if (JANSSON_TEST_WITH_VALGRIND)
add_test(memcheck__${test}
${MEMCHECK_COMMAND} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${test}
WORKING_DIRECTORY ${JANSSON_TEMP_DIR})
else()
add_test(${test}
if(JANSSON_TEST_WITH_VALGRIND)
add_test(memcheck__${test} ${MEMCHECK_COMMAND}
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${test}
WORKING_DIRECTORY ${JANSSON_TEMP_DIR})
endif ()
endforeach ()
else()
add_test(${test} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${test}
WORKING_DIRECTORY ${JANSSON_TEMP_DIR})
endif()
endforeach()
# Test harness for the suites tests.
build_testprog(json_process ${PROJECT_SOURCE_DIR}/test/bin)
set(SUITE_TEST_CMD ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/json_process)
set(SUITES encoding-flags valid invalid invalid-unicode)
foreach (SUITE ${SUITES})
foreach(SUITE ${SUITES})
file(GLOB TESTDIRS ${jansson_SOURCE_DIR}/test/suites/${SUITE}/*)
foreach (TESTDIR ${TESTDIRS})
if (IS_DIRECTORY ${TESTDIR})
foreach(TESTDIR ${TESTDIRS})
if(IS_DIRECTORY ${TESTDIR})
get_filename_component(TNAME ${TESTDIR} NAME)
if (JANSSON_TEST_WITH_VALGRIND)
add_test(memcheck__${SUITE}__${TNAME}
${MEMCHECK_COMMAND} ${SUITE_TEST_CMD} ${TESTDIR})
else()
add_test(${SUITE}__${TNAME}
if(JANSSON_TEST_WITH_VALGRIND)
add_test(memcheck__${SUITE}__${TNAME} ${MEMCHECK_COMMAND}
${SUITE_TEST_CMD} ${TESTDIR})
endif()
if ((${SUITE} STREQUAL "valid" OR ${SUITE} STREQUAL "invalid") AND NOT EXISTS ${TESTDIR}/nostrip)
if (JANSSON_TEST_WITH_VALGRIND)
add_test(memcheck__${SUITE}__${TNAME}__strip
${MEMCHECK_COMMAND} ${SUITE_TEST_CMD} --strip ${TESTDIR})
else()
add_test(${SUITE}__${TNAME}__strip
${SUITE_TEST_CMD} --strip ${TESTDIR})
add_test(${SUITE}__${TNAME} ${SUITE_TEST_CMD} ${TESTDIR})
endif()
endif ()
endif ()
endforeach ()
endforeach ()
if (JANSSON_COVERAGE)
if((${SUITE} STREQUAL "valid" OR ${SUITE} STREQUAL "invalid")
AND NOT EXISTS ${TESTDIR}/nostrip)
if(JANSSON_TEST_WITH_VALGRIND)
add_test(memcheck__${SUITE}__${TNAME}__strip ${MEMCHECK_COMMAND}
${SUITE_TEST_CMD} --strip ${TESTDIR})
else()
add_test(${SUITE}__${TNAME}__strip ${SUITE_TEST_CMD} --strip
${TESTDIR})
endif()
endif()
endif()
endforeach()
endforeach()
if(JANSSON_COVERAGE)
setup_target_for_coverage(
coverage # Coverage make target "make coverage".
coverage # Name of output directory.
make # Name of test runner executable.
test) # Arguments to the test runner above (make test).
if (JANSSON_COVERALLS)
if(JANSSON_COVERALLS)
set(COVERAGE_SRCS ${JANSSON_SRC})
coveralls_setup("${COVERAGE_SRCS}" ${JANSSON_COVERALLS_UPLOAD})
endif ()
endif ()
endif()
endif()
# Enable using "make check" just like the autotools project.
# By default cmake creates a target "make test"
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND}
# Enable using "make check" just like the autotools project. By default cmake
# creates a target "make test"
add_custom_target(
check
COMMAND ${CMAKE_CTEST_COMMAND}
DEPENDS json_process ${api_tests})
endif ()
endif()
#
# Installation preparation.
#
# Allow the user to override installation directories.
set(JANSSON_INSTALL_LIB_DIR lib CACHE PATH "Installation directory for libraries")
set(JANSSON_INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables")
set(JANSSON_INSTALL_INCLUDE_DIR include CACHE PATH "Installation directory for header files")
set(JANSSON_INSTALL_LIB_DIR
lib
CACHE PATH "Installation directory for libraries")
set(JANSSON_INSTALL_BIN_DIR
bin
CACHE PATH "Installation directory for executables")
set(JANSSON_INSTALL_INCLUDE_DIR
include
CACHE PATH "Installation directory for header files")
if(WIN32 AND NOT CYGWIN)
set(DEF_INSTALL_CMAKE_DIR cmake)
@ -599,11 +605,12 @@ else()
set(DEF_INSTALL_CMAKE_DIR lib/cmake/jansson)
endif()
set(JANSSON_INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
set(JANSSON_INSTALL_CMAKE_DIR
${DEF_INSTALL_CMAKE_DIR}
CACHE PATH "Installation directory for CMake files")
# Create pkg-conf file.
# (We use the same files as ./configure does, so we
# have to defined the same variables used there).
# Create pkg-conf file. (We use the same files as ./configure does, so we have
# to defined the same variables used there).
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX})
set(libdir ${CMAKE_INSTALL_PREFIX}/${JANSSON_INSTALL_LIB_DIR})
@ -619,76 +626,80 @@ foreach(p LIB BIN INCLUDE CMAKE)
endif()
endforeach()
# Export targets (This is used for other CMake projects to easily find the libraries and include files).
export(TARGETS jansson
FILE "${PROJECT_BINARY_DIR}/JanssonTargets.cmake")
# Export targets (This is used for other CMake projects to easily find the
# libraries and include files).
export(TARGETS jansson FILE "${PROJECT_BINARY_DIR}/JanssonTargets.cmake")
export(PACKAGE jansson)
# Generate the config file for the build-tree.
set(JANSSON__INCLUDE_DIRS
"${PROJECT_SOURCE_DIR}/include"
set(JANSSON__INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/include"
"${PROJECT_BINARY_DIR}/include")
set(JANSSON_INCLUDE_DIRS ${JANSSON__INCLUDE_DIRS} CACHE PATH "Jansson include directories")
set(JANSSON_INCLUDE_DIRS
${JANSSON__INCLUDE_DIRS}
CACHE PATH "Jansson include directories")
configure_file(${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in
${PROJECT_BINARY_DIR}/JanssonConfig.cmake
@ONLY)
${PROJECT_BINARY_DIR}/JanssonConfig.cmake @ONLY)
# Generate the config file for the installation tree.
file(RELATIVE_PATH
REL_INCLUDE_DIR
"${JANSSON_INSTALL_CMAKE_DIR}"
"${JANSSON_INSTALL_INCLUDE_DIR}") # Calculate the relative directory from the Cmake dir.
file(RELATIVE_PATH REL_INCLUDE_DIR "${JANSSON_INSTALL_CMAKE_DIR}"
"${JANSSON_INSTALL_INCLUDE_DIR}") # Calculate the relative directory from
# the Cmake dir.
# Note the EVENT_CMAKE_DIR is defined in JanssonConfig.cmake.in,
# we escape it here so it's evaluated when it is included instead
# so that the include dirs are given relative to where the
# config file is located.
set(JANSSON__INCLUDE_DIRS
"\${JANSSON_CMAKE_DIR}/${REL_INCLUDE_DIR}")
configure_file(${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in
${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake
@ONLY)
# Note the EVENT_CMAKE_DIR is defined in JanssonConfig.cmake.in, we escape it
# here so it's evaluated when it is included instead so that the include dirs
# are given relative to where the config file is located.
set(JANSSON__INCLUDE_DIRS "\${JANSSON_CMAKE_DIR}/${REL_INCLUDE_DIR}")
configure_file(
${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in
${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake @ONLY)
# Generate version info for both build-tree and install-tree.
configure_file(${PROJECT_SOURCE_DIR}/cmake/JanssonConfigVersion.cmake.in
${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake
@ONLY)
${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake @ONLY)
# Define the public headers.
set_target_properties(jansson PROPERTIES PUBLIC_HEADER "${JANSSON_HDR_PUBLIC}")
#TODO: fix this.
# TODO: fix this.
#
# Install targets.
#
# Disabled by OBS
option(JANSSON_INSTALL "Generate installation target" OFF)
if (JANSSON_INSTALL)
install(TARGETS jansson
if(JANSSON_INSTALL)
install(
TARGETS jansson
EXPORT JanssonTargets
LIBRARY DESTINATION "${JANSSON_INSTALL_LIB_DIR}" COMPONENT lib
ARCHIVE DESTINATION "${JANSSON_INSTALL_LIB_DIR}" COMPONENT lib
RUNTIME DESTINATION "${JANSSON_INSTALL_BIN_DIR}" COMPONENT lib # Windows DLLs
RUNTIME DESTINATION "${JANSSON_INSTALL_BIN_DIR}" COMPONENT lib # Windows
# DLLs
PUBLIC_HEADER DESTINATION "${JANSSON_INSTALL_INCLUDE_DIR}" COMPONENT dev)
# Install the pkg-config.
install (FILES
${CMAKE_CURRENT_BINARY_DIR}/jansson.pc
DESTINATION ${JANSSON_INSTALL_LIB_DIR}/pkgconfig COMPONENT dev)
# Install the pkg-config.
install(
FILES ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc
DESTINATION ${JANSSON_INSTALL_LIB_DIR}/pkgconfig
COMPONENT dev)
# Install the configs.
install(FILES
${PROJECT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake
# Install the configs.
install(
FILES ${PROJECT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake
${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake
DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}" COMPONENT dev)
DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}"
COMPONENT dev)
# Install exports for the install-tree.
install(EXPORT JanssonTargets
DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}" COMPONENT dev)
# Install exports for the install-tree.
install(
EXPORT JanssonTargets
DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}"
COMPONENT dev)
endif()
# For use when simply using add_library from a parent project to build jansson.
set(JANSSON_LIBRARIES jansson CACHE STRING "Jansson libraries")
set(JANSSON_LIBRARIES
jansson
CACHE STRING "Jansson libraries")
target_include_directories(jansson
PUBLIC src "${CMAKE_CURRENT_BINARY_DIR}/include")
target_include_directories(jansson PUBLIC src
"${CMAKE_CURRENT_BINARY_DIR}/include")

55
deps/libcaption/CMakeLists.txt vendored
View File

@ -1,41 +1,40 @@
cmake_minimum_required(VERSION 2.8.12)
project(libcaption)
add_definitions(-D__STDC_CONSTANT_MACROS)
if (WIN32)
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
endif()
if (UNIX AND NOT APPLE)
add_compile_options("-fPIC")
endif()
add_library(caption STATIC)
add_library(OBS::caption ALIAS caption)
# Don't need to prefix local includes with "caption/*"
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/caption)
set(CAPTION_SOURCES
target_sources(
caption
PRIVATE src/caption.c
src/utf8.c
caption/utf8.h
src/srt.c
src/scc.c
src/mpeg.c
src/cea708.c
src/xds.c
src/caption.c
src/eia608_charmap.c
src/eia608_from_utf8.c
src/eia608.c
)
set(CAPTION_HEADERS
caption/utf8.h
caption/scc.h
src/mpeg.c
caption/mpeg.h
src/cea708.c
caption/cea708.h
src/xds.c
src/eia608.c
caption/eia608.h
caption/caption.h
src/eia608_from_utf8.c
src/eia608_charmap.c
caption/eia608_charmap.h
)
PUBLIC caption/caption.h)
add_library(caption STATIC ${CAPTION_SOURCES})
set_target_properties(caption PROPERTIES
FOLDER "deps"
target_compile_definitions(
caption PRIVATE __STDC_CONSTANT_MACROS
"$<$<BOOL:${OS_WINDOWS}>:_CRT_SECURE_NO_WARNINGS>")
target_include_directories(
caption
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/caption
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
set_target_properties(
caption
PROPERTIES FOLDER "deps"
VERSION "0"
SOVERSION "0"
POSITION_INDEPENDENT_CODE ON)

42
deps/libff/CMakeLists.txt vendored
View File

@ -1,8 +1,15 @@
cmake_minimum_required (VERSION 2.8.12)
project (libff)
cmake_minimum_required(VERSION 2.8.12)
project(libff)
find_package(FFmpeg REQUIRED
COMPONENTS avcodec avfilter avdevice avutil swscale avformat swresample)
find_package(
FFmpeg REQUIRED
COMPONENTS avcodec
avfilter
avdevice
avutil
swscale
avformat
swresample)
include_directories(${FFMPEG_INCLUDE_DIRS})
@ -20,9 +27,7 @@ set(libff_HEADERS
libff/ff-threading.h
libff/ff-timer.h
libff/ff-util.h
#
libff/ff-demuxer.h
#
libff/ff-decoder.h)
set(libff_SOURCES
@ -32,30 +37,21 @@ set(libff_SOURCES
libff/ff-packet-queue.c
libff/ff-timer.c
libff/ff-util.c
#
libff/ff-demuxer.c
#
libff/ff-decoder.c
libff/ff-audio-decoder.c
libff/ff-video-decoder.c)
if (WIN32)
list(APPEND libff_SOURCES
libff/ff-threading-windows.c)
if(WIN32)
list(APPEND libff_SOURCES libff/ff-threading-windows.c)
else(WIN32)
list(APPEND libff_SOURCES
libff/ff-threading-posix.c)
list(APPEND libff_SOURCES libff/ff-threading-posix.c)
endif(WIN32)
add_library (libff STATIC
${libff_HEADERS}
${libff_SOURCES})
set_target_properties(libff PROPERTIES
FOLDER "deps"
POSITION_INDEPENDENT_CODE ON)
add_library(libff STATIC ${libff_HEADERS} ${libff_SOURCES})
set_target_properties(libff PROPERTIES FOLDER "deps" POSITION_INDEPENDENT_CODE
ON)
target_include_directories(libff
PUBLIC .)
target_include_directories(libff PUBLIC .)
target_link_libraries (libff
${FFMPEG_LIBRARIES})
target_link_libraries(libff ${FFMPEG_LIBRARIES})

124
deps/lzma/CMakeLists.txt vendored
View File

@ -1,56 +1,19 @@
cmake_minimum_required(VERSION 3.2)
project(lzma)
set(LIBLZMA_INCLUDE_DIRS
"${CMAKE_CURRENT_SOURCE_DIR}"
"${CMAKE_CURRENT_SOURCE_DIR}/liblzma/api"
CACHE PATH "lzma include path")
add_library(lzma STATIC)
add_library(OBS::lzma ALIAS lzma)
set(LIBLZMA_CONFIG
"${CMAKE_CURRENT_SOURCE_DIR}/config.h"
CACHE PATH "lzma config.h path")
target_sources(lzma PRIVATE config.h)
include_directories(
${LIBLZMA_INCLUDE_DIRS}
common
liblzma/api
liblzma/check
liblzma/common
liblzma/delta
liblzma/lz
liblzma/lzma
liblzma/rangecoder
liblzma/simple
)
target_sources(
lzma
PRIVATE liblzma/check/check.c liblzma/check/crc32_table.c
liblzma/check/crc32_fast.c liblzma/check/crc64_table.c
liblzma/check/crc64_fast.c liblzma/check/sha256.c)
add_definitions(
-DHAVE_CONFIG_H
-DTUKLIB_SYMBOL_PREFIX=lzma_)
if(WIN32)
if(MSVC)
add_compile_options($<IF:$<CONFIG:Debug>,/MTd,/MT> /Zl)
add_compile_options("/wd4244")
add_compile_options("/wd4267")
endif()
add_definitions(
-Dinline=_inline
-Drestrict=__restrict)
endif()
set(liblzma_check_SOURCES
liblzma/check/check.c)
list(APPEND liblzma_check_SOURCES
liblzma/check/crc32_table.c
liblzma/check/crc32_fast.c
liblzma/check/crc64_table.c
liblzma/check/crc64_fast.c
liblzma/check/sha256.c)
set(liblzma_common_SOURCES
liblzma/common/common.c
target_sources(
lzma
PRIVATE liblzma/common/common.c
liblzma/common/block_util.c
liblzma/common/easy_preset.c
liblzma/common/filter_common.c
@ -89,35 +52,31 @@ set(liblzma_common_SOURCES
liblzma/common/stream_flags_decoder.c
liblzma/common/vli_decoder.c)
set(liblzma_delta_SOURCES
liblzma/delta/delta_common.c
liblzma/delta/delta_encoder.c
target_sources(
lzma PRIVATE liblzma/delta/delta_common.c liblzma/delta/delta_encoder.c
liblzma/delta/delta_decoder.c)
set(liblzma_lzma_SOURCES
liblzma/lzma/lzma_encoder.c
target_sources(
lzma
PRIVATE liblzma/lzma/lzma_encoder.c
liblzma/lzma/lzma_encoder_presets.c
liblzma/lzma/lzma_encoder_optimum_fast.c
liblzma/lzma/lzma_encoder_optimum_normal.c
liblzma/lzma/fastpos_table.c
liblzma/lzma/lzma_decoder.c
liblzma/lzma/lzma2_encoder.c
liblzma/lzma/lzma2_decoder.c)
set(liblzma_lz_SOURCES
liblzma/lz/lz_encoder.c
liblzma/lz/lz_encoder_mf.c
target_sources(lzma PRIVATE liblzma/lz/lz_encoder.c liblzma/lz/lz_encoder_mf.c
liblzma/lz/lz_decoder.c)
set(liblzma_rangecoder_SOURCES
liblzma/rangecoder/price_table.c)
target_sources(lzma PRIVATE liblzma/rangecoder/price_table.c)
set(liblzma_simple_SOURCES
liblzma/simple/simple_coder.c
target_sources(
lzma
PRIVATE liblzma/simple/simple_coder.c
liblzma/simple/simple_encoder.c
liblzma/simple/simple_decoder.c
liblzma/simple/arm.c
liblzma/simple/armthumb.c
liblzma/simple/ia64.c
@ -125,24 +84,29 @@ set(liblzma_simple_SOURCES
liblzma/simple/sparc.c
liblzma/simple/x86.c)
if (WIN32)
SET_SOURCE_FILES_PROPERTIES(
${liblzma_check_SOURCES}
${liblzma_common_SOURCES}
${liblzma_delta_SOURCES}
${liblzma_lz_SOURCES}
${liblzma_lzma_SOURCES}
${liblzma_rangecoder_SOURCES}
${liblzma_simple_SOURCES}
PROPERTIES LANGUAGE C)
target_compile_definitions(lzma PRIVATE HAVE_CONFIG_H
TUKLIB_SYMBOL_PREFIX=lzma_)
target_include_directories(
lzma
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/common
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/check
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/common
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/delta
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/lz
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/lzma
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/rangecoder
${CMAKE_CURRENT_SOURCE_DIR}/liblzma/simple
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/liblzma/api)
if(OS_WINDOWS)
if(MSVC)
target_compile_options(lzma PRIVATE "$<IF:$<CONFIG:Debug>,/MTd,/MT>" /Zl
/wd4244 /wd4267)
endif()
target_compile_definitions(lzma PRIVATE inline=_inline restrict=__restrict)
endif()
add_library(lzma STATIC
${liblzma_check_SOURCES}
${liblzma_common_SOURCES}
${liblzma_delta_SOURCES}
${liblzma_lz_SOURCES}
${liblzma_lzma_SOURCES}
${liblzma_rangecoder_SOURCES}
${liblzma_simple_SOURCES})
set_target_properties(lzma PROPERTIES FOLDER "deps")

46
deps/media-playback/CMakeLists.txt vendored
View File

@ -1,39 +1,23 @@
project(media-playback)
find_package(FFmpeg REQUIRED
COMPONENTS avcodec avdevice avutil avformat)
option(ENABLE_SIMDE "Enable non-native SSE2 SIMD support" ON)
include_directories(
${CMAKE_SOURCE_DIR}/libobs
${FFMPEG_INCLUDE_DIRS}
)
find_package(FFmpeg REQUIRED COMPONENTS avcodec avdevice avutil avformat)
set(media-playback_HEADERS
media-playback/closest-format.h
media-playback/decode.h
media-playback/media.h
)
set(media-playback_SOURCES
media-playback/decode.c
media-playback/media.c
)
add_library(media-playback INTERFACE)
add_library(OBS::media-playback ALIAS media-playback)
add_library(media-playback STATIC
${media-playback_HEADERS}
${media-playback_SOURCES}
)
target_sources(
media-playback
INTERFACE media-playback/media.c media-playback/media.h
media-playback/decode.c media-playback/decode.h
media-playback/closest-format.h)
target_compile_options(media-playback
PUBLIC
${ARCH_SIMD_FLAGS})
target_link_libraries(media-playback INTERFACE FFmpeg::avcodec FFmpeg::avdevice
FFmpeg::avutil FFmpeg::avformat)
target_include_directories(media-playback
PUBLIC .
)
target_include_directories(media-playback INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(media-playback
${FFMPEG_LIBRARIES}
)
set_target_properties(media-playback PROPERTIES
FOLDER "deps"
POSITION_INDEPENDENT_CODE ON)
target_compile_options(media-playback INTERFACE ${ARCH_SIMD_FLAGS})
target_compile_definitions(media-playback INTERFACE ${ARCH_SIMD_DEFINES})

21
deps/opts-parser/CMakeLists.txt vendored
View File

@ -1,17 +1,10 @@
project(opts-parser)
set(opts-parser_SOURCES
opts-parser.c)
set(opts-parser_HEADERS
opts-parser.h)
add_library(opts-parser INTERFACE)
add_library(OBS::opts-parser ALIAS opts-parser)
add_library(opts-parser STATIC
${opts-parser_SOURCES}
${opts-parser_HEADERS})
target_include_directories(opts-parser
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(opts-parser
libobs)
set_target_properties(opts-parser PROPERTIES
FOLDER "deps"
POSITION_INDEPENDENT_CODE ON)
target_sources(opts-parser INTERFACE opts-parser.c opts-parser.h)
target_link_libraries(opts-parser INTERFACE OBS::libobs)
target_include_directories(opts-parser INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

39
deps/w32-pthreads/CMakeLists.txt vendored
View File

@ -1,30 +1,25 @@
project(w32-pthreads)
if(NOT WIN32)
return()
if(POLICY CMP0090)
cmake_policy(SET CMP0090 NEW)
endif()
project(w32-pthreads)
add_library(w32-pthreads SHARED)
add_library(OBS::w32-pthreads ALIAS w32-pthreads)
target_sources(w32-pthreads PRIVATE implement.h pthread.c pthread.h sched.h
semaphore.h w32-pthreads.rc)
set(MODULE_DESCRIPTION "POSIX Threads for Windows")
configure_file(${CMAKE_SOURCE_DIR}/cmake/winrc/obs-module.rc.in w32-pthreads.rc)
set(w32-pthreads_SOURCES
pthread.c
configure_file(${CMAKE_SOURCE_DIR}/cmake/bundle/windows/obs-module.rc.in
w32-pthreads.rc)
set(w32-pthreads_HEADERS
implement.h
pthread.h
sched.h
semaphore.h)
target_compile_definitions(w32-pthreads PRIVATE __CLEANUP_C PTW32_BUILD)
target_include_directories(
w32-pthreads PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>")
add_library(w32-pthreads SHARED
${w32-pthreads_SOURCES}
${w32-pthreads_HEADERS})
target_compile_definitions(w32-pthreads
PRIVATE __CLEANUP_C PTW32_BUILD)
target_include_directories(w32-pthreads
PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>")
target_link_libraries(w32-pthreads)
set_target_properties(w32-pthreads PROPERTIES FOLDER "deps")
install_obs_core(w32-pthreads EXPORT w32-pthreads)
setup_binary_target(w32-pthreads)
export_target(w32-pthreads)

6
deps/w32-pthreads/cmake/w32-pthreadsConfig.cmake.in vendored Normal file
View File

@ -0,0 +1,6 @@
@PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
check_required_components("@PROJECT_NAME@")
set(LIBOBS_LIBRARIES w32-pthreads)