wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-22 16:37:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1937 - Part 2: Update libaom source.

Browse source
This commit is contained in:
Job Bautista 2022-06-25 18:15:40 +08:00 • committed by roytam1
commit ecb7ec7377
948 changed files with 244949 additions and 88095 deletions
Download patch file Download diff file Expand all files Collapse all files

1
media/libaom/src/build/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
x86*-win32-vs*

96
media/libaom/src/build/cmake/aom_config_defaults.cmake
View file

@ -42,15 +42,15 @@ set_aom_detect_var(HAVE_MSA 0 "Enables MSA optimizations.")
set_aom_detect_var(HAVE_VSX 0 "Enables VSX optimizations.")
# x86/x86_64 feature flags.
set_aom_detect_var(HAVE_AVX 0 "Enables AVX optimizations.")
set_aom_detect_var(HAVE_AVX2 0 "Enables AVX2 optimizations.")
set_aom_detect_var(HAVE_MMX 0 "Enables MMX optimizations. ")
set_aom_detect_var(HAVE_SSE 0 "Enables SSE optimizations.")
set_aom_detect_var(HAVE_SSE2 0 "Enables SSE2 optimizations.")
set_aom_detect_var(HAVE_SSE3 0 "Enables SSE3 optimizations.")
set_aom_detect_var(HAVE_SSSE3 0 "Enables SSSE3 optimizations.")
set_aom_detect_var(HAVE_SSE4_1 0 "Enables SSE 4.1 optimizations.")
set_aom_detect_var(HAVE_SSE4_2 0 "Enables SSE 4.2 optimizations.")
set_aom_detect_var(HAVE_SSSE3 0 "Enables SSSE3 optimizations.")
set_aom_detect_var(HAVE_AVX 0 "Enables AVX optimizations.")
set_aom_detect_var(HAVE_AVX2 0 "Enables AVX2 optimizations.")
# Flags describing the build environment.
set_aom_detect_var(HAVE_FEXCEPT 0
@ -71,21 +71,34 @@ set_aom_config_var(AOM_RTCD_FLAGS ""
set_aom_config_var(CONFIG_AV1_DECODER 1 "Enable AV1 decoder.")
set_aom_config_var(CONFIG_AV1_ENCODER 1 "Enable AV1 encoder.")
set_aom_config_var(CONFIG_BIG_ENDIAN 0 "Internal flag.")
set_aom_config_var(CONFIG_FPMT_TEST 0 "Enable FPMT testing.")
set_aom_config_var(CONFIG_FRAME_PARALLEL_ENCODE 0
"Enable frame parallelism during encode.")
set_aom_config_var(
CONFIG_FRAME_PARALLEL_ENCODE_2 0
"Enable frame parallelism during encode for frames in lower layer depths.")
set_aom_config_var(CONFIG_GCC 0 "Building with GCC (detect).")
set_aom_config_var(CONFIG_GCOV 0 "Enable gcov support.")
set_aom_config_var(CONFIG_GPROF 0 "Enable gprof support.")
set_aom_config_var(CONFIG_LIBYUV 1 "Enables libyuv scaling/conversion support.")
set_aom_config_var(CONFIG_AV1_HIGHBITDEPTH 1
"Build with high bitdepth support.")
set_aom_config_var(CONFIG_AV1_TEMPORAL_DENOISING 0
"Build with temporal denoising support.")
set_aom_config_var(CONFIG_MULTITHREAD 1 "Multithread support.")
set_aom_config_var(CONFIG_OS_SUPPORT 0 "Internal flag.")
set_aom_config_var(CONFIG_PIC 0 "Build with PIC enabled.")
set_aom_config_var(CONFIG_REALTIME_ONLY 0
"Build for RTC-only. See aomcx.h for all disabled features.")
set_aom_config_var(CONFIG_RUNTIME_CPU_DETECT 1 "Runtime CPU detection support.")
set_aom_config_var(CONFIG_SHARED 0 "Build shared libs.")
set_aom_config_var(CONFIG_WEBM_IO 1 "Enables WebM support.")
# Debugging flags.
set_aom_config_var(CONFIG_BITSTREAM_DEBUG 0 "Bitstream debugging flag.")
set_aom_config_var(CONFIG_DEBUG 0 "Debug build flag.")
set_aom_config_var(CONFIG_DEBUG 0 "Enable debug-only code.")
set_aom_config_var(CONFIG_EXCLUDE_SIMD_MISMATCH 0
"Exclude mismatch in SIMD functions for testing/debugging.")
set_aom_config_var(CONFIG_MISMATCH_DEBUG 0 "Mismatch debugging flag.")
# AV1 feature flags.
@ -102,39 +115,58 @@ set_aom_config_var(FORCE_HIGHBITDEPTH_DECODING 0
mark_as_advanced(FORCE_HIGHBITDEPTH_DECODING)
set_aom_config_var(CONFIG_MAX_DECODE_PROFILE 2
"Max profile to support decoding.")
set_aom_config_var(CONFIG_NORMAL_TILE_MODE 0 "Only enables normal tile mode.")
set_aom_config_var(
CONFIG_NORMAL_TILE_MODE 0
"Only enables general decoding (disables large scale tile decoding).")
set_aom_config_var(CONFIG_SIZE_LIMIT 0 "Limit max decode width/height.")
set_aom_config_var(CONFIG_SPATIAL_RESAMPLING 1 "Spatial resampling.")
set_aom_config_var(CONFIG_TUNE_BUTTERAUGLI 0
"Enable encoding tuning for Butteraugli.")
set_aom_config_var(CONFIG_TUNE_VMAF 0 "Enable encoding tuning for VMAF.")
set_aom_config_var(DECODE_HEIGHT_LIMIT 0 "Set limit for decode height.")
set_aom_config_var(DECODE_WIDTH_LIMIT 0 "Set limit for decode width.")
set_aom_config_var(CONFIG_TUNE_VMAF 0 "Enable encoding tuning for VMAF.")
set_aom_config_var(STATIC_LINK_JXL 0 "Statically link the JPEG-XL library.")
# AV1 experiment flags.
set_aom_config_var(CONFIG_SPEED_STATS 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_COLLECT_RD_STATS 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_DIST_8X8 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_ENTROPY_STATS 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_INTER_STATS_ONLY 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_RD_DEBUG 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_SHARP_SETTINGS 0 "AV1 experiment flag.")
set_aom_config_var(CONFIG_DISABLE_FULL_PIXEL_SPLIT_8X8 1
"Disable full_pixel_motion_search_based_split on BLOCK_8X8.")
set_aom_config_var(CONFIG_COLLECT_PARTITION_STATS 0
"Collect stats on partition decisions.")
set_aom_config_var(CONFIG_COLLECT_COMPONENT_TIMING 0
"Collect encoding component timing information.")
set_aom_config_var(CONFIG_LPF_MASK 0
"Enable the use loop filter bitmasks for optimizations.")
set_aom_config_var(CONFIG_HTB_TRELLIS 0
"Enable the use of hash table for trellis optimizations.")
set_aom_config_var(CONFIG_REALTIME_ONLY 0
"Build for RTC-only to reduce binary size.")
set_aom_config_var(CONFIG_AV1_HIGHBITDEPTH 1
"Build with high bitdepth support.")
set_aom_config_var(CONFIG_NN_V2 0 "Fully-connected neural nets ver.2.")
set_aom_config_var(CONFIG_SUPERRES_IN_RECODE 1
"Enable encoding both full-res and superres in recode loop"
"when SUPERRES_AUTO mode is used.")
set_aom_config_var(CONFIG_BITRATE_ACCURACY 0
"AV1 experiment: Improve bitrate accuracy.")
set_aom_config_var(
CONFIG_BITRATE_ACCURACY_BL 0
"AV1 experiment: Baseline of improve bitrate accuracy experiment.")
set_aom_config_var(CONFIG_BITSTREAM_DEBUG 0
"AV1 experiment: Bitstream debugging.")
set_aom_config_var(
CONFIG_COLLECT_COMPONENT_TIMING 0
"AV1 experiment: Collect encoding component timing information.")
set_aom_config_var(
CONFIG_COLLECT_PARTITION_STATS 0
"AV1 experiment: Collect partition timing stats. Can be 1 or 2.")
set_aom_config_var(CONFIG_COLLECT_RD_STATS 0 "AV1 experiment.")
set_aom_config_var(
CONFIG_DISABLE_FULL_PIXEL_SPLIT_8X8 1
"AV1 experiment: Disable full_pixel_motion_search_based_split on BLOCK_8X8.")
set_aom_config_var(CONFIG_ENTROPY_STATS 0 "AV1 experiment.")
set_aom_config_var(CONFIG_INTER_STATS_ONLY 0 "AV1 experiment.")
set_aom_config_var(CONFIG_NN_V2 0
"AV1 experiment: Fully-connected neural nets ver.2.")
set_aom_config_var(CONFIG_OPTICAL_FLOW_API 0
"AV1 experiment: for optical flow API.")
set_aom_config_var(CONFIG_PARTITION_SEARCH_ORDER 0
"AV1 experiment: Use alternative partition search order.")
set_aom_config_var(CONFIG_RATECTRL_LOG 0
"AV1 experiment: Log rate control decision.")
set_aom_config_var(CONFIG_RD_COMMAND 0
"AV1 experiment: Use external rdmult and q_index.")
set_aom_config_var(CONFIG_RD_DEBUG 0 "AV1 experiment.")
set_aom_config_var(
CONFIG_RT_ML_PARTITIONING 0
"AV1 experiment: Build with ML-based partitioning for Real Time.")
set_aom_config_var(CONFIG_SPEED_STATS 0 "AV1 experiment.")
set_aom_config_var(CONFIG_TFLITE 0
"AV1 experiment: Enable tensorflow lite library.")
set_aom_config_var(CONFIG_THREE_PASS 0
"AV1 experiment: Enable three-pass encoding.")
#
# Variables in this section control optional features of the build system.
#

105
media/libaom/src/build/cmake/aom_configure.cmake
View file

@ -44,7 +44,7 @@ endif()
list(APPEND aom_build_vars ${AOM_CONFIG_VARS} ${AOM_OPTION_VARS})
foreach(cache_var ${aom_build_vars})
get_property(cache_var_helpstring CACHE ${cache_var} PROPERTY HELPSTRING)
if("${cache_var_helpstring}" STREQUAL "${cmake_cmdline_helpstring}")
if(cache_var_helpstring STREQUAL cmake_cmdline_helpstring)
set(AOM_CMAKE_CONFIG "${AOM_CMAKE_CONFIG} -D${cache_var}=${${cache_var}}")
endif()
endforeach()
@ -53,11 +53,10 @@ string(STRIP "${AOM_CMAKE_CONFIG}" AOM_CMAKE_CONFIG)
# Detect target CPU.
if(NOT AOM_TARGET_CPU)
string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cpu_lowercase)
if("${cpu_lowercase}" STREQUAL "amd64"
OR "${cpu_lowercase}" STREQUAL "x86_64")
if(${CMAKE_SIZEOF_VOID_P} EQUAL 4)
if(cpu_lowercase STREQUAL "amd64" OR cpu_lowercase STREQUAL "x86_64")
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
set(AOM_TARGET_CPU "x86")
elseif(${CMAKE_SIZEOF_VOID_P} EQUAL 8)
elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(AOM_TARGET_CPU "x86_64")
else()
message(
@ -66,15 +65,13 @@ if(NOT AOM_TARGET_CPU)
" CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}\n"
" CMAKE_GENERATOR=${CMAKE_GENERATOR}\n")
endif()
elseif("${cpu_lowercase}" STREQUAL "i386"
OR "${cpu_lowercase}" STREQUAL "x86")
elseif(cpu_lowercase STREQUAL "i386" OR cpu_lowercase STREQUAL "x86")
set(AOM_TARGET_CPU "x86")
elseif("${cpu_lowercase}" MATCHES "^arm"
OR "${cpu_lowercase}" MATCHES "^mips")
elseif(cpu_lowercase MATCHES "^arm" OR cpu_lowercase MATCHES "^mips")
set(AOM_TARGET_CPU "${cpu_lowercase}")
elseif("${cpu_lowercase}" MATCHES "aarch64")
elseif(cpu_lowercase MATCHES "aarch64")
set(AOM_TARGET_CPU "arm64")
elseif("${cpu_lowercase}" MATCHES "^ppc")
elseif(cpu_lowercase MATCHES "^ppc")
set(AOM_TARGET_CPU "ppc")
else()
message(WARNING "The architecture ${CMAKE_SYSTEM_PROCESSOR} is not "
@ -105,13 +102,37 @@ string(STRIP "${AOM_CMAKE_CONFIG}" AOM_CMAKE_CONFIG)
message("--- aom_configure: Detected CPU: ${AOM_TARGET_CPU}")
set(AOM_TARGET_SYSTEM ${CMAKE_SYSTEM_NAME})
if("${CMAKE_BUILD_TYPE}" MATCHES "Deb")
string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lowercase)
if(build_type_lowercase STREQUAL "debug")
set(CONFIG_DEBUG 1)
endif()
if(BUILD_SHARED_LIBS)
set(CONFIG_PIC 1)
set(CONFIG_SHARED 1)
elseif(NOT CONFIG_PIC)
# Update the variable only when it does not carry the CMake assigned help
# string for variables specified via the command line. This allows the user to
# force CONFIG_PIC=0.
unset(cache_helpstring)
get_property(cache_helpstring CACHE CONFIG_PIC PROPERTY HELPSTRING)
if(NOT "${cache_helpstring}" STREQUAL "${cmake_cmdline_helpstring}")
aom_check_c_compiles("pie_check" "
#if !(__pie__ || __PIE__)
#error Neither __pie__ or __PIE__ are set
#endif
extern void unused(void);
void unused(void) {}" HAVE_PIE)
if(HAVE_PIE)
# If -fpie or -fPIE are used ensure the assembly code has PIC enabled to
# avoid DT_TEXTRELs: /usr/bin/ld: warning: creating DT_TEXTREL in a PIE
set(CONFIG_PIC 1)
message(
"CONFIG_PIC enabled for position independent executable (PIE) build")
endif()
endif()
unset(cache_helpstring)
endif()
if(NOT MSVC)
@ -120,8 +141,8 @@ if(NOT MSVC)
# TODO(tomfinegan): clang needs -pie in CMAKE_EXE_LINKER_FLAGS for this to
# work.
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
if("${AOM_TARGET_SYSTEM}" STREQUAL "Linux"
AND "${AOM_TARGET_CPU}" MATCHES "^armv[78]")
if(AOM_TARGET_SYSTEM STREQUAL "Linux"
AND AOM_TARGET_CPU MATCHES "^armv[78]")
set(AOM_AS_FLAGS ${AOM_AS_FLAGS} --defsym PIC=1)
else()
set(AOM_AS_FLAGS ${AOM_AS_FLAGS} -DPIC)
@ -129,7 +150,7 @@ if(NOT MSVC)
endif()
endif()
if("${AOM_TARGET_CPU}" STREQUAL "x86" OR "${AOM_TARGET_CPU}" STREQUAL "x86_64")
if(AOM_TARGET_CPU STREQUAL "x86" OR AOM_TARGET_CPU STREQUAL "x86_64")
find_program(AS_EXECUTABLE yasm $ENV{YASM_PATH})
if(NOT AS_EXECUTABLE OR ENABLE_NASM)
unset(AS_EXECUTABLE CACHE)
@ -149,11 +170,11 @@ if("${AOM_TARGET_CPU}" STREQUAL "x86" OR "${AOM_TARGET_CPU}" STREQUAL "x86_64")
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")
elseif(AOM_TARGET_CPU MATCHES "arm")
if(AOM_TARGET_SYSTEM STREQUAL "Darwin")
set(AS_EXECUTABLE as)
set(AOM_AS_FLAGS -arch ${AOM_TARGET_CPU} -isysroot ${CMAKE_OSX_SYSROOT})
elseif("${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
elseif(AOM_TARGET_SYSTEM STREQUAL "Windows")
if(NOT AS_EXECUTABLE)
set(AS_EXECUTABLE ${CMAKE_C_COMPILER} -c -mimplicit-it=always)
endif()
@ -197,14 +218,17 @@ if(CONFIG_GPROF)
require_compiler_flag("-pg" YES)
endif()
if("${AOM_TARGET_SYSTEM}" MATCHES "Darwin\|Linux\|Windows\|Android")
if(AOM_TARGET_SYSTEM MATCHES "Darwin\|Linux\|Windows\|Android")
set(CONFIG_OS_SUPPORT 1)
endif()
# The default _WIN32_WINNT value in MinGW is 0x0502 (Windows XP with SP2). Set
# it to 0x0601 (Windows 7).
if("${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
if(AOM_TARGET_SYSTEM STREQUAL "Windows")
# The default _WIN32_WINNT value in MinGW is 0x0502 (Windows XP with SP2). Set
# it to 0x0601 (Windows 7).
add_compiler_flag_if_supported("-D_WIN32_WINNT=0x0601")
# Prevent windows.h from defining the min and max macros. This allows us to
# use std::min and std::max.
add_compiler_flag_if_supported("-DNOMINMAX")
endif()
#
@ -276,7 +300,10 @@ else()
add_compiler_flag_if_supported("-Wall")
add_compiler_flag_if_supported("-Wdisabled-optimization")
add_compiler_flag_if_supported("-Wextra")
add_compiler_flag_if_supported("-Wextra-semi")
add_compiler_flag_if_supported("-Wextra-semi-stmt")
add_compiler_flag_if_supported("-Wfloat-conversion")
add_compiler_flag_if_supported("-Wformat=2")
add_c_flag_if_supported("-Wimplicit-function-declaration")
add_compiler_flag_if_supported("-Wlogical-op")
add_compiler_flag_if_supported("-Wpointer-arith")
@ -288,21 +315,25 @@ else()
add_compiler_flag_if_supported("-Wunused")
add_compiler_flag_if_supported("-Wvla")
if(CMAKE_C_COMPILER_ID MATCHES "GNU"
AND "${SANITIZE}" MATCHES "address|undefined")
if(CMAKE_C_COMPILER_ID MATCHES "GNU" AND SANITIZE MATCHES "address|undefined")
# This combination has more stack overhead, so we account for it by
# providing higher stack limit than usual.
add_c_flag_if_supported("-Wstack-usage=170000")
add_cxx_flag_if_supported("-Wstack-usage=270000")
elseif(CONFIG_RD_DEBUG) # Another case where higher stack usage is expected.
add_c_flag_if_supported("-Wstack-usage=117000")
add_c_flag_if_supported("-Wstack-usage=135000")
add_cxx_flag_if_supported("-Wstack-usage=240000")
else()
add_c_flag_if_supported("-Wstack-usage=100000")
add_cxx_flag_if_supported("-Wstack-usage=240000")
endif()
if(CMAKE_C_COMPILER_ID MATCHES "GNU" AND SANITIZE MATCHES "address")
# Disable no optimization warning when compiling with sanitizers
add_compiler_flag_if_supported("-Wno-disabled-optimization")
endif()
# Add -Wshadow only for C files to avoid massive gtest warning spam.
add_c_flag_if_supported("-Wshadow")
@ -311,7 +342,7 @@ else()
# Quiet gcc 6 vs 7 abi warnings:
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77728
if("${AOM_TARGET_CPU}" MATCHES "arm")
if(AOM_TARGET_CPU MATCHES "arm")
add_cxx_flag_if_supported("-Wno-psabi")
endif()
@ -319,13 +350,33 @@ else()
add_compiler_flag_if_supported("-Werror")
endif()
if("${CMAKE_BUILD_TYPE}" MATCHES "Rel")
if(build_type_lowercase 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()
# Prior to r23, or with ANDROID_USE_LEGACY_TOOLCHAIN_FILE set,
# android.toolchain.cmake would set normal (non-cache) versions of variables
# like CMAKE_C_FLAGS_RELEASE which would mask the ones added to the cache
# variable in add_compiler_flag_if_supported(), etc. As a workaround we add
# everything accumulated in AOM_C/CXX_FLAGS to the normal versions. This could
# also be addressed by reworking the flag tests and adding the results directly
# to target_compile_options() as in e.g., libgav1, but that's a larger task.
# https://github.com/android/ndk/wiki/Changelog-r23#changes
if(ANDROID
AND ("${ANDROID_NDK_MAJOR}" LESS 23 OR ANDROID_USE_LEGACY_TOOLCHAIN_FILE))
foreach(lang C;CXX)
string(STRIP "${AOM_${lang}_FLAGS}" AOM_${lang}_FLAGS)
if(AOM_${lang}_FLAGS)
foreach(config ${AOM_${lang}_CONFIGS})
set(${config} "${${config}} ${AOM_${lang}_FLAGS}")
endforeach()
endif()
endforeach()
endif()
set(AOM_LIB_LINK_TYPE PUBLIC)
if(EMSCRIPTEN)

4
media/libaom/src/build/cmake/aom_experiment_deps.cmake
View file

@ -21,8 +21,4 @@ macro(fix_experiment_configs)
change_config_and_warn(CONFIG_INSPECTION 1 CONFIG_ANALYZER)
endif()
if(CONFIG_DIST_8X8 AND CONFIG_MULTITHREAD)
change_config_and_warn(CONFIG_DIST_8X8 0 CONFIG_MULTITHREAD)
endif()
endmacro()

41
media/libaom/src/build/cmake/aom_install.cmake
View file

@ -10,8 +10,7 @@
#
list(APPEND AOM_INSTALL_INCS "${AOM_ROOT}/aom/aom.h"
"${AOM_ROOT}/aom/aom_codec.h" "${AOM_ROOT}/aom/aom_frame_buffer.h"
"${AOM_ROOT}/aom/aom_image.h" "${AOM_ROOT}/aom/aom_integer.h"
"${AOM_ROOT}/aom/aom.h")
"${AOM_ROOT}/aom/aom_image.h" "${AOM_ROOT}/aom/aom_integer.h")
if(CONFIG_AV1_DECODER)
list(APPEND AOM_INSTALL_INCS "${AOM_ROOT}/aom/aom_decoder.h"
@ -20,14 +19,15 @@ endif()
if(CONFIG_AV1_ENCODER)
list(APPEND AOM_INSTALL_INCS "${AOM_ROOT}/aom/aomcx.h"
"${AOM_ROOT}/aom/aom_encoder.h")
"${AOM_ROOT}/aom/aom_encoder.h"
"${AOM_ROOT}/aom/aom_external_partition.h")
endif()
# Generate aom.pc and setup dependencies to ensure it is created when necessary.
# Note: aom.pc generation uses GNUInstallDirs:
# https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
macro(setup_aom_install_targets)
if(NOT (MSVC OR XCODE))
if(NOT XCODE)
include("GNUInstallDirs")
set(AOM_PKG_CONFIG_FILE "${AOM_CONFIG_DIR}/aom.pc")
@ -39,14 +39,19 @@ macro(setup_aom_install_targets)
add_custom_command(
OUTPUT "${AOM_PKG_CONFIG_FILE}"
COMMAND ${CMAKE_COMMAND} ARGS
-DAOM_CONFIG_DIR=${AOM_CONFIG_DIR} -DAOM_ROOT=${AOM_ROOT}
-DAOM_CONFIG_DIR=${AOM_CONFIG_DIR}
-DAOM_ROOT=${AOM_ROOT}
-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
-DCMAKE_INSTALL_BINDIR=${CMAKE_INSTALL_BINDIR}
-DCMAKE_INSTALL_INCLUDEDIR=${CMAKE_INSTALL_INCLUDEDIR}
-DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}
-DCMAKE_PROJECT_NAME=${CMAKE_PROJECT_NAME}
-DCONFIG_MULTITHREAD=${CONFIG_MULTITHREAD}
-DHAVE_PTHREAD_H=${HAVE_PTHREAD_H} -P
-DCONFIG_TUNE_VMAF=${CONFIG_TUNE_VMAF}
-DCONFIG_TUNE_BUTTERAUGLI=${CONFIG_TUNE_BUTTERAUGLI}
-DCONFIG_TFLITE=${CONFIG_TFLITE}
-DHAVE_PTHREAD_H=${HAVE_PTHREAD_H}
-P
"${AOM_ROOT}/build/cmake/pkg_config.cmake"
COMMENT "Writing aom.pc"
VERBATIM)
@ -78,19 +83,15 @@ macro(setup_aom_install_targets)
set(AOM_INSTALL_LIBS aom)
endif()
# Setup the install rules.
install(
FILES ${AOM_INSTALL_INCS}
DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/aom")
install(
FILES "${AOM_PKG_CONFIG_FILE}"
DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
install(TARGETS ${AOM_INSTALL_LIBS} DESTINATION
"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
if(ENABLE_EXAMPLES)
install(TARGETS ${AOM_INSTALL_BINS} DESTINATION
"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
endif()
# Setup the install rules. install() will automatically prepend
# CMAKE_INSTALL_PREFIX to relative paths
install(FILES ${AOM_INSTALL_INCS}
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/aom")
install(FILES "${AOM_PKG_CONFIG_FILE}"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
install(TARGETS ${AOM_INSTALL_LIBS};${AOM_INSTALL_BINS}
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
endif()
endmacro()

84
media/libaom/src/build/cmake/aom_optimization.cmake
View file

@ -44,9 +44,10 @@ function(add_intrinsics_object_library flag opt_name target_to_update sources)
endif()
set(target_name ${target_to_update}_${opt_name}_intrinsics)
add_library(${target_name} OBJECT ${${sources}})
set_property(TARGET ${target_name} PROPERTY FOLDER ${AOM_TARGET_CPU})
if(MSVC)
get_msvc_intrinsic_flag(${flag} "flag")
get_msvc_intrinsic_flag("${flag}" "flag")
endif()
if("${flag}" STREQUAL "-mavx2")
@ -83,7 +84,7 @@ endfunction()
function(add_intrinsics_source_to_target flag target sources)
target_sources(${target} PRIVATE ${${sources}})
if(MSVC)
get_msvc_intrinsic_flag(${flag} "flag")
get_msvc_intrinsic_flag("${flag}" "flag")
endif()
if(flag)
foreach(source ${${sources}})
@ -100,6 +101,7 @@ function(get_asm_obj_format out_format)
if("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
set(objformat "macho64")
elseif("${AOM_TARGET_SYSTEM}" STREQUAL "MSYS"
OR "${AOM_TARGET_SYSTEM}" STREQUAL "CYGWIN"
OR "${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
set(objformat "win64")
else()
@ -109,6 +111,7 @@ function(get_asm_obj_format out_format)
if("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
set(objformat "macho32")
elseif("${AOM_TARGET_SYSTEM}" STREQUAL "MSYS"
OR "${AOM_TARGET_SYSTEM}" STREQUAL "CYGWIN"
OR "${AOM_TARGET_SYSTEM}" STREQUAL "Windows")
set(objformat "win32")
else()
@ -127,46 +130,59 @@ endfunction()
# into the aom library target(s). 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.
#
# In shared library configs every step described above happens twice, and
# directory/target/object names are updated to include _shared and _static
# suffixes.
function(add_asm_library lib_name asm_sources)
if("${${asm_sources}}" STREQUAL "")
return()
endif()
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}")
list(APPEND asm_configs "static")
if(BUILD_SHARED_LIBS)
list(APPEND asm_configs "shared")
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(aom PRIVATE "${asm_object}")
if(BUILD_SHARED_LIBS)
target_sources(aom_static PRIVATE "${asm_object}")
foreach(asm_config ${asm_configs})
set(asm_lib_name ${lib_name}_${asm_config})
set(asm_lib_obj_dir "${AOM_CONFIG_DIR}/asm_objects/${asm_lib_name}")
if(NOT EXISTS "${asm_lib_obj_dir}")
file(MAKE_DIRECTORY "${asm_lib_obj_dir}")
endif()
add_library(${asm_lib_name} STATIC ${${asm_sources}})
set_property(TARGET ${asm_lib_name} PROPERTY FOLDER ${AOM_TARGET_CPU})
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)
if(BUILD_SHARED_LIBS AND "${asm_config}" STREQUAL "static")
target_sources(aom_static PRIVATE "${asm_object}")
else()
target_sources(aom PRIVATE "${asm_object}")
endif()
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).
add_dummy_source_file_to_target("${asm_lib_name}" "c")
# Add the new lib target to the global list of aom library targets.
list(APPEND AOM_LIB_TARGETS ${asm_lib_name})
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).
add_dummy_source_file_to_target("${lib_name}" "c")
# 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()
@ -236,5 +252,5 @@ function(add_rtcd_build_step config output source symbol)
WORKING_DIRECTORY ${AOM_CONFIG_DIR}
VERBATIM)
set_property(SOURCE ${source} PROPERTY OBJECT_DEPENDS ${output})
set_property(SOURCE ${output} PROPERTY GENERATED)
set_property(SOURCE ${output} PROPERTY GENERATED TRUE)
endfunction()

12
media/libaom/src/build/cmake/compiler_flags.cmake
View file

@ -59,6 +59,12 @@ function(add_c_flag_if_supported c_flag)
return()
endif()
# Between 3.17.0 and 3.18.2 check_c_compiler_flag() sets a normal variable at
# parent scope while check_cxx_source_compiles() continues to set an internal
# cache variable, so we unset both to avoid the failure / success state
# persisting between checks. See
# https://gitlab.kitware.com/cmake/cmake/-/issues/21207.
unset(C_FLAG_SUPPORTED)
unset(C_FLAG_SUPPORTED CACHE)
message("Checking C compiler flag support for: " ${c_flag})
check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED)
@ -89,6 +95,12 @@ function(add_cxx_flag_if_supported cxx_flag)
return()
endif()
# Between 3.17.0 and 3.18.2 check_cxx_compiler_flag() sets a normal variable
# at parent scope while check_cxx_source_compiles() continues to set an
# internal cache variable, so we unset both to avoid the failure / success
# state persisting between checks. See
# https://gitlab.kitware.com/cmake/cmake/-/issues/21207.
unset(CXX_FLAG_SUPPORTED)
unset(CXX_FLAG_SUPPORTED CACHE)
message("Checking C++ compiler flag support for: " ${cxx_flag})
check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED)

48
media/libaom/src/build/cmake/exports.cmake
View file

@ -17,9 +17,9 @@ include("${AOM_ROOT}/build/cmake/exports_sources.cmake")
# Creates the custom target which handles generation of the symbol export lists.
function(setup_exports_target)
if("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
if(APPLE)
set(symbol_file_ext "syms")
elseif("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS" AND MSVC)
elseif(WIN32)
set(symbol_file_ext "def")
else()
set(symbol_file_ext "ver")
@ -27,23 +27,25 @@ function(setup_exports_target)
set(aom_sym_file "${AOM_CONFIG_DIR}/libaom.${symbol_file_ext}")
add_custom_target(generate_exports
COMMAND ${CMAKE_COMMAND}
-DAOM_ROOT="${AOM_ROOT}"
-DAOM_CONFIG_DIR="${AOM_CONFIG_DIR}"
-DAOM_TARGET_SYSTEM=${AOM_TARGET_SYSTEM}
-DAOM_SYM_FILE="${aom_sym_file}"
-DAOM_MSVC=${MSVC}
-DAOM_XCODE=${XCODE}
-DCONFIG_NAME=$<CONFIG>
-DCONFIG_AV1_DECODER=${CONFIG_AV1_DECODER}
-DCONFIG_AV1_ENCODER=${CONFIG_AV1_ENCODER}
-DCONFIG_INSPECTION=${CONFIG_INSPECTION}
-DENABLE_TESTS=${ENABLE_TESTS}
-P
"${AOM_ROOT}/build/cmake/generate_exports.cmake"
SOURCES ${AOM_EXPORTS_SOURCES}
DEPENDS ${AOM_EXPORTS_SOURCES})
add_custom_target(
generate_exports
COMMAND ${CMAKE_COMMAND}
-DAOM_ROOT="${AOM_ROOT}"
-DAOM_CONFIG_DIR="${AOM_CONFIG_DIR}"
-DAOM_TARGET_SYSTEM=${AOM_TARGET_SYSTEM}
-DAOM_SYM_FILE="${aom_sym_file}"
-DAOM_MSVC=${MSVC}
-DAOM_XCODE=${XCODE}
-DCMAKE_SHARED_LIBRARY_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}"
-DCONFIG_NAME=$<CONFIG>
-DCONFIG_AV1_DECODER=${CONFIG_AV1_DECODER}
-DCONFIG_AV1_ENCODER=${CONFIG_AV1_ENCODER}
-DCONFIG_INSPECTION=${CONFIG_INSPECTION}
-DENABLE_TESTS=${ENABLE_TESTS}
-P
"${AOM_ROOT}/build/cmake/generate_exports.cmake"
SOURCES ${AOM_EXPORTS_SOURCES}
DEPENDS ${AOM_EXPORTS_SOURCES} BYPRODUCTS ${aom_sym_file})
# Make libaom depend on the exports file, and set flags to pick it up when
# creating the dylib.
@ -54,14 +56,12 @@ function(setup_exports_target)
APPEND_STRING
PROPERTY LINK_FLAGS "-exported_symbols_list ${aom_sym_file}")
elseif(WIN32)
if(NOT MSVC)
set_property(TARGET aom
APPEND_STRING
PROPERTY LINK_FLAGS "-Wl,--version-script ${aom_sym_file}")
else()
if(MSVC)
set_property(TARGET aom
APPEND_STRING
PROPERTY LINK_FLAGS "/DEF:${aom_sym_file}")
else()
target_sources(aom PRIVATE "${aom_sym_file}")
endif()
# TODO(tomfinegan): Sort out the import lib situation and flags for MSVC.

13
media/libaom/src/build/cmake/generate_exports.cmake
View file

@ -10,6 +10,7 @@
#
cmake_minimum_required(VERSION 3.5)
# CMAKE_SHARED_LIBRARY_PREFIX can be empty
set(REQUIRED_ARGS "AOM_ROOT" "AOM_CONFIG_DIR" "AOM_TARGET_SYSTEM" "AOM_SYM_FILE"
"CONFIG_AV1_DECODER" "CONFIG_AV1_ENCODER")
@ -23,8 +24,9 @@ include("${AOM_ROOT}/build/cmake/exports_sources.cmake")
if("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
set(symbol_prefix "_")
elseif("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS" AND AOM_MSVC)
file(WRITE "${AOM_SYM_FILE}" "LIBRARY aom\n" "EXPORTS\n")
elseif("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS")
file(WRITE "${AOM_SYM_FILE}" "LIBRARY ${CMAKE_SHARED_LIBRARY_PREFIX}aom\n"
"EXPORTS\n")
else()
set(symbol_suffix ";")
endif()
@ -33,8 +35,9 @@ set(aom_sym_file "${AOM_SYM_FILE}")
if("${AOM_TARGET_SYSTEM}" STREQUAL "Darwin")
file(REMOVE "${aom_sym_file}")
elseif("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS" AND AOM_MSVC)
file(WRITE "${aom_sym_file}" "LIBRARY aom\n" "EXPORTS\n")
elseif("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS")
file(WRITE "${aom_sym_file}" "LIBRARY ${CMAKE_SHARED_LIBRARY_PREFIX}aom\n"
"EXPORTS\n")
else()
file(WRITE "${aom_sym_file}" "{\nglobal:\n")
endif()
@ -47,7 +50,7 @@ endforeach()
foreach(exported_symbol ${exported_symbols})
string(STRIP "${exported_symbol}" exported_symbol)
if("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS" AND AOM_MSVC)
if("${AOM_TARGET_SYSTEM}" MATCHES "Windows\|MSYS")
string(SUBSTRING ${exported_symbol} 0 4 export_type)
string(COMPARE EQUAL "${export_type}" "data" is_data)
if(is_data)

37
media/libaom/src/build/cmake/ios-Info.plist
View file

@ -1,37 +0,0 @@
<?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>

384
media/libaom/src/build/cmake/iosbuild.sh
View file

@ -1,384 +0,0 @@
#!/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}"
# TODO(tomfinegan@google.com): switch to cmake.
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 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}

37
media/libaom/src/build/cmake/msvc_runtime.cmake
View file

@ -1,37 +0,0 @@
#
# 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_BUILD_CMAKE_MSVC_RUNTIME_CMAKE_)
return()
endif() # AOM_BUILD_CMAKE_MSVC_RUNTIME_CMAKE_
set(AOM_BUILD_CMAKE_MSVC_RUNTIME_CMAKE_ 1)
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()

10
media/libaom/src/build/cmake/pkg_config.cmake
View file

@ -51,8 +51,14 @@ file(
APPEND "${pkgconfig_file}"
"Description: Alliance for Open Media AV1 codec library v${aom_version}.\n")
file(APPEND "${pkgconfig_file}" "Version: ${package_version}\n")
file(APPEND "${pkgconfig_file}" "Requires:\n")
file(APPEND "${pkgconfig_file}" "Conflicts:\n")
file(APPEND "${pkgconfig_file}" "Requires:")
if(CONFIG_TUNE_VMAF)
file(APPEND "${pkgconfig_file}" " libvmaf")
endif()
if(CONFIG_TUNE_BUTTERAUGLI)
file(APPEND "${pkgconfig_file}" " libjxl")
endif()
file(APPEND "${pkgconfig_file}" "\nConflicts:\n")
file(APPEND "${pkgconfig_file}" "Libs: -L\${libdir} -l${pkg_name}\n")
if(CONFIG_MULTITHREAD AND HAVE_PTHREAD_H)
file(APPEND "${pkgconfig_file}" "Libs.private: -lm -lpthread\n")

4
media/libaom/src/build/cmake/rtcd.pl Normal file → Executable file
View file

@ -91,7 +91,9 @@ sub specialize {
sub add_proto {
my $fn = splice(@_, -2, 1);
$ALL_FUNCS{$fn} = \@_;
my @proto = @_;
foreach (@proto) { tr/\t/ / }
$ALL_FUNCS{$fn} = \@proto;
specialize $fn, "c";
}

27
media/libaom/src/build/cmake/toolchains/arm64-android-clang.cmake → media/libaom/src/build/cmake/toolchains/android.cmake
View file

@ -8,21 +8,22 @@
# 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_BUILD_CMAKE_TOOLCHAINS_ARM64_ANDROID_CLANG_CMAKE_)
if(AOM_BUILD_CMAKE_TOOLCHAINS_ANDROID_CMAKE_)
return()
endif() # AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_ANDROID_CLANG_CMAKE_
set(AOM_BUILD_CMAKE_TOOLCHAINS_ARM64_ANDROID_CLANG_CMAKE_ 1)
endif() # AOM_BUILD_CMAKE_TOOLCHAINS_ANDROID_CMAKE_
set(AOM_BUILD_CMAKE_TOOLCHAINS_ANDROID_CMAKE_ 1)
if(NOT ANDROID_PLATFORM)
set(ANDROID_PLATFORM android-21)
set(ANDROID_PLATFORM android-24)
endif()
# Choose target architecture with:
#
# -DANDROID_ABI={armeabi-v7a,armeabi-v7a with NEON,arm64-v8a,x86,x86_64}
if(NOT ANDROID_ABI)
set(ANDROID_ABI arm64-v8a)
endif()
set(AS_EXECUTABLE as)
# Toolchain files don't have access to cached variables:
# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
# environment variable when loaded the first time.
@ -39,10 +40,16 @@ endif()
include("${AOM_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
# No intrinsics flag required for arm64-android-clang.
set(AOM_NEON_INTRIN_FLAG "")
if(ANDROID_ABI MATCHES "^armeabi")
set(AOM_NEON_INTRIN_FLAG "-mfpu=neon")
endif()
# No runtime cpu detect for arm64-android-clang.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE STRING "")
if(ANDROID_ABI MATCHES "^arm")
set(AS_EXECUTABLE as)
# No runtime cpu detect for arm targets.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE STRING "")
elseif(ANDROID_ABI MATCHES "^x86")
set(AS_EXECUTABLE yasm)
endif()
set(CMAKE_SYSTEM_NAME "Android")

5
media/libaom/src/build/cmake/toolchains/arm-ios-common.cmake
View file

@ -16,9 +16,10 @@ 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_C_FLAGS_INIT "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_FLAGS_INIT "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-arch ${CMAKE_SYSTEM_PROCESSOR}")
# No runtime cpu detect for arm*-ios targets.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE STRING "")

4
media/libaom/src/build/cmake/toolchains/arm64-linux-gcc.cmake
View file

@ -24,8 +24,8 @@ 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(CMAKE_C_FLAGS_INIT "-march=armv8-a")
set(CMAKE_CXX_FLAGS_INIT "-march=armv8-a")
set(AOM_AS_FLAGS "-march=armv8-a")
set(CMAKE_SYSTEM_PROCESSOR "arm64")

8
media/libaom/src/build/cmake/toolchains/armv7-linux-gcc.cmake
View file

@ -28,13 +28,15 @@ 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 ${AOM_EXTRA_TOOLCHAIN_FLAGS}")
set(CMAKE_CXX_COMPILER_ARG1 "-march=armv7-a ${AOM_EXTRA_TOOLCHAIN_FLAGS}")
set(CMAKE_C_FLAGS_INIT "-march=armv7-a -mfpu=vfpv3 \
${AOM_EXTRA_TOOLCHAIN_FLAGS}")
set(CMAKE_CXX_FLAGS_INIT "-march=armv7-a -mfpu=vfpv3 \
${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")
set(AOM_NEON_INTRIN_FLAG "-mfpu=neon")
set(AOM_NEON_INTRIN_FLAG "-mfpu=neon ${AOM_EXTRA_TOOLCHAIN_FLAGS}")
# No runtime cpu detect for armv7-linux-gcc.
set(CONFIG_RUNTIME_CPU_DETECT 0 CACHE STRING "")

5
media/libaom/src/build/cmake/toolchains/ios-simulator-common.cmake
View file

@ -16,8 +16,9 @@ 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_C_FLAGS_INIT "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_FLAGS_INIT "-arch ${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-arch ${CMAKE_SYSTEM_PROCESSOR}")
# TODO(tomfinegan): Handle bit code embedding.

5
media/libaom/src/build/cmake/toolchains/mips32-linux-gcc.cmake
View file

@ -65,8 +65,9 @@ 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_C_FLAGS_INIT "-EL ${MIPS_CFLAGS}")
set(CMAKE_CXX_FLAGS_INIT "-EL ${MIPS_CXXFLAGS}")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-EL ${MIPS_CXXFLAGS}")
set(CMAKE_SYSTEM_PROCESSOR "mips32")
# No runtime cpu detect for mips32-linux-gcc.

5
media/libaom/src/build/cmake/toolchains/mips64-linux-gcc.cmake
View file

@ -42,8 +42,9 @@ 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_C_FLAGS_INIT "-EL ${MIPS_CFLAGS}")
set(CMAKE_CXX_FLAGS_INIT "-EL ${MIPS_CXXFLAGS}")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-EL ${MIPS_CXXFLAGS}")
set(CMAKE_SYSTEM_PROCESSOR "mips64")
# No runtime cpu detect for mips64-linux-gcc.

5
media/libaom/src/build/cmake/toolchains/x86-linux.cmake
View file

@ -15,5 +15,6 @@ set(AOM_BUILD_CMAKE_TOOLCHAINS_X86_LINUX_CMAKE_ 1)
set(CMAKE_SYSTEM_PROCESSOR "x86")
set(CMAKE_SYSTEM_NAME "Linux")
set(CMAKE_C_COMPILER_ARG1 "-m32")
set(CMAKE_CXX_COMPILER_ARG1 "-m32")
set(CMAKE_C_FLAGS_INIT "-m32")
set(CMAKE_CXX_FLAGS_INIT "-m32")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-m32")

5
media/libaom/src/build/cmake/toolchains/x86-macos.cmake
View file

@ -11,8 +11,9 @@
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")
set(CMAKE_C_FLAGS_INIT "-arch i386")
set(CMAKE_CXX_FLAGS_INIT "-arch i386")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-arch i386")
# Apple tools always complain in 32 bit mode without PIC.
set(CONFIG_PIC 1 CACHE STRING "")

5
media/libaom/src/build/cmake/toolchains/x86-mingw-gcc.cmake
View file

@ -15,8 +15,9 @@ set(AOM_BUILD_CMAKE_TOOLCHAINS_X86_MINGW_GCC_CMAKE_ 1)
set(CMAKE_SYSTEM_PROCESSOR "x86")
set(CMAKE_SYSTEM_NAME "Windows")
set(CMAKE_C_COMPILER_ARG1 "-m32")
set(CMAKE_CXX_COMPILER_ARG1 "-m32")
set(CMAKE_C_FLAGS_INIT "-m32")
set(CMAKE_CXX_FLAGS_INIT "-m32")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-m32")
if("${CROSS}" STREQUAL "")
set(CROSS i686-w64-mingw32-)

4
media/libaom/src/build/cmake/version.cmake
View file

@ -24,7 +24,9 @@ include("${AOM_ROOT}/build/cmake/util.cmake")
# Generate the version string for this run.
unset(aom_version)
if(EXISTS "${GIT_EXECUTABLE}")
execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${AOM_ROOT}/.git describe
execute_process(COMMAND ${GIT_EXECUTABLE}
--git-dir=${AOM_ROOT}/.git describe
--match=v[0-9]*
OUTPUT_VARIABLE aom_version
ERROR_QUIET
RESULT_VARIABLE version_check_result)

4
media/libaom/src/build/cmake/version.pl Normal file → Executable file
View file

@ -62,7 +62,9 @@ my $version_patch = $version_components[2];
my $version_extra = "";
if (length($git_desc) > 0) {
my @git_desc_components = split('-', $git_desc, 2);
$version_extra = $git_desc_components[1];
if (@git_desc_components > 1) {
$version_extra = $git_desc_components[1];
}
}
open(my $version_file, '>', $version_filename) or