wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-07 07:47: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

15
third_party/aom/build/cmake/aom_config.c.cmake vendored Normal file
View file

@ -0,0 +1,15 @@
/*
* 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 "aom/aom_codec.h"
static const char* const cfg = "${AOM_CMAKE_CONFIG}";
static const char* const aom_git_hash = "${AOM_GIT_HASH}";
const char *aom_codec_build_config(void) {return cfg;}
const char *aom_codec_git_hash(void) {return aom_git_hash;}

167
third_party/aom/build/cmake/aom_config_defaults.cmake vendored Normal file
View file

@ -0,0 +1,167 @@
##
## 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.
##
# Defaults for every libaom configuration variable. Here we add all libaom
# config variables to the cmake variable cache, but omit the FORCE parameter to
# allow users to specify values when executing cmake to generate build files.
# Values here are used only if not set by the user.
set(RESTRICT "" CACHE STRING "Sets RESTRICT value for current target.")
set(INLINE "" CACHE STRING "Sets INLINE value for current target.")
set(ARCH_ARM 0 CACHE BOOL "Enables ARM architecture.")
set(ARCH_MIPS 0 CACHE BOOL "Enables MIPS architecture.")
set(ARCH_X86 0 CACHE BOOL "Enables X86 architecture.")
set(ARCH_X86_64 0 CACHE BOOL "Enables X86_64 architecture.")
set(HAVE_EDSP 0 CACHE BOOL "Enables EDSP optimizations.")
set(HAVE_MEDIA 0 CACHE BOOL "Enables MEDIA optimizations.")
set(HAVE_NEON 0 CACHE BOOL "Enables NEON intrinsics optimizations.")
set(HAVE_NEON_ASM 0 CACHE BOOL "Enables NEON assembly optimizations.")
set(HAVE_MIPS32 0 CACHE BOOL "Enables MIPS32 optimizations.")
set(HAVE_DSPR2 0 CACHE BOOL "Enables DSPR2 optimizations.")
set(HAVE_MSA 0 CACHE BOOL "Enables MSA optimizations.")
set(HAVE_MIPS64 0 CACHE BOOL "Enables MIPS64 optimizations. ")
set(HAVE_MMX 0 CACHE BOOL "Enables MMX optimizations. ")
set(HAVE_SSE 0 CACHE BOOL "Enables SSE optimizations.")
set(HAVE_SSE2 0 CACHE BOOL "Enables SSE2 optimizations.")
set(HAVE_SSE3 0 CACHE BOOL "Enables SSE3 optimizations.")
set(HAVE_SSSE3 0 CACHE BOOL "Enables SSSE3 optimizations.")
set(HAVE_SSE4_1 0 CACHE BOOL "Enables SSE 4.1 optimizations.")
set(HAVE_AVX 0 CACHE BOOL "Enables AVX optimizations.")
set(HAVE_AVX2 0 CACHE BOOL "Enables AVX2 optimizations.")
set(HAVE_AOM_PORTS 0 CACHE BOOL "Internal flag, deprecated.")
set(HAVE_FEXCEPT 0 CACHE BOOL "Internal flag, GNU fenv.h present for target.")
set(HAVE_PTHREAD_H 0 CACHE BOOL "Internal flag, target pthread support.")
set(HAVE_UNISTD_H 0 CACHE BOOL "Internal flag, unistd.h present for target.")
set(HAVE_WXWIDGETS 0 CACHE BOOL "WxWidgets present.")
set(CONFIG_DEPENDENCY_TRACKING 1 CACHE BOOL "Internal flag.")
set(CONFIG_EXTERNAL_BUILD 0 CACHE BOOL "Internal flag.")
set(CONFIG_INSTALL_DOCS 0 CACHE BOOL "Internal flag.")
set(CONFIG_INSTALL_BINS 0 CACHE BOOL "Internal flag.")
set(CONFIG_INSTALL_LIBS 0 CACHE BOOL "Internal flag.")
set(CONFIG_INSTALL_SRCS 0 CACHE BOOL "Internal flag.")
set(CONFIG_DEBUG 0 CACHE BOOL "Internal flag.")
set(CONFIG_GPROF 0 CACHE BOOL "Internal flag.")
set(CONFIG_GCOV 0 CACHE BOOL "Internal flag.")
set(CONFIG_RVCT 0 CACHE BOOL "Internal flag.")
set(CONFIG_GCC 0 CACHE BOOL "Internal flag.")
set(CONFIG_MSVS 0 CACHE BOOL "Internal flag.")
set(CONFIG_PIC 0 CACHE BOOL "Internal flag.")
set(CONFIG_BIG_ENDIAN 0 CACHE BOOL "Internal flag.")
set(CONFIG_CODEC_SRCS 0 CACHE BOOL "Internal flag.")
set(CONFIG_DEBUG_LIBS 0 CACHE BOOL "Internal flag.")
set(CONFIG_RUNTIME_CPU_DETECT 1 CACHE BOOL "Internal flag.")
set(CONFIG_POSTPROC 1 CACHE BOOL "Internal flag.")
set(CONFIG_MULTITHREAD 1 CACHE BOOL "Internal flag.")
set(CONFIG_INTERNAL_STATS 0 CACHE BOOL "Internal flag.")
set(CONFIG_AV1_ENCODER 1 CACHE BOOL "Enable AV1 encoder.")
set(CONFIG_AV1_DECODER 1 CACHE BOOL "Enable AV1 decoder.")
set(CONFIG_AV1 1 CACHE BOOL "Internal flag.")
set(CONFIG_ENCODERS 1 CACHE BOOL "Enable encoding.")
set(CONFIG_DECODERS 1 CACHE BOOL "Enable decoding.")
set(CONFIG_STATIC_MSVCRT 0 CACHE BOOL "Internal flag.")
set(CONFIG_SPATIAL_RESAMPLING 1 CACHE BOOL "Internal flag.")
set(CONFIG_REALTIME_ONLY 0 CACHE BOOL "Internal flag.")
set(CONFIG_ONTHEFLY_BITPACKING 0 CACHE BOOL "Internal flag.")
set(CONFIG_ERROR_CONCEALMENT 0 CACHE BOOL "Internal flag.")
set(CONFIG_SHARED 0 CACHE BOOL "Internal flag.")
set(CONFIG_STATIC 1 CACHE BOOL "Internal flag.")
set(CONFIG_SMALL 0 CACHE BOOL "Internal flag.")
set(CONFIG_POSTPROC_VISUALIZER 0 CACHE BOOL "Internal flag.")
set(CONFIG_OS_SUPPORT 0 CACHE BOOL "Internal flag.")
set(CONFIG_UNIT_TESTS 1 CACHE BOOL "Internal flag.")
set(CONFIG_WEBM_IO 1 CACHE BOOL "Enables WebM support.")
set(CONFIG_LIBYUV 1 CACHE BOOL "Enables libyuv scaling and conversion support.")
set(CONFIG_ACCOUNTING 0 CACHE BOOL "Enables bit accounting.")
set(CONFIG_INSPECTION 0 CACHE BOOL "Enables bitstream inspection.")
set(CONFIG_DECODE_PERF_TESTS 0 CACHE BOOL "Internal flag.")
set(CONFIG_ENCODE_PERF_TESTS 0 CACHE BOOL "Internal flag.")
set(CONFIG_COEFFICIENT_RANGE_CHECKING 0 CACHE BOOL "Internal flag.")
set(CONFIG_LOWBITDEPTH 1 CACHE BOOL "Internal flag.")
set(CONFIG_HIGHBITDEPTH 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXPERIMENTAL 0 CACHE BOOL "Internal flag.")
set(CONFIG_SIZE_LIMIT 0 CACHE BOOL "Internal flag.")
set(CONFIG_AOM_QM 0 CACHE BOOL "Internal flag.")
set(CONFIG_FP_MB_STATS 0 CACHE BOOL "Internal flag.")
set(CONFIG_CDEF 1 CACHE BOOL "Internal flag.")
set(CONFIG_VAR_TX 0 CACHE BOOL "Internal flag.")
set(CONFIG_RECT_TX 1 CACHE BOOL "Internal flag.")
set(CONFIG_REF_MV 1 CACHE BOOL "Internal flag.")
set(CONFIG_TPL_MV 0 CACHE BOOL "Internal flag.")
set(CONFIG_DUAL_FILTER 1 CACHE BOOL "Internal flag.")
set(CONFIG_CONVOLVE_ROUND 0 CACHE BOOL "Internal flag.")
set(CONFIG_COMPOUND_ROUND 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_TX 0 CACHE BOOL "Internal flag.")
set(CONFIG_TX64X64 0 CACHE BOOL "Internal flag.")
set(CONFIG_SUB8X8_MC 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_INTRA 1 CACHE BOOL "Internal flag.")
set(CONFIG_INTRA_INTERP 0 CACHE BOOL "Internal flag.")
set(CONFIG_FILTER_INTRA 0 CACHE BOOL "Internal flag.")
set(CONFIG_INTRABC 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_INTER 0 CACHE BOOL "Internal flag.")
set(CONFIG_INTERINTRA 0 CACHE BOOL "Internal flag.")
set(CONFIG_WEDGE 0 CACHE BOOL "Internal flag.")
set(CONFIG_COMPOUND_SEGMENT 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_REFS 1 CACHE BOOL "Internal flag.")
set(CONFIG_GLOBAL_MOTION 0 CACHE BOOL "Internal flag.")
set(CONFIG_NEW_QUANT 0 CACHE BOOL "Internal flag.")
set(CONFIG_SUPERTX 0 CACHE BOOL "Internal flag.")
set(CONFIG_ANS 0 CACHE BOOL "Internal flag.")
set(CONFIG_EC_MULTISYMBOL 1 CACHE BOOL "Internal flag.")
set(CONFIG_NEW_TOKENSET 1 CACHE BOOL "Internal flag.")
set(CONFIG_LOOP_RESTORATION 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_PARTITION 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_PARTITION_TYPES 0 CACHE BOOL "Internal flag.")
set(CONFIG_UNPOISON_PARTITION_CTX 0 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_TILE 0 CACHE BOOL "Internal flag.")
set(CONFIG_MOTION_VAR 0 CACHE BOOL "Internal flag.")
set(CONFIG_NCOBMC 0 CACHE BOOL "Internal flag.")
set(CONFIG_WARPED_MOTION 0 CACHE BOOL "Internal flag.")
set(CONFIG_Q_ADAPT_PROBS 0 CACHE BOOL "Internal flag.")
set(CONFIG_SUBFRAME_PROB_UPDATE 0 CACHE BOOL "Internal flag.")
set(CONFIG_BITSTREAM_DEBUG 0 CACHE BOOL "Internal flag.")
set(CONFIG_ALT_INTRA 1 CACHE BOOL "Internal flag.")
set(CONFIG_PALETTE 1 CACHE BOOL "Internal flag.")
set(CONFIG_PALETTE_DELTA_ENCODING 0 CACHE BOOL "Internal flag.")
set(CONFIG_DAALA_EC 1 CACHE BOOL "Internal flag.")
set(CONFIG_RAWBITS 0 CACHE BOOL "Internal flag.")
set(CONFIG_EC_SMALLMUL 0 CACHE BOOL "Internal flag.")
set(CONFIG_PVQ 0 CACHE BOOL "Internal flag.")
set(CONFIG_CFL 0 CACHE BOOL "Internal flag.")
set(CONFIG_XIPHRC 0 CACHE BOOL "Internal flag.")
set(CONFIG_CB4X4 1 CACHE BOOL "Internal flag.")
set(CONFIG_CHROMA_2X2 0 CACHE BOOL "Internal flag.")
set(CONFIG_FRAME_SIZE 0 CACHE BOOL "Internal flag.")
set(CONFIG_DELTA_Q 1 CACHE BOOL "Internal flag.")
set(CONFIG_EXT_DELTA_Q 0 CACHE BOOL "Internal flag.")
set(CONFIG_ADAPT_SCAN 0 CACHE BOOL "Internal flag.")
set(CONFIG_FILTER_7BIT 1 CACHE BOOL "Internal flag.")
set(CONFIG_PARALLEL_DEBLOCKING 0 CACHE BOOL "Internal flag.")
set(CONFIG_PARALLEL_DEBLOCKING_15TAP 0 CACHE BOOL "Internal flag.")
set(CONFIG_LOOPFILTERING_ACROSS_TILES 0 CACHE BOOL "Internal flag.")
set(CONFIG_TILE_GROUPS 1 CACHE BOOL "Internal flag.")
set(CONFIG_EC_ADAPT 1 CACHE BOOL "Internal flag.")
set(CONFIG_TEMPMV_SIGNALING 0 CACHE BOOL "Internal flag.")
set(CONFIG_RD_DEBUG 0 CACHE BOOL "Internal flag.")
set(CONFIG_REFERENCE_BUFFER 1 CACHE BOOL "Internal flag.")
set(CONFIG_COEF_INTERLEAVE 0 CACHE BOOL "Internal flag.")
set(CONFIG_ENTROPY_STATS 0 CACHE BOOL "Internal flag.")
set(CONFIG_MASKED_TX 0 CACHE BOOL "Internal flag.")
set(CONFIG_DEPENDENT_HORZTILES 0 CACHE BOOL "Internal flag.")
set(CONFIG_DAALA_DIST 0 CACHE BOOL "Internal flag.")
set(CONFIG_TRIPRED 0 CACHE BOOL "Internal flag.")
set(CONFIG_PALETTE_THROUGHPUT 1 CACHE BOOL "Internal flag.")
set(CONFIG_REF_ADAPT 0 CACHE BOOL "Internal flag.")
set(CONFIG_LV_MAP 0 CACHE BOOL "Internal flag.")
set(CONFIG_TXK_SEL 0 CACHE BOOL "Internal flag.")
set(CONFIG_MV_COMPRESS 1 CACHE BOOL "Internal flag.")
set(CONFIG_FRAME_SUPERRES 0 CACHE BOOL "Internal flag.")
set(CONFIG_NEW_MULTISYMBOL 0 CACHE BOOL "Internal flag.")
set(CONFIG_COMPOUND_SINGLEREF 0 CACHE BOOL "Internal flag.")
set(CONFIG_ANALYZER 0 CACHE BOOL "Internal flag.")

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)

204
third_party/aom/build/cmake/aom_optimization.cmake vendored Normal file
View file

@ -0,0 +1,204 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_AOM_OPTIMIZATION_CMAKE_)
set(AOM_BUILD_CMAKE_AOM_OPTIMIZATION_CMAKE_ 1)
# Translate $flag to one which MSVC understands, and write the new flag to the
# variable named by $translated_flag (or unset it, when MSVC needs no flag).
function (get_msvc_intrinsic_flag flag translated_flag)
if ("${flag}" STREQUAL "-mavx")
set(${translated_flag} "/arch:AVX" PARENT_SCOPE)
elseif ("${flag}" STREQUAL "-mavx2")
set(${translated_flag} "/arch:AVX2" PARENT_SCOPE)
else ()
# MSVC does not need flags for intrinsics flavors other than AVX/AVX2.
unset(${translated_flag} PARENT_SCOPE)
endif ()
endfunction ()
# Adds an object library target. Terminates generation if $flag is not supported
# by the current compiler. $flag is the intrinsics flag required by the current
# compiler, and is added to the compile flags for all sources in $sources.
# $opt_name is used to name the target. $target_to_update is made
# dependent upon the created target.
#
# Note: the libaom target is always updated because OBJECT libraries have rules
# that disallow the direct addition of .o files to them as dependencies. Static
# libraries do not have this limitation.
function (add_intrinsics_object_library flag opt_name target_to_update sources)
set(target_name ${target_to_update}_${opt_name}_intrinsics)
add_library(${target_name} OBJECT ${${sources}})
if (MSVC)
get_msvc_intrinsic_flag(${flag} "flag")
endif ()
if (flag)
target_compile_options(${target_name} PUBLIC ${flag})
endif ()
target_sources(aom PUBLIC $<TARGET_OBJECTS:${target_name}>)
# Add the new lib target to the global list of aom library targets.
list(APPEND AOM_LIB_TARGETS ${target_name})
set(AOM_LIB_TARGETS ${AOM_LIB_TARGETS} PARENT_SCOPE)
endfunction ()
# Adds sources in list named by $sources to $target and adds $flag to the
# compile flags for each source file.
function (add_intrinsics_source_to_target flag target sources)
target_sources(${target} PUBLIC ${${sources}})
if (MSVC)
get_msvc_intrinsic_flag(${flag} "flag")
endif ()
if (flag)
foreach (source ${${sources}})
set_property(SOURCE ${source} APPEND PROPERTY COMPILE_FLAGS ${flag})
endforeach ()
endif ()
endfunction ()
# Writes object format for the current target to the var named by $out_format,
# or terminates the build when the object format for the current target is
# unknown.
function (get_asm_obj_format out_format)
if ("${AOM_TARGET_CPU}" STREQUAL "x86_64")
if ("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
set(objformat "macho64")
elseif ("${AOM_TARGET_SYSTEM}" STREQUAL "Linux")
set(objformat "elf64")
elseif ("${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
set(objformat "win64")
else ()
message(FATAL_ERROR "Unknown obj format: ${AOM_TARGET_SYSTEM}")
endif ()
elseif ("${AOM_TARGET_CPU}" STREQUAL "x86")
if ("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
set(objformat "macho32")
elseif ("${AOM_TARGET_SYSTEM}" STREQUAL "Linux")
set(objformat "elf32")
elseif ("${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
set(objformat "win32")
else ()
message(FATAL_ERROR "Unknown obj format: ${AOM_TARGET_SYSTEM}")
endif ()
else ()
message(FATAL_ERROR
"Unknown obj format: ${AOM_TARGET_CPU}-${AOM_TARGET_SYSTEM}")
endif ()
set(${out_format} ${objformat} PARENT_SCOPE)
endfunction ()
# Adds library target named $lib_name for ASM files in variable named by
# $asm_sources. Builds an output directory path from $lib_name. Links $lib_name
# into $dependent_target. Generates a dummy C file with a dummy function to
# ensure that all cmake generators can determine the linker language, and that
# build tools don't complain that an object exposes no symbols.
function (add_asm_library lib_name asm_sources dependent_target)
set(asm_lib_obj_dir "${AOM_CONFIG_DIR}/asm_objects/${lib_name}")
if (NOT EXISTS "${asm_lib_obj_dir}")
file(MAKE_DIRECTORY "${asm_lib_obj_dir}")
endif ()
# TODO(tomfinegan): If cmake ever allows addition of .o files to OBJECT lib
# targets, make this OBJECT instead of STATIC to hide the target from
# consumers of the AOM cmake build.
add_library(${lib_name} STATIC ${${asm_sources}})
foreach (asm_source ${${asm_sources}})
get_filename_component(asm_source_name "${asm_source}" NAME)
set(asm_object "${asm_lib_obj_dir}/${asm_source_name}.o")
add_custom_command(OUTPUT "${asm_object}"
COMMAND ${AS_EXECUTABLE}
ARGS ${AOM_AS_FLAGS}
-I${AOM_ROOT} -I${AOM_CONFIG_DIR}
-o "${asm_object}" "${asm_source}"
DEPENDS "${asm_source}"
COMMENT "Building ASM object ${asm_object}"
WORKING_DIRECTORY "${AOM_CONFIG_DIR}"
VERBATIM)
target_sources(${lib_name} PRIVATE "${asm_object}")
endforeach ()
# The above created a target containing only ASM sources. Cmake needs help
# here to determine the linker language. Add a dummy C file to force the
# linker language to C. We don't bother with setting the LINKER_LANGUAGE
# property on the library target because not all generators obey it (looking
# at you, xcode generator).
set(dummy_c_file "${AOM_CONFIG_DIR}/${lib_name}_dummy.c")
file(WRITE "${dummy_c_file}"
"// Generated file. DO NOT EDIT!\n"
"// ${lib_name} needs C file to force link language, ignore me.\n"
"void ${lib_name}_dummy_function(void) {}\n")
target_sources(${lib_name} PUBLIC ${dummy_c_file})
target_link_libraries(${dependent_target} PRIVATE ${lib_name})
# Add the new lib target to the global list of aom library targets.
list(APPEND AOM_LIB_TARGETS ${lib_name})
set(AOM_LIB_TARGETS ${AOM_LIB_TARGETS} PARENT_SCOPE)
endfunction ()
# Converts asm sources in $asm_sources using $AOM_ADS2GAS and calls
# add_asm_library() to create a library from the converted sources. At
# generation time the converted sources are created, and a custom rule is added
# to ensure the sources are reconverted when the original asm source is updated.
# See add_asm_library() for more information.
function (add_gas_asm_library lib_name asm_sources dependent_target)
set(asm_converted_source_dir "${AOM_CONFIG_DIR}/asm_gas/${lib_name}")
if (NOT EXISTS "${asm_converted_source_dir}")
file(MAKE_DIRECTORY "${asm_converted_source_dir}")
endif ()
# Create the converted version of each assembly source at generation time.
unset(gas_target_sources)
foreach (neon_asm_source ${${asm_sources}})
get_filename_component(output_asm_source "${neon_asm_source}" NAME)
set(output_asm_source "${asm_converted_source_dir}/${output_asm_source}")
set(output_asm_source "${output_asm_source}.${AOM_GAS_EXT}")
execute_process(COMMAND "${PERL_EXECUTABLE}" "${AOM_ADS2GAS}"
INPUT_FILE "${neon_asm_source}"
OUTPUT_FILE "${output_asm_source}")
list(APPEND gas_target_sources "${output_asm_source}")
endforeach ()
add_asm_library("${lib_name}" "gas_target_sources" "${dependent_target}")
# For each of the converted sources, create a custom rule that will regenerate
# the converted source when its input is touched.
list(LENGTH gas_target_sources num_asm_files)
math(EXPR num_asm_files "${num_asm_files} - 1")
foreach(NUM RANGE ${num_asm_files})
list(GET ${asm_sources} ${NUM} neon_asm_source)
list(GET gas_target_sources ${NUM} gas_asm_source)
# Grab only the filename for the custom command output to keep build output
# reasonably sane.
get_filename_component(neon_name "${neon_asm_source}" NAME)
get_filename_component(gas_name "${gas_asm_source}" NAME)
add_custom_command(
OUTPUT "${gas_asm_source}"
COMMAND ${PERL_EXECUTABLE}
ARGS "${AOM_ADS2GAS}" < "${neon_asm_source}" > "${gas_asm_source}"
DEPENDS "${neon_asm_source}"
COMMENT "ads2gas conversion ${neon_name} -> ${gas_name}"
WORKING_DIRECTORY "${AOM_CONFIG_DIR}"
VERBATIM)
endforeach ()
# Update the sources list passed in to include the converted asm source files.
list(APPEND asm_sources ${gas_target_sources})
set(${asm_sources} ${${asm_sources}} PARENT_SCOPE)
endfunction ()
endif () # AOM_BUILD_CMAKE_AOM_OPTIMIZATION_CMAKE_

93
third_party/aom/build/cmake/aom_version.pl vendored Executable file
View file

@ -0,0 +1,93 @@
#!/usr/bin/env perl
##
## 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.
##
use strict;
use warnings;
use 5.010;
use Getopt::Long;
my $version_data;
my $version_filename;
GetOptions('version_data=s' => \$version_data,
'version_filename=s' => \$version_filename) or
die("Invalid arg(s): $!");
if (!defined $version_data || length($version_data) == 0 ||
!defined $version_filename || length($version_filename) == 0) {
die("--version_data and --version_filename are required.");
}
# Determine if $version_data is a filename or a git tag/description.
my $version_string;
if (-r $version_data) {
# $version_data is the path to the CHANGELOG. Parse the most recent version.
my $changelog_filename = $version_data;
open(my $changelog_file, '<', $changelog_filename) or
die("Unable to open CHANGELOG @ $changelog_filename: $!.");
while (my $line = <$changelog_file>) {
my @split_line = split(" ", $line, 3);
next if @split_line < 2;
$version_string = $split_line[1];
last if substr($version_string, 0, 1) eq "v";
}
close($changelog_file);
} else {
# $version_data is either a tag name or a full git description, one of:
# tagName OR tagName-commitsSinceTag-shortCommitHash
# In either case we want the first element of the array returned by split.
$version_string = (split("-", $version_data))[0];
}
if (substr($version_string, 0, 1) eq "v") {
$version_string = substr($version_string, 1);
}
my @version_components = split('\.', $version_string, 4);
my $version_major = $version_components[0];
my $version_minor = $version_components[1];
my $version_patch = $version_components[2];
my $version_extra = "";
if (@version_components > 3) {
$version_extra = $version_components[3];
}
open(my $version_file, '>', $version_filename) or
die("Cannot open $version_filename: $!");
my $version_packed = "((VERSION_MAJOR<<16)|(VERSION_MINOR<<8)|(VERSION_PATCH))";
my $year = (localtime)[5] + 1900;
my $lic_block = << "EOF";
/*
* Copyright (c) $year, 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.
*/
EOF
select $version_file;
print << "EOF";
$lic_block
#define VERSION_MAJOR $version_major
#define VERSION_MINOR $version_minor
#define VERSION_PATCH $version_patch
#define VERSION_EXTRA \"$version_extra\"
#define VERSION_PACKED $version_packed
#define VERSION_STRING_NOSP \"v$version_string\"
#define VERSION_STRING \" v$version_string\"
EOF
close($version_file);

218
third_party/aom/build/cmake/compiler_flags.cmake vendored Normal file
View file

@ -0,0 +1,218 @@
##
## 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(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
# Strings used to cache failed C/CXX flags.
set(AOM_FAILED_C_FLAGS)
set(AOM_FAILED_CXX_FLAGS)
# Checks C compiler for support of $c_flag. Adds $c_flag to $CMAKE_C_FLAGS when
# the compile test passes. Caches $c_flag in $AOM_FAILED_C_FLAGS when the test
# fails.
function (add_c_flag_if_supported c_flag)
unset(C_FLAG_FOUND CACHE)
string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND)
unset(C_FLAG_FAILED CACHE)
string(FIND "${AOM_FAILED_C_FLAGS}" "${c_flag}" C_FLAG_FAILED)
if (${C_FLAG_FOUND} EQUAL -1 AND ${C_FLAG_FAILED} EQUAL -1)
unset(C_FLAG_SUPPORTED CACHE)
message("Checking C compiler flag support for: " ${c_flag})
check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED)
if (C_FLAG_SUPPORTED)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${c_flag}" CACHE STRING "" FORCE)
else ()
set(AOM_FAILED_C_FLAGS "${AOM_FAILED_C_FLAGS} ${c_flag}" CACHE STRING ""
FORCE)
endif ()
endif ()
endfunction ()
# Checks C++ compiler for support of $cxx_flag. Adds $cxx_flag to
# $CMAKE_CXX_FLAGS when the compile test passes. Caches $c_flag in
# $AOM_FAILED_CXX_FLAGS when the test fails.
function (add_cxx_flag_if_supported cxx_flag)
unset(CXX_FLAG_FOUND CACHE)
string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND)
unset(CXX_FLAG_FAILED CACHE)
string(FIND "${AOM_FAILED_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FAILED)
if (${CXX_FLAG_FOUND} EQUAL -1 AND ${CXX_FLAG_FAILED} EQUAL -1)
unset(CXX_FLAG_SUPPORTED CACHE)
message("Checking CXX compiler flag support for: " ${cxx_flag})
check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED)
if (CXX_FLAG_SUPPORTED)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flag}" CACHE STRING ""
FORCE)
else()
set(AOM_FAILED_CXX_FLAGS "${AOM_FAILED_CXX_FLAGS} ${cxx_flag}" CACHE
STRING "" FORCE)
endif ()
endif ()
endfunction ()
# Convenience method for adding a flag to both the C and C++ compiler command
# lines.
function (add_compiler_flag_if_supported flag)
add_c_flag_if_supported(${flag})
add_cxx_flag_if_supported(${flag})
endfunction ()
# Checks C compiler for support of $c_flag and terminates generation when
# support is not present.
function (require_c_flag c_flag update_c_flags)
unset(C_FLAG_FOUND CACHE)
string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND)
if (${C_FLAG_FOUND} EQUAL -1)
unset(HAVE_C_FLAG CACHE)
message("Checking C compiler flag support for: " ${c_flag})
check_c_compiler_flag("${c_flag}" HAVE_C_FLAG)
if (NOT HAVE_C_FLAG)
message(FATAL_ERROR
"${PROJECT_NAME} requires support for C flag: ${c_flag}.")
endif ()
if (update_c_flags)
set(CMAKE_C_FLAGS "${c_flag} ${CMAKE_C_FLAGS}" CACHE STRING "" FORCE)
endif ()
endif ()
endfunction ()
# Checks CXX compiler for support of $cxx_flag and terminates generation when
# support is not present.
function (require_cxx_flag cxx_flag update_cxx_flags)
unset(CXX_FLAG_FOUND CACHE)
string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND)
if (${CXX_FLAG_FOUND} EQUAL -1)
unset(HAVE_CXX_FLAG CACHE)
message("Checking CXX compiler flag support for: " ${cxx_flag})
check_cxx_compiler_flag("${cxx_flag}" HAVE_CXX_FLAG)
if (NOT HAVE_CXX_FLAG)
message(FATAL_ERROR
"${PROJECT_NAME} requires support for CXX flag: ${cxx_flag}.")
endif ()
if (update_cxx_flags)
set(CMAKE_CXX_FLAGS "${cxx_flag} ${CMAKE_CXX_FLAGS}" CACHE STRING ""
FORCE)
endif ()
endif ()
endfunction ()
# Checks for support of $flag by both the C and CXX compilers. Terminates
# generation when support is not present in both compilers.
function (require_flag flag update_cmake_flags)
require_c_flag(${flag} ${update_cmake_flags})
require_cxx_flag(${flag} ${update_cmake_flags})
endfunction ()
# Checks only non-MSVC targets for support of $c_flag and terminates generation
# when support is not present.
function (require_c_flag_nomsvc c_flag update_c_flags)
if (NOT MSVC)
require_c_flag(${c_flag} ${update_c_flags})
endif ()
endfunction ()
# Checks only non-MSVC targets for support of $cxx_flag and terminates
# generation when support is not present.
function (require_cxx_flag_nomsvc cxx_flag update_cxx_flags)
if (NOT MSVC)
require_cxx_flag(${cxx_flag} ${update_cxx_flags})
endif ()
endfunction ()
# Checks only non-MSVC targets for support of $flag by both the C and CXX
# compilers. Terminates generation when support is not present in both
# compilers.
function (require_flag_nomsvc flag update_cmake_flags)
require_c_flag_nomsvc(${flag} ${update_cmake_flags})
require_cxx_flag_nomsvc(${flag} ${update_cmake_flags})
endfunction ()
# Adds $preproc_def to C compiler command line (as -D$preproc_def) if not
# already present.
function (add_c_preproc_definition preproc_def)
unset(PREPROC_DEF_FOUND CACHE)
string(FIND "${CMAKE_C_FLAGS}" "${preproc_def}" PREPROC_DEF_FOUND)
if (${PREPROC_DEF_FOUND} EQUAL -1)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D${preproc_def}" CACHE STRING ""
FORCE)
endif ()
endfunction ()
# Adds $preproc_def to CXX compiler command line (as -D$preproc_def) if not
# already present.
function (add_cxx_preproc_definition preproc_def)
unset(PREPROC_DEF_FOUND CACHE)
string(FIND "${CMAKE_CXX_FLAGS}" "${preproc_def}" PREPROC_DEF_FOUND)
if (${PREPROC_DEF_FOUND} EQUAL -1)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D${preproc_def}" CACHE STRING ""
FORCE)
endif ()
endfunction ()
# Adds $preproc_def to C and CXX compiler command line (as -D$preproc_def) if
# not already present.
function (add_preproc_definition preproc_def)
add_c_preproc_definition(${preproc_def})
add_cxx_preproc_definition(${preproc_def})
endfunction ()
# Adds $flag to assembler command line.
function (append_as_flag flag)
unset(AS_FLAG_FOUND CACHE)
string(FIND "${AOM_AS_FLAGS}" "${flag}" AS_FLAG_FOUND)
if (${AS_FLAG_FOUND} EQUAL -1)
set(AOM_AS_FLAGS "${AOM_AS_FLAGS} ${flag}" CACHE STRING "" FORCE)
endif ()
endfunction ()
# Adds $flag to the C compiler command line.
function (append_c_flag flag)
unset(C_FLAG_FOUND CACHE)
string(FIND "${CMAKE_C_FLAGS}" "${flag}" C_FLAG_FOUND)
if (${C_FLAG_FOUND} EQUAL -1)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" CACHE STRING "" FORCE)
endif ()
endfunction ()
# Adds $flag to the CXX compiler command line.
function (append_cxx_flag flag)
unset(CXX_FLAG_FOUND CACHE)
string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" CXX_FLAG_FOUND)
if (${CXX_FLAG_FOUND} EQUAL -1)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" CACHE STRING "" FORCE)
endif ()
endfunction ()
# Adds $flag to the C and CXX compiler command lines.
function (append_compiler_flag flag)
append_c_flag(${flag})
append_cxx_flag(${flag})
endfunction ()
# Adds $flag to the executable linker command line.
function (append_exe_linker_flag flag)
unset(LINKER_FLAG_FOUND CACHE)
string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" LINKER_FLAG_FOUND)
if (${LINKER_FLAG_FOUND} EQUAL -1)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}" CACHE STRING
"" FORCE)
endif ()
endfunction ()

133
third_party/aom/build/cmake/compiler_tests.cmake vendored Normal file
View file

@ -0,0 +1,133 @@
##
## 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(CheckCSourceCompiles)
include(CheckCXXSourceCompiles)
# The basic main() function used in all compile tests.
set(AOM_C_MAIN "\nint main(void) { return 0; }")
set(AOM_CXX_MAIN "\nint main() { return 0; }")
# Strings containing the names of passed and failed tests.
set(AOM_C_PASSED_TESTS)
set(AOM_C_FAILED_TESTS)
set(AOM_CXX_PASSED_TESTS)
set(AOM_CXX_FAILED_TESTS)
function(aom_push_var var new_value)
set(SAVED_${var} ${var} PARENT_SCOPE)
set(${var} ${new_value} PARENT_SCOPE)
endfunction ()
function(aom_pop_var var)
set(var ${SAVED_${var}} PARENT_SCOPE)
unset(SAVED_${var} PARENT_SCOPE)
endfunction ()
# Confirms $test_source compiles and stores $test_name in one of
# $AOM_C_PASSED_TESTS or $AOM_C_FAILED_TESTS depending on out come. When the
# test passes $result_var is set to 1. When it fails $result_var is unset.
# The test is not run if the test name is found in either of the passed or
# failed test variables.
function(aom_check_c_compiles test_name test_source result_var)
unset(C_TEST_PASSED CACHE)
unset(C_TEST_FAILED CACHE)
string(FIND "${AOM_C_PASSED_TESTS}" "${test_name}" C_TEST_PASSED)
string(FIND "${AOM_C_FAILED_TESTS}" "${test_name}" C_TEST_FAILED)
if (${C_TEST_PASSED} EQUAL -1 AND ${C_TEST_FAILED} EQUAL -1)
unset(C_TEST_COMPILED CACHE)
message("Running C compiler test: ${test_name}")
check_c_source_compiles("${test_source} ${AOM_C_MAIN}" C_TEST_COMPILED)
set(${result_var} ${C_TEST_COMPILED} PARENT_SCOPE)
if (C_TEST_COMPILED)
set(AOM_C_PASSED_TESTS "${AOM_C_PASSED_TESTS} ${test_name}" CACHE STRING
"" FORCE)
else ()
set(AOM_C_FAILED_TESTS "${AOM_C_FAILED_TESTS} ${test_name}" CACHE STRING
"" FORCE)
message("C Compiler test ${test_name} failed.")
endif ()
elseif (NOT ${C_TEST_PASSED} EQUAL -1)
set(${result_var} 1 PARENT_SCOPE)
else () # ${C_TEST_FAILED} NOT EQUAL -1
unset(${result_var} PARENT_SCOPE)
endif ()
endfunction ()
# Confirms $test_source compiles and stores $test_name in one of
# $AOM_CXX_PASSED_TESTS or $AOM_CXX_FAILED_TESTS depending on out come. When the
# test passes $result_var is set to 1. When it fails $result_var is unset.
# The test is not run if the test name is found in either of the passed or
# failed test variables.
function(aom_check_cxx_compiles test_name test_source result_var)
unset(CXX_TEST_PASSED CACHE)
unset(CXX_TEST_FAILED CACHE)
string(FIND "${AOM_CXX_PASSED_TESTS}" "${test_name}" CXX_TEST_PASSED)
string(FIND "${AOM_CXX_FAILED_TESTS}" "${test_name}" CXX_TEST_FAILED)
if (${CXX_TEST_PASSED} EQUAL -1 AND ${CXX_TEST_FAILED} EQUAL -1)
unset(CXX_TEST_COMPILED CACHE)
message("Running CXX compiler test: ${test_name}")
check_cxx_source_compiles("${test_source} ${AOM_CXX_MAIN}"
CXX_TEST_COMPILED)
set(${result_var} ${CXX_TEST_COMPILED} PARENT_SCOPE)
if (CXX_TEST_COMPILED)
set(AOM_CXX_PASSED_TESTS "${AOM_CXX_PASSED_TESTS} ${test_name}" CACHE
STRING "" FORCE)
else ()
set(AOM_CXX_FAILED_TESTS "${AOM_CXX_FAILED_TESTS} ${test_name}" CACHE
STRING "" FORCE)
message("CXX Compiler test ${test_name} failed.")
endif ()
elseif (NOT ${CXX_TEST_PASSED} EQUAL -1)
set(${result_var} 1 PARENT_SCOPE)
else () # ${CXX_TEST_FAILED} NOT EQUAL -1
unset(${result_var} PARENT_SCOPE)
endif ()
endfunction ()
# Convenience function that confirms $test_source compiles as C and C++.
# $result_var is set to 1 when both tests are successful, and 0 when one or both
# tests fail.
# Note: This function is intended to be used to write to result variables that are
# expanded via configure_file(). $result_var is set to 1 or 0 to allow direct
# usage of the value in generated source files.
function(aom_check_source_compiles test_name test_source result_var)
unset(C_PASSED)
unset(CXX_PASSED)
aom_check_c_compiles(${test_name} ${test_source} C_PASSED)
aom_check_cxx_compiles(${test_name} ${test_source} CXX_PASSED)
if (C_PASSED AND CXX_PASSED)
set(${result_var} 1 PARENT_SCOPE)
else ()
set(${result_var} 0 PARENT_SCOPE)
endif ()
endfunction ()
# When inline support is detected for the current compiler the supported
# inlining keyword is written to $result in caller scope.
function (aom_get_inline result)
aom_check_source_compiles("inline_check_1"
"static inline void function(void) {}"
HAVE_INLINE_1)
if (HAVE_INLINE_1 EQUAL 1)
set(${result} "inline" PARENT_SCOPE)
return()
endif ()
# Check __inline.
aom_check_source_compiles("inline_check_2"
"static __inline void function(void) {}"
HAVE_INLINE_2)
if (HAVE_INLINE_2 EQUAL 1)
set(${result} "__inline" PARENT_SCOPE)
endif ()
endfunction ()

72
third_party/aom/build/cmake/cpu.cmake vendored Normal file
View file

@ -0,0 +1,72 @@
##
## Copyright (c) 2017, 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.
##
if ("${AOM_TARGET_CPU}" STREQUAL "arm64")
set(ARCH_ARM 1)
set(HAVE_NEON 1)
set(RTCD_ARCH_ARM "yes")
set(RTCD_HAVE_NEON "yes")
elseif ("${AOM_TARGET_CPU}" MATCHES "^armv7")
set(ARCH_ARM 1)
set(HAVE_NEON 1)
set(HAVE_NEON_ASM 1)
set(RTCD_ARCH_ARM "yes")
set(RTCD_HAVE_NEON "yes")
set(RTCD_HAVE_NEON_ASM "yes")
elseif ("${AOM_TARGET_CPU}" MATCHES "^mips")
set(ARCH_MIPS 1)
if ("${AOM_TARGET_CPU}" STREQUAL "mips32")
set(HAVE_MIPS32 1)
elseif ("${AOM_TARGET_CPU}" STREQUAL "mips64")
set(HAVE_MIPS64 1)
endif ()
set(RTCD_ARCH_MIPS "yes")
if (HAVE_DSPR2)
set(RTCD_HAVE_DSPR2 "yes")
endif ()
if (HAVE_MSA)
set(RTCD_HAVE_MSA "yes")
endif ()
elseif ("${AOM_TARGET_CPU}" MATCHES "^x86")
if ("${AOM_TARGET_CPU}" STREQUAL "x86")
set(ARCH_X86 1)
set(RTCD_ARCH_X86 "yes")
elseif ("${AOM_TARGET_CPU}" STREQUAL "x86_64")
set(ARCH_X86_64 1)
set(RTCD_ARCH_X86_64 "yes")
endif ()
set(HAVE_MMX 1)
set(HAVE_SSE 1)
set(HAVE_SSE2 1)
set(HAVE_SSE3 1)
set(HAVE_SSSE3 1)
set(HAVE_SSE4_1 1)
set(HAVE_AVX 1)
set(HAVE_AVX2 1)
set(RTCD_HAVE_MMX "yes")
set(RTCD_HAVE_SSE "yes")
set(RTCD_HAVE_SSE2 "yes")
set(RTCD_HAVE_SSE3 "yes")
set(RTCD_HAVE_SSSE3 "yes")
set(RTCD_HAVE_SSE4_1 "yes")
set(RTCD_HAVE_AVX "yes")
set(RTCD_HAVE_AVX2 "yes")
endif ()
foreach (config_var ${AOM_CONFIG_VARS})
if (${${config_var}})
set(RTCD_${config_var} yes)
endif ()
endforeach ()

84
third_party/aom/build/cmake/generate_aom_config_templates.cmake vendored Normal file
View file

@ -0,0 +1,84 @@
##
## Copyright (c) 2017, 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.
##
cmake_minimum_required(VERSION 3.5)
string(TIMESTAMP year "%Y")
set(asm_file_header_block
"\;
\; Copyright (c) ${year}, 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.
\;
")
set(h_file_header_block
"/*
* Copyright (c) ${year}, 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.
*/
\#ifndef AOM_CONFIG_H_
\#define AOM_CONFIG_H_
")
# Terminates cmake execution when $var_name is an empty string, or the variable
# name it contains does not expand to an existing directory.
function (check_directory_var var_name)
if ("${var_name}" STREQUAL "")
message(FATAL_ERROR "The CMake variable ${var_name} must be defined.")
endif ()
if (NOT EXISTS "${${var_name}}")
message(FATAL_ERROR "${${var_name}} (${var_name}) missing.")
endif ()
endfunction ()
check_directory_var(AOM_CONFIG_DIR)
check_directory_var(AOM_ROOT)
set(AOM_DEFAULTS "${AOM_ROOT}/build/cmake/aom_config_defaults.cmake")
if (NOT EXISTS "${AOM_DEFAULTS}")
message(FATAL_ERROR
"Configuration default values file (${AOM_DEFAULTS}) missing.")
endif ()
include("${AOM_ROOT}/build/cmake/aom_config_defaults.cmake")
get_cmake_property(cmake_cache_vars CACHE_VARIABLES)
set(aom_config_h_template "${AOM_CONFIG_DIR}/aom_config.h.cmake")
file(WRITE "${aom_config_h_template}" ${h_file_header_block})
foreach(cache_var ${cmake_cache_vars})
if (NOT "${cache_var}" MATCHES "AOM_CONFIG_DIR\|AOM_ROOT\|^CMAKE_")
file(APPEND
"${aom_config_h_template}" "\#define ${cache_var} \${${cache_var}}\n")
endif ()
endforeach()
file(APPEND "${aom_config_h_template}" "\#endif /* AOM_CONFIG_H_ */")
set(aom_asm_config_template "${AOM_CONFIG_DIR}/aom_config.asm.cmake")
file(WRITE "${aom_asm_config_template}" ${asm_file_header_block})
foreach(cache_var ${cmake_cache_vars})
if (NOT "${cache_var}" MATCHES
"AOM_CONFIG_DIR\|AOM_ROOT\|^CMAKE_\|INLINE\|RESTRICT")
file(APPEND "${aom_asm_config_template}"
"${cache_var} equ \${${cache_var}}\n")
endif ()
endforeach ()

26
third_party/aom/build/cmake/msvc_runtime.cmake vendored Normal file
View file

@ -0,0 +1,26 @@
##
## Copyright (c) 2017, 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.
##
if (MSVC)
# CMake defaults to producing code linked to the DLL MSVC runtime. That will
# not work with googletest, and isn't what we want anyway.
if (NOT "${MSVC_RUNTIME}" STREQUAL "dll")
foreach (flag_var
CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
if (${flag_var} MATCHES "/MD")
string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
endif (${flag_var} MATCHES "/MD")
endforeach (flag_var)
endif ()
endif ()

137
third_party/aom/build/cmake/rtcd_config.cmake vendored Normal file
View file

@ -0,0 +1,137 @@
##
## Copyright (c) 2017, 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.
##
ARCH_ARM=${RTCD_ARCH_ARM}
ARCH_MIPS=${RTCD_ARCH_MIPS}
ARCH_X86=${RTCD_ARCH_X86}
ARCH_X86_64=${RTCD_ARCH_X86_64}
HAVE_NEON=${RTCD_HAVE_NEON}
HAVE_NEON_ASM=${RTCD_HAVE_NEON_ASM}
HAVE_MIPS32=${RTCD_HAVE_MIPS32}
HAVE_DSPR2=${RTCD_HAVE_DSPR2}
HAVE_MSA=${RTCD_HAVE_MSA}
HAVE_MIPS64=${RTCD_HAVE_MIPS64}
HAVE_MMX=${RTCD_HAVE_MMX}
HAVE_SSE=${RTCD_HAVE_SSE}
HAVE_SSE2=${RTCD_HAVE_SSE2}
HAVE_SSE3=${RTCD_HAVE_SSE3}
HAVE_SSSE3=${RTCD_HAVE_SSSE3}
HAVE_SSE4_1=${RTCD_HAVE_SSE4_1}
HAVE_AVX=${RTCD_HAVE_AVX}
HAVE_AVX2=${RTCD_HAVE_AVX2}
CONFIG_ACCOUNTING=${RTCD_CONFIG_ACCOUNTING}
CONFIG_INSPECTION=${RTCD_CONFIG_INSPECTION}
CONFIG_ADAPT_SCAN=${RTCD_CONFIG_ADAPT_SCAN}
CONFIG_ALT_INTRA=${RTCD_CONFIG_ALT_INTRA}
CONFIG_ANS=${RTCD_CONFIG_ANS}
CONFIG_HIGHBITDEPTH=${RTCD_CONFIG_HIGHBITDEPTH}
CONFIG_AOM_QM=${RTCD_CONFIG_AOM_QM}
CONFIG_AV1=${RTCD_CONFIG_AV1}
CONFIG_AV1_DECODER=${RTCD_CONFIG_AV1_DECODER}
CONFIG_AV1_ENCODER=${RTCD_CONFIG_AV1_ENCODER}
CONFIG_BIG_ENDIAN=${RTCD_CONFIG_BIG_ENDIAN}
CONFIG_BITSTREAM_DEBUG=${RTCD_CONFIG_BITSTREAM_DEBUG}
CONFIG_CB4X4=${RTCD_CONFIG_CB4X4}
CONFIG_CDEF=${RTCD_CONFIG_CDEF}
CONFIG_CHROMA_2X2=${RTCD_CONFIG_CHROMA_2X2}
CONFIG_CODEC_SRCS=${RTCD_CONFIG_CODEC_SRCS}
CONFIG_COEFFICIENT_RANGE_CHECKING=${RTCD_CONFIG_COEFFICIENT_RANGE_CHECKING}
CONFIG_COEF_INTERLEAVE=${RTCD_CONFIG_COEF_INTERLEAVE}
CONFIG_COMPOUND_SEGMENT=${RTCD_CONFIG_COMPOUND_SEGMENT}
CONFIG_CONVOLVE_ROUND=${RTCD_CONFIG_CONVOLVE_ROUND}
CONFIG_DAALA_DIST=${RTCD_CONFIG_DAALA_DIST}
CONFIG_DAALA_EC=${RTCD_CONFIG_DAALA_EC}
CONFIG_DEBUG=${RTCD_CONFIG_DEBUG}
CONFIG_DEBUG_LIBS=${RTCD_CONFIG_DEBUG_LIBS}
CONFIG_DECODERS=${RTCD_CONFIG_DECODERS}
CONFIG_DECODE_PERF_TESTS=${RTCD_CONFIG_DECODE_PERF_TESTS}
CONFIG_DELTA_Q=${RTCD_CONFIG_DELTA_Q}
CONFIG_DEPENDENCY_TRACKING=${RTCD_CONFIG_DEPENDENCY_TRACKING}
CONFIG_DEPENDENT_HORZTILES=${RTCD_CONFIG_DEPENDENT_HORZTILES}
CONFIG_DUAL_FILTER=${RTCD_CONFIG_DUAL_FILTER}
CONFIG_EC_ADAPT=${RTCD_CONFIG_EC_ADAPT}
CONFIG_EC_MULTISYMBOL=${RTCD_CONFIG_EC_MULTISYMBOL}
CONFIG_ENCODERS=${RTCD_CONFIG_ENCODERS}
CONFIG_ENCODE_PERF_TESTS=${RTCD_CONFIG_ENCODE_PERF_TESTS}
CONFIG_ENTROPY_STATS=${RTCD_CONFIG_ENTROPY_STATS}
CONFIG_ERROR_CONCEALMENT=${RTCD_CONFIG_ERROR_CONCEALMENT}
CONFIG_EXPERIMENTAL=${RTCD_CONFIG_EXPERIMENTAL}
CONFIG_EXTERNAL_BUILD=${RTCD_CONFIG_EXTERNAL_BUILD}
CONFIG_EXT_INTER=${RTCD_CONFIG_EXT_INTER}
CONFIG_EXT_INTRA=${RTCD_CONFIG_EXT_INTRA}
CONFIG_EXT_PARTITION=${RTCD_CONFIG_EXT_PARTITION}
CONFIG_EXT_PARTITION_TYPES=${RTCD_CONFIG_EXT_PARTITION_TYPES}
CONFIG_EXT_REFS=${RTCD_CONFIG_EXT_REFS}
CONFIG_EXT_TILE=${RTCD_CONFIG_EXT_TILE}
CONFIG_EXT_TX=${RTCD_CONFIG_EXT_TX}
CONFIG_FILTER_7BIT=${RTCD_CONFIG_FILTER_7BIT}
CONFIG_FILTER_INTRA=${RTCD_CONFIG_FILTER_INTRA}
CONFIG_FP_MB_STATS=${RTCD_CONFIG_FP_MB_STATS}
CONFIG_FRAME_SIZE=${RTCD_CONFIG_FRAME_SIZE}
CONFIG_GCC=${RTCD_CONFIG_GCC}
CONFIG_GCOV=${RTCD_CONFIG_GCOV}
CONFIG_GLOBAL_MOTION=${RTCD_CONFIG_GLOBAL_MOTION}
CONFIG_GPROF=${RTCD_CONFIG_GPROF}
CONFIG_INSTALL_BINS=${RTCD_CONFIG_INSTALL_BINS}
CONFIG_INSTALL_DOCS=${RTCD_CONFIG_INSTALL_DOCS}
CONFIG_INSTALL_LIBS=${RTCD_CONFIG_INSTALL_LIBS}
CONFIG_INSTALL_SRCS=${RTCD_CONFIG_INSTALL_SRCS}
CONFIG_INTERNAL_STATS=${RTCD_CONFIG_INTERNAL_STATS}
CONFIG_INTRA_INTERP=${RTCD_CONFIG_INTRA_INTERP}
CONFIG_LIBYUV=${RTCD_CONFIG_LIBYUV}
CONFIG_LOOPFILTERING_ACROSS_TILES=${RTCD_CONFIG_LOOPFILTERING_ACROSS_TILES}
CONFIG_LOOP_RESTORATION=${RTCD_CONFIG_LOOP_RESTORATION}
CONFIG_LOWBITDEPTH=${RTCD_CONFIG_LOWBITDEPTH}
CONFIG_LV_MAP=${RTCD_CONFIG_LV_MAP}
CONFIG_MASKED_TX=${RTCD_CONFIG_MASKED_TX}
CONFIG_MOTION_VAR=${RTCD_CONFIG_MOTION_VAR}
CONFIG_MSVS=${RTCD_CONFIG_MSVS}
CONFIG_MULTITHREAD=${RTCD_CONFIG_MULTITHREAD}
CONFIG_MV_COMPRESS=${RTCD_CONFIG_MV_COMPRESS}
CONFIG_NCOBMC=${RTCD_CONFIG_NCOBMC}
CONFIG_NEW_QUANT=${RTCD_CONFIG_NEW_QUANT}
CONFIG_NEW_TOKENSET=${RTCD_CONFIG_NEW_TOKENSET}
CONFIG_ONTHEFLY_BITPACKING=${RTCD_CONFIG_ONTHEFLY_BITPACKING}
CONFIG_OS_SUPPORT=${RTCD_CONFIG_OS_SUPPORT}
CONFIG_PALETTE=${RTCD_CONFIG_PALETTE}
CONFIG_PALETTE_THROUGHPUT=${RTCD_CONFIG_PALETTE_THROUGHPUT}
CONFIG_PARALLEL_DEBLOCKING=${RTCD_CONFIG_PARALLEL_DEBLOCKING}
CONFIG_PIC=${RTCD_CONFIG_PIC}
CONFIG_POSTPROC=${RTCD_CONFIG_POSTPROC}
CONFIG_POSTPROC_VISUALIZER=${RTCD_CONFIG_POSTPROC_VISUALIZER}
CONFIG_PVQ=${RTCD_CONFIG_PVQ}
CONFIG_RAWBITS=${RTCD_CONFIG_RAWBITS}
CONFIG_RD_DEBUG=${RTCD_CONFIG_RD_DEBUG}
CONFIG_REALTIME_ONLY=${RTCD_CONFIG_REALTIME_ONLY}
CONFIG_RECT_TX=${RTCD_CONFIG_RECT_TX}
CONFIG_REFERENCE_BUFFER=${RTCD_CONFIG_REFERENCE_BUFFER}
CONFIG_REF_ADAPT=${RTCD_CONFIG_REF_ADAPT}
CONFIG_REF_MV=${RTCD_CONFIG_REF_MV}
CONFIG_RUNTIME_CPU_DETECT=${RTCD_CONFIG_RUNTIME_CPU_DETECT}
CONFIG_RVCT=${RTCD_CONFIG_RVCT}
CONFIG_SHARED=${RTCD_CONFIG_SHARED}
CONFIG_SIZE_LIMIT=${RTCD_CONFIG_SIZE_LIMIT}
CONFIG_SMALL=${RTCD_CONFIG_SMALL}
CONFIG_SPATIAL_RESAMPLING=${RTCD_CONFIG_SPATIAL_RESAMPLING}
CONFIG_STATIC=${RTCD_CONFIG_STATIC}
CONFIG_STATIC_MSVCRT=${RTCD_CONFIG_STATIC_MSVCRT}
CONFIG_SUB8X8_MC=${RTCD_CONFIG_SUB8X8_MC}
CONFIG_SUPERTX=${RTCD_CONFIG_SUPERTX}
CONFIG_TEMPMV_SIGNALING=${RTCD_CONFIG_TEMPMV_SIGNALING}
CONFIG_TILE_GROUPS=${RTCD_CONFIG_TILE_GROUPS}
CONFIG_TPL_MV=${RTCD_CONFIG_TPL_MV}
CONFIG_TRIPRED=${RTCD_CONFIG_TRIPRED}
CONFIG_TX64X64=${RTCD_CONFIG_TX64X64}
CONFIG_UNIT_TESTS=${RTCD_CONFIG_UNIT_TESTS}
CONFIG_UNPOISON_PARTITION_CTX=${RTCD_CONFIG_UNPOISON_PARTITION_CTX}
CONFIG_VAR_TX=${RTCD_CONFIG_VAR_TX}
CONFIG_WARPED_MOTION=${RTCD_CONFIG_WARPED_MOTION}
CONFIG_WEBM_IO=${RTCD_CONFIG_WEBM_IO}
CONFIG_XIPHRC=${RTCD_CONFIG_XIPHRC}

31
third_party/aom/build/cmake/toolchains/arm-ios-common.cmake vendored Normal file
View file

@ -0,0 +1,31 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_)
set(AOM_BUILD_CMAKE_ARM_IOS_COMMON_CMAKE_ 1)
set(CMAKE_SYSTEM_NAME "Darwin")
set(CMAKE_OSX_SYSROOT iphoneos)
set(CMAKE_C_COMPILER clang)
set(CMAKE_C_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
# Assembler sources must be converted for ARM iOS targets.
set(AOM_ADS2GAS_REQUIRED 1)
set(AOM_ADS2GAS "${CMAKE_CURRENT_SOURCE_DIR}/build/make/ads2gas_apple.pl")
set(AOM_GAS_EXT "S")
# No runtime cpu detect for arm*-ios targets.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
# TODO(tomfinegan): Handle bit code embedding.
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_

24
third_party/aom/build/cmake/toolchains/arm64-ios.cmake vendored Normal file
View file

@ -0,0 +1,24 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_ 1)
if (XCODE)
# TODO(tomfinegan): Handle arm builds in Xcode.
message(FATAL_ERROR "This toolchain does not support Xcode.")
endif ()
set(CMAKE_SYSTEM_PROCESSOR "arm64")
set(CMAKE_OSX_ARCHITECTURES "arm64")
include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_

35
third_party/aom/build/cmake/toolchains/arm64-linux-gcc.cmake vendored Normal file
View file

@ -0,0 +1,35 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_ 1)
set(CMAKE_SYSTEM_NAME "Linux")
if ("${CROSS}" STREQUAL "")
# Default the cross compiler prefix to something known to work.
set(CROSS aarch64-linux-gnu-)
endif ()
set(CMAKE_C_COMPILER ${CROSS}gcc)
set(CMAKE_CXX_COMPILER ${CROSS}g++)
set(AS_EXECUTABLE ${CROSS}as)
set(CMAKE_C_COMPILER_ARG1 "-march=armv8-a")
set(CMAKE_CXX_COMPILER_ARG1 "-march=armv8-a")
set(AOM_AS_FLAGS "-march=armv8-a")
set(CMAKE_SYSTEM_PROCESSOR "arm64")
# No intrinsics flag required for arm64-linux-gcc.
set(AOM_NEON_INTRIN_FLAG "")
# No runtime cpu detect for arm64-linux-gcc.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_

34
third_party/aom/build/cmake/toolchains/armv7-ios.cmake vendored Normal file
View file

@ -0,0 +1,34 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_ 1)
if (XCODE)
# TODO(tomfinegan): Handle arm builds in Xcode.
message(FATAL_ERROR "This toolchain does not support Xcode.")
endif ()
set(CMAKE_SYSTEM_PROCESSOR "armv7")
set(CMAKE_OSX_ARCHITECTURES "armv7")
include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
# No intrinsics flag required for armv7s-ios.
set(AOM_NEON_INTRIN_FLAG "")
# No runtime cpu detect for armv7s-ios.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
# RTCD generation requires --disable-media for armv7s-ios.
set(AOM_RTCD_FLAGS ${AOM_RTCD_FLAGS} --disable-media)
string(STRIP AOM_RTCD_FLAGS ${AOM_RTCD_FLAGS})
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_

48
third_party/aom/build/cmake/toolchains/armv7-linux-gcc.cmake vendored Normal file
View file

@ -0,0 +1,48 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_ 1)
set(CMAKE_SYSTEM_NAME "Linux")
if ("${CROSS}" STREQUAL "")
# Default the cross compiler prefix to something known to work.
set(CROSS arm-linux-gnueabihf-)
endif ()
if (NOT ${CROSS} MATCHES hf-$)
set(AOM_EXTRA_TOOLCHAIN_FLAGS "-mfloat-abi=softfp")
endif ()
set(CMAKE_C_COMPILER ${CROSS}gcc)
set(CMAKE_CXX_COMPILER ${CROSS}g++)
set(AS_EXECUTABLE ${CROSS}as)
set(CMAKE_C_COMPILER_ARG1
"-march=armv7-a -mfpu=neon ${AOM_EXTRA_TOOLCHAIN_FLAGS}")
set(CMAKE_CXX_COMPILER_ARG1
"-march=armv7-a -mfpu=neon ${AOM_EXTRA_TOOLCHAIN_FLAGS}")
set(AOM_AS_FLAGS
--defsym ARCHITECTURE=7 -march=armv7-a -mfpu=neon
${AOM_EXTRA_TOOLCHAIN_FLAGS})
set(CMAKE_SYSTEM_PROCESSOR "armv7")
# No intrinsics flag required for armv7-linux-gcc.
set(AOM_NEON_INTRIN_FLAG "")
# Assembler sources must be converted for armv7-linux-gcc targets.
set(AOM_ADS2GAS_REQUIRED 1)
set(AOM_ADS2GAS "${CMAKE_CURRENT_SOURCE_DIR}/build/make/ads2gas.pl")
set(AOM_GAS_EXT "S")
# No runtime cpu detect for armv7-linux-gcc.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_

34
third_party/aom/build/cmake/toolchains/armv7s-ios.cmake vendored Normal file
View file

@ -0,0 +1,34 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_ 1)
if (XCODE)
# TODO(tomfinegan): Handle arm builds in Xcode.
message(FATAL_ERROR "This toolchain does not support Xcode.")
endif ()
set(CMAKE_SYSTEM_PROCESSOR "armv7s")
set(CMAKE_OSX_ARCHITECTURES "armv7s")
include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
# No intrinsics flag required for armv7s-ios.
set(AOM_NEON_INTRIN_FLAG "")
# No runtime cpu detect for armv7s-ios.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
# RTCD generation requires --disable-media for armv7s-ios.
set(AOM_RTCD_FLAGS ${AOM_RTCD_FLAGS} --disable-media)
string(STRIP AOM_RTCD_FLAGS ${AOM_RTCD_FLAGS})
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_

23
third_party/aom/build/cmake/toolchains/ios-simulator-common.cmake vendored Normal file
View file

@ -0,0 +1,23 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_IOS_SIMULATOR_COMMON_CMAKE_)
set(AOM_BUILD_CMAKE_IOS_SIMULATOR_COMMON_CMAKE_ 1)
set(CMAKE_SYSTEM_NAME "Darwin")
set(CMAKE_OSX_SYSROOT iphonesimulator)
set(CMAKE_C_COMPILER clang)
set(CMAKE_C_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
# TODO(tomfinegan): Handle bit code embedding.
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_IOS_SIMULATOR_COMMON_CMAKE_

71
third_party/aom/build/cmake/toolchains/mips32-linux-gcc.cmake vendored Normal file
View file

@ -0,0 +1,71 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_MIPS32_LINUX_GCC_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_MIPS32_LINUX_GCC_CMAKE_ 1)
set(CMAKE_SYSTEM_NAME "Linux")
if (ENABLE_DSPR2 AND ENABLE_MSA)
message(FATAL_ERROR "ENABLE_DSPR2 and ENABLE_MSA cannot be combined.")
endif ()
if (ENABLE_DSPR2)
set(HAVE_DSPR2 1 CACHE BOOL "" FORCE)
if ("${CROSS}" STREQUAL "")
# Default the cross compiler prefix to something known to work.
set(CROSS mips-linux-gnu-)
endif ()
set(MIPS_CFLAGS "-mdspr2")
set(MIPS_CXXFLAGS "-mdspr2")
elseif (ENABLE_MSA)
set(HAVE_MSA 1 CACHE BOOL "" FORCE)
if ("${CROSS}" STREQUAL "")
# Default the cross compiler prefix to something known to work.
set(CROSS mips-mti-linux-gnu-)
endif ()
set(MIPS_CFLAGS "-mmsa")
set(MIPS_CXXFLAGS "-mmsa")
endif ()
if ("${CROSS}" STREQUAL "")
# TODO(tomfinegan): Make it possible to turn this off. The $CROSS prefix
# won't be desired on a mips host.
# Default cross compiler prefix to something that might work for an
# unoptimized build.
set(CROSS mips-linux-gnu-)
endif ()
if ("${MIPS_CPU}" STREQUAL "")
set(MIPS_CFLAGS "${MIPS_CFLAGS} -mips32r2")
set(MIPS_CXXFLAGS "${MIPS_CXXFLAGS} -mips32r2")
elseif ("${MIPS_CPU}" STREQUAL "p5600")
set(P56_FLAGS
"-mips32r5 -mload-store-pairs -msched-weight -mhard-float -mfp64")
set(MIPS_CFLAGS "${MIPS_CFLAGS} ${P56_FLAGS}")
set(MIPS_CXXFLAGS "${MIPS_CXXFLAGS} ${P56_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "-mfp64 ${CMAKE_EXE_LINKER_FLAGS}")
endif ()
set(CMAKE_C_COMPILER ${CROSS}gcc)
set(CMAKE_CXX_COMPILER ${CROSS}g++)
set(AS_EXECUTABLE ${CROSS}as)
set(CMAKE_C_COMPILER_ARG1 "-EL ${MIPS_CFLAGS}")
set(CMAKE_CXX_COMPILER_ARG1 "-EL ${MIPS_CXXFLAGS}")
set(CMAKE_SYSTEM_PROCESSOR "mips32")
# No runtime cpu detect for mips32-linux-gcc.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_MIPS32_LINUX_GCC_CMAKE_

48
third_party/aom/build/cmake/toolchains/mips64-linux-gcc.cmake vendored Normal file
View file

@ -0,0 +1,48 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_MIPS64_LINUX_GCC_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_MIPS64_LINUX_GCC_CMAKE_ 1)
set(CMAKE_SYSTEM_NAME "Linux")
if ("${CROSS}" STREQUAL "")
# TODO(tomfinegan): Make it possible to turn this off. The $CROSS prefix
# won't be desired on a mips host.
# Default the cross compiler prefix to something known to work.
set(CROSS mips-img-linux-gnu-)
endif ()
if (ENABLE_MSA)
set(HAVE_MSA 1 CACHE BOOL "" FORCE)
set(MIPS_CFLAGS "-mmsa")
set(MIPS_CXXFLAGS "-mmsa")
endif ()
if ("${MIPS_CPU}" STREQUAL "i6400" OR "${MIPS_CPU}" STREQUAL "p6600")
set(MIPS_CPU_FLAGS "-mips64r6 -mabi=64 -mload-store-pairs -msched-weight")
set(MIPS_CPU_FLAGS "${MIPS_CPU_FLAGS} -mhard-float -mfp64")
set(MIPS_CFLAGS "${MIPS_CFLAGS} ${MIPS_CPU_FLAGS}")
set(MIPS_CXXFLAGS "${MIPS_CXXFLAGS} ${MIPS_CPU_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS
"-mips64r6 -mabi64 -mfp64 ${CMAKE_EXE_LINKER_FLAGS}")
endif ()
set(CMAKE_C_COMPILER ${CROSS}gcc)
set(CMAKE_CXX_COMPILER ${CROSS}g++)
set(AS_EXECUTABLE ${CROSS}as)
set(CMAKE_C_COMPILER_ARG1 "-EL ${MIPS_CFLAGS}")
set(CMAKE_CXX_COMPILER_ARG1 "-EL ${MIPS_CXXFLAGS}")
set(CMAKE_SYSTEM_PROCESSOR "mips64")
# No runtime cpu detect for mips64-linux-gcc.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE BOOL "")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_MIPS64_LINUX_GCC_CMAKE_

27
third_party/aom/build/cmake/toolchains/x86-ios-simulator.cmake vendored Normal file
View file

@ -0,0 +1,27 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_X86_IOS_SIMULATOR_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_X86_IOS_SIMULATOR_CMAKE_ 1)
if (XCODE)
# TODO(tomfinegan): Handle ios sim builds in Xcode.
message(FATAL_ERROR "This toolchain does not support Xcode.")
endif ()
set(CMAKE_SYSTEM_PROCESSOR "i386")
set(CMAKE_OSX_ARCHITECTURES "i386")
# Avoid noisy PIC/PIE warnings.
set(CONFIG_PIC 1 CACHE BOOL "")
include("${CMAKE_CURRENT_LIST_DIR}/ios-simulator-common.cmake")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_X86_IOS_SIMULATOR_CMAKE_

14
third_party/aom/build/cmake/toolchains/x86-linux.cmake vendored Normal file
View file

@ -0,0 +1,14 @@
##
## Copyright (c) 2017, 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.
##
set(CMAKE_SYSTEM_PROCESSOR "x86")
set(CMAKE_SYSTEM_NAME "Linux")
set(CMAKE_C_COMPILER_ARG1 "-m32")
set(CMAKE_CXX_COMPILER_ARG1 "-m32")

18
third_party/aom/build/cmake/toolchains/x86-macos.cmake vendored Normal file
View file

@ -0,0 +1,18 @@
##
## Copyright (c) 2017, 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.
##
set(CMAKE_SYSTEM_PROCESSOR "x86")
set(CMAKE_SYSTEM_NAME "Darwin")
set(CMAKE_OSX_ARCHITECTURES "i386")
set(CMAKE_C_COMPILER_ARG1 "-arch i386")
set(CMAKE_CXX_COMPILER_ARG1 "-arch i386")
# Apple tools always complain in 32 bit mode without PIC.
set(CONFIG_PIC 1 CACHE STRING "")

24
third_party/aom/build/cmake/toolchains/x86_64-ios-simulator.cmake vendored Normal file
View file

@ -0,0 +1,24 @@
##
## Copyright (c) 2017, 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.
##
if (NOT AOM_BUILD_CMAKE_TOOLCHAINS_X86_64_IOS_SIMULATOR_CMAKE_)
set(AOM_BUILD_CMAKE_TOOLCHAINS_X86_64_IOS_SIMULATOR_CMAKE_ 1)
if (XCODE)
# TODO(tomfinegan): Handle ios sim builds in Xcode.
message(FATAL_ERROR "This toolchain does not support Xcode.")
endif ()
set(CMAKE_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_OSX_ARCHITECTURES "x86_64")
include("${CMAKE_CURRENT_LIST_DIR}/ios-simulator-common.cmake")
endif () # AOM_BUILD_CMAKE_TOOLCHAINS_X86_64_IOS_SIMULATOR_CMAKE_

201
third_party/aom/build/make/Android.mk vendored Normal file
View file

@ -0,0 +1,201 @@
##
## 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.
##
#
# This file is to be used for compiling libaom for Android using the NDK.
# In an Android project place a libaom checkout in the jni directory.
# Run the configure script from the jni directory. Base libaom
# encoder/decoder configuration will look similar to:
# ./libaom/configure --target=armv7-android-gcc --disable-examples \
# --sdk-path=/opt/android-ndk-r6b/
#
# When targeting Android, realtime-only is enabled by default. This can
# be overridden by adding the command line flag:
# --disable-realtime-only
#
# This will create .mk files that contain variables that contain the
# source files to compile.
#
# Place an Android.mk file in the jni directory that references the
# Android.mk file in the libaom directory:
# LOCAL_PATH := $(call my-dir)
# include $(CLEAR_VARS)
# include jni/libaom/build/make/Android.mk
#
# There are currently two TARGET_ARCH_ABI targets for ARM.
# armeabi and armeabi-v7a. armeabi-v7a is selected by creating an
# Application.mk in the jni directory that contains:
# APP_ABI := armeabi-v7a
#
# By default libaom will detect at runtime the existance of NEON extension.
# For this we import the 'cpufeatures' module from the NDK sources.
# libaom can also be configured without this runtime detection method.
# Configuring with --disable-runtime-cpu-detect will assume presence of NEON.
# Configuring with --disable-runtime-cpu-detect --disable-neon \
# --disable-neon-asm
# will remove any NEON dependency.
# To change to building armeabi, run ./libaom/configure again, but with
# --target=armv6-android-gcc and modify the Application.mk file to
# set APP_ABI := armeabi
#
# Running ndk-build will build libaom and include it in your project.
#
CONFIG_DIR := $(LOCAL_PATH)/
LIBAOM_PATH := $(LOCAL_PATH)/libaom
ASM_CNV_PATH_LOCAL := $(TARGET_ARCH_ABI)/ads2gas
ASM_CNV_PATH := $(LOCAL_PATH)/$(ASM_CNV_PATH_LOCAL)
# Use the makefiles generated by upstream configure to determine which files to
# build. Also set any architecture-specific flags.
ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
include $(CONFIG_DIR)libs-armv7-android-gcc.mk
LOCAL_ARM_MODE := arm
else ifeq ($(TARGET_ARCH_ABI),armeabi)
include $(CONFIG_DIR)libs-armv6-android-gcc.mk
LOCAL_ARM_MODE := arm
else ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
include $(CONFIG_DIR)libs-armv8-android-gcc.mk
LOCAL_ARM_MODE := arm
else ifeq ($(TARGET_ARCH_ABI),x86)
include $(CONFIG_DIR)libs-x86-android-gcc.mk
else ifeq ($(TARGET_ARCH_ABI),x86_64)
include $(CONFIG_DIR)libs-x86_64-android-gcc.mk
else ifeq ($(TARGET_ARCH_ABI),mips)
include $(CONFIG_DIR)libs-mips-android-gcc.mk
else
$(error Not a supported TARGET_ARCH_ABI: $(TARGET_ARCH_ABI))
endif
# Rule that is normally in Makefile created by libaom
# configure. Used to filter out source files based on configuration.
enabled=$(filter-out $($(1)-no),$($(1)-yes))
# Override the relative path that is defined by the libaom
# configure process
SRC_PATH_BARE := $(LIBAOM_PATH)
# Include the list of files to be built
include $(LIBAOM_PATH)/libs.mk
# Optimise the code. May want to revisit this setting in the future.
LOCAL_CFLAGS := -O3
# For x86, include the source code in the search path so it will find files
# like x86inc.asm and x86_abi_support.asm
LOCAL_ASMFLAGS := -I$(LIBAOM_PATH)
.PRECIOUS: %.asm.s
$(ASM_CNV_PATH)/libaom/%.asm.s: $(LIBAOM_PATH)/%.asm
@mkdir -p $(dir $@)
@$(CONFIG_DIR)$(ASM_CONVERSION) <$< > $@
# For building *_rtcd.h, which have rules in libs.mk
TGT_ISA:=$(word 1, $(subst -, ,$(TOOLCHAIN)))
target := libs
LOCAL_SRC_FILES += aom_config.c
# Remove duplicate entries
CODEC_SRCS_UNIQUE = $(sort $(CODEC_SRCS))
# Pull out C files. aom_config.c is in the immediate directory and
# so it does not need libaom/ prefixed like the rest of the source files.
# The neon files with intrinsics need to have .neon appended so the proper
# flags are applied.
CODEC_SRCS_C = $(filter %.c, $(CODEC_SRCS_UNIQUE))
LOCAL_NEON_SRCS_C = $(filter %_neon.c, $(CODEC_SRCS_C))
LOCAL_CODEC_SRCS_C = $(filter-out aom_config.c %_neon.c, $(CODEC_SRCS_C))
LOCAL_SRC_FILES += $(foreach file, $(LOCAL_CODEC_SRCS_C), libaom/$(file))
ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
LOCAL_SRC_FILES += $(foreach file, $(LOCAL_NEON_SRCS_C), libaom/$(file).neon)
else # If there are neon sources then we are building for arm64 and do not need to specify .neon
LOCAL_SRC_FILES += $(foreach file, $(LOCAL_NEON_SRCS_C), libaom/$(file))
endif
# Pull out assembly files, splitting NEON from the rest. This is
# done to specify that the NEON assembly files use NEON assembler flags.
# x86 assembly matches %.asm, arm matches %.asm.s
# x86:
CODEC_SRCS_ASM_X86 = $(filter %.asm, $(CODEC_SRCS_UNIQUE))
LOCAL_SRC_FILES += $(foreach file, $(CODEC_SRCS_ASM_X86), libaom/$(file))
# arm:
CODEC_SRCS_ASM_ARM_ALL = $(filter %.asm.s, $(CODEC_SRCS_UNIQUE))
CODEC_SRCS_ASM_ARM = $(foreach v, \
$(CODEC_SRCS_ASM_ARM_ALL), \
$(if $(findstring neon,$(v)),,$(v)))
CODEC_SRCS_ASM_ADS2GAS = $(patsubst %.s, \
$(ASM_CNV_PATH_LOCAL)/libaom/%.s, \
$(CODEC_SRCS_ASM_ARM))
LOCAL_SRC_FILES += $(CODEC_SRCS_ASM_ADS2GAS)
ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
CODEC_SRCS_ASM_NEON = $(foreach v, \
$(CODEC_SRCS_ASM_ARM_ALL),\
$(if $(findstring neon,$(v)),$(v),))
CODEC_SRCS_ASM_NEON_ADS2GAS = $(patsubst %.s, \
$(ASM_CNV_PATH_LOCAL)/libaom/%.s, \
$(CODEC_SRCS_ASM_NEON))
LOCAL_SRC_FILES += $(patsubst %.s, \
%.s.neon, \
$(CODEC_SRCS_ASM_NEON_ADS2GAS))
endif
LOCAL_CFLAGS += \
-DHAVE_CONFIG_H=aom_config.h \
-I$(LIBAOM_PATH) \
-I$(ASM_CNV_PATH)
LOCAL_MODULE := libaom
ifeq ($(CONFIG_RUNTIME_CPU_DETECT),yes)
LOCAL_STATIC_LIBRARIES := cpufeatures
endif
# Add a dependency to force generation of the RTCD files.
define rtcd_dep_template
rtcd_dep_template_SRCS := $(addprefix $(LOCAL_PATH)/, $(LOCAL_SRC_FILES))
rtcd_dep_template_SRCS := $$(rtcd_dep_template_SRCS:.neon=)
ifeq ($(CONFIG_AV1), yes)
$$(rtcd_dep_template_SRCS): av1_rtcd.h
endif
$$(rtcd_dep_template_SRCS): aom_scale_rtcd.h
$$(rtcd_dep_template_SRCS): aom_dsp_rtcd.h
ifneq ($(findstring $(TARGET_ARCH_ABI),x86 x86_64),)
$$(rtcd_dep_template_SRCS): aom_config.asm
endif
endef
$(eval $(call rtcd_dep_template))
.PHONY: clean
clean:
@echo "Clean: ads2gas files [$(TARGET_ARCH_ABI)]"
@$(RM) $(CODEC_SRCS_ASM_ADS2GAS) $(CODEC_SRCS_ASM_NEON_ADS2GAS)
@$(RM) -r $(ASM_CNV_PATH)
@$(RM) $(CLEAN-OBJS)
ifeq ($(ENABLE_SHARED),1)
include $(BUILD_SHARED_LIBRARY)
else
include $(BUILD_STATIC_LIBRARY)
endif
ifeq ($(CONFIG_RUNTIME_CPU_DETECT),yes)
$(call import-module,cpufeatures)
endif

466
third_party/aom/build/make/Makefile vendored Normal file
View file

@ -0,0 +1,466 @@
## 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 config.mk
quiet?=true
ifeq ($(target),)
# If a target wasn't specified, invoke for all enabled targets.
.DEFAULT:
@for t in $(ALL_TARGETS); do \
$(MAKE) --no-print-directory target=$$t $(MAKECMDGOALS) || exit $$?;\
done
all: .DEFAULT
clean:: .DEFAULT
exampletest: .DEFAULT
install:: .DEFAULT
test:: .DEFAULT
test-no-data-check:: .DEFAULT
testdata:: .DEFAULT
utiltest: .DEFAULT
exampletest-no-data-check utiltest-no-data-check: .DEFAULT
test_%: .DEFAULT ;
# Note: md5sum is not installed on OS X, but openssl is. Openssl may not be
# installed on cygwin, so we need to autodetect here.
md5sum := $(firstword $(wildcard \
$(foreach e,md5sum openssl,\
$(foreach p,$(subst :, ,$(PATH)),$(p)/$(e)*))\
))
md5sum := $(if $(filter %openssl,$(md5sum)),$(md5sum) dgst -md5,$(md5sum))
TGT_CC:=$(word 3, $(subst -, ,$(TOOLCHAIN)))
dist:
@for t in $(ALL_TARGETS); do \
$(MAKE) --no-print-directory target=$$t $(MAKECMDGOALS) || exit $$?;\
done
# Run configure for the user with the current toolchain.
@if [ -d "$(DIST_DIR)/src" ]; then \
mkdir -p "$(DIST_DIR)/build"; \
cd "$(DIST_DIR)/build"; \
echo "Rerunning configure $(CONFIGURE_ARGS)"; \
../src/configure $(CONFIGURE_ARGS); \
$(if $(filter vs%,$(TGT_CC)),make NO_LAUNCH_DEVENV=1;) \
fi
@if [ -d "$(DIST_DIR)" ]; then \
echo " [MD5SUM] $(DIST_DIR)"; \
cd $(DIST_DIR) && \
$(md5sum) `find . -name md5sums.txt -prune -o -type f -print` \
| sed -e 's/MD5(\(.*\))= \([0-9a-f]\{32\}\)/\2 \1/' \
> md5sums.txt;\
fi
endif
# Since we invoke make recursively for multiple targets we need to include the
# .mk file for the correct target, but only when $(target) is non-empty.
ifneq ($(target),)
include $(target)-$(TOOLCHAIN).mk
endif
BUILD_ROOT?=.
VPATH=$(SRC_PATH_BARE)
CFLAGS+=-I$(BUILD_PFX)$(BUILD_ROOT) -I$(SRC_PATH)
CXXFLAGS+=-I$(BUILD_PFX)$(BUILD_ROOT) -I$(SRC_PATH)
ASFLAGS+=-I$(BUILD_PFX)$(BUILD_ROOT)/ -I$(SRC_PATH)/
DIST_DIR?=dist
HOSTCC?=gcc
TGT_ISA:=$(word 1, $(subst -, ,$(TOOLCHAIN)))
TGT_OS:=$(word 2, $(subst -, ,$(TOOLCHAIN)))
TGT_CC:=$(word 3, $(subst -, ,$(TOOLCHAIN)))
quiet:=$(if $(or $(verbose), $(V)),, yes)
qexec=$(if $(quiet),@)
# Cancel built-in implicit rules
%: %.o
%.asm:
%.a:
%: %.cc
#
# Common rules"
#
.PHONY: all
all:
.PHONY: clean
clean::
rm -f $(OBJS-yes) $(OBJS-yes:.o=.d) $(OBJS-yes:.asm.s.o=.asm.s)
rm -f $(CLEAN-OBJS)
.PHONY: clean
distclean: clean
if [ -z "$(target)" ]; then \
rm -f Makefile; \
rm -f config.log config.mk; \
rm -f aom_config.[hc] aom_config.asm; \
else \
rm -f $(target)-$(TOOLCHAIN).mk; \
fi
.PHONY: dist
dist:
.PHONY: exampletest
exampletest:
.PHONY: install
install::
.PHONY: test
test::
.PHONY: testdata
testdata::
.PHONY: utiltest
utiltest:
.PHONY: test-no-data-check exampletest-no-data-check utiltest-no-data-check
test-no-data-check::
exampletest-no-data-check utiltest-no-data-check:
# Force to realign stack always on OS/2
ifeq ($(TOOLCHAIN), x86-os2-gcc)
CFLAGS += -mstackrealign
endif
$(BUILD_PFX)%_mmx.c.d: CFLAGS += -mmmx
$(BUILD_PFX)%_mmx.c.o: CFLAGS += -mmmx
$(BUILD_PFX)%_sse2.c.d: CFLAGS += -msse2
$(BUILD_PFX)%_sse2.c.o: CFLAGS += -msse2
$(BUILD_PFX)%_sse3.c.d: CFLAGS += -msse3
$(BUILD_PFX)%_sse3.c.o: CFLAGS += -msse3
$(BUILD_PFX)%_ssse3.c.d: CFLAGS += -mssse3
$(BUILD_PFX)%_ssse3.c.o: CFLAGS += -mssse3
$(BUILD_PFX)%_sse4.c.d: CFLAGS += -msse4.1
$(BUILD_PFX)%_sse4.c.o: CFLAGS += -msse4.1
$(BUILD_PFX)%_avx.c.d: CFLAGS += -mavx
$(BUILD_PFX)%_avx.c.o: CFLAGS += -mavx
$(BUILD_PFX)%_avx2.c.d: CFLAGS += -mavx2
$(BUILD_PFX)%_avx2.c.o: CFLAGS += -mavx2
$(BUILD_PFX)%_mmx.cc.d: CXXFLAGS += -mmmx
$(BUILD_PFX)%_mmx.cc.o: CXXFLAGS += -mmmx
$(BUILD_PFX)%_sse2.cc.d: CXXFLAGS += -msse2
$(BUILD_PFX)%_sse2.cc.o: CXXFLAGS += -msse2
$(BUILD_PFX)%_sse3.cc.d: CXXFLAGS += -msse3
$(BUILD_PFX)%_sse3.cc.o: CXXFLAGS += -msse3
$(BUILD_PFX)%_ssse3.cc.d: CXXFLAGS += -mssse3
$(BUILD_PFX)%_ssse3.cc.o: CXXFLAGS += -mssse3
$(BUILD_PFX)%_sse4.cc.d: CXXFLAGS += -msse4.1
$(BUILD_PFX)%_sse4.cc.o: CXXFLAGS += -msse4.1
$(BUILD_PFX)%_avx.cc.d: CXXFLAGS += -mavx
$(BUILD_PFX)%_avx.cc.o: CXXFLAGS += -mavx
$(BUILD_PFX)%_avx2.cc.d: CXXFLAGS += -mavx2
$(BUILD_PFX)%_avx2.cc.o: CXXFLAGS += -mavx2
$(BUILD_PFX)%.c.d: %.c
$(if $(quiet),@echo " [DEP] $@")
$(qexec)mkdir -p $(dir $@)
$(qexec)$(CC) $(INTERNAL_CFLAGS) $(CFLAGS) -M $< | $(fmt_deps) > $@
$(BUILD_PFX)%.c.o: %.c
$(if $(quiet),@echo " [CC] $@")
$(qexec)$(if $(CONFIG_DEPENDENCY_TRACKING),,mkdir -p $(dir $@))
$(qexec)$(CC) $(INTERNAL_CFLAGS) $(CFLAGS) -c -o $@ $<
$(BUILD_PFX)%.cc.d: %.cc
$(if $(quiet),@echo " [DEP] $@")
$(qexec)mkdir -p $(dir $@)
$(qexec)$(CXX) $(INTERNAL_CFLAGS) $(CXXFLAGS) -M $< | $(fmt_deps) > $@
$(BUILD_PFX)%.cc.o: %.cc
$(if $(quiet),@echo " [CXX] $@")
$(qexec)$(if $(CONFIG_DEPENDENCY_TRACKING),,mkdir -p $(dir $@))
$(qexec)$(CXX) $(INTERNAL_CFLAGS) $(CXXFLAGS) -c -o $@ $<
$(BUILD_PFX)%.cpp.d: %.cpp
$(if $(quiet),@echo " [DEP] $@")
$(qexec)mkdir -p $(dir $@)
$(qexec)$(CXX) $(INTERNAL_CFLAGS) $(CXXFLAGS) -M $< | $(fmt_deps) > $@
$(BUILD_PFX)%.cpp.o: %.cpp
$(if $(quiet),@echo " [CXX] $@")
$(qexec)$(if $(CONFIG_DEPENDENCY_TRACKING),,mkdir -p $(dir $@))
$(qexec)$(CXX) $(INTERNAL_CFLAGS) $(CXXFLAGS) -c -o $@ $<
$(BUILD_PFX)%.asm.d: %.asm
$(if $(quiet),@echo " [DEP] $@")
$(qexec)mkdir -p $(dir $@)
$(qexec)$(SRC_PATH_BARE)/build/make/gen_asm_deps.sh \
--build-pfx=$(BUILD_PFX) --depfile=$@ $(ASFLAGS) $< > $@
$(BUILD_PFX)%.asm.o: %.asm
$(if $(quiet),@echo " [AS] $@")
$(qexec)$(if $(CONFIG_DEPENDENCY_TRACKING),,mkdir -p $(dir $@))
$(qexec)$(AS) $(ASFLAGS) -o $@ $<
$(BUILD_PFX)%.s.d: %.s
$(if $(quiet),@echo " [DEP] $@")
$(qexec)mkdir -p $(dir $@)
$(qexec)$(SRC_PATH_BARE)/build/make/gen_asm_deps.sh \
--build-pfx=$(BUILD_PFX) --depfile=$@ $(ASFLAGS) $< > $@
$(BUILD_PFX)%.s.o: %.s
$(if $(quiet),@echo " [AS] $@")
$(qexec)$(if $(CONFIG_DEPENDENCY_TRACKING),,mkdir -p $(dir $@))
$(qexec)$(AS) $(ASFLAGS) -o $@ $<
.PRECIOUS: %.c.S
%.c.S: CFLAGS += -DINLINE_ASM
$(BUILD_PFX)%.c.S: %.c
$(if $(quiet),@echo " [GEN] $@")
$(qexec)$(if $(CONFIG_DEPENDENCY_TRACKING),,mkdir -p $(dir $@))
$(qexec)$(CC) -S $(CFLAGS) -o $@ $<
.PRECIOUS: %.asm.s
$(BUILD_PFX)%.asm.s: %.asm
$(if $(quiet),@echo " [ASM CONVERSION] $@")
$(qexec)mkdir -p $(dir $@)
$(qexec)$(ASM_CONVERSION) <$< >$@
# If we're in debug mode, pretend we don't have GNU strip, to fall back to
# the copy implementation
HAVE_GNU_STRIP := $(if $(CONFIG_DEBUG),,$(HAVE_GNU_STRIP))
ifeq ($(HAVE_GNU_STRIP),yes)
# Older binutils strip global symbols not needed for relocation processing
# when given --strip-unneeded. Using nm and awk to identify globals and
# keep them caused command line length issues under mingw and segfaults in
# test_libaom were observed under OS/2: simply use --strip-debug.
%.a: %_g.a
$(if $(quiet),@echo " [STRIP] $@ < $<")
$(qexec)$(STRIP) --strip-debug \
-o $@ $<
else
%.a: %_g.a
$(if $(quiet),@echo " [CP] $@ < $<")
$(qexec)cp $< $@
endif
#
# Utility functions
#
pairmap=$(if $(strip $(2)),\
$(call $(1),$(word 1,$(2)),$(word 2,$(2)))\
$(call pairmap,$(1),$(wordlist 3,$(words $(2)),$(2)))\
)
enabled=$(filter-out $($(1)-no),$($(1)-yes))
cond_enabled=$(if $(filter yes,$($(1))), $(call enabled,$(2)))
find_file1=$(word 1,$(wildcard $(subst //,/,$(addsuffix /$(1),$(2)))))
find_file=$(foreach f,$(1),$(call find_file1,$(strip $(f)),$(strip $(2))) )
obj_pats=.c=.c.o $(AS_SFX)=$(AS_SFX).o .cc=.cc.o .cpp=.cpp.o
objs=$(addprefix $(BUILD_PFX),$(foreach p,$(obj_pats),$(filter %.o,$(1:$(p))) ))
install_map_templates=$(eval $(call install_map_template,$(1),$(2)))
not=$(subst yes,no,$(1))
ifeq ($(CONFIG_MSVS),yes)
lib_file_name=$(1).lib
else
lib_file_name=lib$(1).a
endif
#
# Rule Templates
#
define linker_template
$(1): $(filter-out -%,$(2))
$(1):
$(if $(quiet),@echo " [LD] $$@")
$(qexec)$$(LD) $$(strip $$(INTERNAL_LDFLAGS) $$(LDFLAGS) -o $$@ $(2) $(3) $$(extralibs))
endef
define linkerxx_template
$(1): $(filter-out -%,$(2))
$(1):
$(if $(quiet),@echo " [LD] $$@")
$(qexec)$$(CXX) $$(strip $$(INTERNAL_LDFLAGS) $$(LDFLAGS) -o $$@ $(2) $(3) $$(extralibs))
endef
# make-3.80 has a bug with expanding large input strings to the eval function,
# which was triggered in some cases by the following component of
# linker_template:
# $(1): $$(call find_file, $(patsubst -l%,lib%.a,$(filter -l%,$(2))),\
# $$(patsubst -L%,%,$$(filter -L%,$$(LDFLAGS) $(2))))
# This may be useful to revisit in the future (it tries to locate libraries
# in a search path and add them as prerequisites
define install_map_template
$(DIST_DIR)/$(1): $(2)
$(if $(quiet),@echo " [INSTALL] $$@")
$(qexec)mkdir -p $$(dir $$@)
$(qexec)cp -p $$< $$@
endef
define archive_template
# Not using a pattern rule here because we don't want to generate empty
# archives when they are listed as a dependency in files not responsible
# for creating them.
$(1):
$(if $(quiet),@echo " [AR] $$@")
$(qexec)$$(AR) $$(ARFLAGS) $$@ $$^
endef
define so_template
# Not using a pattern rule here because we don't want to generate empty
# archives when they are listed as a dependency in files not responsible
# for creating them.
#
# This needs further abstraction for dealing with non-GNU linkers.
$(1):
$(if $(quiet),@echo " [LD] $$@")
$(qexec)$$(LD) -shared $$(LDFLAGS) \
-Wl,--no-undefined -Wl,-soname,$$(SONAME) \
-Wl,--version-script,$$(EXPORTS_FILE) -o $$@ \
$$(filter %.o,$$^) $$(extralibs)
endef
define dl_template
# Not using a pattern rule here because we don't want to generate empty
# archives when they are listed as a dependency in files not responsible
# for creating them.
$(1):
$(if $(quiet),@echo " [LD] $$@")
$(qexec)$$(LD) -dynamiclib $$(LDFLAGS) \
-exported_symbols_list $$(EXPORTS_FILE) \
-Wl,-headerpad_max_install_names,-compatibility_version,1.0,-current_version,$$(VERSION_MAJOR) \
-o $$@ \
$$(filter %.o,$$^) $$(extralibs)
endef
define dll_template
# Not using a pattern rule here because we don't want to generate empty
# archives when they are listed as a dependency in files not responsible
# for creating them.
$(1):
$(if $(quiet),@echo " [LD] $$@")
$(qexec)$$(LD) -Zdll $$(LDFLAGS) \
-o $$@ \
$$(filter %.o,$$^) $$(extralibs) $$(EXPORTS_FILE)
endef
#
# Get current configuration
#
ifneq ($(target),)
include $(SRC_PATH_BARE)/$(target:-$(TOOLCHAIN)=).mk
endif
skip_deps := $(filter %clean,$(MAKECMDGOALS))
skip_deps += $(findstring testdata,$(MAKECMDGOALS))
ifeq ($(strip $(skip_deps)),)
ifeq ($(CONFIG_DEPENDENCY_TRACKING),yes)
# Older versions of make don't like -include directives with no arguments
ifneq ($(filter %.d,$(OBJS-yes:.o=.d)),)
-include $(filter %.d,$(OBJS-yes:.o=.d))
endif
endif
endif
#
# Configuration dependent rules
#
$(call pairmap,install_map_templates,$(INSTALL_MAPS))
DOCS=$(call cond_enabled,CONFIG_INSTALL_DOCS,DOCS)
.docs: $(DOCS)
@touch $@
INSTALL-DOCS=$(call cond_enabled,CONFIG_INSTALL_DOCS,INSTALL-DOCS)
ifeq ($(MAKECMDGOALS),dist)
INSTALL-DOCS+=$(call cond_enabled,CONFIG_INSTALL_DOCS,DIST-DOCS)
endif
.install-docs: .docs $(addprefix $(DIST_DIR)/,$(INSTALL-DOCS))
@touch $@
clean::
rm -f .docs .install-docs $(DOCS)
BINS=$(call enabled,BINS)
.bins: $(BINS)
@touch $@
INSTALL-BINS=$(call cond_enabled,CONFIG_INSTALL_BINS,INSTALL-BINS)
ifeq ($(MAKECMDGOALS),dist)
INSTALL-BINS+=$(call cond_enabled,CONFIG_INSTALL_BINS,DIST-BINS)
endif
.install-bins: .bins $(addprefix $(DIST_DIR)/,$(INSTALL-BINS))
@touch $@
clean::
rm -f .bins .install-bins $(BINS)
LIBS=$(call enabled,LIBS)
.libs: $(LIBS)
@touch $@
$(foreach lib,$(filter %_g.a,$(LIBS)),$(eval $(call archive_template,$(lib))))
$(foreach lib,$(filter %so.$(SO_VERSION_MAJOR).$(SO_VERSION_MINOR).$(SO_VERSION_PATCH),$(LIBS)),$(eval $(call so_template,$(lib))))
$(foreach lib,$(filter %$(SO_VERSION_MAJOR).dylib,$(LIBS)),$(eval $(call dl_template,$(lib))))
$(foreach lib,$(filter %$(SO_VERSION_MAJOR).dll,$(LIBS)),$(eval $(call dll_template,$(lib))))
INSTALL-LIBS=$(call cond_enabled,CONFIG_INSTALL_LIBS,INSTALL-LIBS)
ifeq ($(MAKECMDGOALS),dist)
INSTALL-LIBS+=$(call cond_enabled,CONFIG_INSTALL_LIBS,DIST-LIBS)
endif
.install-libs: .libs $(addprefix $(DIST_DIR)/,$(INSTALL-LIBS))
@touch $@
clean::
rm -f .libs .install-libs $(LIBS)
ifeq ($(CONFIG_EXTERNAL_BUILD),yes)
PROJECTS=$(call enabled,PROJECTS)
.projects: $(PROJECTS)
@touch $@
INSTALL-PROJECTS=$(call cond_enabled,CONFIG_INSTALL_PROJECTS,INSTALL-PROJECTS)
ifeq ($(MAKECMDGOALS),dist)
INSTALL-PROJECTS+=$(call cond_enabled,CONFIG_INSTALL_PROJECTS,DIST-PROJECTS)
endif
.install-projects: .projects $(addprefix $(DIST_DIR)/,$(INSTALL-PROJECTS))
@touch $@
clean::
rm -f .projects .install-projects $(PROJECTS)
endif
# If there are any source files to be distributed, then include the build
# system too.
ifneq ($(call enabled,DIST-SRCS),)
DIST-SRCS-yes += configure
DIST-SRCS-yes += build/make/configure.sh
DIST-SRCS-yes += build/make/gen_asm_deps.sh
DIST-SRCS-yes += build/make/Makefile
DIST-SRCS-$(CONFIG_MSVS) += build/make/gen_msvs_def.sh
DIST-SRCS-$(CONFIG_MSVS) += build/make/gen_msvs_sln.sh
DIST-SRCS-$(CONFIG_MSVS) += build/make/gen_msvs_vcxproj.sh
DIST-SRCS-$(CONFIG_MSVS) += build/make/msvs_common.sh
DIST-SRCS-$(CONFIG_RVCT) += build/make/armlink_adapter.sh
DIST-SRCS-$(ARCH_ARM) += build/make/ads2gas.pl
DIST-SRCS-$(ARCH_ARM) += build/make/ads2gas_apple.pl
DIST-SRCS-$(ARCH_ARM) += build/make/ads2armasm_ms.pl
DIST-SRCS-$(ARCH_ARM) += build/make/thumb.pm
DIST-SRCS-yes += $(target:-$(TOOLCHAIN)=).mk
endif
INSTALL-SRCS := $(call cond_enabled,CONFIG_INSTALL_SRCS,INSTALL-SRCS)
ifeq ($(MAKECMDGOALS),dist)
INSTALL-SRCS += $(call cond_enabled,CONFIG_INSTALL_SRCS,DIST-SRCS)
endif
.install-srcs: $(addprefix $(DIST_DIR)/src/,$(INSTALL-SRCS))
@touch $@
clean::
rm -f .install-srcs
ifeq ($(CONFIG_EXTERNAL_BUILD),yes)
BUILD_TARGETS += .projects
INSTALL_TARGETS += .install-projects
endif
BUILD_TARGETS += .docs .libs .bins
INSTALL_TARGETS += .install-docs .install-srcs .install-libs .install-bins
all: $(BUILD_TARGETS)
install:: $(INSTALL_TARGETS)
dist: $(INSTALL_TARGETS)
test::
.SUFFIXES: # Delete default suffix rules

39
third_party/aom/build/make/ads2armasm_ms.pl vendored Executable file
View file

@ -0,0 +1,39 @@
#!/usr/bin/env perl
## 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.
##
use FindBin;
use lib $FindBin::Bin;
use thumb;
print "; This file was created from a .asm file\n";
print "; using the ads2armasm_ms.pl script.\n";
while (<STDIN>)
{
undef $comment;
undef $line;
s/REQUIRE8//;
s/PRESERVE8//;
s/^\s*ARM\s*$//;
s/AREA\s+\|\|(.*)\|\|/AREA |$1|/;
s/qsubaddx/qsax/i;
s/qaddsubx/qasx/i;
thumb::FixThumbInstructions($_, 1);
s/ldrneb/ldrbne/i;
s/ldrneh/ldrhne/i;
s/^(\s*)ENDP.*/$&\n$1ALIGN 4/;
print;
}

236
third_party/aom/build/make/ads2gas.pl vendored Executable file
View file

@ -0,0 +1,236 @@
#!/usr/bin/env perl
## 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.
##
# ads2gas.pl
# Author: Eric Fung (efung (at) acm.org)
#
# Convert ARM Developer Suite 1.0.1 syntax assembly source to GNU as format
#
# Usage: cat inputfile | perl ads2gas.pl > outputfile
#
use FindBin;
use lib $FindBin::Bin;
use thumb;
my $thumb = 0;
foreach my $arg (@ARGV) {
$thumb = 1 if ($arg eq "-thumb");
}
print "@ This file was created from a .asm file\n";
print "@ using the ads2gas.pl script.\n";
print "\t.equ DO1STROUNDING, 0\n";
if ($thumb) {
print "\t.syntax unified\n";
print "\t.thumb\n";
}
# Stack of procedure names.
@proc_stack = ();
while (<STDIN>)
{
undef $comment;
undef $line;
$comment_char = ";";
$comment_sub = "@";
# Handle comments.
if (/$comment_char/)
{
$comment = "";
($line, $comment) = /(.*?)$comment_char(.*)/;
$_ = $line;
}
# Load and store alignment
s/@/,:/g;
# Hexadecimal constants prefaced by 0x
s/#&/#0x/g;
# Convert :OR: to |
s/:OR:/ | /g;
# Convert :AND: to &
s/:AND:/ & /g;
# Convert :NOT: to ~
s/:NOT:/ ~ /g;
# Convert :SHL: to <<
s/:SHL:/ << /g;
# Convert :SHR: to >>
s/:SHR:/ >> /g;
# Convert ELSE to .else
s/\bELSE\b/.else/g;
# Convert ENDIF to .endif
s/\bENDIF\b/.endif/g;
# Convert ELSEIF to .elseif
s/\bELSEIF\b/.elseif/g;
# Convert LTORG to .ltorg
s/\bLTORG\b/.ltorg/g;
# Convert endfunc to nothing.
s/\bendfunc\b//ig;
# Convert FUNCTION to nothing.
s/\bFUNCTION\b//g;
s/\bfunction\b//g;
s/\bENTRY\b//g;
s/\bMSARMASM\b/0/g;
s/^\s+end\s+$//g;
# Convert IF :DEF:to .if
# gcc doesn't have the ability to do a conditional
# if defined variable that is set by IF :DEF: on
# armasm, so convert it to a normal .if and then
# make sure to define a value elesewhere
if (s/\bIF :DEF:\b/.if /g)
{
s/=/==/g;
}
# Convert IF to .if
if (s/\bIF\b/.if/g)
{
s/=+/==/g;
}
# Convert INCLUDE to .INCLUDE "file"
s/INCLUDE(\s*)(.*)$/.include $1\"$2\"/;
# Code directive (ARM vs Thumb)
s/CODE([0-9][0-9])/.code $1/;
# No AREA required
# But ALIGNs in AREA must be obeyed
s/^\s*AREA.*ALIGN=([0-9])$/.text\n.p2align $1/;
# If no ALIGN, strip the AREA and align to 4 bytes
s/^\s*AREA.*$/.text\n.p2align 2/;
# DCD to .word
# This one is for incoming symbols
s/DCD\s+\|(\w*)\|/.long $1/;
# DCW to .short
s/DCW\s+\|(\w*)\|/.short $1/;
s/DCW(.*)/.short $1/;
# Constants defined in scope
s/DCD(.*)/.long $1/;
s/DCB(.*)/.byte $1/;
# RN to .req
if (s/RN\s+([Rr]\d+|lr)/.req $1/)
{
print;
print "$comment_sub$comment\n" if defined $comment;
next;
}
# Make function visible to linker, and make additional symbol with
# prepended underscore
s/EXPORT\s+\|([\$\w]*)\|/.global $1 \n\t.type $1, function/;
s/IMPORT\s+\|([\$\w]*)\|/.global $1/;
s/EXPORT\s+([\$\w]*)/.global $1/;
s/export\s+([\$\w]*)/.global $1/;
# No vertical bars required; make additional symbol with prepended
# underscore
s/^\|(\$?\w+)\|/_$1\n\t$1:/g;
# Labels need trailing colon
# s/^(\w+)/$1:/ if !/EQU/;
# put the colon at the end of the line in the macro
s/^([a-zA-Z_0-9\$]+)/$1:/ if !/EQU/;
# ALIGN directive
s/\bALIGN\b/.balign/g;
if ($thumb) {
# ARM code - we force everything to thumb with the declaration in the header
s/\sARM//g;
} else {
# ARM code
s/\sARM/.arm/g;
}
# push/pop
s/(push\s+)(r\d+)/stmdb sp\!, \{$2\}/g;
s/(pop\s+)(r\d+)/ldmia sp\!, \{$2\}/g;
# NEON code
s/(vld1.\d+\s+)(q\d+)/$1\{$2\}/g;
s/(vtbl.\d+\s+[^,]+),([^,]+)/$1,\{$2\}/g;
if ($thumb) {
thumb::FixThumbInstructions($_, 0);
}
# eabi_attributes numerical equivalents can be found in the
# "ARM IHI 0045C" document.
# REQUIRE8 Stack is required to be 8-byte aligned
s/\sREQUIRE8/.eabi_attribute 24, 1 \@Tag_ABI_align_needed/g;
# PRESERVE8 Stack 8-byte align is preserved
s/\sPRESERVE8/.eabi_attribute 25, 1 \@Tag_ABI_align_preserved/g;
# Use PROC and ENDP to give the symbols a .size directive.
# This makes them show up properly in debugging tools like gdb and valgrind.
if (/\bPROC\b/)
{
my $proc;
/^_([\.0-9A-Z_a-z]\w+)\b/;
$proc = $1;
push(@proc_stack, $proc) if ($proc);
s/\bPROC\b/@ $&/;
}
if (/\bENDP\b/)
{
my $proc;
s/\bENDP\b/@ $&/;
$proc = pop(@proc_stack);
$_ = "\t.size $proc, .-$proc".$_ if ($proc);
}
# EQU directive
s/(\S+\s+)EQU(\s+\S+)/.equ $1, $2/;
# Begin macro definition
if (/\bMACRO\b/) {
$_ = <STDIN>;
s/^/.macro/;
s/\$//g; # remove formal param reference
s/;/@/g; # change comment characters
}
# For macros, use \ to reference formal params
s/\$/\\/g; # End macro definition
s/\bMEND\b/.endm/; # No need to tell it where to stop assembling
next if /^\s*END\s*$/;
print;
print "$comment_sub$comment\n" if defined $comment;
}
# Mark that this object doesn't need an executable stack.
printf ("\t.section\t.note.GNU-stack,\"\",\%\%progbits\n");

235
third_party/aom/build/make/ads2gas_apple.pl vendored Executable file
View file

@ -0,0 +1,235 @@
#!/usr/bin/env perl
## 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.
##
# ads2gas_apple.pl
# Author: Eric Fung (efung (at) acm.org)
#
# Convert ARM Developer Suite 1.0.1 syntax assembly source to GNU as format
#
# Usage: cat inputfile | perl ads2gas_apple.pl > outputfile
#
my $chromium = 0;
foreach my $arg (@ARGV) {
$chromium = 1 if ($arg eq "-chromium");
}
print "@ This file was created from a .asm file\n";
print "@ using the ads2gas_apple.pl script.\n\n";
print "\t.set WIDE_REFERENCE, 0\n";
print "\t.set ARCHITECTURE, 5\n";
print "\t.set DO1STROUNDING, 0\n";
my %register_aliases;
my %macro_aliases;
my @mapping_list = ("\$0", "\$1", "\$2", "\$3", "\$4", "\$5", "\$6", "\$7", "\$8", "\$9");
my @incoming_array;
my @imported_functions;
# Perl trim function to remove whitespace from the start and end of the string
sub trim($)
{
my $string = shift;
$string =~ s/^\s+//;
$string =~ s/\s+$//;
return $string;
}
while (<STDIN>)
{
# Load and store alignment
s/@/,:/g;
# Comment character
s/;/ @/g;
# Hexadecimal constants prefaced by 0x
s/#&/#0x/g;
# Convert :OR: to |
s/:OR:/ | /g;
# Convert :AND: to &
s/:AND:/ & /g;
# Convert :NOT: to ~
s/:NOT:/ ~ /g;
# Convert :SHL: to <<
s/:SHL:/ << /g;
# Convert :SHR: to >>
s/:SHR:/ >> /g;
# Convert ELSE to .else
s/\bELSE\b/.else/g;
# Convert ENDIF to .endif
s/\bENDIF\b/.endif/g;
# Convert ELSEIF to .elseif
s/\bELSEIF\b/.elseif/g;
# Convert LTORG to .ltorg
s/\bLTORG\b/.ltorg/g;
# Convert IF :DEF:to .if
# gcc doesn't have the ability to do a conditional
# if defined variable that is set by IF :DEF: on
# armasm, so convert it to a normal .if and then
# make sure to define a value elesewhere
if (s/\bIF :DEF:\b/.if /g)
{
s/=/==/g;
}
# Convert IF to .if
if (s/\bIF\b/.if/g)
{
s/=/==/g;
}
# Convert INCLUDE to .INCLUDE "file"
s/INCLUDE(\s*)(.*)$/.include $1\"$2\"/;
# Code directive (ARM vs Thumb)
s/CODE([0-9][0-9])/.code $1/;
# No AREA required
# But ALIGNs in AREA must be obeyed
s/^\s*AREA.*ALIGN=([0-9])$/.text\n.p2align $1/;
# If no ALIGN, strip the AREA and align to 4 bytes
s/^\s*AREA.*$/.text\n.p2align 2/;
# DCD to .word
# This one is for incoming symbols
s/DCD\s+\|(\w*)\|/.long $1/;
# DCW to .short
s/DCW\s+\|(\w*)\|/.short $1/;
s/DCW(.*)/.short $1/;
# Constants defined in scope
s/DCD(.*)/.long $1/;
s/DCB(.*)/.byte $1/;
# Build a hash of all the register - alias pairs.
if (s/(.*)RN(.*)/$1 .req $2/g)
{
$register_aliases{trim($1)} = trim($2);
next;
}
while (($key, $value) = each(%register_aliases))
{
s/\b$key\b/$value/g;
}
# Make function visible to linker, and make additional symbol with
# prepended underscore
s/EXPORT\s+\|([\$\w]*)\|/.globl _$1\n\t.globl $1/;
# Prepend imported functions with _
if (s/IMPORT\s+\|([\$\w]*)\|/.globl $1/)
{
$function = trim($1);
push(@imported_functions, $function);
}
foreach $function (@imported_functions)
{
s/$function/_$function/;
}
# No vertical bars required; make additional symbol with prepended
# underscore
s/^\|(\$?\w+)\|/_$1\n\t$1:/g;
# Labels need trailing colon
# s/^(\w+)/$1:/ if !/EQU/;
# put the colon at the end of the line in the macro
s/^([a-zA-Z_0-9\$]+)/$1:/ if !/EQU/;
# ALIGN directive
s/\bALIGN\b/.balign/g;
# Strip ARM
s/\sARM/@ ARM/g;
# Strip REQUIRE8
#s/\sREQUIRE8/@ REQUIRE8/g;
s/\sREQUIRE8/@ /g;
# Strip PRESERVE8
s/\sPRESERVE8/@ PRESERVE8/g;
# Strip PROC and ENDPROC
s/\bPROC\b/@/g;
s/\bENDP\b/@/g;
# EQU directive
s/(.*)EQU(.*)/.set $1, $2/;
# Begin macro definition
if (/\bMACRO\b/)
{
# Process next line down, which will be the macro definition
$_ = <STDIN>;
$trimmed = trim($_);
# remove commas that are separating list
$trimmed =~ s/,//g;
# string to array
@incoming_array = split(/\s+/, $trimmed);
print ".macro @incoming_array[0]\n";
# remove the first element, as that is the name of the macro
shift (@incoming_array);
@macro_aliases{@incoming_array} = @mapping_list;
next;
}
while (($key, $value) = each(%macro_aliases))
{
$key =~ s/\$/\\\$/;
s/$key\b/$value/g;
}
# For macros, use \ to reference formal params
# s/\$/\\/g; # End macro definition
s/\bMEND\b/.endm/; # No need to tell it where to stop assembling
next if /^\s*END\s*$/;
# Clang used by Chromium differs slightly from clang in XCode in what it
# will accept in the assembly.
if ($chromium) {
s/qsubaddx/qsax/i;
s/qaddsubx/qasx/i;
s/ldrneb/ldrbne/i;
s/ldrneh/ldrhne/i;
s/(vqshrun\.s16 .*, \#)0$/${1}8/i;
# http://llvm.org/bugs/show_bug.cgi?id=16022
s/\.include/#include/;
}
print;
}

53
third_party/aom/build/make/armlink_adapter.sh vendored Executable file
View file

@ -0,0 +1,53 @@
#!/bin/sh
## 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.
##
verbose=0
set -- $*
for i; do
if [ "$i" = "-o" ]; then
on_of=1
elif [ "$i" = "-v" ]; then
verbose=1
elif [ "$i" = "-g" ]; then
args="${args} --debug"
elif [ "$on_of" = "1" ]; then
outfile=$i
on_of=0
elif [ -f "$i" ]; then
infiles="$infiles $i"
elif [ "${i#-l}" != "$i" ]; then
libs="$libs ${i#-l}"
elif [ "${i#-L}" != "$i" ]; then
libpaths="${libpaths} ${i#-L}"
else
args="${args} ${i}"
fi
shift
done
# Absolutize library file names
for f in $libs; do
found=0
for d in $libpaths; do
[ -f "$d/$f" ] && infiles="$infiles $d/$f" && found=1 && break
[ -f "$d/lib${f}.so" ] && infiles="$infiles $d/lib${f}.so" && found=1 && break
[ -f "$d/lib${f}.a" ] && infiles="$infiles $d/lib${f}.a" && found=1 && break
done
[ $found -eq 0 ] && infiles="$infiles $f"
done
for d in $libpaths; do
[ -n "$libsearchpath" ] && libsearchpath="${libsearchpath},"
libsearchpath="${libsearchpath}$d"
done
cmd="armlink $args --userlibpath=$libsearchpath --output=$outfile $infiles"
[ $verbose -eq 1 ] && echo $cmd
$cmd

1556
third_party/aom/build/make/configure.sh vendored Normal file
View file

File diff suppressed because it is too large Load diff

65
third_party/aom/build/make/gen_asm_deps.sh vendored Executable file
View file

@ -0,0 +1,65 @@
#!/bin/sh
##
## 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.
##
self=$0
show_help() {
echo "usage: $self [options] <srcfile>"
echo
echo "Generate Makefile dependency information from assembly code source"
echo
exit 1
}
die_unknown(){
echo "Unknown option \"$1\"."
echo "See $0 --help for available options."
exit 1
}
for opt do
optval="${opt#*=}"
case "$opt" in
--build-pfx=*) pfx="${optval}"
;;
--depfile=*) out="${optval}"
;;
-I*) raw_inc_paths="${raw_inc_paths} ${opt}"
inc_path="${inc_path} ${opt#-I}"
;;
-h|--help) show_help
;;
*) [ -f "$opt" ] && srcfile="$opt"
;;
esac
done
[ -n "$srcfile" ] || show_help
sfx=${sfx:-asm}
includes=$(LC_ALL=C egrep -i "include +\"?[a-z0-9_/]+\.${sfx}" $srcfile |
perl -p -e "s;.*?([a-z0-9_/]+.${sfx}).*;\1;")
#" restore editor state
for inc in ${includes}; do
found_inc_path=
for idir in ${inc_path}; do
[ -f "${idir}/${inc}" ] && found_inc_path="${idir}" && break
done
if [ -f `dirname $srcfile`/$inc ]; then
# Handle include files in the same directory as the source
$self --build-pfx=$pfx --depfile=$out ${raw_inc_paths} `dirname $srcfile`/$inc
elif [ -n "${found_inc_path}" ]; then
# Handle include files on the include path
$self --build-pfx=$pfx --depfile=$out ${raw_inc_paths} "${found_inc_path}/$inc"
else
# Handle generated includes in the build root (which may not exist yet)
echo ${out} ${out%d}o: "${pfx}${inc}"
fi
done
echo ${out} ${out%d}o: $srcfile

82
third_party/aom/build/make/gen_msvs_def.sh vendored Executable file
View file

@ -0,0 +1,82 @@
#!/bin/bash
## 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.
##
self=$0
self_basename=${self##*/}
EOL=$'\n'
show_help() {
cat <<EOF
Usage: ${self_basename} [options] file1 [file2 ...]
This script generates a MSVC module definition file containing a list of symbols
to export from a DLL. Source files are technically bash scripts (and thus may
use #comment syntax) but in general, take the form of a list of symbols:
<kind> symbol1 [symbol2, symbol3, ...]
where <kind> is either 'text' or 'data'
Options:
--help Print this message
--out=filename Write output to a file [stdout]
--name=project_name Name of the library (required)
EOF
exit 1
}
die() {
echo "${self_basename}: $@"
exit 1
}
die_unknown(){
echo "Unknown option \"$1\"."
echo "See ${self_basename} --help for available options."
exit 1
}
text() {
for sym in "$@"; do
echo " $sym" >> ${outfile}
done
}
data() {
for sym in "$@"; do
printf " %-40s DATA\n" "$sym" >> ${outfile}
done
}
# Process command line
for opt in "$@"; do
optval="${opt#*=}"
case "$opt" in
--help|-h) show_help
;;
--out=*) outfile="$optval"
;;
--name=*) name="${optval}"
;;
-*) die_unknown $opt
;;
*) file_list[${#file_list[@]}]="$opt"
esac
done
outfile=${outfile:-/dev/stdout}
[ -n "$name" ] || die "Library name (--name) must be specified!"
echo "LIBRARY ${name}" > ${outfile}
echo "EXPORTS" >> ${outfile}
for f in "${file_list[@]}"; do
. $f
done

254
third_party/aom/build/make/gen_msvs_sln.sh vendored Executable file
View file

@ -0,0 +1,254 @@
#!/bin/bash
## 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.
##
self=$0
self_basename=${self##*/}
EOL=$'\n'
EOLDOS=$'\r'
show_help() {
cat <<EOF
Usage: ${self_basename} [options] file1 [file2 ...]
This script generates a Visual Studio solution file from a list of project
files.
Options:
--help Print this message
--out=outfile Redirect output to a file
--ver=version Version (12,14) of visual studio to generate for
--target=isa-os-cc Target specifier
EOF
exit 1
}
die() {
echo "${self_basename}: $@" >&2
[ -f "${outfile}" ] && rm -f ${outfile}{,.mk}
exit 1
}
die_unknown(){
echo "Unknown option \"$1\"." >&2
echo "See ${self_basename} --help for available options." >&2
[ -f "${outfile}" ] && rm -f ${outfile}{,.mk}
exit 1
}
indent1=$'\t'
indent=""
indent_push() {
indent="${indent}${indent1}"
}
indent_pop() {
indent="${indent%${indent1}}"
}
parse_project() {
local file=$1
local name=`grep RootNamespace "$file" | sed 's,.*<.*>\(.*\)</.*>.*,\1,'`
local guid=`grep ProjectGuid "$file" | sed 's,.*<.*>\(.*\)</.*>.*,\1,'`
# save the project GUID to a varaible, normalizing to the basename of the
# vcxproj file without the extension
local var
var=${file##*/}
var=${var%%.${sfx}}
eval "${var}_file=\"$1\""
eval "${var}_name=$name"
eval "${var}_guid=$guid"
cur_config_list=`grep -B1 'Label="Configuration"' $file |
grep Condition | cut -d\' -f4`
new_config_list=$(for i in $config_list $cur_config_list; do
echo $i
done | sort | uniq)
if [ "$config_list" != "" ] && [ "$config_list" != "$new_config_list" ]; then
mixed_platforms=1
fi
config_list="$new_config_list"
eval "${var}_config_list=\"$cur_config_list\""
proj_list="${proj_list} ${var}"
}
process_project() {
eval "local file=\${$1_file}"
eval "local name=\${$1_name}"
eval "local guid=\${$1_guid}"
# save the project GUID to a varaible, normalizing to the basename of the
# vcproj file without the extension
local var
var=${file##*/}
var=${var%%.${sfx}}
eval "${var}_guid=$guid"
echo "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"$name\", \"$file\", \"$guid\""
echo "EndProject"
}
process_global() {
echo "Global"
indent_push
#
# Solution Configuration Platforms
#
echo "${indent}GlobalSection(SolutionConfigurationPlatforms) = preSolution"
indent_push
IFS_bak=${IFS}
IFS=$'\r'$'\n'
if [ "$mixed_platforms" != "" ]; then
config_list="
Release|Mixed Platforms
Debug|Mixed Platforms"
fi
for config in ${config_list}; do
echo "${indent}$config = $config"
done
IFS=${IFS_bak}
indent_pop
echo "${indent}EndGlobalSection"
#
# Project Configuration Platforms
#
echo "${indent}GlobalSection(ProjectConfigurationPlatforms) = postSolution"
indent_push
for proj in ${proj_list}; do
eval "local proj_guid=\${${proj}_guid}"
eval "local proj_config_list=\${${proj}_config_list}"
IFS=$'\r'$'\n'
for config in ${proj_config_list}; do
if [ "$mixed_platforms" != "" ]; then
local c=${config%%|*}
echo "${indent}${proj_guid}.${c}|Mixed Platforms.ActiveCfg = ${config}"
echo "${indent}${proj_guid}.${c}|Mixed Platforms.Build.0 = ${config}"
else
echo "${indent}${proj_guid}.${config}.ActiveCfg = ${config}"
echo "${indent}${proj_guid}.${config}.Build.0 = ${config}"
fi
done
IFS=${IFS_bak}
done
indent_pop
echo "${indent}EndGlobalSection"
#
# Solution Properties
#
echo "${indent}GlobalSection(SolutionProperties) = preSolution"
indent_push
echo "${indent}HideSolutionNode = FALSE"
indent_pop
echo "${indent}EndGlobalSection"
indent_pop
echo "EndGlobal"
}
process_makefile() {
IFS_bak=${IFS}
IFS=$'\r'$'\n'
local TAB=$'\t'
cat <<EOF
MSBUILD_TOOL := msbuild.exe
found_devenv := \$(shell which \$(MSBUILD_TOOL) >/dev/null 2>&1 && echo yes)
.nodevenv.once:
${TAB}@echo " * \$(MSBUILD_TOOL) not found in path."
${TAB}@echo " * "
${TAB}@echo " * You will have to build all configurations manually using the"
${TAB}@echo " * Visual Studio IDE. To allow make to build them automatically,"
${TAB}@echo " * add the Common7/IDE directory of your Visual Studio"
${TAB}@echo " * installation to your path, eg:"
${TAB}@echo " * C:\Program Files\Microsoft Visual Studio 12.0\Common7\IDE"
${TAB}@echo " * "
${TAB}@touch \$@
CLEAN-OBJS += \$(if \$(found_devenv),,.nodevenv.once)
EOF
for sln_config in ${config_list}; do
local config=${sln_config%%|*}
local platform=${sln_config##*|}
local nows_sln_config=`echo $sln_config | sed -e 's/[^a-zA-Z0-9]/_/g'`
cat <<EOF
BUILD_TARGETS += \$(if \$(NO_LAUNCH_DEVENV),,$nows_sln_config)
clean::
${TAB}rm -rf "$platform"/"$config"
.PHONY: $nows_sln_config
ifneq (\$(found_devenv),)
$nows_sln_config: $outfile
${TAB}\$(MSBUILD_TOOL) $outfile -m -t:Build \\
${TAB}${TAB}-p:Configuration="$config" -p:Platform="$platform"
else
$nows_sln_config: $outfile .nodevenv.once
${TAB}@echo " * Skipping build of $sln_config (\$(MSBUILD_TOOL) not in path)."
${TAB}@echo " * "
endif
EOF
done
IFS=${IFS_bak}
}
# Process command line
outfile=/dev/stdout
for opt in "$@"; do
optval="${opt#*=}"
case "$opt" in
--help|-h) show_help
;;
--out=*) outfile="${optval}"; mkoutfile="${optval}".mk
;;
--dep=*) eval "${optval%%:*}_deps=\"\${${optval%%:*}_deps} ${optval##*:}\""
;;
--ver=*) vs_ver="$optval"
case $optval in
12|14)
;;
*) die Unrecognized Visual Studio Version in $opt
;;
esac
;;
--target=*) target="${optval}"
;;
-*) die_unknown $opt
;;
*) file_list[${#file_list[@]}]="$opt"
esac
done
outfile=${outfile:-/dev/stdout}
mkoutfile=${mkoutfile:-/dev/stdout}
case "${vs_ver:-12}" in
12) sln_vers="12.00"
sln_vers_str="Visual Studio 2013"
;;
14) sln_vers="14.00"
sln_vers_str="Visual Studio 2015"
;;
esac
sfx=vcxproj
for f in "${file_list[@]}"; do
parse_project $f
done
cat >${outfile} <<EOF
Microsoft Visual Studio Solution File, Format Version $sln_vers${EOLDOS}
# $sln_vers_str${EOLDOS}
EOF
for proj in ${proj_list}; do
process_project $proj >>${outfile}
done
process_global >>${outfile}
process_makefile >${mkoutfile}

474
third_party/aom/build/make/gen_msvs_vcxproj.sh vendored Executable file
View file

@ -0,0 +1,474 @@
#!/bin/bash
## 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.
##
self=$0
self_basename=${self##*/}
self_dirname=$(dirname "$0")
. "$self_dirname/msvs_common.sh"|| exit 127
show_help() {
cat <<EOF
Usage: ${self_basename} --name=projname [options] file1 [file2 ...]
This script generates a Visual Studio project file from a list of source
code files.
Options:
--help Print this message
--exe Generate a project for building an Application
--lib Generate a project for creating a static library
--dll Generate a project for creating a dll
--static-crt Use the static C runtime (/MT)
--enable-werror Treat warnings as errors (/WX)
--target=isa-os-cc Target specifier (required)
--out=filename Write output to a file [stdout]
--name=project_name Name of the project (required)
--proj-guid=GUID GUID to use for the project
--module-def=filename File containing export definitions (for DLLs)
--ver=version Version (12,14) of visual studio to generate for
--src-path-bare=dir Path to root of source tree
-Ipath/to/include Additional include directories
-DFLAG[=value] Preprocessor macros to define
-Lpath/to/lib Additional library search paths
-llibname Library to link against
EOF
exit 1
}
tag_content() {
local tag=$1
local content=$2
shift
shift
if [ $# -ne 0 ]; then
echo "${indent}<${tag}"
indent_push
tag_attributes "$@"
echo "${indent}>${content}</${tag}>"
indent_pop
else
echo "${indent}<${tag}>${content}</${tag}>"
fi
}
generate_filter() {
local name=$1
local pats=$2
local file_list_sz
local i
local f
local saveIFS="$IFS"
local pack
echo "generating filter '$name' from ${#file_list[@]} files" >&2
IFS=*
file_list_sz=${#file_list[@]}
for i in ${!file_list[@]}; do
f=${file_list[i]}
for pat in ${pats//;/$IFS}; do
if [ "${f##*.}" == "$pat" ]; then
unset file_list[i]
objf=$(echo ${f%.*}.obj \
| sed -e "s,$src_path_bare,," \
-e 's/^[\./]\+//g' -e 's,[:/ ],_,g')
if ([ "$pat" == "asm" ] || [ "$pat" == "s" ]) && $asm_use_custom_step; then
# Avoid object file name collisions, i.e. aom_config.c and
# aom_config.asm produce the same object file without
# this additional suffix.
objf=${objf%.obj}_asm.obj
open_tag CustomBuild \
Include="$f"
for plat in "${platforms[@]}"; do
for cfg in Debug Release; do
tag_content Message "Assembling %(Filename)%(Extension)" \
Condition="'\$(Configuration)|\$(Platform)'=='$cfg|$plat'"
tag_content Command "$(eval echo \$asm_${cfg}_cmdline) -o \$(IntDir)$objf" \
Condition="'\$(Configuration)|\$(Platform)'=='$cfg|$plat'"
tag_content Outputs "\$(IntDir)$objf" \
Condition="'\$(Configuration)|\$(Platform)'=='$cfg|$plat'"
done
done
close_tag CustomBuild
elif [ "$pat" == "c" ] || \
[ "$pat" == "cc" ] || [ "$pat" == "cpp" ]; then
open_tag ClCompile \
Include="$f"
# Separate file names with Condition?
tag_content ObjectFileName "\$(IntDir)$objf"
# Check for AVX and turn it on to avoid warnings.
if [[ $f =~ avx.?\.c$ ]]; then
tag_content AdditionalOptions "/arch:AVX"
fi
close_tag ClCompile
elif [ "$pat" == "h" ] ; then
tag ClInclude \
Include="$f"
elif [ "$pat" == "vcxproj" ] ; then
open_tag ProjectReference \
Include="$f"
depguid=`grep ProjectGuid "$f" | sed 's,.*<.*>\(.*\)</.*>.*,\1,'`
tag_content Project "$depguid"
tag_content ReferenceOutputAssembly false
close_tag ProjectReference
else
tag None \
Include="$f"
fi
break
fi
done
done
IFS="$saveIFS"
}
# Process command line
unset target
for opt in "$@"; do
optval="${opt#*=}"
case "$opt" in
--help|-h) show_help
;;
--target=*) target="${optval}"
;;
--out=*) outfile="$optval"
;;
--name=*) name="${optval}"
;;
--proj-guid=*) guid="${optval}"
;;
--module-def=*) module_def="${optval}"
;;
--exe) proj_kind="exe"
;;
--dll) proj_kind="dll"
;;
--lib) proj_kind="lib"
;;
--src-path-bare=*)
src_path_bare=$(fix_path "$optval")
src_path_bare=${src_path_bare%/}
;;
--static-crt) use_static_runtime=true
;;
--enable-werror) werror=true
;;
--ver=*)
vs_ver="$optval"
case "$optval" in
12|14)
;;
*) die Unrecognized Visual Studio Version in $opt
;;
esac
;;
-I*)
opt=${opt##-I}
opt=$(fix_path "$opt")
opt="${opt%/}"
incs="${incs}${incs:+;}&quot;${opt}&quot;"
yasmincs="${yasmincs} -I&quot;${opt}&quot;"
;;
-D*) defines="${defines}${defines:+;}${opt##-D}"
;;
-L*) # fudge . to $(OutDir)
if [ "${opt##-L}" == "." ]; then
libdirs="${libdirs}${libdirs:+;}&quot;\$(OutDir)&quot;"
else
# Also try directories for this platform/configuration
opt=${opt##-L}
opt=$(fix_path "$opt")
libdirs="${libdirs}${libdirs:+;}&quot;${opt}&quot;"
libdirs="${libdirs}${libdirs:+;}&quot;${opt}/\$(PlatformName)/\$(Configuration)&quot;"
libdirs="${libdirs}${libdirs:+;}&quot;${opt}/\$(PlatformName)&quot;"
fi
;;
-l*) libs="${libs}${libs:+ }${opt##-l}.lib"
;;
-*) die_unknown $opt
;;
*)
# The paths in file_list are fixed outside of the loop.
file_list[${#file_list[@]}]="$opt"
case "$opt" in
*.asm|*.s) uses_asm=true
;;
esac
;;
esac
done
# Make one call to fix_path for file_list to improve performance.
fix_file_list file_list
outfile=${outfile:-/dev/stdout}
guid=${guid:-`generate_uuid`}
asm_use_custom_step=false
uses_asm=${uses_asm:-false}
case "${vs_ver:-12}" in
12|14)
asm_use_custom_step=$uses_asm
;;
esac
[ -n "$name" ] || die "Project name (--name) must be specified!"
[ -n "$target" ] || die "Target (--target) must be specified!"
if ${use_static_runtime:-false}; then
release_runtime=MultiThreaded
debug_runtime=MultiThreadedDebug
lib_sfx=mt
else
release_runtime=MultiThreadedDLL
debug_runtime=MultiThreadedDebugDLL
lib_sfx=md
fi
# Calculate debug lib names: If a lib ends in ${lib_sfx}.lib, then rename
# it to ${lib_sfx}d.lib. This precludes linking to release libs from a
# debug exe, so this may need to be refactored later.
for lib in ${libs}; do
if [ "$lib" != "${lib%${lib_sfx}.lib}" ]; then
lib=${lib%.lib}d.lib
fi
debug_libs="${debug_libs}${debug_libs:+ }${lib}"
done
debug_libs=${debug_libs// /;}
libs=${libs// /;}
# List of all platforms supported for this target
case "$target" in
x86_64*)
platforms[0]="x64"
asm_Debug_cmdline="yasm -Xvc -g cv8 -f win64 ${yasmincs} &quot;%(FullPath)&quot;"
asm_Release_cmdline="yasm -Xvc -f win64 ${yasmincs} &quot;%(FullPath)&quot;"
;;
x86*)
platforms[0]="Win32"
asm_Debug_cmdline="yasm -Xvc -g cv8 -f win32 ${yasmincs} &quot;%(FullPath)&quot;"
asm_Release_cmdline="yasm -Xvc -f win32 ${yasmincs} &quot;%(FullPath)&quot;"
;;
arm*)
platforms[0]="ARM"
asm_Debug_cmdline="armasm -nologo -oldit &quot;%(FullPath)&quot;"
asm_Release_cmdline="armasm -nologo -oldit &quot;%(FullPath)&quot;"
;;
*) die "Unsupported target $target!"
;;
esac
generate_vcxproj() {
echo "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
open_tag Project \
DefaultTargets="Build" \
ToolsVersion="4.0" \
xmlns="http://schemas.microsoft.com/developer/msbuild/2003" \
open_tag ItemGroup \
Label="ProjectConfigurations"
for plat in "${platforms[@]}"; do
for config in Debug Release; do
open_tag ProjectConfiguration \
Include="$config|$plat"
tag_content Configuration $config
tag_content Platform $plat
close_tag ProjectConfiguration
done
done
close_tag ItemGroup
open_tag PropertyGroup \
Label="Globals"
tag_content ProjectGuid "{${guid}}"
tag_content RootNamespace ${name}
tag_content Keyword ManagedCProj
if [ "${platforms[0]}" = "ARM" ]; then
tag_content AppContainerApplication true
# The application type can be one of "Windows Store",
# "Windows Phone" or "Windows Phone Silverlight". The
# actual value doesn't matter from the libaom point of view,
# since a static library built for one works on the others.
# The PlatformToolset field needs to be set in sync with this;
# for Windows Store and Windows Phone Silverlight it should be
# v120 while it should be v120_wp81 if the type is Windows Phone.
tag_content ApplicationType "Windows Store"
tag_content ApplicationTypeRevision 8.1
fi
close_tag PropertyGroup
tag Import \
Project="\$(VCTargetsPath)\\Microsoft.Cpp.Default.props"
for plat in "${platforms[@]}"; do
for config in Release Debug; do
open_tag PropertyGroup \
Condition="'\$(Configuration)|\$(Platform)'=='$config|$plat'" \
Label="Configuration"
if [ "$proj_kind" = "exe" ]; then
tag_content ConfigurationType Application
elif [ "$proj_kind" = "dll" ]; then
tag_content ConfigurationType DynamicLibrary
else
tag_content ConfigurationType StaticLibrary
fi
if [ "$vs_ver" = "12" ]; then
# Setting a PlatformToolset indicating windows phone isn't
# enough to build code for arm with MSVC 2013, one strictly
# has to enable AppContainerApplication as well.
tag_content PlatformToolset v120
fi
if [ "$vs_ver" = "14" ]; then
tag_content PlatformToolset v140
fi
tag_content CharacterSet Unicode
if [ "$config" = "Release" ]; then
tag_content WholeProgramOptimization true
fi
close_tag PropertyGroup
done
done
tag Import \
Project="\$(VCTargetsPath)\\Microsoft.Cpp.props"
open_tag ImportGroup \
Label="PropertySheets"
tag Import \
Project="\$(UserRootDir)\\Microsoft.Cpp.\$(Platform).user.props" \
Condition="exists('\$(UserRootDir)\\Microsoft.Cpp.\$(Platform).user.props')" \
Label="LocalAppDataPlatform"
close_tag ImportGroup
tag PropertyGroup \
Label="UserMacros"
for plat in "${platforms[@]}"; do
plat_no_ws=`echo $plat | sed 's/[^A-Za-z0-9_]/_/g'`
for config in Debug Release; do
open_tag PropertyGroup \
Condition="'\$(Configuration)|\$(Platform)'=='$config|$plat'"
tag_content OutDir "\$(SolutionDir)$plat_no_ws\\\$(Configuration)\\"
tag_content IntDir "$plat_no_ws\\\$(Configuration)\\${name}\\"
if [ "$proj_kind" == "lib" ]; then
if [ "$config" == "Debug" ]; then
config_suffix=d
else
config_suffix=""
fi
tag_content TargetName "${name}${lib_sfx}${config_suffix}"
fi
close_tag PropertyGroup
done
done
for plat in "${platforms[@]}"; do
for config in Debug Release; do
open_tag ItemDefinitionGroup \
Condition="'\$(Configuration)|\$(Platform)'=='$config|$plat'"
if [ "$name" == "aom" ]; then
hostplat=$plat
if [ "$hostplat" == "ARM" ]; then
hostplat=Win32
fi
fi
open_tag ClCompile
if [ "$config" = "Debug" ]; then
opt=Disabled
runtime=$debug_runtime
curlibs=$debug_libs
debug=_DEBUG
else
opt=MaxSpeed
runtime=$release_runtime
curlibs=$libs
tag_content FavorSizeOrSpeed Speed
debug=NDEBUG
fi
extradefines=";$defines"
tag_content Optimization $opt
tag_content AdditionalIncludeDirectories "$incs;%(AdditionalIncludeDirectories)"
tag_content PreprocessorDefinitions "WIN32;$debug;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE$extradefines;%(PreprocessorDefinitions)"
tag_content RuntimeLibrary $runtime
tag_content WarningLevel Level3
if ${werror:-false}; then
tag_content TreatWarningAsError true
fi
# We need to override the defaults for these settings
# if AppContainerApplication is set.
tag_content CompileAsWinRT false
tag_content PrecompiledHeader NotUsing
tag_content SDLCheck false
close_tag ClCompile
case "$proj_kind" in
exe)
open_tag Link
tag_content GenerateDebugInformation true
# Console is the default normally, but if
# AppContainerApplication is set, we need to override it.
tag_content SubSystem Console
close_tag Link
;;
dll)
open_tag Link
tag_content GenerateDebugInformation true
tag_content ModuleDefinitionFile $module_def
close_tag Link
;;
lib)
;;
esac
close_tag ItemDefinitionGroup
done
done
open_tag ItemGroup
generate_filter "Source Files" "c;cc;cpp;def;odl;idl;hpj;bat;asm;asmx;s"
close_tag ItemGroup
open_tag ItemGroup
generate_filter "Header Files" "h;hm;inl;inc;xsd"
close_tag ItemGroup
open_tag ItemGroup
generate_filter "Build Files" "mk"
close_tag ItemGroup
open_tag ItemGroup
generate_filter "References" "vcxproj"
close_tag ItemGroup
tag Import \
Project="\$(VCTargetsPath)\\Microsoft.Cpp.targets"
open_tag ImportGroup \
Label="ExtensionTargets"
close_tag ImportGroup
close_tag Project
# This must be done from within the {} subshell
echo "Ignored files list (${#file_list[@]} items) is:" >&2
for f in "${file_list[@]}"; do
echo " $f" >&2
done
}
# This regexp doesn't catch most of the strings in the vcxproj format,
# since they're like <tag>path</tag> instead of <tag attr="path" />
# as previously. It still seems to work ok despite this.
generate_vcxproj |
sed -e '/"/s;\([^ "]\)/;\1\\;g' |
sed -e '/xmlns/s;\\;/;g' > ${outfile}
exit

37
third_party/aom/build/make/ios-Info.plist vendored Normal file
View file

@ -0,0 +1,37 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>en</string>
<key>CFBundleExecutable</key>
<string>AOM</string>
<key>CFBundleIdentifier</key>
<string>org.webmproject.AOM</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>AOM</string>
<key>CFBundlePackageType</key>
<string>FMWK</string>
<key>CFBundleShortVersionString</key>
<string>${VERSION}</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleSupportedPlatforms</key>
<array>
<string>iPhoneOS</string>
</array>
<key>CFBundleVersion</key>
<string>${VERSION}</string>
<key>MinimumOSVersion</key>
<string>${IOS_VERSION_MIN}</string>
<key>UIDeviceFamily</key>
<array>
<integer>1</integer>
<integer>2</integer>
</array>
<key>AOMFullVersion</key>
<string>${FULLVERSION}</string>
</dict>
</plist>

383
third_party/aom/build/make/iosbuild.sh vendored Executable file
View file

@ -0,0 +1,383 @@
#!/bin/sh
## 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.
##
## This script generates 'AOM.framework'. An iOS app can encode and decode AVx
## video by including 'AOM.framework'.
##
## Run iosbuild.sh to create 'AOM.framework' in the current directory.
##
set -e
devnull='> /dev/null 2>&1'
BUILD_ROOT="_iosbuild"
CONFIGURE_ARGS="--disable-docs
--disable-examples
--disable-libyuv
--disable-unit-tests"
DIST_DIR="_dist"
FRAMEWORK_DIR="AOM.framework"
FRAMEWORK_LIB="AOM.framework/AOM"
HEADER_DIR="${FRAMEWORK_DIR}/Headers/aom"
SCRIPT_DIR=$(dirname "$0")
LIBAOM_SOURCE_DIR=$(cd ${SCRIPT_DIR}/../..; pwd)
LIPO=$(xcrun -sdk iphoneos${SDK} -find lipo)
ORIG_PWD="$(pwd)"
ARM_TARGETS="arm64-darwin-gcc
armv7-darwin-gcc
armv7s-darwin-gcc"
SIM_TARGETS="x86-iphonesimulator-gcc
x86_64-iphonesimulator-gcc"
OSX_TARGETS="x86-darwin16-gcc
x86_64-darwin16-gcc"
TARGETS="${ARM_TARGETS} ${SIM_TARGETS}"
# Configures for the target specified by $1, and invokes make with the dist
# target using $ as the distribution output directory.
build_target() {
local target="$1"
local old_pwd="$(pwd)"
local target_specific_flags=""
vlog "***Building target: ${target}***"
case "${target}" in
x86-*)
target_specific_flags="--enable-pic"
vlog "Enabled PIC for ${target}"
;;
esac
mkdir "${target}"
cd "${target}"
eval "${LIBAOM_SOURCE_DIR}/configure" --target="${target}" \
${CONFIGURE_ARGS} ${EXTRA_CONFIGURE_ARGS} ${target_specific_flags} \
${devnull}
export DIST_DIR
eval make dist ${devnull}
cd "${old_pwd}"
vlog "***Done building target: ${target}***"
}
# Returns the preprocessor symbol for the target specified by $1.
target_to_preproc_symbol() {
target="$1"
case "${target}" in
arm64-*)
echo "__aarch64__"
;;
armv7-*)
echo "__ARM_ARCH_7A__"
;;
armv7s-*)
echo "__ARM_ARCH_7S__"
;;
x86-*)
echo "__i386__"
;;
x86_64-*)
echo "__x86_64__"
;;
*)
echo "#error ${target} unknown/unsupported"
return 1
;;
esac
}
# Create a aom_config.h shim that, based on preprocessor settings for the
# current target CPU, includes the real aom_config.h for the current target.
# $1 is the list of targets.
create_aom_framework_config_shim() {
local targets="$1"
local config_file="${HEADER_DIR}/aom_config.h"
local preproc_symbol=""
local target=""
local include_guard="AOM_FRAMEWORK_HEADERS_AOM_AOM_CONFIG_H_"
local file_header="/*
* Copyright (c) $(date +%Y), 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.
*/
/* GENERATED FILE: DO NOT EDIT! */
#ifndef ${include_guard}
#define ${include_guard}
#if defined"
printf "%s" "${file_header}" > "${config_file}"
for target in ${targets}; do
preproc_symbol=$(target_to_preproc_symbol "${target}")
printf " ${preproc_symbol}\n" >> "${config_file}"
printf "#define AOM_FRAMEWORK_TARGET \"${target}\"\n" >> "${config_file}"
printf "#include \"AOM/aom/${target}/aom_config.h\"\n" >> "${config_file}"
printf "#elif defined" >> "${config_file}"
mkdir "${HEADER_DIR}/${target}"
cp -p "${BUILD_ROOT}/${target}/aom_config.h" "${HEADER_DIR}/${target}"
done
# Consume the last line of output from the loop: We don't want it.
sed -i '' -e '$d' "${config_file}"
printf "#endif\n\n" >> "${config_file}"
printf "#endif // ${include_guard}" >> "${config_file}"
}
# Verifies that $FRAMEWORK_LIB fat library contains requested builds.
verify_framework_targets() {
local requested_cpus=""
local cpu=""
# Extract CPU from full target name.
for target; do
cpu="${target%%-*}"
if [ "${cpu}" = "x86" ]; then
# lipo -info outputs i386 for libaom x86 targets.
cpu="i386"
fi
requested_cpus="${requested_cpus}${cpu} "
done
# Get target CPUs present in framework library.
local targets_built=$(${LIPO} -info ${FRAMEWORK_LIB})
# $LIPO -info outputs a string like the following:
# Architectures in the fat file: $FRAMEWORK_LIB <architectures>
# Capture only the architecture strings.
targets_built=${targets_built##*: }
# Sort CPU strings to make the next step a simple string compare.
local actual=$(echo ${targets_built} | tr " " "\n" | sort | tr "\n" " ")
local requested=$(echo ${requested_cpus} | tr " " "\n" | sort | tr "\n" " ")
vlog "Requested ${FRAMEWORK_LIB} CPUs: ${requested}"
vlog "Actual ${FRAMEWORK_LIB} CPUs: ${actual}"
if [ "${requested}" != "${actual}" ]; then
elog "Actual ${FRAMEWORK_LIB} targets do not match requested target list."
elog " Requested target CPUs: ${requested}"
elog " Actual target CPUs: ${actual}"
return 1
fi
}
# Configures and builds each target specified by $1, and then builds
# AOM.framework.
build_framework() {
local lib_list=""
local targets="$1"
local target=""
local target_dist_dir=""
# Clean up from previous build(s).
rm -rf "${BUILD_ROOT}" "${FRAMEWORK_DIR}"
# Create output dirs.
mkdir -p "${BUILD_ROOT}"
mkdir -p "${HEADER_DIR}"
cd "${BUILD_ROOT}"
for target in ${targets}; do
build_target "${target}"
target_dist_dir="${BUILD_ROOT}/${target}/${DIST_DIR}"
if [ "${ENABLE_SHARED}" = "yes" ]; then
local suffix="dylib"
else
local suffix="a"
fi
lib_list="${lib_list} ${target_dist_dir}/lib/libaom.${suffix}"
done
cd "${ORIG_PWD}"
# The basic libaom API includes are all the same; just grab the most recent
# set.
cp -p "${target_dist_dir}"/include/aom/* "${HEADER_DIR}"
# Build the fat library.
${LIPO} -create ${lib_list} -output ${FRAMEWORK_DIR}/AOM
# Create the aom_config.h shim that allows usage of aom_config.h from
# within AOM.framework.
create_aom_framework_config_shim "${targets}"
# Copy in aom_version.h.
cp -p "${BUILD_ROOT}/${target}/aom_version.h" "${HEADER_DIR}"
if [ "${ENABLE_SHARED}" = "yes" ]; then
# Adjust the dylib's name so dynamic linking in apps works as expected.
install_name_tool -id '@rpath/AOM.framework/AOM' ${FRAMEWORK_DIR}/AOM
# Copy in Info.plist.
cat "${SCRIPT_DIR}/ios-Info.plist" \
| sed "s/\${FULLVERSION}/${FULLVERSION}/g" \
| sed "s/\${VERSION}/${VERSION}/g" \
| sed "s/\${IOS_VERSION_MIN}/${IOS_VERSION_MIN}/g" \
> "${FRAMEWORK_DIR}/Info.plist"
fi
# Confirm AOM.framework/AOM contains the targets requested.
verify_framework_targets ${targets}
vlog "Created fat library ${FRAMEWORK_LIB} containing:"
for lib in ${lib_list}; do
vlog " $(echo ${lib} | awk -F / '{print $2, $NF}')"
done
}
# Trap function. Cleans up the subtree used to build all targets contained in
# $TARGETS.
cleanup() {
local readonly res=$?
cd "${ORIG_PWD}"
if [ $res -ne 0 ]; then
elog "build exited with error ($res)"
fi
if [ "${PRESERVE_BUILD_OUTPUT}" != "yes" ]; then
rm -rf "${BUILD_ROOT}"
fi
}
print_list() {
local indent="$1"
shift
local list="$@"
for entry in ${list}; do
echo "${indent}${entry}"
done
}
iosbuild_usage() {
cat << EOF
Usage: ${0##*/} [arguments]
--help: Display this message and exit.
--enable-shared: Build a dynamic framework for use on iOS 8 or later.
--extra-configure-args <args>: Extra args to pass when configuring libaom.
--macosx: Uses darwin16 targets instead of iphonesimulator targets for x86
and x86_64. Allows linking to framework when builds target MacOSX
instead of iOS.
--preserve-build-output: Do not delete the build directory.
--show-build-output: Show output from each library build.
--targets <targets>: Override default target list. Defaults:
$(print_list " " ${TARGETS})
--test-link: Confirms all targets can be linked. Functionally identical to
passing --enable-examples via --extra-configure-args.
--verbose: Output information about the environment and each stage of the
build.
EOF
}
elog() {
echo "${0##*/} failed because: $@" 1>&2
}
vlog() {
if [ "${VERBOSE}" = "yes" ]; then
echo "$@"
fi
}
trap cleanup EXIT
# Parse the command line.
while [ -n "$1" ]; do
case "$1" in
--extra-configure-args)
EXTRA_CONFIGURE_ARGS="$2"
shift
;;
--help)
iosbuild_usage
exit
;;
--enable-shared)
ENABLE_SHARED=yes
;;
--preserve-build-output)
PRESERVE_BUILD_OUTPUT=yes
;;
--show-build-output)
devnull=
;;
--test-link)
EXTRA_CONFIGURE_ARGS="${EXTRA_CONFIGURE_ARGS} --enable-examples"
;;
--targets)
TARGETS="$2"
shift
;;
--macosx)
TARGETS="${ARM_TARGETS} ${OSX_TARGETS}"
;;
--verbose)
VERBOSE=yes
;;
*)
iosbuild_usage
exit 1
;;
esac
shift
done
if [ "${ENABLE_SHARED}" = "yes" ]; then
CONFIGURE_ARGS="--enable-shared ${CONFIGURE_ARGS}"
fi
FULLVERSION=$("${SCRIPT_DIR}"/version.sh --bare "${LIBAOM_SOURCE_DIR}")
VERSION=$(echo "${FULLVERSION}" | sed -E 's/^v([0-9]+\.[0-9]+\.[0-9]+).*$/\1/')
if [ "$ENABLE_SHARED" = "yes" ]; then
IOS_VERSION_OPTIONS="--enable-shared"
IOS_VERSION_MIN="8.0"
else
IOS_VERSION_OPTIONS=""
IOS_VERSION_MIN="6.0"
fi
if [ "${VERBOSE}" = "yes" ]; then
cat << EOF
BUILD_ROOT=${BUILD_ROOT}
DIST_DIR=${DIST_DIR}
CONFIGURE_ARGS=${CONFIGURE_ARGS}
EXTRA_CONFIGURE_ARGS=${EXTRA_CONFIGURE_ARGS}
FRAMEWORK_DIR=${FRAMEWORK_DIR}
FRAMEWORK_LIB=${FRAMEWORK_LIB}
HEADER_DIR=${HEADER_DIR}
LIBAOM_SOURCE_DIR=${LIBAOM_SOURCE_DIR}
LIPO=${LIPO}
MAKEFLAGS=${MAKEFLAGS}
ORIG_PWD=${ORIG_PWD}
PRESERVE_BUILD_OUTPUT=${PRESERVE_BUILD_OUTPUT}
TARGETS="$(print_list "" ${TARGETS})"
ENABLE_SHARED=${ENABLE_SHARED}
OSX_TARGETS="${OSX_TARGETS}"
SIM_TARGETS="${SIM_TARGETS}"
SCRIPT_DIR="${SCRIPT_DIR}"
FULLVERSION="${FULLVERSION}"
VERSION="${VERSION}"
IOS_VERSION_MIN="${IOS_VERSION_MIN}"
EOF
fi
build_framework "${TARGETS}"
echo "Successfully built '${FRAMEWORK_DIR}' for:"
print_list "" ${TARGETS}

114
third_party/aom/build/make/msvs_common.sh vendored Normal file
View file

@ -0,0 +1,114 @@
#!/bin/bash
## 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.
##
if [ "$(uname -o 2>/dev/null)" = "Cygwin" ] \
&& cygpath --help >/dev/null 2>&1; then
FIXPATH='cygpath -m'
else
FIXPATH='echo_path'
fi
die() {
echo "${self_basename}: $@" >&2
exit 1
}
die_unknown(){
echo "Unknown option \"$1\"." >&2
echo "See ${self_basename} --help for available options." >&2
exit 1
}
echo_path() {
for path; do
echo "$path"
done
}
# Output one, possibly changed based on the system, path per line.
fix_path() {
$FIXPATH "$@"
}
# Corrects the paths in file_list in one pass for efficiency.
# $1 is the name of the array to be modified.
fix_file_list() {
declare -n array_ref=$1
files=$(fix_path "${array_ref[@]}")
local IFS=$'\n'
array_ref=($files)
}
generate_uuid() {
local hex="0123456789ABCDEF"
local i
local uuid=""
local j
#93995380-89BD-4b04-88EB-625FBE52EBFB
for ((i=0; i<32; i++)); do
(( j = $RANDOM % 16 ))
uuid="${uuid}${hex:$j:1}"
done
echo "${uuid:0:8}-${uuid:8:4}-${uuid:12:4}-${uuid:16:4}-${uuid:20:12}"
}
indent1=" "
indent=""
indent_push() {
indent="${indent}${indent1}"
}
indent_pop() {
indent="${indent%${indent1}}"
}
tag_attributes() {
for opt in "$@"; do
optval="${opt#*=}"
[ -n "${optval}" ] ||
die "Missing attribute value in '$opt' while generating $tag tag"
echo "${indent}${opt%%=*}=\"${optval}\""
done
}
open_tag() {
local tag=$1
shift
if [ $# -ne 0 ]; then
echo "${indent}<${tag}"
indent_push
tag_attributes "$@"
echo "${indent}>"
else
echo "${indent}<${tag}>"
indent_push
fi
}
close_tag() {
local tag=$1
indent_pop
echo "${indent}</${tag}>"
}
tag() {
local tag=$1
shift
if [ $# -ne 0 ]; then
echo "${indent}<${tag}"
indent_push
tag_attributes "$@"
indent_pop
echo "${indent}/>"
else
echo "${indent}<${tag}/>"
fi
}

424
third_party/aom/build/make/rtcd.pl vendored Executable file
View file

@ -0,0 +1,424 @@
#!/usr/bin/env perl
no strict 'refs';
use warnings;
use Getopt::Long;
Getopt::Long::Configure("auto_help") if $Getopt::Long::VERSION > 2.32;
my %ALL_FUNCS = ();
my @ALL_ARCHS;
my @ALL_FORWARD_DECLS;
my @REQUIRES;
my %opts = ();
my %disabled = ();
my %required = ();
my @argv;
foreach (@ARGV) {
$disabled{$1} = 1, next if /--disable-(.*)/;
$required{$1} = 1, next if /--require-(.*)/;
push @argv, $_;
}
# NB: use GetOptions() instead of GetOptionsFromArray() for compatibility.
@ARGV = @argv;
GetOptions(
\%opts,
'arch=s',
'sym=s',
'config=s',
);
foreach my $opt (qw/arch config/) {
if (!defined($opts{$opt})) {
warn "--$opt is required!\n";
Getopt::Long::HelpMessage('-exit' => 1);
}
}
foreach my $defs_file (@ARGV) {
if (!-f $defs_file) {
warn "$defs_file: $!\n";
Getopt::Long::HelpMessage('-exit' => 1);
}
}
open CONFIG_FILE, $opts{config} or
die "Error opening config file '$opts{config}': $!\n";
my %config = ();
while (<CONFIG_FILE>) {
next if !/^(?:CONFIG_|HAVE_)/;
chomp;
s/\r$//;
my @pair = split /=/;
$config{$pair[0]} = $pair[1];
}
close CONFIG_FILE;
#
# Routines for the RTCD DSL to call
#
sub aom_config($) {
return (defined $config{$_[0]}) ? $config{$_[0]} : "";
}
sub specialize {
if (@_ <= 1) {
die "'specialize' must be called with a function name and at least one ",
"architecture ('C' is implied): \n@_\n";
}
my $fn=$_[0];
shift;
foreach my $opt (@_) {
eval "\$${fn}_${opt}=${fn}_${opt}";
}
}
sub add_proto {
my $fn = splice(@_, -2, 1);
$ALL_FUNCS{$fn} = \@_;
specialize $fn, "c";
}
sub require {
foreach my $fn (keys %ALL_FUNCS) {
foreach my $opt (@_) {
my $ofn = eval "\$${fn}_${opt}";
next if !$ofn;
# if we already have a default, then we can disable it, as we know
# we can do better.
my $best = eval "\$${fn}_default";
if ($best) {
my $best_ofn = eval "\$${best}";
if ($best_ofn && "$best_ofn" ne "$ofn") {
eval "\$${best}_link = 'false'";
}
}
eval "\$${fn}_default=${fn}_${opt}";
eval "\$${fn}_${opt}_link='true'";
}
}
}
sub forward_decls {
push @ALL_FORWARD_DECLS, @_;
}
#
# Include the user's directives
#
foreach my $f (@ARGV) {
open FILE, "<", $f or die "cannot open $f: $!\n";
my $contents = join('', <FILE>);
close FILE;
eval $contents or warn "eval failed: $@\n";
}
#
# Process the directives according to the command line
#
sub process_forward_decls() {
foreach (@ALL_FORWARD_DECLS) {
$_->();
}
}
sub determine_indirection {
aom_config("CONFIG_RUNTIME_CPU_DETECT") eq "yes" or &require(@ALL_ARCHS);
foreach my $fn (keys %ALL_FUNCS) {
my $n = "";
my @val = @{$ALL_FUNCS{$fn}};
my $args = pop @val;
my $rtyp = "@val";
my $dfn = eval "\$${fn}_default";
$dfn = eval "\$${dfn}";
foreach my $opt (@_) {
my $ofn = eval "\$${fn}_${opt}";
next if !$ofn;
my $link = eval "\$${fn}_${opt}_link";
next if $link && $link eq "false";
$n .= "x";
}
if ($n eq "x") {
eval "\$${fn}_indirect = 'false'";
} else {
eval "\$${fn}_indirect = 'true'";
}
}
}
sub declare_function_pointers {
foreach my $fn (sort keys %ALL_FUNCS) {
my @val = @{$ALL_FUNCS{$fn}};
my $args = pop @val;
my $rtyp = "@val";
my $dfn = eval "\$${fn}_default";
$dfn = eval "\$${dfn}";
foreach my $opt (@_) {
my $ofn = eval "\$${fn}_${opt}";
next if !$ofn;
print "$rtyp ${ofn}($args);\n";
}
if (eval "\$${fn}_indirect" eq "false") {
print "#define ${fn} ${dfn}\n";
} else {
print "RTCD_EXTERN $rtyp (*${fn})($args);\n";
}
print "\n";
}
}
sub set_function_pointers {
foreach my $fn (sort keys %ALL_FUNCS) {
my @val = @{$ALL_FUNCS{$fn}};
my $args = pop @val;
my $rtyp = "@val";
my $dfn = eval "\$${fn}_default";
$dfn = eval "\$${dfn}";
if (eval "\$${fn}_indirect" eq "true") {
print " $fn = $dfn;\n";
foreach my $opt (@_) {
my $ofn = eval "\$${fn}_${opt}";
next if !$ofn;
next if "$ofn" eq "$dfn";
my $link = eval "\$${fn}_${opt}_link";
next if $link && $link eq "false";
my $cond = eval "\$have_${opt}";
print " if (${cond}) $fn = $ofn;\n"
}
}
}
}
sub filter {
my @filtered;
foreach (@_) { push @filtered, $_ unless $disabled{$_}; }
return @filtered;
}
#
# Helper functions for generating the arch specific RTCD files
#
sub common_top() {
my $include_guard = uc($opts{sym})."_H_";
print <<EOF;
#ifndef ${include_guard}
#define ${include_guard}
#ifdef RTCD_C
#define RTCD_EXTERN
#else
#define RTCD_EXTERN extern
#endif
EOF
process_forward_decls();
print <<EOF;
#ifdef __cplusplus
extern "C" {
#endif
EOF
declare_function_pointers("c", @ALL_ARCHS);
print <<EOF;
void $opts{sym}(void);
EOF
}
sub common_bottom() {
print <<EOF;
#ifdef __cplusplus
} // extern "C"
#endif
#endif
EOF
}
sub x86() {
determine_indirection("c", @ALL_ARCHS);
# Assign the helper variable for each enabled extension
foreach my $opt (@ALL_ARCHS) {
my $opt_uc = uc $opt;
eval "\$have_${opt}=\"flags & HAS_${opt_uc}\"";
}
common_top;
print <<EOF;
#ifdef RTCD_C
#include "aom_ports/x86.h"
static void setup_rtcd_internal(void)
{
int flags = x86_simd_caps();
(void)flags;
EOF
set_function_pointers("c", @ALL_ARCHS);
print <<EOF;
}
#endif
EOF
common_bottom;
}
sub arm() {
determine_indirection("c", @ALL_ARCHS);
# Assign the helper variable for each enabled extension
foreach my $opt (@ALL_ARCHS) {
my $opt_uc = uc $opt;
# Enable neon assembly based on HAVE_NEON logic instead of adding new
# HAVE_NEON_ASM logic
if ($opt eq 'neon_asm') { $opt_uc = 'NEON' }
eval "\$have_${opt}=\"flags & HAS_${opt_uc}\"";
}
common_top;
print <<EOF;
#include "aom_config.h"
#ifdef RTCD_C
#include "aom_ports/arm.h"
static void setup_rtcd_internal(void)
{
int flags = arm_cpu_caps();
(void)flags;
EOF
set_function_pointers("c", @ALL_ARCHS);
print <<EOF;
}
#endif
EOF
common_bottom;
}
sub mips() {
determine_indirection("c", @ALL_ARCHS);
common_top;
print <<EOF;
#include "aom_config.h"
#ifdef RTCD_C
static void setup_rtcd_internal(void)
{
EOF
set_function_pointers("c", @ALL_ARCHS);
print <<EOF;
#if HAVE_DSPR2
void aom_dsputil_static_init();
aom_dsputil_static_init();
#endif
}
#endif
EOF
common_bottom;
}
sub unoptimized() {
determine_indirection "c";
common_top;
print <<EOF;
#include "aom_config.h"
#ifdef RTCD_C
static void setup_rtcd_internal(void)
{
EOF
set_function_pointers "c";
print <<EOF;
}
#endif
EOF
common_bottom;
}
#
# Main Driver
#
&require("c");
if ($opts{arch} eq 'x86') {
@ALL_ARCHS = filter(qw/mmx sse sse2 sse3 ssse3 sse4_1 avx avx2/);
x86;
} elsif ($opts{arch} eq 'x86_64') {
@ALL_ARCHS = filter(qw/mmx sse sse2 sse3 ssse3 sse4_1 avx avx2/);
@REQUIRES = filter(keys %required ? keys %required : qw/mmx sse sse2/);
&require(@REQUIRES);
x86;
} elsif ($opts{arch} eq 'mips32' || $opts{arch} eq 'mips64') {
@ALL_ARCHS = filter("$opts{arch}");
open CONFIG_FILE, $opts{config} or
die "Error opening config file '$opts{config}': $!\n";
while (<CONFIG_FILE>) {
if (/HAVE_DSPR2=yes/) {
@ALL_ARCHS = filter("$opts{arch}", qw/dspr2/);
last;
}
if (/HAVE_MSA=yes/) {
@ALL_ARCHS = filter("$opts{arch}", qw/msa/);
last;
}
}
close CONFIG_FILE;
mips;
} elsif ($opts{arch} eq 'armv6') {
@ALL_ARCHS = filter(qw/media/);
arm;
} elsif ($opts{arch} =~ /armv7\w?/) {
@ALL_ARCHS = filter(qw/media neon_asm neon/);
@REQUIRES = filter(keys %required ? keys %required : qw/media/);
&require(@REQUIRES);
arm;
} elsif ($opts{arch} eq 'armv8' || $opts{arch} eq 'arm64' ) {
@ALL_ARCHS = filter(qw/neon/);
arm;
} else {
unoptimized;
}
__END__
=head1 NAME
rtcd -
=head1 SYNOPSIS
Usage: rtcd.pl [options] FILE
See 'perldoc rtcd.pl' for more details.
=head1 DESCRIPTION
Reads the Run Time CPU Detections definitions from FILE and generates a
C header file on stdout.
=head1 OPTIONS
Options:
--arch=ARCH Architecture to generate defs for (required)
--disable-EXT Disable support for EXT extensions
--require-EXT Require support for EXT extensions
--sym=SYMBOL Unique symbol to use for RTCD initialization function
--config=FILE File with CONFIG_FOO=yes lines to parse

71
third_party/aom/build/make/thumb.pm vendored Normal file
View file

@ -0,0 +1,71 @@
#!/usr/bin/env perl
##
## 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.
##
package thumb;
sub FixThumbInstructions($$)
{
my $short_branches = $_[1];
my $branch_shift_offset = $short_branches ? 1 : 0;
# Write additions with shifts, such as "add r10, r11, lsl #8",
# in three operand form, "add r10, r10, r11, lsl #8".
s/(add\s+)(r\d+),\s*(r\d+),\s*(lsl #\d+)/$1$2, $2, $3, $4/g;
# Convert additions with a non-constant shift into a sequence
# with left shift, addition and a right shift (to restore the
# register to the original value). Currently the right shift
# isn't necessary in the code base since the values in these
# registers aren't used, but doing the shift for consistency.
# This converts instructions such as "add r12, r12, r5, lsl r4"
# into the sequence "lsl r5, r4", "add r12, r12, r5", "lsr r5, r4".
s/^(\s*)(add)(\s+)(r\d+),\s*(r\d+),\s*(r\d+),\s*lsl (r\d+)/$1lsl$3$6, $7\n$1$2$3$4, $5, $6\n$1lsr$3$6, $7/g;
# Convert loads with right shifts in the indexing into a
# sequence of an add, load and sub. This converts
# "ldrb r4, [r9, lr, asr #1]" into "add r9, r9, lr, asr #1",
# "ldrb r9, [r9]", "sub r9, r9, lr, asr #1".
s/^(\s*)(ldrb)(\s+)(r\d+),\s*\[(\w+),\s*(\w+),\s*(asr #\d+)\]/$1add $3$5, $5, $6, $7\n$1$2$3$4, [$5]\n$1sub $3$5, $5, $6, $7/g;
# Convert register indexing with writeback into a separate add
# instruction. This converts "ldrb r12, [r1, r2]!" into
# "ldrb r12, [r1, r2]", "add r1, r1, r2".
s/^(\s*)(ldrb)(\s+)(r\d+),\s*\[(\w+),\s*(\w+)\]!/$1$2$3$4, [$5, $6]\n$1add $3$5, $6/g;
# Convert negative register indexing into separate sub/add instructions.
# This converts "ldrne r4, [src, -pstep, lsl #1]" into
# "subne src, src, pstep, lsl #1", "ldrne r4, [src]",
# "addne src, src, pstep, lsl #1". In a couple of cases where
# this is used, it's used for two subsequent load instructions,
# where a hand-written version of it could merge two subsequent
# add and sub instructions.
s/^(\s*)((ldr|str|pld)(ne)?)(\s+)(r\d+,\s*)?\[(\w+), -([^\]]+)\]/$1sub$4$5$7, $7, $8\n$1$2$5$6\[$7\]\n$1add$4$5$7, $7, $8/g;
# Convert register post indexing to a separate add instruction.
# This converts "ldrneb r9, [r0], r2" into "ldrneb r9, [r0]",
# "addne r0, r0, r2".
s/^(\s*)((ldr|str)(ne)?[bhd]?)(\s+)(\w+),(\s*\w+,)?\s*\[(\w+)\],\s*(\w+)/$1$2$5$6,$7 [$8]\n$1add$4$5$8, $8, $9/g;
# Convert a conditional addition to the pc register into a series of
# instructions. This converts "addlt pc, pc, r3, lsl #2" into
# "itttt lt", "movlt.n r12, pc", "addlt.w r12, #12",
# "addlt.w r12, r12, r3, lsl #2", "movlt.n pc, r12".
# This assumes that r12 is free at this point.
s/^(\s*)addlt(\s+)pc,\s*pc,\s*(\w+),\s*lsl\s*#(\d+)/$1itttt$2lt\n$1movlt.n$2r12, pc\n$1addlt.w$2r12, #12\n$1addlt.w$2r12, r12, $3, lsl #($4-$branch_shift_offset)\n$1movlt.n$2pc, r12/g;
# Convert "mov pc, lr" into "bx lr", since the former only works
# for switching from arm to thumb (and only in armv7), but not
# from thumb to arm.
s/mov(\s*)pc\s*,\s*lr/bx$1lr/g;
}
1;

77
third_party/aom/build/make/version.sh vendored Executable file
View file

@ -0,0 +1,77 @@
#!/bin/sh
## 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.
##
for opt in "$@"; do
optval="${opt#*=}"
case "$opt" in
--bare) bare=true ;;
*) break ;;
esac
shift
done
source_path=${1:-.}
out_file=${2}
id=${3:-VERSION_STRING}
git_version_id=""
if [ -e "${source_path}/.git" ]; then
# Source Path is a git working copy. Check for local modifications.
# Note that git submodules may have a file as .git, not a directory.
export GIT_DIR="${source_path}/.git"
git_version_id=`git describe --match=v[0-9]* 2>/dev/null`
fi
changelog_version=""
for p in "${source_path}" "${source_path}/.."; do
if [ -z "$git_version_id" -a -f "${p}/CHANGELOG" ]; then
changelog_version=`head -n1 "${p}/CHANGELOG" | awk '{print $2}'`
changelog_version="${changelog_version}"
break
fi
done
version_str="${changelog_version}${git_version_id}"
bare_version=${version_str#v}
major_version=${bare_version%%.*}
bare_version=${bare_version#*.}
minor_version=${bare_version%%.*}
bare_version=${bare_version#*.}
patch_version=${bare_version%%-*}
bare_version=${bare_version#${patch_version}}
extra_version=${bare_version##-}
#since they'll be used as integers below make sure they are or force to 0
for v in major_version minor_version patch_version; do
if eval echo \$$v |grep -E -q '[^[:digit:]]'; then
eval $v=0
fi
done
if [ ${bare} ]; then
echo "${changelog_version}${git_version_id}" > $$.tmp
else
cat<<EOF>$$.tmp
#define VERSION_MAJOR $major_version
#define VERSION_MINOR $minor_version
#define VERSION_PATCH $patch_version
#define VERSION_EXTRA "$extra_version"
#define VERSION_PACKED ((VERSION_MAJOR<<16)|(VERSION_MINOR<<8)|(VERSION_PATCH))
#define ${id}_NOSP "${version_str}"
#define ${id} " ${version_str}"
EOF
fi
if [ -n "$out_file" ]; then
diff $$.tmp ${out_file} >/dev/null 2>&1 || cat $$.tmp > ${out_file}
else
cat $$.tmp
fi
rm $$.tmp