diff --git a/ports/avisynthplus/add-include-chrono.patch b/ports/avisynthplus/add-include-chrono.patch deleted file mode 100644 index 6c24a91607..0000000000 --- a/ports/avisynthplus/add-include-chrono.patch +++ /dev/null @@ -1,24 +0,0 @@ -diff --git a/avs_core/core/avisynth.cpp b/avs_core/core/avisynth.cpp -index c66d39e..5bc61a3 100644 ---- a/avs_core/core/avisynth.cpp -+++ b/avs_core/core/avisynth.cpp -@@ -45,6 +45,7 @@ - #include "FilterConstructor.h" - #include "PluginManager.h" - #include "MappedList.h" -+#include - #include - #include - #include -diff --git a/avs_core/core/cache.cpp b/avs_core/core/cache.cpp -index 76eb7cf..957e102 100644 ---- a/avs_core/core/cache.cpp -+++ b/avs_core/core/cache.cpp -@@ -38,6 +38,7 @@ - #include "InternalEnvironment.h" - #include "DeviceManager.h" - #include -+#include - #include - - #ifdef X86_32 diff --git a/ports/avisynthplus/backport_409369a.patch b/ports/avisynthplus/backport_409369a.patch new file mode 100644 index 0000000000..4594dd37dd --- /dev/null +++ b/ports/avisynthplus/backport_409369a.patch @@ -0,0 +1,600 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 75894c35..7a29d141 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -52,12 +52,15 @@ CMAKE_MINIMUM_REQUIRED( VERSION 3.6.2...3.11 ) + + # Get PROJECT_VERSION property from 'avs_core/core/version.h.in' + file(READ "avs_core/core/version.h.in" versioning) +-string(REGEX MATCH "AVS_MAJOR_VER ([0-9]*)" _ ${versioning}) ++ ++string(REGEX MATCH "AVS_MAJOR_VER[ \\t]+([0-9]*)" _ ${versioning}) + set(version_major ${CMAKE_MATCH_1}) +-string(REGEX MATCH "AVS_MINOR_VER ([0-9]*)" _ ${versioning}) ++string(REGEX MATCH "AVS_MINOR_VER[ \\t]+([0-9]*)" _ ${versioning}) + set(version_minor ${CMAKE_MATCH_1}) +-string(REGEX MATCH "AVS_BUGFIX_VER ([0-9]*)" _ ${versioning}) ++string(REGEX MATCH "AVS_BUGFIX_VER[ \\t]+([0-9]*)" _ ${versioning}) + set(version_bugfix ${CMAKE_MATCH_1}) ++# Combine version variables for use in the project command ++set(PROJECT_VERSION_STRING "${version_major}.${version_minor}.${version_bugfix}") + + # Get AVISYNTH_INTERFACE_VERSION from avs_core/include/avisynth.h + file(READ "avs_core/include/avisynth.h" versioning) +@@ -76,7 +79,7 @@ endif() + + if(NOT HEADERS_ONLY) + +- project("AviSynth+" VERSION ${version_major}.${version_minor}.${version_bugfix} LANGUAGES CXX) ++ project("AviSynth+" VERSION ${PROJECT_VERSION_STRING} LANGUAGES CXX) + + # message("Compiler ID: ${CMAKE_CXX_COMPILER_ID} ") + +@@ -88,72 +91,132 @@ if(NOT HEADERS_ONLY) + set(CMAKE_CXX_STANDARD_LIBRARIES "" CACHE STRING "" FORCE) + + # We require C++17 or higher. +-if(CMAKE_VERSION VERSION_GREATER 3.7) +- set(CMAKE_CXX_STANDARD 17) +- set(CMAKE_CXX_STANDARD_REQUIRED TRUE) +- set(CMAKE_CXX_EXTENSIONS FALSE) +-endif() ++ if(CMAKE_VERSION VERSION_GREATER 3.7) ++ set(CMAKE_CXX_STANDARD 17) ++ set(CMAKE_CXX_STANDARD_REQUIRED TRUE) ++ set(CMAKE_CXX_EXTENSIONS FALSE) ++ endif() + + # Detect Intel processors and turn Intel SIMD on or off automatically. +- message("-- Detected target processor as: ${CMAKE_SYSTEM_PROCESSOR}") +- string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" ARCHID) +- if( ("${ARCHID}" STREQUAL "x86") OR +- ("${ARCHID}" STREQUAL "x64") OR +- ("${ARCHID}" STREQUAL "i686") OR +- ("${ARCHID}" STREQUAL "amd64") OR +- ("${ARCHID}" STREQUAL "x86_64") ) +- set(INTEL_SIMD "ON") ++ # Old logic relied on the host processor: ${CMAKE_SYSTEM_PROCESSOR} ++ ++ set(INTEL_SIMD "OFF") ++ # Use a list of known Intel-compatible architecture names for the default ON state. ++ set(INTEL_ARCH_NAMES "win32" "x64" "x86" "i386" "amd64" "x86_64" "i686") ++ ++ # Check the TARGET architecture using the most reliable variables (CMAKE_GENERATOR_PLATFORM and PLATFORMID_LOWER) ++ string(TOLOWER "${PLATFORMID}" PLATFORMID_LOWER) ++ string(TOLOWER "${CMAKE_GENERATOR_PLATFORM}" GEN_PLATFORM_LOWER) # Often holds x64, ARM64, etc. ++ string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" HOST_ARCH_LOWER) ++ ++ # --- DEBUG OUTPUT START --- ++ # message(STATUS "--- SIMD Detection Variables ---") ++ # message(STATUS "CMAKE_SYSTEM_PROCESSOR (Host Arch): ${CMAKE_SYSTEM_PROCESSOR}") ++ # message(STATUS "Host Arch Lower: ${HOST_ARCH_LOWER}") ++ # message(STATUS "PLATFORMID_LOWER (VS Target Platform): ${PLATFORMID_LOWER}") ++ # message(STATUS "CMAKE_GENERATOR_PLATFORM (Generator Target): ${CMAKE_GENERATOR_PLATFORM}") ++ # message(STATUS "INTEL_ARCH_NAMES: ${INTEL_ARCH_NAMES}") ++ # message(STATUS "------------------------------------") ++ # --- DEBUG OUTPUT END --- ++ # e.g. ARM64 cross-compile on x64 machine: ++ # CMAKE_SYSTEM_PROCESSOR (Host Arch): AMD64 ++ # Host Arch Lower: amd64 ++ # PLATFORMID_LOWER (VS Target Platform): ++ # CMAKE_GENERATOR_PLATFORM (Generator Target): ARM64 ++ ++ list(FIND INTEL_ARCH_NAMES "${HOST_ARCH_LOWER}" _found_arch) ++ list(FIND INTEL_ARCH_NAMES "${PLATFORMID_LOWER}" _found_target_platform_id) ++ list(FIND INTEL_ARCH_NAMES "${GEN_PLATFORM_LOWER}" _found_target_gen) ++ ++ # 1. Check if the target platform is explicitly known non-Intel (ARM64, AARCH64) ++ if("${PLATFORMID_LOWER}" STREQUAL "arm64" OR "${GEN_PLATFORM_LOWER}" STREQUAL "arm64") ++ set(INTEL_SIMD "OFF") ++ message(STATUS "Target is ARM64/AARCH64, INTEL_SIMD forced OFF.") + else() +- set(INTEL_SIMD "OFF") ++ # 2. Inclusion Check: We are NOT targeting ARM64. ++ ++ # Define a boolean check: Did we find a match in the explicit target variables OR the host architecture? ++ if(_found_target_gen GREATER -1 OR _found_target_platform_id GREATER -1) ++ # Found a match in a generator-set variable (e.g., Win32, x64 when explicitly chosen) ++ set(INTEL_SIMD "ON") ++ message(STATUS "Target architecture is explicitly set and Intel-compatible, INTEL_SIMD set ON.") ++ elseif(_found_arch GREATER -1 AND "${GEN_PLATFORM_LOWER}" STREQUAL "") ++ # FALLBACK: Target platform is NOT set (Default Configuration), but the Host is Intel-compatible. ++ # The default target platform for a multi-config generator on a bare x64 host is x64. ++ set(INTEL_SIMD "ON") ++ message(STATUS "Target platform not specified; defaulting to Host (${CMAKE_SYSTEM_PROCESSOR}), INTEL_SIMD set ON.") ++ endif() + endif() ++ # message(STATUS "Final INTEL_SIMD initial assumption: ${INTEL_SIMD}") ++ option(ENABLE_INTEL_SIMD "Enable SIMD intrinsics for Intel processors" "${INTEL_SIMD}") + + option(ENABLE_PLUGINS "Build set of default external plugins" ON) +- option(ENABLE_INTEL_SIMD "Enable SIMD intrinsics for Intel processors" "${INTEL_SIMD}") + set(USER_AVS_PLUGINDIR_LOCATION ".local/lib/avisynth" CACHE STRING "Override path for user-local plugins, with $HOME omitted (default: .local/lib/avisynth)") + option(ENABLE_CUDA "Enable CUDA support" OFF) + set(CORE_PLUGIN_INSTALL_PATH "${CMAKE_INSTALL_FULL_LIBDIR}" CACHE STRING "Set system plugin install parent directory (default: value of CMAKE_INSTALL_FULL_LIBDIR)") + +-if(CMAKE_VERSION VERSION_GREATER 3.9) +- get_cmake_property(MULTI_CONFIG GENERATOR_IS_MULTI_CONFIG) +- if(MULTI_CONFIG) +- if(CMAKE_CONFIGURATION_TYPES) +- set(CMAKE_CONFIGURATION_TYPES Debug Release RelWithDebInfo) +- set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING "Reset the configurations to what we need" FORCE) +- endif() +- message("-- Build type: Multi-configuration (${CMAKE_CONFIGURATION_TYPES})") +- else() +- # When CMAKE_BUILD_TYPE is not defined, CMake defaults to a simple -O0 configuration, no compiler optimizations +- # and no debug symbols. For single-configuration generators (Makefiles, Ninja, etc.) we can make Release the +- # assumed default if it isn't explicitly set by the user. Multi-config generators like Visual Studio ignore +- # CMAKE_BUILD_TYPE. +- +- # Unfortunately, this is not visible in CMakeCache, but it can be seen to take effect in build.ninja or running +- # make with VERBOSE=1 adding the appropriate Release flags. +- if(NOT CMAKE_BUILD_TYPE) +- set(CMAKE_BUILD_TYPE "Release") ++ if(CMAKE_VERSION VERSION_GREATER 3.9) ++ get_cmake_property(MULTI_CONFIG GENERATOR_IS_MULTI_CONFIG) ++ if(MULTI_CONFIG) ++ if(CMAKE_CONFIGURATION_TYPES) ++ set(CMAKE_CONFIGURATION_TYPES Debug Release RelWithDebInfo) ++ set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING "Reset the configurations to what we need" FORCE) ++ endif() ++ message("-- Build type: Multi-configuration (${CMAKE_CONFIGURATION_TYPES})") ++ else() ++ # When CMAKE_BUILD_TYPE is not defined, CMake defaults to a simple -O0 configuration, no compiler optimizations ++ # and no debug symbols. For single-configuration generators (Makefiles, Ninja, etc.) we can make Release the ++ # assumed default if it isn't explicitly set by the user. Multi-config generators like Visual Studio ignore ++ # CMAKE_BUILD_TYPE. ++ ++ # Unfortunately, this is not visible in CMakeCache, but it can be seen to take effect in build.ninja or running ++ # make with VERBOSE=1 adding the appropriate Release flags. ++ if(NOT CMAKE_BUILD_TYPE) ++ set(CMAKE_BUILD_TYPE "Release") ++ endif() ++ message("-- Build type: ${CMAKE_BUILD_TYPE}") + endif() +- message("-- Build type: ${CMAKE_BUILD_TYPE}") + endif() +-endif() + +- IF( MSVC ) # Check for Visual Studio ++ # Use this one to be safe: ++ # Check for the Visual Studio generator, not the MSVC compiler ID, as this ++ # block configures VS project structure (platforms/toolsets), which fails for Ninja/MSVC. ++ if( CMAKE_GENERATOR MATCHES "Visual Studio" ) ++ ## IF( MSVC ) # Check for Visual Studio + + #1910-1919 = VS 15.0 (v141 toolset) Visual Studio 2017 + #1920-1929 = VS 16.0 (v142 toolset) Visual Studio 2019 +- #1930-1939 = VS 17.0 (v143 toolset) Visual Studio 2022 +- ++ #1930-1949 = VS 17.x (v143 toolset) Visual Studio 2022 ++ # ( 1940-1949 = VS v17.10+: Toolset v143 (Still!) | Compiler 19.4x) ++ #1950-1959 = VS 18.0 (v145 toolset) Visual Studio 2026 ++ + # detect if the target is for x86 +- string(TOLOWER "${CMAKE_VS_PLATFORM_NAME}" PLATFORMID) +- if(("${PLATFORMID}" STREQUAL "win32") OR +- ("${PLATFORMID}" STREQUAL "x64" )) +- set(NON_X86_PLATFORM "OFF") ++ # PLATFORMID_LOWER is just a lowercase copy of CMAKE_VS_PLATFORM_NAME ++ string(TOLOWER "${CMAKE_VS_PLATFORM_NAME}" PLATFORMID_LOWER) ++ ++ # message("-- PLATFORMID_LOWER: ${PLATFORMID_LOWER}") ++ ++ if(("${PLATFORMID_LOWER}" STREQUAL "win32") OR ++ ("${PLATFORMID_LOWER}" STREQUAL "x64") OR ++ ("${PLATFORMID_LOWER}" STREQUAL "arm64")) # allow arm64 targets ++ set(SUPPORTED_MSVC_PLATFORM "ON") + else() +- set(NON_X86_PLATFORM "ON") ++ set(SUPPORTED_MSVC_PLATFORM "OFF") ++ endif() ++ ++ if(SUPPORTED_MSVC_PLATFORM STREQUAL "OFF") ++ message(FATAL_ERROR "MSVC/ClangCL only supported on Win32, x64, or ARM64 targets. Use MinGW (llvm-mingw or gcc). Unsupported target: ${CMAKE_VS_PLATFORM_NAME}.") + endif() + +- if(NON_X86_PLATFORM) +- message(FATAL_ERROR "MSVC/ClangCL only supported on x86(-64). Use MinGW (llvm-mingw or gcc).") ++#[[ ++ # check to disable ARM64 by default ++ # PF: re-allowed; VS2026 can build ARM64 even with LLVM ++ if(("${PLATFORMID_LOWER}" STREQUAL "arm64") AND (NOT DEFINED ENABLE_ARM64_WITH_MSVC_TESTING)) ++ # This FATAL_ERROR can be commented out or protected by the ENABLE_ARM64_TESTING cache variable. ++ # To enable the build, define -DENABLE_ARM64_TESTING=ON when running cmake. ++ message(FATAL_ERROR "MSVC ARM64 platform is currently disabled by default. Define ENABLE_ARM64_WITH_MSVC_TESTING=ON to proceed or use MinGW (llvm-mingw or gcc).") + endif() ++#]] + + IF( MSVC_VERSION VERSION_LESS 1910 ) + MESSAGE(FATAL_ERROR "Visual C++ 2017 or newer required.") +@@ -163,10 +226,6 @@ endif() + file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/Output/system") + file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/Output/c_api") + +- # Needed to properly handle __has_include() in avs_core/filesystem.h +- # See note in filesystem/README.md +- add_definitions("/Zc:__cplusplus") +- + IF(MSVC_IDE) + message("MSVC_IDE support found, reported CMAKE_GENERATOR_TOOLSET is: ${CMAKE_GENERATOR_TOOLSET}") + string( TOLOWER "${CMAKE_GENERATOR_TOOLSET}" cmake_gentoolset_lower) +@@ -195,7 +254,7 @@ endif() + endif() + set(CLANG_IN_VS "1") + ELSEIF(cmake_gentoolset_lower STREQUAL "v141_clang_c2") +- #1900 is reported ++ #1900 is reported + message("v141_clang_c2 toolset was specified via -T. Reported MSVC_VERSION is: ${MSVC_VERSION}") + message("May not work, try clangcl or LLVM") + set(CLANG_IN_VS "1") +@@ -207,25 +266,15 @@ endif() + if(WINXP_SUPPORT) + # We want our project to also run on Windows XP + # Not for LLVM: Clang stopped XP support in 2016 +- # 1900 (VS2015) is not supported but we leave here +- IF(MSVC_VERSION VERSION_LESS 1910 ) +- IF(NOT CLANG_IN_VS STREQUAL "1") +- set(CMAKE_GENERATOR_TOOLSET "v140_xp" CACHE STRING "The compiler toolset to use for Visual Studio." FORCE) # VS2015 +- # https://connect.microsoft.com/VisualStudio/feedback/details/1789709/visual-c-2015-runtime-broken-on-windows-server-2003-c-11-magic-statics +- message("CMAKE_GENERATOR_TOOLSET is forced to: ${CMAKE_GENERATOR_TOOLSET}") +- add_definitions("/Zc:threadSafeInit-") +- ENDIF() +- ELSE() +- IF(NOT CLANG_IN_VS STREQUAL "1") +- # Setting CMAKE_GENERATOR_TOOLSET here has no effect, only when passed (-T option) or set directly, so we just check it +- IF(CMAKE_GENERATOR_TOOLSET STREQUAL "v141_xp") +- # v141_xp is still available in Visual Studio 2022 ++ IF(NOT CLANG_IN_VS STREQUAL "1") ++ # Setting CMAKE_GENERATOR_TOOLSET here has no effect, only when passed (-T option) or set directly, so we just check it ++ IF(CMAKE_GENERATOR_TOOLSET STREQUAL "v141_xp") ++ # v141_xp is still available in Visual Studio 2022 and 2026. + message("CMAKE_GENERATOR_TOOLSET is XP compatible: ${CMAKE_GENERATOR_TOOLSET}, extra XP options added") + # https://connect.microsoft.com/VisualStudio/feedback/details/1789709/visual-c-2015-runtime-broken-on-windows-server-2003-c-11-magic-statics +- add_definitions("/Zc:threadSafeInit-") +- ELSE() ++ # later done: add_definitions("/Zc:threadSafeInit-") ++ ELSE() + message(FATAL_ERROR "For XP you must specify v141_xp toolset with -T option (or 'Optional toolset to use' in CMake GUI)!") +- ENDIF() + ENDIF() + ENDIF() + endif() +@@ -239,18 +288,7 @@ endif() + set(IntelClassic_IN_VS "1") + endif() + +- IF(CLANG_IN_VS STREQUAL "1") +- #these are unknown +- #set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexceptions") +- #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions") +- add_compile_options(${CMAKE_CXX_FLAGS} /EHa -Wno-inconsistent-missing-override) +- ELSEIF(IntelLLVM_IN_VS STREQUAL "1") +- # The CXX compiler identification is IntelLLVM 2021.4.0 or 2023.0.0 with MSVC-like command-line +- message("IntelLLVM in VS environment chosen, setting additional flags") +- # contrary to MSVC-like commandline interface, these are not set - /EHa +- # from 2021.2 default fp is fast for /O2 +- add_compile_options(${CMAKE_CXX_FLAGS} -Wno-inconsistent-missing-override /EHa /fp:precise) +- ELSEIF(IntelClassic_IN_VS STREQUAL "1") ++ IF(IntelClassic_IN_VS STREQUAL "1") + # Intel C++ Compiler 19.2 + message("Intel Classic chosen, setting additional flags") + set(DELETE_THIS "/std:c++17") # if it would co-exist with /Qstd=c++17 +@@ -279,26 +317,8 @@ endif() + message("MSVC flags: ${CompilerFlag}:${${CompilerFlag}}") + endforeach() + ELSE() +- # MSVC +- # Enable C++ with SEH exceptions +- # Avoid an obnoxious 'overriding /EHsc with /EHa' warning when +- # using something other than MSBuild +- add_compile_options(${CMAKE_CXX_FLAGS} /EHa) +- # Behavior is new in Visual Studio 2022: +- # Floating-point contractions (mul+add to fma) aren't generated by default under /fp:precise +- # Enable it manually +- if (NOT (MSVC_VERSION LESS 1930)) # at least VS2022 +- add_compile_options(${CMAKE_CXX_FLAGS} /fp:contract) +- endif() ++ # Plain MSVC branch continues; per-target options are applied later + ENDIF() +- # Prevent VC++ from complaining about not using MS-specific functions +- add_definitions("/D _CRT_SECURE_NO_WARNINGS /D _SECURE_SCL=0") +- +- # Enable CRT heap debugging - only effective in debug builds +- add_definitions("/D _CRTDBG_MAP_ALLOC") +- +- # if missing, some modules inhibit source containing assembler/simd parts +- add_definitions("/D __SSE2__") # fixme: does it really need anymore? + + # CPU_ARCH can be overridden with the corresponding values when using MSVC: + # IA32 (disabled), +@@ -308,52 +328,14 @@ endif() + # AVX2 (Haswell and higher, 2013) + if(CMAKE_SIZEOF_VOID_P EQUAL 4) + set(MSVC_CPU_ARCH "SSE2" CACHE STRING "Set MSVC architecture optimization level (default: SSE2)") +- add_compile_options(/arch:${MSVC_CPU_ARCH}) +- endif() +- +- IF(CLANG_IN_VS STREQUAL "1" OR IntelLLVM_IN_VS STREQUAL "1") +- # suppress other frequent but harmless/unavoidable warnings +- add_compile_options(-Wno-unused-function -Wno-reorder -Wno-unused-value) +- # allow per-function attributes like __attribute__((__target__("sse4.1"))) +- add_compile_options(-Wno-gcc-compat) +- ENDIF() +- +- # Enable standards-conformance mode for MSVC compilers that support this +- # flag (Visual C++ 2017 and later). Default. DirectShowSource will remove if needed. +- # The headers in the XP-side SDK also have errors if built in conformance mode, +- # so if we're building for XP, don't turn that on. +- if (NOT WINXP_SUPPORT) +- if (NOT (MSVC_VERSION LESS 1910)) +- add_compile_options(/permissive-) +- endif() +- endif() +- +- if(ENABLE_INTEL_SIMD) +- add_definitions("/D INTEL_INTRINSICS") ++ # /arch: applied later per-target + endif() + + ELSE() + # not MS Visual Studio IDE +- +- # CMAKE_CXX_STANDARD doesn't cover the use-case of pre-final C++17 support, +- # but I'd assume most setups with a new enough version of CMake to use +- # CMAKE_CXX_STANDARD 17 would also be running a version of GCC/Clang new enough +- # to not need this. So this will most likely only ever be used by setups running +- # older versions of CMake; regardless, it shouldn't be necessary to force a +- # CMAKE_VERSION check on this part unless the mere presence of CMAKE_CXX_STANDARD 17 +- # ends up causing problems for the older compilers here. +- if( ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8)) OR +- ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)) ) +- add_compile_options(${CMAKE_CXX_FLAGS} -std=c++1z) +- endif() +- +- if(ENABLE_INTEL_SIMD) +- add_compile_options(-msse2 -DINTEL_INTRINSICS) +- endif() +- + if(WIN32) + SET( CMAKE_SHARED_LINKER_FLAGS "-Wl,--enable-stdcall-fixup" ) +- add_compile_options(-D__CRT__NO_INLINE=1) ++ # __CRT__NO_INLINE: moved to per-target definitions + elseif(APPLE) + # macOS uses Clang's linker, doesn't like --no-undefined + SET( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-undefined,error" ) +@@ -365,13 +347,149 @@ endif() + ENDIF() + + add_subdirectory("avs_core") ++ ++ # Start tracking targets before the plugins subdirectory is processed ++ get_property(_targets_before_plugins GLOBAL PROPERTY BUILT_TARGETS) ++ + if(ENABLE_PLUGINS) + add_subdirectory("plugins") + endif() ++ ++ # End tracking targets and apply fixes here ++ get_property(_targets_after_plugins GLOBAL PROPERTY BUILT_TARGETS) ++ ++ # Calculate targets added in the plugins subdirectory ++ list(REMOVE_ITEM _targets_after_plugins ${_targets_before_plugins}) ++ set(NEW_PLUGIN_TARGETS ${_targets_after_plugins}) ++ ++ # Combine AvsCore and the newly discovered plugins into one list for fixing ++ set(ALL_AFFECTED_TARGETS) ++ if(TARGET AvsCore) ++ list(APPEND ALL_AFFECTED_TARGETS AvsCore) ++ endif() ++ list(APPEND ALL_AFFECTED_TARGETS ${NEW_PLUGIN_TARGETS}) ++ ++ # ----------------------------------------------------------------------- ++ # Per-target, modern & safe application of options/defines (CORE and PLUGINS) ++ # ----------------------------------------------------------------------- ++ foreach(AFFECTED_TARGET ${ALL_AFFECTED_TARGETS}) ++ if(TARGET ${AFFECTED_TARGET}) ++ message(STATUS "Applying Intel/Clang compiler fixes to target: ${AFFECTED_TARGET}") ++ ++ # Check if the target is a library or executable (exclude INTERFACE targets) ++ get_target_property(_target_type ${AFFECTED_TARGET} TYPE) ++ if(NOT ( ++ ${_target_type} STREQUAL "SHARED_LIBRARY" OR ++ ${_target_type} STREQUAL "STATIC_LIBRARY" OR ++ ${_target_type} STREQUAL "MODULE_LIBRARY" ++ )) ++ # Skip if it's not a compileable target (e.g., if it was an interface target) ++ continue() ++ endif() + +-else() ++ # Use a compound check: If the generator is Visual Studio, or the compiler ID ++ # is MSVC AND we are on Windows, run the MSVC-specific logic. ++ if( CMAKE_GENERATOR MATCHES "Visual Studio" OR (MSVC AND WIN32) ) ++ # Using only if(MSVC) will fail with MinGW if the compiler ID is MSVC but the generator is not VS. ++ # This robust check ensures that the MSVC block only runs in an MSVC environment. + +- project(AviSynth-Headers VERSION ${version_major}.${version_minor}.${version_bugfix} LANGUAGES CXX) ++ # Handle ARM64 soft intrinsics if requested (for AvsCore logic) ++ if("${PLATFORMID}" STREQUAL "ARM64" AND ENABLE_INTEL_SIMD) ++ target_compile_definitions(${AFFECTED_TARGET} PRIVATE USE_SOFT_INTRINSICS) ++ endif() ++ ++ # Needed to properly handle __has_include() in avs_core/filesystem.h ++ # See note in filesystem/README.md ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /Zc:__cplusplus) ++ ++ # Prevent VC++ secure CRT warnings, and add __SSE2__ flag. (Why?) ++ target_compile_definitions(${AFFECTED_TARGET} PRIVATE ++ _CRT_SECURE_NO_WARNINGS ++ _SECURE_SCL=0 ++ _CRTDBG_MAP_ALLOC ++ __SSE2__ ++ ) ++ ++ # INTEL intrinsics master switch (if enabled) ++ if(ENABLE_INTEL_SIMD) ++ target_compile_definitions(${AFFECTED_TARGET} PRIVATE INTEL_INTRINSICS) ++ endif() ++ ++ # Compiler-specific options for IntelLLVM / Clang ++ if(CLANG_IN_VS STREQUAL "1") ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /EHa -Wno-inconsistent-missing-override) ++ target_compile_options(${AFFECTED_TARGET} PRIVATE -Wno-unused-function -Wno-reorder -Wno-unused-value -Wno-gcc-compat) ++ elseif(IntelLLVM_IN_VS STREQUAL "1") ++ target_compile_options(${AFFECTED_TARGET} PRIVATE -Wno-inconsistent-missing-override /EHa /fp:precise) ++ target_compile_options(${AFFECTED_TARGET} PRIVATE -Wno-unused-function -Wno-reorder -Wno-unused-value -Wno-gcc-compat) ++ elseif(IntelClassic_IN_VS STREQUAL "1") ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /EHa) ++ else() ++ # Plain MSVC ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /EHa) ++ if (NOT (MSVC_VERSION LESS 1930)) # VS2022+ ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /fp:contract) ++ endif() ++ endif() ++ ++ # Enable standards-conformance mode for MSVC compilers that support this ++ # flag (Visual C++ 2017 and later). Default. DirectShowSource will remove if needed. ++ # The headers in the XP-side SDK also have errors if built in conformance mode, ++ # so if we're building for XP, don't turn that on. ++ ++ # Plus check: Skip /permissive- if the target (e.g. DirectShowSource) requests it. ++ # Filled in plugin's CMakeLists.txt ++ get_target_property(_skip_permissive ${AFFECTED_TARGET} SKIP_PERMISSIVE_FLAG) ++ ++ if(NOT _skip_permissive) # old DirectShowSource ++ if (NOT WINXP_SUPPORT) ++ if (NOT (MSVC_VERSION LESS 1910)) ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /permissive-) ++ endif() ++ endif() ++ endif() ++ ++ # Check if XP support is enabled AND if the XP toolset is used (v141_xp) ++ if (WINXP_SUPPORT) ++ if (CMAKE_GENERATOR_TOOLSET STREQUAL "v141_xp") ++ # C++11 static initialization fix for XP/Server 2003 ++ target_compile_options(${AFFECTED_TARGET} PRIVATE "/Zc:threadSafeInit-") ++ endif() ++ endif() ++ ++ # 32-bit arch tuning ++ if(CMAKE_SIZEOF_VOID_P EQUAL 4) ++ target_compile_options(${AFFECTED_TARGET} PRIVATE /arch:${MSVC_CPU_ARCH}) ++ endif() ++ else() ++ # CMAKE_CXX_STANDARD doesn't cover the use-case of pre-final C++17 support, ++ # but I'd assume most setups with a new enough version of CMake to use ++ # CMAKE_CXX_STANDARD 17 would also be running a version of GCC/Clang new enough ++ # to not need this. So this will most likely only ever be used by setups running ++ # older versions of CMake; regardless, it shouldn't be necessary to force a ++ # CMAKE_VERSION check on this part unless the mere presence of CMAKE_CXX_STANDARD 17 ++ # ends up causing problems for the older compilers here. ++ # Legacy C++17 support for older GCC/Clang ++ if( ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8)) OR ++ ((CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)) ) ++ target_compile_options(${AFFECTED_TARGET} PRIVATE -std=c++1z) ++ endif() ++ ++ if(ENABLE_INTEL_SIMD) ++ target_compile_options(${AFFECTED_TARGET} PRIVATE -msse2) ++ target_compile_definitions(${AFFECTED_TARGET} PRIVATE INTEL_INTRINSICS) ++ endif() ++ if(WIN32) ++ target_compile_definitions(${AFFECTED_TARGET} PRIVATE __CRT__NO_INLINE=1) ++ endif() ++ endif() ++ endif() ++ endforeach() ++ ++ ++else() ++ # HEADERS_ONLY is ON ++ project(AviSynth-Headers VERSION ${PROJECT_VERSION_STRING} LANGUAGES CXX) + message(STATUS "Install Only Headers: ON") + + add_library(${PROJECT_NAME} INTERFACE) +@@ -388,31 +506,31 @@ else() + FIND_PACKAGE(Git) + INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}) + ADD_CUSTOM_TARGET( +- VersionGen +- ${CMAKE_COMMAND} -D SRC=${CMAKE_CURRENT_SOURCE_DIR}/avs_core/core/version.h.in +- -D DST=${CMAKE_CURRENT_BINARY_DIR}/version.h +- -D GIT=${GIT_EXECUTABLE} +- -D REPO=${CMAKE_SOURCE_DIR} +- -P ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/Version.cmake ++ VersionGen ++ ${CMAKE_COMMAND} -D SRC=${CMAKE_CURRENT_SOURCE_DIR}/avs_core/core/version.h.in ++ -D DST=${CMAKE_CURRENT_BINARY_DIR}/version.h ++ -D GIT=${GIT_EXECUTABLE} ++ -D REPO=${CMAKE_SOURCE_DIR} ++ -P ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/Version.cmake + ) + + include(GNUInstallDirs) + + install( +- FILES ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avisynth.h +- ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avisynth_c.h +- DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/avisynth ++ FILES ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avisynth.h ++ ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avisynth_c.h ++ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/avisynth + ) + + install( +- DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avs +- DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/avisynth ++ DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/avs_core/include/avs ++ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/avisynth + ) + + install( +- FILES "${CMAKE_CURRENT_BINARY_DIR}/version.h" +- "${CMAKE_CURRENT_BINARY_DIR}/arch.h" +- DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/avisynth/avs" ++ FILES "${CMAKE_CURRENT_BINARY_DIR}/version.h" ++ "${CMAKE_CURRENT_BINARY_DIR}/arch.h" ++ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/avisynth/avs" + ) + + +@@ -420,9 +538,9 @@ endif() + + # uninstall target + configure_file( +- "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" +- "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" +- IMMEDIATE @ONLY) ++ "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" ++ "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" ++ IMMEDIATE @ONLY) + + add_custom_target(uninstall +- COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) ++ COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) +\ No newline at end of file +diff --git a/plugins/DirectShowSource/CMakeLists.txt b/plugins/DirectShowSource/CMakeLists.txt +index 668dc68b..220ed28a 100644 +--- a/plugins/DirectShowSource/CMakeLists.txt ++++ b/plugins/DirectShowSource/CMakeLists.txt +@@ -34,12 +34,12 @@ target_link_libraries(${ProjectName} "Winmm.lib" "Quartz.lib" "Ole32.lib" "User3 + # Include directories + target_include_directories(${ProjectName} PRIVATE ${AvsCore_SOURCE_DIR} ${DSHOWSRC_BASECLASSES_PATH}) + +-if (MSVC_IDE) +- # Old v7 SDK code won't compile otherwise +- set(DELETE_THIS "/permissive-") +- STRING( REPLACE "${DELETE_THIS}" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") +- STRING( REPLACE "${DELETE_THIS}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") ++# Mark this target for skipping /permissive- ++# Old v7 SDK code won't compile otherwise, DirectShow Base Classes use non-conformant C++. ++# High-level CMakeLists.txt checks this property and won't inject the flag. ++set_target_properties(${ProjectName} PROPERTIES SKIP_PERMISSIVE_FLAG ON) + ++if (MSVC_IDE) + # Copy output to a common folder for easy deployment + add_custom_command( + TARGET ${ProjectName} diff --git a/ports/avisynthplus/portfile.cmake b/ports/avisynthplus/portfile.cmake index 91fa40ca6f..f054b90fb6 100644 --- a/ports/avisynthplus/portfile.cmake +++ b/ports/avisynthplus/portfile.cmake @@ -2,10 +2,10 @@ vcpkg_from_github( OUT_SOURCE_PATH SOURCE_PATH REPO AviSynth/AviSynthPlus REF "v${VERSION}" - SHA512 0e0daa83e3ab729fdc35a52c60c23c9142f1229187af893d0dbbd36f88eced36f63a3e8c767a3dc825edaa5395a49a5aad726f6b61de8f6b291557eec20de426 + SHA512 63a6c793261690500876edf8bd31011700ab077554533efaf613372edd8cdc44a0e348b6e82723ab88be969764d41d031b58fcfbf993e447ef1a280fe90e3f80 HEAD_REF master PATCHES - add-include-chrono.patch # https://github.com/AviSynth/AviSynthPlus/pull/414 + backport_409369a.patch # Fix Ninja + MSVC issue ) vcpkg_download_distfile(GHC_ARCHIVE diff --git a/ports/avisynthplus/vcpkg.json b/ports/avisynthplus/vcpkg.json index 57d4e62e56..de2e2d29c6 100644 --- a/ports/avisynthplus/vcpkg.json +++ b/ports/avisynthplus/vcpkg.json @@ -1,7 +1,6 @@ { "name": "avisynthplus", - "version": "3.7.3", - "port-version": 1, + "version": "3.7.5", "description": "An improved version of the AviSynth frameserver, with improved features and developer friendliness", "homepage": "https://avs-plus.net/", "license": "GPL-2.0", diff --git a/versions/a-/avisynthplus.json b/versions/a-/avisynthplus.json index 8be326276e..e5a6a97bf1 100644 --- a/versions/a-/avisynthplus.json +++ b/versions/a-/avisynthplus.json @@ -1,5 +1,10 @@ { "versions": [ + { + "git-tree": "e75504877f3c24b1d295443a9a52576d8d00b517", + "version": "3.7.5", + "port-version": 0 + }, { "git-tree": "02aec32ec997a98d60fe28b529bc2ad132d4b5c7", "version": "3.7.3", diff --git a/versions/baseline.json b/versions/baseline.json index 86157466cc..6b57198acf 100644 --- a/versions/baseline.json +++ b/versions/baseline.json @@ -425,8 +425,8 @@ "port-version": 0 }, "avisynthplus": { - "baseline": "3.7.3", - "port-version": 1 + "baseline": "3.7.5", + "port-version": 0 }, "avro-c": { "baseline": "1.12.0",