blob: 08af3b1e1bb8d871454c04c0e6f1723a655b91be [file] [log] [blame] [edit]
#
# Copyright (c) 2021, Alliance for Open Media. All rights reserved
#
# This source code is subject to the terms of the BSD 3-Clause Clear License and
# the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
# License was not distributed with this source code in the LICENSE file, you can
# obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the Alliance
# for Open Media Patent License 1.0 was not distributed with this source code in
# the PATENTS file, you can obtain it at aomedia.org/license/patent-license/.
#
if(AOM_BUILD_CMAKE_AOM_CONFIGURE_CMAKE_)
return()
endif() # AOM_BUILD_CMAKE_AOM_CONFIGURE_CMAKE_
set(AOM_BUILD_CMAKE_AOM_CONFIGURE_CMAKE_ 1)
include(FindGit)
include(FindPerl)
include(FindThreads)
include("${AOM_ROOT}/build/cmake/aom_config_defaults.cmake")
include("${AOM_ROOT}/build/cmake/aom_experiment_deps.cmake")
include("${AOM_ROOT}/build/cmake/aom_optimization.cmake")
include("${AOM_ROOT}/build/cmake/compiler_flags.cmake")
include("${AOM_ROOT}/build/cmake/compiler_tests.cmake")
include("${AOM_ROOT}/build/cmake/util.cmake")
if(DEFINED CONFIG_LOWBITDEPTH)
message(WARNING "CONFIG_LOWBITDEPTH has been removed. \
high bit depth internal pipeline is always used.")
endif()
# Generate the user config settings.
list(APPEND aom_build_vars ${AOM_CONFIG_VARS} ${AOM_OPTION_VARS})
foreach(cache_var ${aom_build_vars})
get_property(
cache_var_helpstring
CACHE ${cache_var}
PROPERTY HELPSTRING)
if("${cache_var_helpstring}" STREQUAL "${cmake_cmdline_helpstring}")
set(AOM_CMAKE_CONFIG "${AOM_CMAKE_CONFIG} -D${cache_var}=${${cache_var}}")
endif()
endforeach()
string(STRIP "${AOM_CMAKE_CONFIG}" AOM_CMAKE_CONFIG)
# Detect target CPU.
if(NOT AOM_TARGET_CPU)
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cpu_lowercase)
if("${cpu_lowercase}" STREQUAL "amd64" OR "${cpu_lowercase}" STREQUAL
"x86_64")
if(${CMAKE_SIZEOF_VOID_P} EQUAL 4)
set(AOM_TARGET_CPU "x86")
elseif(${CMAKE_SIZEOF_VOID_P} EQUAL 8)
set(AOM_TARGET_CPU "x86_64")
else()
message(
FATAL_ERROR
"--- Unexpected pointer size (${CMAKE_SIZEOF_VOID_P}) for\n"
" CMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}\n"
" CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}\n"
" CMAKE_GENERATOR=${CMAKE_GENERATOR}\n")
endif()
elseif("${cpu_lowercase}" STREQUAL "i386" OR "${cpu_lowercase}" STREQUAL
"x86")
set(AOM_TARGET_CPU "x86")
elseif("${cpu_lowercase}" MATCHES "^arm" OR "${cpu_lowercase}" MATCHES
"^mips")
set(AOM_TARGET_CPU "${cpu_lowercase}")
elseif("${cpu_lowercase}" MATCHES "aarch64")
set(AOM_TARGET_CPU "arm64")
elseif("${cpu_lowercase}" MATCHES "^ppc")
set(AOM_TARGET_CPU "ppc")
else()
message(WARNING "The architecture ${CMAKE_SYSTEM_PROCESSOR} is not "
"supported, falling back to the generic target")
set(AOM_TARGET_CPU "generic")
endif()
endif()
if(CMAKE_TOOLCHAIN_FILE) # Add toolchain file to config string.
if(IS_ABSOLUTE "${CMAKE_TOOLCHAIN_FILE}")
file(RELATIVE_PATH toolchain_path "${AOM_CONFIG_DIR}"
"${CMAKE_TOOLCHAIN_FILE}")
else()
set(toolchain_path "${CMAKE_TOOLCHAIN_FILE}")
endif()
set(toolchain_string "-DCMAKE_TOOLCHAIN_FILE=\\\"${toolchain_path}\\\"")
set(AOM_CMAKE_CONFIG "${toolchain_string} ${AOM_CMAKE_CONFIG}")
else()
# Add detected CPU to the config string.
set(AOM_CMAKE_CONFIG "-DAOM_TARGET_CPU=${AOM_TARGET_CPU} ${AOM_CMAKE_CONFIG}")
endif()
set(AOM_CMAKE_CONFIG "-G \\\"${CMAKE_GENERATOR}\\\" ${AOM_CMAKE_CONFIG}")
file(RELATIVE_PATH source_path "${AOM_CONFIG_DIR}" "${AOM_ROOT}")
set(AOM_CMAKE_CONFIG "cmake ${source_path} ${AOM_CMAKE_CONFIG}")
string(STRIP "${AOM_CMAKE_CONFIG}" AOM_CMAKE_CONFIG)
message("--- aom_configure: Detected CPU: ${AOM_TARGET_CPU}")
set(AOM_TARGET_SYSTEM ${CMAKE_SYSTEM_NAME})
if("${CMAKE_BUILD_TYPE}" MATCHES "Deb")
set(CONFIG_DEBUG 1)
endif()
if(BUILD_SHARED_LIBS)
set(CONFIG_PIC 1)
set(CONFIG_SHARED 1)
endif()
if(NOT MSVC)
if(CONFIG_PIC)
# TODO(tomfinegan): clang needs -pie in CMAKE_EXE_LINKER_FLAGS for this to
# work.
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
if("${AOM_TARGET_SYSTEM}" STREQUAL "Linux" AND "${AOM_TARGET_CPU}" MATCHES
"^armv[78]")
set(AOM_AS_FLAGS ${AOM_AS_FLAGS} --defsym PIC=1)
else()
set(AOM_AS_FLAGS ${AOM_AS_FLAGS} -DPIC)
endif()
endif()
endif()
if("${AOM_TARGET_CPU}" STREQUAL "x86" OR "${AOM_TARGET_CPU}" STREQUAL "x86_64")
find_program(AS_EXECUTABLE yasm $ENV{YASM_PATH})
if(NOT AS_EXECUTABLE OR ENABLE_NASM)
unset(AS_EXECUTABLE CACHE)
find_program(AS_EXECUTABLE nasm $ENV{NASM_PATH})
if(AS_EXECUTABLE)
test_nasm()
endif()
endif()
if(NOT AS_EXECUTABLE)
message(
FATAL_ERROR
"Unable to find assembler. Install 'yasm' or 'nasm.' "
"To build without optimizations, add -DAOM_TARGET_CPU=generic to "
"your cmake command line.")
endif()
get_asm_obj_format("objformat")
set(AOM_AS_FLAGS -f ${objformat} ${AOM_AS_FLAGS})
string(STRIP "${AOM_AS_FLAGS}" AOM_AS_FLAGS)
elseif("${AOM_TARGET_CPU}" MATCHES "arm")
if("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
set(AS_EXECUTABLE as)
set(AOM_AS_FLAGS -arch ${AOM_TARGET_CPU} -isysroot ${CMAKE_OSX_SYSROOT})
elseif("${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
if(NOT AS_EXECUTABLE)
set(AS_EXECUTABLE ${CMAKE_C_COMPILER} -c -mimplicit-it=always)
endif()
else()
if(NOT AS_EXECUTABLE)
set(AS_EXECUTABLE as)
endif()
endif()
find_program(as_executable_found ${AS_EXECUTABLE})
if(NOT as_executable_found)
message(
FATAL_ERROR
"Unable to find assembler and optimizations are enabled."
"Searched for ${AS_EXECUTABLE}. Install it, add it to your path, or "
"set the assembler directly by adding -DAS_EXECUTABLE=<assembler path> "
"to your CMake command line."
"To build without optimizations, add -DAOM_TARGET_CPU=generic to your "
"cmake command line.")
endif()
string(STRIP "${AOM_AS_FLAGS}" AOM_AS_FLAGS)
endif()
if(CONFIG_ANALYZER)
include(FindwxWidgets)
find_package(wxWidgets REQUIRED adv base core)
include(${wxWidgets_USE_FILE})
endif()
if(NOT MSVC AND CMAKE_C_COMPILER_ID MATCHES "GNU\|Clang")
set(CONFIG_GCC 1)
endif()
if(CONFIG_GCOV)
message("--- Testing for CONFIG_GCOV support.")
require_linker_flag("-fprofile-arcs -ftest-coverage")
require_compiler_flag("-fprofile-arcs -ftest-coverage" YES)
endif()
if(CONFIG_GPROF)
message("--- Testing for CONFIG_GPROF support.")
require_compiler_flag("-pg" YES)
endif()
if("${AOM_TARGET_SYSTEM}" MATCHES "Darwin\|Linux\|Windows\|Android")
set(CONFIG_OS_SUPPORT 1)
endif()
# The default _WIN32_WINNT value in MinGW is 0x0502 (Windows XP with SP2). Set
# it to 0x0601 (Windows 7).
if("${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
add_compiler_flag_if_supported("-D_WIN32_WINNT=0x0601")
endif()
#
# Fix CONFIG_* dependencies. This must be done before including cpu.cmake to
# ensure RTCD_CONFIG_* are properly set.
fix_experiment_configs()
# Test compiler support.
aom_get_inline("INLINE")
# Don't just check for pthread.h, but use the result of the full pthreads
# including a linking check in FindThreads above.
set(HAVE_PTHREAD_H ${CMAKE_USE_PTHREADS_INIT})
aom_check_source_compiles("unistd_check" "#include <unistd.h>" HAVE_UNISTD_H)
if(NOT MSVC)
aom_push_var(CMAKE_REQUIRED_LIBRARIES "m")
aom_check_c_compiles(
"fenv_check"
"#define _GNU_SOURCE
#include <fenv.h>
void unused(void) {
(void)unused;
(void)feenableexcept(FE_DIVBYZERO | FE_INVALID);
}"
HAVE_FEXCEPT)
aom_pop_var(CMAKE_REQUIRED_LIBRARIES)
endif()
include("${AOM_ROOT}/build/cmake/cpu.cmake")
if(ENABLE_CCACHE)
set_compiler_launcher(ENABLE_CCACHE ccache)
endif()
if(ENABLE_DISTCC)
set_compiler_launcher(ENABLE_DISTCC distcc)
endif()
if(ENABLE_GOMA)
set_compiler_launcher(ENABLE_GOMA gomacc)
endif()
if(NOT CONFIG_AV1_DECODER AND NOT CONFIG_AV1_ENCODER)
message(FATAL_ERROR "Decoder and encoder disabled, nothing to build.")
endif()
if(DECODE_HEIGHT_LIMIT OR DECODE_WIDTH_LIMIT)
change_config_and_warn(CONFIG_SIZE_LIMIT 1
"DECODE_HEIGHT_LIMIT and DECODE_WIDTH_LIMIT")
endif()
if(CONFIG_SIZE_LIMIT)
if(NOT DECODE_HEIGHT_LIMIT OR NOT DECODE_WIDTH_LIMIT)
message(FATAL_ERROR "When setting CONFIG_SIZE_LIMIT, DECODE_HEIGHT_LIMIT "
"and DECODE_WIDTH_LIMIT must be set.")
endif()
endif()
# Test compiler flags.
if(MSVC)
add_compiler_flag_if_supported("/W3")
# Disable MSVC warnings that suggest making code non-portable.
add_compiler_flag_if_supported("/wd4996")
if(ENABLE_WERROR)
add_compiler_flag_if_supported("/WX")
endif()
else()
require_c_flag("-std=c99" YES)
require_cxx_flag_nomsvc("-std=c++11" YES)
add_compiler_flag_if_supported("-Wall")
add_compiler_flag_if_supported("-Wdisabled-optimization")
add_compiler_flag_if_supported("-Wextra")
add_compiler_flag_if_supported("-Wfloat-conversion")
add_compiler_flag_if_supported("-Wlogical-op")
add_compiler_flag_if_supported("-Wpointer-arith")
add_compiler_flag_if_supported("-Wshorten-64-to-32")
add_compiler_flag_if_supported("-Wsign-compare")
add_compiler_flag_if_supported("-Wstring-conversion")
add_compiler_flag_if_supported("-Wtype-limits")
add_compiler_flag_if_supported("-Wuninitialized")
add_compiler_flag_if_supported("-Wunused")
add_compiler_flag_if_supported("-Wvla")
if(CMAKE_C_COMPILER_ID MATCHES "GNU" AND "${SANITIZE}" MATCHES
"address|undefined")
# This combination has more stack overhead, so we account for it by
# providing higher stack limit than usual.
add_c_flag_if_supported("-Wstack-usage=170000")
add_cxx_flag_if_supported("-Wstack-usage=270000")
elseif(CONFIG_RD_DEBUG) # Another case where higher stack usage is expected.
add_c_flag_if_supported("-Wstack-usage=140000")
add_cxx_flag_if_supported("-Wstack-usage=270000")
else()
add_c_flag_if_supported("-Wstack-usage=100000")
add_cxx_flag_if_supported("-Wstack-usage=240000")
endif()
if(CMAKE_C_COMPILER_ID MATCHES "GNU" AND SANITIZE MATCHES "address")
# Disable no optimization warning when compiling with sanitizers
add_compiler_flag_if_supported("-Wno-disabled-optimization")
endif()
# Flags valid for C, but not for C++.
add_c_flag_if_supported("-Wimplicit-function-declaration")
# Add -Wshadow only for C files to avoid massive gtest warning spam.
add_c_flag_if_supported("-Wshadow")
# Add -Wundef only for C files to avoid massive gtest warning spam.
add_c_flag_if_supported("-Wundef")
# Quiet gcc 6 vs 7 abi warnings:
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77728
if("${AOM_TARGET_CPU}" MATCHES "arm")
add_cxx_flag_if_supported("-Wno-psabi")
endif()
if(ENABLE_WERROR)
add_compiler_flag_if_supported("-Werror")
endif()
if("${CMAKE_BUILD_TYPE}" MATCHES "Rel")
add_compiler_flag_if_supported("-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0")
endif()
add_compiler_flag_if_supported("-D_LARGEFILE_SOURCE")
add_compiler_flag_if_supported("-D_FILE_OFFSET_BITS=64")
endif()
set(AOM_LIB_LINK_TYPE PUBLIC)
if(EMSCRIPTEN)
# Avoid CMake generation time errors resulting from collisions with the form
# of target_link_libraries() used by Emscripten.cmake.
unset(AOM_LIB_LINK_TYPE)
endif()
# Generate aom_config templates.
set(aom_config_asm_template "${AOM_CONFIG_DIR}/config/aom_config.asm.cmake")
set(aom_config_h_template "${AOM_CONFIG_DIR}/config/aom_config.h.cmake")
execute_process(
COMMAND
${CMAKE_COMMAND} -DAOM_CONFIG_DIR=${AOM_CONFIG_DIR} -DAOM_ROOT=${AOM_ROOT}
-P "${AOM_ROOT}/build/cmake/generate_aom_config_templates.cmake")
# Generate aom_config.{asm,h}.
configure_file("${aom_config_asm_template}"
"${AOM_CONFIG_DIR}/config/aom_config.asm")
configure_file("${aom_config_h_template}"
"${AOM_CONFIG_DIR}/config/aom_config.h")
# Read the current git hash.
find_package(Git)
if(NOT GIT_FOUND)
message("--- Git missing, version will be read from CHANGELOG.")
endif()
configure_file("${AOM_ROOT}/build/cmake/aom_config.c.template"
"${AOM_CONFIG_DIR}/config/aom_config.c")
# Find Perl and generate the RTCD sources.
find_package(Perl)
if(NOT PERL_FOUND)
message(FATAL_ERROR "Perl is required to build libaom.")
endif()
set(AOM_RTCD_CONFIG_FILE_LIST
"${AOM_ROOT}/aom_dsp/aom_dsp_rtcd_defs.pl"
"${AOM_ROOT}/aom_scale/aom_scale_rtcd.pl"
"${AOM_ROOT}/av1/common/av1_rtcd_defs.pl")
set(AOM_RTCD_HEADER_FILE_LIST
"${AOM_CONFIG_DIR}/config/aom_dsp_rtcd.h"
"${AOM_CONFIG_DIR}/config/aom_scale_rtcd.h"
"${AOM_CONFIG_DIR}/config/av1_rtcd.h")
set(AOM_RTCD_SOURCE_FILE_LIST
"${AOM_ROOT}/aom_dsp/aom_dsp_rtcd.c"
"${AOM_ROOT}/aom_scale/aom_scale_rtcd.c"
"${AOM_ROOT}/av1/common/av1_rtcd.c")
set(AOM_RTCD_SYMBOL_LIST aom_dsp_rtcd aom_scale_rtcd av1_rtcd)
list(LENGTH AOM_RTCD_SYMBOL_LIST AOM_RTCD_CUSTOM_COMMAND_COUNT)
math(EXPR AOM_RTCD_CUSTOM_COMMAND_COUNT "${AOM_RTCD_CUSTOM_COMMAND_COUNT} - 1")
foreach(NUM RANGE ${AOM_RTCD_CUSTOM_COMMAND_COUNT})
list(GET AOM_RTCD_CONFIG_FILE_LIST ${NUM} AOM_RTCD_CONFIG_FILE)
list(GET AOM_RTCD_HEADER_FILE_LIST ${NUM} AOM_RTCD_HEADER_FILE)
list(GET AOM_RTCD_SOURCE_FILE_LIST ${NUM} AOM_RTCD_SOURCE_FILE)
list(GET AOM_RTCD_SYMBOL_LIST ${NUM} AOM_RTCD_SYMBOL)
execute_process(
COMMAND
${PERL_EXECUTABLE} "${AOM_ROOT}/build/cmake/rtcd.pl"
--arch=${AOM_TARGET_CPU} --sym=${AOM_RTCD_SYMBOL} ${AOM_RTCD_FLAGS}
--config=${AOM_CONFIG_DIR}/config/aom_config.h ${AOM_RTCD_CONFIG_FILE}
OUTPUT_FILE ${AOM_RTCD_HEADER_FILE})
endforeach()
# Generate aom_version.h.
execute_process(
COMMAND
${CMAKE_COMMAND} -DAOM_CONFIG_DIR=${AOM_CONFIG_DIR} -DAOM_ROOT=${AOM_ROOT}
-DGIT_EXECUTABLE=${GIT_EXECUTABLE} -DPERL_EXECUTABLE=${PERL_EXECUTABLE} -P
"${AOM_ROOT}/build/cmake/version.cmake")