wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-08 00:07:30 +09:00
Code Issues Projects Releases Packages Wiki Activity

Import aom library

Browse source 
This is the reference implementation for the Alliance for Open Media's av1 video code.

The commit used was 4d668d7feb1f8abd809d1bca0418570a7f142a36.
This commit is contained in:
trav90 2018-10-15 21:45:30 -05:00 • committed by Roy Tam
commit edc8d83307
989 changed files with 470949 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

306
third_party/aom/build/cmake/aom_configure.cmake vendored Normal file
View file

@ -0,0 +1,306 @@
##
## Copyright (c) 2016, Alliance for Open Media. All rights reserved
##
## This source code is subject to the terms of the BSD 2 Clause License and
## the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
## was not distributed with this source code in the LICENSE file, you can
## obtain it at www.aomedia.org/license/software. 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 www.aomedia.org/license/patent.
##
include(FindGit)
include(FindPerl)
include(FindThreads)
include(FindwxWidgets)
set(AOM_SUPPORTED_CPU_TARGETS
"arm64 armv7 armv7s generic mips32 mips64 x86 x86_64")
# Generate the user config settings. This must occur before include of
# aom_config_defaults.cmake (because it turns every config variable into a cache
# variable with its own help string).
get_cmake_property(cmake_cache_vars CACHE_VARIABLES)
foreach(cache_var ${cmake_cache_vars})
get_property(cache_var_helpstring CACHE ${cache_var} PROPERTY HELPSTRING)
set(cmdline_helpstring "No help, variable specified on the command line.")
if("${cache_var_helpstring}" STREQUAL "${cmdline_helpstring}")
set(AOM_CMAKE_CONFIG "${AOM_CMAKE_CONFIG} -D${cache_var}=${${cache_var}}")
endif ()
endforeach()
string(STRIP "${AOM_CMAKE_CONFIG}" AOM_CMAKE_CONFIG)
include("${AOM_ROOT}/build/cmake/aom_config_defaults.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")
# Build a list of all configurable variables.
get_cmake_property(cmake_cache_vars CACHE_VARIABLES)
foreach (var ${cmake_cache_vars})
if ("${var}" MATCHES "^CONFIG_")
list(APPEND AOM_CONFIG_VARS ${var})
endif ()
endforeach ()
# Detect target CPU.
if (NOT AOM_TARGET_CPU)
if ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "AMD64" OR
"${CMAKE_SYSTEM_PROCESSOR}" 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 ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "i386" OR
"${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86")
set(AOM_TARGET_CPU "x86")
elseif ("${CMAKE_SYSTEM_PROCESSOR}" MATCHES "^arm" OR
"${CMAKE_SYSTEM_PROCESSOR}" MATCHES "^mips")
set(AOM_TARGET_CPU "${CMAKE_SYSTEM_PROCESSOR}")
endif ()
endif ()
if (CMAKE_TOOLCHAIN_FILE)
# Add toolchain file to config string.
set(toolchain_string "-DCMAKE_TOOLCHAIN_FILE=\\\"${CMAKE_TOOLCHAIN_FILE}\\\"")
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}")
string(STRIP "${AOM_CMAKE_CONFIG}" AOM_CMAKE_CONFIG)
message("--- aom_configure: Detected CPU: ${AOM_TARGET_CPU}")
set(AOM_TARGET_SYSTEM ${CMAKE_SYSTEM_NAME})
if (NOT "${AOM_SUPPORTED_CPU_TARGETS}" MATCHES "${AOM_TARGET_CPU}")
message(FATAL_ERROR "No RTCD support for ${AOM_TARGET_CPU}. Create it, or "
"add -DAOM_TARGET_CPU=generic to your cmake command line for a "
"generic build of libaom and tools.")
endif ()
if ("${AOM_TARGET_CPU}" STREQUAL "x86" OR "${AOM_TARGET_CPU}" STREQUAL "x86_64")
# TODO(tomfinegan): Support nasm at least as well as the existing build
# system.
find_program(AS_EXECUTABLE yasm $ENV{YASM_PATH})
if (NOT AS_EXECUTABLE)
message(FATAL_ERROR "Unable to find yasm. 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 "Linux")
# arm linux assembler settings controlled by
# build/cmake/toolchains/arm*-linux*.cmake
endif ()
if (NOT AS_EXECUTABLE)
message(FATAL_ERROR
"Unknown assembler for: ${AOM_TARGET_CPU}-${AOM_TARGET_SYSTEM}")
endif ()
string(STRIP "${AOM_AS_FLAGS}" AOM_AS_FLAGS)
endif ()
include("${AOM_ROOT}/build/cmake/cpu.cmake")
# 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)
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("-Wimplicit-function-declaration")
add_compiler_flag_if_supported("-Wpointer-arith")
add_compiler_flag_if_supported("-Wsign-compare")
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")
# TODO(jzern): this could be added as a cxx flags for test/*.cc only,
# avoiding third_party.
add_c_flag_if_supported("-Wshorten-64-to-32")
# 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")
if (ENABLE_WERROR)
add_compiler_flag_if_supported("-Werror")
endif ()
# Flag(s) added here negate CMake defaults and produce build output similar
# to the existing configure/make build system.
add_compiler_flag_if_supported("-Wno-unused-function")
if (CMAKE_C_COMPILER_ID MATCHES "GNU\|Clang")
set(CONFIG_GCC 1)
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 ()
if ("${AOM_TARGET_SYSTEM}" MATCHES "Darwin\|Linux\|Windows")
set(CONFIG_OS_SUPPORT 1)
endif ()
# Test compiler support.
aom_get_inline("INLINE")
# TODO(tomfinegan): aom_ports_check is legacy; HAVE_AOM_PORTS is not used
# anywhere in the aom sources. To be removed after parity with the legacy
# build system stops being important.
aom_check_source_compiles("aom_ports_check"
"#include \"${AOM_ROOT}/aom/aom_integer.h\""
HAVE_AOM_PORTS)
aom_check_source_compiles("pthread_check" "#include <pthread.h>" HAVE_PTHREAD_H)
aom_check_source_compiles("unistd_check" "#include <unistd.h>" HAVE_UNISTD_H)
if (CONFIG_ANALYZER)
find_package(wxWidgets REQUIRED adv base core)
include(${wxWidgets_USE_FILE})
if (NOT CONFIG_INSPECTION)
set(CONFIG_INSPECTION 1)
message(WARNING
"--- Enabled CONFIG_INSPECTION, required for CONFIG_ANALYZER.")
endif ()
endif ()
if (CONFIG_ANS AND CONFIG_DAALA_EC)
message(FATAL_ERROR
"CONFIG_ANS and CONFIG_DAALA_EC cannot be enabled together.")
endif ()
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)feenableexcept(FE_DIVBYZERO | FE_INVALID);
}" HAVE_FEXCEPT)
aom_pop_var(CMAKE_REQUIRED_LIBRARIES)
endif()
# Generate aom_config templates.
set(aom_config_asm_template "${AOM_CONFIG_DIR}/aom_config.asm.cmake")
set(aom_config_h_template "${AOM_CONFIG_DIR}/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}/aom_config.asm")
configure_file("${aom_config_h_template}" "${AOM_CONFIG_DIR}/aom_config.h")
# Read the current git hash.
find_package(Git)
set(AOM_GIT_DESCRIPTION)
set(AOM_GIT_HASH)
if (GIT_FOUND)
# TODO(tomfinegan): Add build rule so users don't have to re-run cmake to
# create accurately versioned cmake builds.
execute_process(COMMAND ${GIT_EXECUTABLE}
--git-dir=${AOM_ROOT}/.git rev-parse HEAD
OUTPUT_VARIABLE AOM_GIT_HASH)
execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${AOM_ROOT}/.git describe
OUTPUT_VARIABLE AOM_GIT_DESCRIPTION ERROR_QUIET)
# Consume the newline at the end of the git output.
string(STRIP "${AOM_GIT_HASH}" AOM_GIT_HASH)
string(STRIP "${AOM_GIT_DESCRIPTION}" AOM_GIT_DESCRIPTION)
endif ()
configure_file("${AOM_ROOT}/build/cmake/aom_config.c.cmake"
"${AOM_CONFIG_DIR}/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 ()
configure_file(
"${AOM_ROOT}/build/cmake/rtcd_config.cmake"
"${AOM_CONFIG_DIR}/${AOM_TARGET_CPU}_rtcd_config.rtcd")
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}/aom_dsp_rtcd.h"
"${AOM_CONFIG_DIR}/aom_scale_rtcd.h"
"${AOM_CONFIG_DIR}/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/make/rtcd.pl"
--arch=${AOM_TARGET_CPU} --sym=${AOM_RTCD_SYMBOL} ${AOM_RTCD_FLAGS}
--config=${AOM_CONFIG_DIR}/${AOM_TARGET_CPU}_rtcd_config.rtcd
${AOM_RTCD_CONFIG_FILE}
OUTPUT_FILE ${AOM_RTCD_HEADER_FILE})
endforeach()
function (add_rtcd_build_step config output source symbol)
add_custom_command(
OUTPUT ${output}
COMMAND ${PERL_EXECUTABLE}
ARGS "${AOM_ROOT}/build/make/rtcd.pl"
--arch=${AOM_TARGET_CPU}
--sym=${symbol}
${AOM_RTCD_FLAGS}
--config=${AOM_CONFIG_DIR}/${AOM_TARGET_CPU}_rtcd_config.rtcd
${config}
> ${output}
DEPENDS ${config}
COMMENT "Generating ${output}"
WORKING_DIRECTORY ${AOM_CONFIG_DIR}
VERBATIM)
set_property(SOURCE ${source} PROPERTY OBJECT_DEPENDS ${output})
set_property(SOURCE ${output} PROPERTY GENERATED)
endfunction ()
# Generate aom_version.h.
if ("${AOM_GIT_DESCRIPTION}" STREQUAL "")
set(AOM_GIT_DESCRIPTION "${AOM_ROOT}/CHANGELOG")
endif ()
execute_process(
COMMAND ${PERL_EXECUTABLE} "${AOM_ROOT}/build/cmake/aom_version.pl"
--version_data=${AOM_GIT_DESCRIPTION}
--version_filename=${AOM_CONFIG_DIR}/aom_version.h)