2026-09-28 14:38:09

Signed-off-by: lizzie <lizzie@eden-emu.dev>

cpmfile.json

@@ -5,11 +5,6 @@
         "repo": "lioncash/biscuit",
         "version": "v0.19.0"
     },
-    "atmosphere_zstd_bic": {
-        "hash": "204f7573ea40de2878759c7ff5b2c016111fc29ae8574df50a3a0db9018c3b012f9040ea7466559130424d4335f2dfd6d7abfdc4d4d67e8a34531b8284f0cc6a",
-        "repo": "Atmosphere-NX/Atmosphere",
-        "version": "3ace80cc7b87e1837fccca1522801bbf6fddc6aa"
-    },
     "boost": {
         "artifact": "boost-%VERSION%.tar.zst",
         "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",

externals/ffmpeg/CMakeLists.txt

@@ -11,110 +11,149 @@ set(FFmpeg_HWACCEL_LDFLAGS)
 
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
     set(FFmpeg_CROSS_COMPILE_FLAGS "")
-    if (ANDROID)
+    if (CMAKE_CROSSCOMPILING)
+        message(STATUS "ffmpeg: Enabling cross compilation ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
         # TODO: Maybe use CMAKE_SYSROOT? and probably provide a toolchain file for android
         # I mean isn't that the "proper" way anyways?
-        string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" FFmpeg_HOST_SYSTEM_NAME)
-        set(TOOLCHAIN "${ANDROID_NDK}/toolchains/llvm/prebuilt/${FFmpeg_HOST_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
-        set(SYSROOT "${TOOLCHAIN}/sysroot")
-        set(FFmpeg_CPU "armv8-a")
-        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-            --enable-cross-compile
-            --arch=arm64
-            #--cpu=${FFmpeg_CPU}
-            --cross-prefix="${TOOLCHAIN}/bin/aarch64-linux-android-"
-            --sysroot="${SYSROOT}"
-            --target-os=android
-            --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
-            --extra-ldflags="-nostdlib"
-        )
-        set(FFmpeg_IS_CROSS_COMPILING TRUE)
-    # User attempts to do a FFmpeg cross compilation because...
-    # Here we just quickly test against host/system processors not matching
-    # TODO: Test for versions not matching as well?
-    elseif (NOT (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES CMAKE_SYSTEM_PROCESSOR
-    AND CMAKE_HOST_SYSTEM_NAME MATCHES CMAKE_SYSTEM_NAME))
-        string(TOLOWER "${CMAKE_SYSTEM_NAME}" FFmpeg_SYSTEM_NAME)
-        if (FFmpeg_SYSTEM_NAME STREQUAL "openorbis" OR FFmpeg_SYSTEM_NAME STREQUAL "managarm")
-            set(FFmpeg_SYSTEM_NAME "none")
-        endif()
-        # TODO: Can we really do better? Auto-detection? Something clever?
-        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-            --enable-cross-compile
-            --arch="${CMAKE_SYSTEM_PROCESSOR}"
-            --target-os="${FFmpeg_SYSTEM_NAME}"
-            --sysroot="${CMAKE_SYSROOT}"
-        )
-        if (DEFINED FFmpeg_CROSS_PREFIX)
-            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --cross-prefix="${FFmpeg_CROSS_PREFIX}")
+        if (ANDROID)
+            string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" FFmpeg_HOST_SYSTEM_NAME)
+            set(TOOLCHAIN "${ANDROID_NDK}/toolchains/llvm/prebuilt/${FFmpeg_HOST_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+            set(SYSROOT "${TOOLCHAIN}/sysroot")
+            set(FFmpeg_CPU "armv8-a")
+            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+                --enable-cross-compile
+                --arch=arm64
+                #--cpu=${FFmpeg_CPU}
+                --cross-prefix="${TOOLCHAIN}/bin/aarch64-linux-android-"
+                --sysroot="${SYSROOT}"
+                --target-os=android
+                --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
+                --extra-ldflags="-nostdlib")
+            set(FFmpeg_IS_CROSS_COMPILING TRUE)
         else()
-            message(WARNING "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: \${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}-")
+            string(TOLOWER "${CMAKE_SYSTEM_NAME}" FFmpeg_SYSTEM_NAME)
+            # systems FFmpeg natively supports
+            if (NOT (NETBSD OR SOLARIS OR FREEBSD
+            OR OPENBSD OR DRAGONFLYBSD OR HAIKU
+            OR LINUX OR MSYS OR WIN32 OR ANDROID OR APPLE))
+                set(FFmpeg_SYSTEM_NAME "none")
+            endif()
+            # TODO: Can we really do better? Auto-detection? Something clever?
+            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+                --enable-cross-compile
+                --arch="${CMAKE_SYSTEM_PROCESSOR}"
+                --target-os="${FFmpeg_SYSTEM_NAME}"
+                --sysroot="${CMAKE_SYSROOT}")
+            if (DEFINED FFmpeg_CROSS_PREFIX)
+                list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --cross-prefix="${FFmpeg_CROSS_PREFIX}")
+            else()
+                message(FATAL_ERROR "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: \${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}-")
+            endif()
+            set(FFmpeg_IS_CROSS_COMPILING TRUE)
         endif()
-        set(FFmpeg_IS_CROSS_COMPILING TRUE)
     endif()
 endif()
 
-if (OPENORBIS OR MANAGARM)
-    # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
-    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+if (WIN32)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --enable-d3d11va
+        --enable-d3d12va
+        --enable-dxva2
+        --enable-hwaccel=d3d11va_h264
+        --enable-hwaccel=d3d11va2_h264
+        --enable-hwaccel=d3d12va_h264
+        --enable-hwaccel=dxva2_h264
+        --enable-hwaccel=d3d11va_vp9
+        --enable-hwaccel=d3d11va2_vp9
+        --enable-hwaccel=d3d12va_vp9
+        --enable-hwaccel=dxva2_vp9)
 elseif (ANDROID)
     list(APPEND FFmpeg_HWACCEL_FLAGS
         --enable-mediacodec
         --enable-jni
-    )
-elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(LIBVA libva)
-    pkg_check_modules(CUDA cuda)
-    pkg_check_modules(FFNVCODEC ffnvcodec)
-    pkg_check_modules(VDPAU vdpau)
+        --enable-decoder=h264_mediacodec
+        --enable-decoder=vp8_mediacodec
+        --enable-decoder=vp9_mediacodec)
+elseif (APPLE)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --enable-videotoolbox
+        --enable-hwaccel=videotoolbox_h264
+        --enable-hwaccel=videotoolbox_vp9)
+endif()
 
-    find_package(X11)
-    if(X11_FOUND)
-        if (NOT APPLE)
-            # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
-            if(SOLARIS)
-                list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                    X11
-                    "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
-            else()
-                pkg_check_modules(LIBDRM libdrm REQUIRED)
-                list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                    ${LIBDRM_LIBRARIES})
-                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                    ${LIBDRM_INCLUDE_DIRS})
-            endif()
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-libdrm)
-        endif()
-        if(LIBVA_FOUND)
-            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
-            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
+find_package(X11)
+if(X11_FOUND)
+    # Include X11 if possible, VDPAU lists it as complementary
+    list(APPEND FFmpeg_HWACCEL_LIBRARIES ${X11_LIBRARIES})
+    list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${X11_INCLUDE_DIRS})
+    list(APPEND FFmpeg_HWACCEL_LDFLAGS ${X11_LDFLAGS})
+else()
+    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+endif()
+message(STATUS "ffmpeg: X11 ${X11_FOUND} ${X11_VERSION}")
+
+find_package(PkgConfig)
+if (PkgConfig_FOUND)
+    pkg_check_modules(LIBDRM libdrm)
+    if (LIBDRM_FOUND)
+        # Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
+        if(SOLARIS)
             list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${X11_LIBRARIES}
-                ${LIBVA-DRM_LIBRARIES}
-                ${LIBVA-X11_LIBRARIES}
-                ${LIBVA_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-hwaccel=h264_vaapi
-                --enable-hwaccel=vp8_vaapi
-                --enable-hwaccel=vp9_vaapi)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${X11_INCLUDE_DIRS}
-                ${LIBVA-DRM_INCLUDE_DIRS}
-                ${LIBVA-X11_INCLUDE_DIRS}
-                ${LIBVA_INCLUDE_DIRS}
-            )
-            message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
+                X11
+                "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
         else()
-            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-            message(WARNING "ffmpeg: libva-dev not found, disabling Video Acceleration API (VA-API)...")
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBDRM_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBDRM_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBDRM_LDFLAGS})
         endif()
-    else()
-        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        message(WARNING "ffmpeg: X11 libraries not found, disabling VA-API...")
+        list(APPEND FFmpeg_HWACCEL_FLAGS --enable-libdrm)
     endif()
 
+    pkg_check_modules(LIBVA libva)
+    if(LIBVA_FOUND)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA_INCLUDE_DIRS})
+        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA_LDFLAGS})
+        list(APPEND FFmpeg_HWACCEL_FLAGS
+            --enable-vaapi
+            --enable-hwaccel=h264_vaapi
+            --enable-hwaccel=vp8_vaapi
+            --enable-hwaccel=vp9_vaapi)
+        # Logically, they can only exist if libva itself exists
+        pkg_check_modules(LIBVA-DRM libva-drm)
+        if (LIBVA-DRM_FOUND)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA-DRM_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA-DRM_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA-DRM_LDFLAGS})
+        endif()
+        message(STATUS "ffmpeg: LIBVA-DRM ${LIBVA-DRM_FOUND} ${LIBVA-DRM_VERSION}")
+        pkg_check_modules(LIBVA-X11 libva-x11)
+        if (LIBVA-X11_FOUND)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA-X11_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA-X11_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA-X11_LDFLAGS})
+        endif()
+        message(STATUS "ffmpeg: LIBVA-X11 ${LIBVA-X11_FOUND} ${LIBVA-X11_VERSION}")
+    else()
+        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+    endif()
+    message(STATUS "ffmpeg: LIBVA ${LIBVA_FOUND} ${LIBVA_VERSION}")
+
+    pkg_check_modules(VDPAU vdpau)
+    if (VDPAU_FOUND)
+        list(APPEND FFmpeg_HWACCEL_FLAGS
+            --enable-vdpau
+            --enable-hwaccel=h264_vdpau
+            --enable-hwaccel=vp9_vdpau)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
+        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
+    else()
+        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
+    endif()
+    message(STATUS "ffmpeg: VDPAU ${VDPAU_FOUND} ${VDPAU_VERSION}")
+
+    pkg_check_modules(FFNVCODEC ffnvcodec)
     if (FFNVCODEC_FOUND)
         list(APPEND FFmpeg_HWACCEL_FLAGS
             --enable-cuvid
@@ -122,39 +161,42 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
             --enable-nvdec
             --enable-hwaccel=h264_nvdec
             --enable-hwaccel=vp8_nvdec
-            --enable-hwaccel=vp9_nvdec
-        )
+            --enable-hwaccel=vp9_nvdec)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${FFNVCODEC_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${FFNVCODEC_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${FFNVCODEC_LDFLAGS})
-        message(STATUS "ffmpeg: ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
         # ffnvenc could load CUDA libraries at the runtime using dlopen/dlsym or LoadLibrary/GetProcAddress
         # here we handle the hard-linking scenario where CUDA is linked during compilation
-        if (CUDA_FOUND)
-            # This line causes build error if CUDA_INCLUDE_DIRS is anything but a single non-empty value
-            #list(APPEND FFmpeg_HWACCEL_FLAGS --extra-cflags=-I${CUDA_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDA_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDA_LDFLAGS})
-            message(STATUS "ffmpeg: CUDA libraries version ${CUDA_VERSION} found, hard-linking will be performed")
-        endif(CUDA_FOUND)
-    endif()
-
-    if (VDPAU_FOUND AND NOT APPLE)
-        list(APPEND FFmpeg_HWACCEL_FLAGS
-            --enable-vdpau
-            --enable-hwaccel=h264_vdpau
-            --enable-hwaccel=vp9_vdpau
-        )
-        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
-        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
-        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
-        message(STATUS "ffmpeg: vdpau libraries version ${VDPAU_VERSION} found")
-    else()
-        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
-        message(WARNING "ffmpeg: libvdpau-dev not found, disabling Video Decode and Presentation API for Unix (VDPAU)...")
+        find_package(CUDAToolkit)
+        if (CUDAToolkit_FOUND)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDAToolkit_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDAToolkit_LDFLAGS})
+        endif()
+        message(STATUS "ffmpeg: CUDAToolkit ${CUDAToolkit_FOUND} ${CUDAToolkit_VERSION}")
     endif()
+    message(STATUS "ffmpeg: FFNVCODEC ${FFNVCODEC_FOUND} ${FFNVCODEC_VERSION}")
 endif()
+message(STATUS "ffmpeg: PkgConfig ${PkgConfig_FOUND} ${PkgConfig_VERSION}")
+
+find_package(Vulkan)
+if (Vulkan_FOUND)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --enable-vulkan
+        --enable-hwaccel=h264_vulkan
+        --enable-hwaccel=vp9_vulkan)
+    list(APPEND FFmpeg_HWACCEL_LIBRARIES ${Vulkan_LIBRARIES})
+    list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${Vulkan_INCLUDE_DIRS})
+endif()
+message(STATUS "ffmpeg: Vulkan ${Vulkan_FOUND} ${Vulkan_VERSION}")
+
+find_package(spirv-headers)
+if (spirv-headers_FOUND)
+    list(APPEND FFmpeg_HWACCEL_LIBRARIES ${spirv-headers_LIBRARIES})
+    list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${spirv-headers_INCLUDE_DIRS})
+    list(APPEND FFmpeg_HWACCEL_LDFLAGS ${spirv-headers_LDFLAGS})
+endif()
+message(STATUS "ffmpeg: spirv-headers ${spirv-headers_FOUND} ${spirv-headers_VERSION}")
 
 if (OPENORBIS)
     list(APPEND FFmpeg_CROSS_COMPILE_LIBS
@@ -162,20 +204,28 @@ if (OPENORBIS)
         -lSceUserService
         -lSceSysmodule
         -lSceNet
-        -lSceLibcInternal
-    )
+        -lSceLibcInternal)
     list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
         --disable-pthreads
         --extra-cflags=${CMAKE_SYSROOT}/usr/include
         --extra-cxxflags=${CMAKE_SYSROOT}/usr/include
-        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
-    )
+        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}")
 elseif (MANAGARM)
     # Required for proper stuff
-    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS 
         --disable-pthreads
-        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
-    )
+        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}")
+endif()
+
+# Usually used by Emscripten
+if (DEFINED CMAKE_AR)
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --ar=${CMAKE_AR})
+endif()
+if (DEFINED CMAKE_NM)
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --nm=${CMAKE_NM})
+endif()
+if (DEFINED CMAKE_RANLIB)
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --ranlib=${CMAKE_RANLIB})
 endif()
 
 if (YUZU_USE_BUNDLED_FFMPEG)
@@ -183,44 +233,33 @@ if (YUZU_USE_BUNDLED_FFMPEG)
 
     set(FFmpeg_INCLUDE_DIR
         "${FFmpeg_SOURCE_DIR}/include;${FFmpeg_HWACCEL_INCLUDE_DIRS}"
-        PARENT_SCOPE
-    )
+        PARENT_SCOPE)
 
     set(FFmpeg_PATH
         "${FFmpeg_SOURCE_DIR}"
-        PARENT_SCOPE
-    )
+        PARENT_SCOPE)
 
     set(FFmpeg_LIBRARY_DIR
         "${FFmpeg_SOURCE_DIR}/bin"
-        PARENT_SCOPE
-    )
+        PARENT_SCOPE)
 
     set(FFmpeg_LIBRARIES
         FFmpeg::FFmpeg
         ${FFmpeg_HWACCEL_LIBRARIES}
-        PARENT_SCOPE
-    )
+        PARENT_SCOPE)
+    
+    set(FFmpeg_FOUND YES)
 else()
     # Build FFmpeg from externals
     message(STATUS "Using FFmpeg from externals")
-
-    if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|amd64)")
-        # FFmpeg has source that requires one of nasm or yasm to assemble it.
-        # REQUIRED throws an error if not found here during configuration rather than during compilation.
-        find_program(ASSEMBLER NAMES nasm yasm)
-        if ("${ASSEMBLER}" STREQUAL "ASSEMBLER-NOTFOUND")
-            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
-        endif()
-    endif()
-
-    find_program(AUTOCONF autoconf)
-    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
-        message(FATAL_ERROR "Required program `autoconf` not found.")
-    endif()
-
     AddJsonPackage(ffmpeg)
 
+    # FFmpeg has source that requires one of nasm or yasm to assemble it.
+    if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|amd64)")
+        find_program(ASSEMBLER NAMES nasm yasm REQUIRED)
+    endif()
+    find_program(AUTOCONF autoconf REQUIRED)
+
     set(FFmpeg_PREFIX ${ffmpeg_SOURCE_DIR})
     set(FFmpeg_BUILD_DIR ${ffmpeg_BINARY_DIR})
     set(FFmpeg_MAKEFILE ${FFmpeg_BUILD_DIR}/Makefile)
@@ -250,8 +289,15 @@ else()
 
     # `configure` parameters builds only exactly what yuzu needs from FFmpeg
     # `--disable-vdpau` is needed to avoid linking issues
-    set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER}  ${CMAKE_C_COMPILER})
-    set(FFmpeg_CXX ${CMAKE_CXX_COMPILER_LAUNCHER}  ${CMAKE_CXX_COMPILER})
+    set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER} ${CMAKE_C_COMPILER})
+    set(FFmpeg_CXX ${CMAKE_CXX_COMPILER_LAUNCHER} ${CMAKE_CXX_COMPILER})
+    set(FFmpeg_HOST_CC ${CMAKE_C_HOST_COMPILER})
+    if (FFmpeg_IS_CROSS_COMPILING)
+        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --ld=${CMAKE_LINKER})
+    endif ()
+    # TODO: This is a bit fragile, it depends on FFmpeg_HWACCEL_LDFLAGS being a list
+    # whereas CMAKE_C_FLAGS (and likewise) is meant to NOT be a list, but rather
+    # an elongated piece of string
     add_custom_command(
         OUTPUT
             ${FFmpeg_MAKEFILE}
@@ -261,10 +307,12 @@ else()
                 --disable-avformat
                 --disable-doc
                 --disable-everything
+                --disable-autodetect
                 --disable-ffmpeg
                 --disable-ffprobe
                 --disable-network
                 --disable-swresample
+                --disable-iconv
                 --enable-decoder=h264
                 --enable-decoder=vp8
                 --enable-decoder=vp9
@@ -272,45 +320,40 @@ else()
                 --enable-pic
                 --cc=${FFmpeg_CC}
                 --cxx=${FFmpeg_CXX}
-                --ld=${CMAKE_LINKER}
                 --extra-cflags=${CMAKE_C_FLAGS}
                 --extra-cxxflags=${CMAKE_CXX_FLAGS}
-                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
+                --extra-ldflags="${FFmpeg_HWACCEL_LDFLAGS}"
+                --host-cc=${FFmpeg_HOST_CC}
                 ${FFmpeg_HWACCEL_FLAGS}
                 ${FFmpeg_CROSS_COMPILE_FLAGS}
         WORKING_DIRECTORY
-            ${FFmpeg_BUILD_DIR}
-    )
+            ${FFmpeg_BUILD_DIR})
     unset(FFmpeg_CC)
     unset(FFmpeg_CXX)
+    unset(FFmpeg_HOST_CC)
+    unset(FFmpeg_LD)
     unset(FFmpeg_HWACCEL_FLAGS)
     unset(FFmpeg_CROSS_COMPILE_FLAGS)
 
     # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
     # with context of the jobserver. Also helps ninja users.
-    execute_process(
-        COMMAND
-            nproc
-        OUTPUT_VARIABLE
-            SYSTEM_THREADS)
+    cmake_host_system_information(RESULT SYSTEM_THREADS QUERY NUMBER_OF_LOGICAL_CORES)
+    set(FFmpeg_MAKE_ARGS "")
+    if (DEFINED SYSTEM_THREADS)
+        set(FFmpeg_MAKE_ARGS -j ${SYSTEM_THREADS})
+    endif()
 
     set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
 
-    # BSD make or Solaris make don't support ffmpeg make-j8
-    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
-        set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
-    else()
-        set(FFmpeg_MAKE_ARGS "")
-    endif()
-
+    # Most distros use 'gmake', Arch uses 'make'
+    find_program(MAKE NAMES gmake make REQUIRED)
     add_custom_command(
         OUTPUT
             ${FFmpeg_BUILD_LIBRARIES}
         COMMAND
-            gmake ${FFmpeg_MAKE_ARGS}
+            ${MAKE} ${FFmpeg_MAKE_ARGS}
         WORKING_DIRECTORY
-            ${FFmpeg_BUILD_DIR}
-    )
+            ${FFmpeg_BUILD_DIR})
 
     set(FFmpeg_INCLUDE_DIR
         "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
@@ -332,12 +375,10 @@ else()
     unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
     unset(FFmpeg_HWACCEL_LDFLAGS)
     unset(FFmpeg_HWACCEL_LIBRARIES)
-
-    if (FFmpeg_FOUND)
-        message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
-    else()
-        message(FATAL_ERROR "FFmpeg not found")
-    endif()
 endif()
-
 unset(FFmpeg_COMPONENTS)
+
+if (NOT FFmpeg_FOUND)
+    message(FATAL_ERROR "FFmpeg not found")
+endif()
+message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -30,7 +30,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),
-    ENABLE_GPU_BUFFER_READBACK("enable_gpu_buffer_readback"),
     SYNC_MEMORY_OPERATIONS("sync_memory_operations"),
     BUFFER_REORDER_DISABLE("disable_buffer_reorder"),
     RENDERER_DEBUG("debug"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -908,13 +908,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.enable_buffer_history_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.ENABLE_GPU_BUFFER_READBACK,
-                    titleId = R.string.enable_gpu_buffer_readback,
-                    descriptionId = R.string.enable_gpu_buffer_readback_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -549,7 +549,6 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.RENDERER_FORCE_MAX_CLOCK.key)
             add(BooleanSetting.RENDERER_REACTIVE_FLUSHING.key)
             add(BooleanSetting.ENABLE_BUFFER_HISTORY.key)
-            add(BooleanSetting.ENABLE_GPU_BUFFER_READBACK.key)
             add(BooleanSetting.USE_OPTIMIZED_VERTEX_BUFFERS.key)
 
             add(HeaderSetting(R.string.hacks))

src/android/app/src/main/res/values-ar/strings.xml

@@ -580,8 +580,6 @@
     <string name="renderer_reactive_flushing_description">يحسن دقة العرض في بعض الألعاب على حساب الأداء.</string>
     <string name="enable_buffer_history">تمكين سجل التخزين المؤقت</string>
     <string name="enable_buffer_history_description">يُتيح هذا الخيار الوصول إلى حالات التخزين المؤقت السابقة. وقد يُحسّن جودة العرض وثبات الأداء في بعض الألعاب.</string>
-    <string name="enable_gpu_buffer_readback">تفعيل قراءة مخزن وحدة معالجة الرسومات</string>
-    <string name="enable_gpu_buffer_readback_description">يحافظ هذا النظام على بيانات المخزن المؤقت المُعدّلة بواسطة وحدة معالجة الرسومات عن طريق قراءتها مرة أخرى قبل التحميل. تتطلب بعض الألعاب ذلك لعرض بعض التأثيرات بشكل صحيح. قد يُسبب ذلك مشاكل إذا لم يتمكن الجهاز من التعامل مع عبء العمل الإضافي.</string>
     <string name="use_optimized_vertex_buffers">مخازن الرؤوس المُحسّنة</string>
     <string name="use_optimized_vertex_buffers_description">يُتيح ربطًا مُحسَّنًا لمخازن الرؤوس لتحسين الأداء. يتطلب برامج تشغيل Mesa 26.0+ Turnip/ برامج تشغيل QCOM. قد يتعطل على برامج تشغيل Turnip القديمة (25.3 وما دون).</string>
 
@@ -1099,7 +1097,6 @@
     <string name="gpu_fence_behavior_immediate">فوري</string>
     <string name="gpu_fence_behavior_balanced">متوازن</string>
     <string name="gpu_fence_behavior_accurate">دقيق</string>
-    <string name="gpu_fence_behavior_strict">صارم</string>
 
     <string name="vram_usage_conservative">محافظ</string>
     <string name="vram_usage_aggressive">عدواني</string>

src/android/app/src/main/res/values-de/strings.xml

@@ -967,7 +967,6 @@ Wirklich fortfahren?</string>
     <string name="gpu_fence_behavior_immediate">Direkt</string>
     <string name="gpu_fence_behavior_balanced">Ausgewogen</string>
     <string name="gpu_fence_behavior_accurate">Genau</string>
-    <string name="gpu_fence_behavior_strict">Strikt</string>
 
     <string name="vram_usage_conservative">Konservativ</string>
     <string name="vram_usage_aggressive">Aggressiv</string>

src/android/app/src/main/res/values-es/strings.xml

@@ -524,8 +524,6 @@
     <string name="renderer_reactive_flushing_description">Mejora la precisión de renderizado en algunos juegos, pero reduce el rendimiento.</string>
     <string name="enable_buffer_history">Activar el historial del búfer</string>
     <string name="enable_buffer_history_description">Permite el acceso al estado del búfer anterior. Esta opción puede mejorar la calidad de renderizado y la consistencia en el rendimiento de algunos juegos.</string>
-    <string name="enable_gpu_buffer_readback">Activar la lectura del buffer de la GPU</string>
-    <string name="enable_gpu_buffer_readback_description">Conserva los datos del búfer modificados por la GPU leyéndolos antes de subirlos.\nAlgunos juegos requieren esto para renderizar correctamente ciertos efectos.\nPuede causar problemas si el hardware no puede soportar la carga de trabajo adicional.</string>
     <string name="use_optimized_vertex_buffers">Búferes de vértices optimizados</string>
     <string name="use_optimized_vertex_buffers_description">Permite la optimización del enlace del búfer de vértices para un mejor rendimiento. Requiere controladores Mesa 26.0+ Turnip/ controladores QCOM. Fallará con controladores Turnip más antiguos (versión 25.3 o inferior).</string>
 
@@ -1038,7 +1036,6 @@
     <string name="gpu_fence_behavior_immediate">Inmediato</string>
     <string name="gpu_fence_behavior_balanced">Equilibrado</string>
     <string name="gpu_fence_behavior_accurate">Preciso</string>
-    <string name="gpu_fence_behavior_strict">Estricto</string>
 
     <string name="vram_usage_conservative">Conservador</string>
     <string name="vram_usage_aggressive">Agresivo</string>

src/android/app/src/main/res/values-ru/strings.xml

@@ -569,8 +569,6 @@
     <string name="renderer_reactive_flushing_description">Повышение точности рендеринга в некоторых играх за счет снижения производительности.</string>
     <string name="enable_buffer_history">Включить историю буфера</string>
     <string name="enable_buffer_history_description">Позволяет обращаться к предыдущим состояниям буфера. Эта опция может повысить качество рендеринга и стабильность производительности в некоторых играх.</string>
-    <string name="enable_gpu_buffer_readback">Включить обратное чтение буфера ГПУ</string>
-    <string name="enable_gpu_buffer_readback_description">Сохраняет измененные ГПУ данные буфера путем чтения их обратно перед выгрузками. Некоторые игры требуют этого, чтобы рендерить определенные эффекты правильно. Может вызывать проблемы если оборудование не может обработать дополнительную рабочую нагрузку.</string>
     <string name="use_optimized_vertex_buffers">Оптимизированные вершинные буферы</string>
     <string name="use_optimized_vertex_buffers_description">Включает оптимизированную привязку вершинного буфера для повышения производительности. Требует Mesa Turnip 26.0+ / QCOM. Приводит к вылету на старых версиях драйверов Turnip (25.3 и ниже).</string>
 
@@ -1088,7 +1086,6 @@
     <string name="gpu_fence_behavior_immediate">Мгновенный</string>
     <string name="gpu_fence_behavior_balanced">Сбалансированный</string>
     <string name="gpu_fence_behavior_accurate">Точный</string>
-    <string name="gpu_fence_behavior_strict">Строгий</string>
 
     <string name="vram_usage_conservative">Консервативный</string>
     <string name="vram_usage_aggressive">Агрессивный</string>

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -570,8 +570,6 @@
     <string name="renderer_reactive_flushing_description">通过牺牲性能来提升某些游戏的渲染精度。</string>
     <string name="enable_buffer_history">启用缓冲区历史</string>
     <string name="enable_buffer_history_description">启用对先前缓冲区状态的访问。此选项可在某些游戏中提升渲染质量并保持性能的一致性。</string>
-    <string name="enable_gpu_buffer_readback">启用 GPU 缓冲区回读</string>
-    <string name="enable_gpu_buffer_readback_description">在上传前回读经由 GPU 修改过的缓冲区数据，以将其保留。一些游戏会用到这项设定以正确渲染某些效果。如果硬件无法处理额外的工作负载，则可能会导致问题。</string>
     <string name="use_optimized_vertex_buffers">优化顶点缓冲区</string>
     <string name="use_optimized_vertex_buffers_description">启用经过优化的顶点缓冲区绑定以提升性能。需要 Mesa 26.0 及以上版本的 Turnip 或 QCOM 驱动程序。若使用较旧版本的 Turnip 驱动 (25.3 及以下版本) 则会导致崩溃。</string>
 
@@ -1089,7 +1087,6 @@
     <string name="gpu_fence_behavior_immediate">即时</string>
     <string name="gpu_fence_behavior_balanced">均衡</string>
     <string name="gpu_fence_behavior_accurate">精确</string>
-    <string name="gpu_fence_behavior_strict">严格</string>
 
     <string name="vram_usage_conservative">保守式</string>
     <string name="vram_usage_aggressive">主动式</string>

src/android/app/src/main/res/values-zh-rTW/strings.xml

@@ -561,8 +561,6 @@
     <string name="renderer_reactive_flushing_description">犧牲效能，以改善部分遊戲的轉譯準確度</string>
     <string name="enable_buffer_history">啟用緩衝區歷史</string>
     <string name="enable_buffer_history_description">允許存取先前的緩衝區狀態。此選項可能會改善部分遊戲的渲染品質與效能穩定性</string>
-    <string name="enable_gpu_buffer_readback">啟用 GPU 緩衝區讀回</string>
-    <string name="enable_gpu_buffer_readback_description">透過在上傳之前先將 GPU 修改過的緩衝區資料讀回來保存資料，部分遊戲需要啟用此功能才能正常渲染遊戲特效。如果硬體無法負荷可能會導致錯誤</string>
     <string name="use_optimized_vertex_buffers">最佳化頂點緩衝區</string>
     <string name="use_optimized_vertex_buffers_description">啟用最佳化的頂點緩衝區綁定。需要安裝 Mesa 26.0+ Turnip drivers/Qualcomm drivers。使用舊版 Turnip drivers 會導致當機 (25.3版和更低的版本)</string>
 

src/android/app/src/main/res/values/arrays.xml

@@ -558,7 +558,6 @@
         <item>@string/gpu_fence_behavior_immediate</item>
         <item>@string/gpu_fence_behavior_balanced</item>
         <item>@string/gpu_fence_behavior_accurate</item>
-        <item>@string/gpu_fence_behavior_strict</item>
     </string-array>
     <integer-array name="gpuFenceBehaviorValues">
         <item>0</item>

src/android/app/src/main/res/values/strings.xml

@@ -586,8 +586,6 @@
     <string name="renderer_reactive_flushing_description">Improves rendering accuracy in some games at the cost of performance.</string>
     <string name="enable_buffer_history">Enable buffer history</string>
     <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
-    <string name="enable_gpu_buffer_readback">Enable GPU Buffer Readback</string>
-    <string name="enable_gpu_buffer_readback_description">Preserves GPU-modified buffer data by reading it back before uploads. Some games require this to render certain effects properly. May cause issues if the hardware cannot handle the additional workload.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
     <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers (25.3 and below).</string>
 
@@ -1138,7 +1136,6 @@
     <string name="gpu_fence_behavior_immediate">Immediate</string>
     <string name="gpu_fence_behavior_balanced">Balanced</string>
     <string name="gpu_fence_behavior_accurate">Accurate</string>
-    <string name="gpu_fence_behavior_strict">Strict</string>
 
     <!-- ASTC Decoding Method Choices -->
     <string name="accelerate_astc_cpu" translatable="false">CPU</string>

src/common/settings.cpp

@@ -178,10 +178,6 @@ bool IsGPUFenceBehaviorAccurate() {
     return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Accurate;
 }
 
-bool IsGPUFenceBehaviorStrict() {
-    return values.gpu_fence_behavior.GetValue() == GpuFenceBehavior::Strict;
-}
-
 bool IsFastmemEnabled() {
     if (values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Debugging)
         return bool(values.cpuopt_fastmem);

src/common/settings.h

@@ -525,7 +525,7 @@ struct Values {
     SwitchableSetting<GpuFenceBehavior, true> gpu_fence_behavior{linkage,
                                                                  GpuFenceBehavior::Default,
                                                                  GpuFenceBehavior::Default,
-                                                                 GpuFenceBehavior::Strict,
+                                                                 GpuFenceBehavior::Accurate,
                                                                  "gpu_fence_behavior",
                                                                  Category::RendererAdvanced,
                                                                  Specialization::Default,
@@ -655,13 +655,6 @@ struct Values {
 
     SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
                                          Category::RendererHacks};
-    SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,
-                                                       false,
-                                                       "enable_gpu_buffer_readback",
-                                                       Category::RendererAdvanced,
-                                                       Specialization::Default,
-                                                       true,
-                                                       true};
 
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
@@ -979,7 +972,6 @@ bool IsDMALevelSafe();
 bool IsGPUFenceBehaviorDefault();
 bool IsGPUFenceBehaviorBalanced();
 bool IsGPUFenceBehaviorAccurate();
-bool IsGPUFenceBehaviorStrict();
 
 bool IsFastmemEnabled();
 void SetNceEnabled(bool is_64bit);

src/common/settings_enums.h

@@ -137,7 +137,7 @@ ENUM(VramUsageMode, Conservative, Aggressive);
 ENUM(RendererBackend, OpenGL_GLSL, Vulkan, Null, OpenGL_GLASM, OpenGL_SPIRV);
 ENUM(GpuAccuracy, Low, High);
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
-ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate, Strict);
+ENUM(GpuFenceBehavior, Default, Immediate, Balanced, Accurate);
 ENUM(CpuBackend, Dynarmic, Nce);
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);
 ENUM(CpuClock, Normal, Boost, Overclock)

src/common/sparse_large_vector.cpp

@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #ifdef _WIN32
+#include <algorithm>
 #include <windows.h>
 #include <mutex>
 #else
@@ -20,32 +21,36 @@ namespace Common {
 
 #ifdef _WIN32
 static std::vector<std::pair<u64, u64>> vector_regions {};
+static std::mutex vector_regions_mutex {};
 
 // Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
 static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
     DWORD code = info->ExceptionRecord->ExceptionCode;
-    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionAddress);
+    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionInformation[1]);
 
-    if (code != EXCEPTION_ACCESS_VIOLATION) {
+    if (code != EXCEPTION_ACCESS_VIOLATION || info->ExceptionRecord->ExceptionInformation[0] == 1) {
         // Not our problem
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
     u64 addr = 0, addr2 = 0;
 
-    for (auto region: vector_regions) {
-        auto addr_shifted = exception_addr >> HostPageBits;
-        if (region.first <= addr_shifted && addr_shifted <= region.second) {
-            addr = addr_shifted;
-        }
+    {
+        std::lock_guard lock(vector_regions_mutex);
+        for (auto region: vector_regions) {
+            auto addr_shifted = exception_addr >> HostPageBits;
+            if (region.first <= addr_shifted && addr_shifted <= region.second) {
+                addr = addr_shifted;
+            }
 
-        // Page-boundary accesses
-        if (auto addr_ = (exception_addr + 0x40) >> HostPageBits; addr_ != addr_shifted && region.first <= addr_ && addr_ <= region.second) {
-            addr2 = addr_;
-        }
+            // Page-boundary accesses
+            if (auto addr_ = (exception_addr + 0x40) >> HostPageBits; addr_ != addr_shifted && region.first <= addr_ && addr_ <= region.second) {
+                addr2 = addr_;
+            }
 
-        if (addr != 0 || addr2 != 0) {
-            break;
+            if (addr != 0 || addr2 != 0) {
+                break;
+            }
         }
     }
 
@@ -77,8 +82,16 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
     auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
     if (res == 0) {
         LOG_CRITICAL(HW_Memory, "Failed to query large buffer region at {:#x} with error {}, will try committing anyway", addr, GetLastError());
+    } else if (info.State == MEM_COMMIT) {
+        DWORD old_protect {};
+        auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
+        if (!VirtualProtect(reinterpret_cast<void*>(addr), HostPageSize, perm, &old_protect)) {
+            LOG_ERROR(HW_Memory, "Failed to change permissions of large buffer region at {:#x}, error {}", addr, GetLastError());
+            return false;
+        }
+        return true;
     } else if (info.State != MEM_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped or is already committed (state {:#x})", addr, info.State);
+        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped (state {:#x})", addr, info.State);
         return false;
     }
 
@@ -123,7 +136,8 @@ void* AllocateMemoryPages(std::size_t size) noexcept {
     void* base = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
 
     if (base != nullptr) {
-        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
+        std::lock_guard lock(vector_regions_mutex);
+        vector_regions.emplace_back(reinterpret_cast<u64>(base) >> HostPageBits, (reinterpret_cast<u64>(base) + size) >> HostPageBits);
 
         static std::once_flag flag;
         std::call_once(flag, []() { AddVectoredExceptionHandler(1, FakePageFaultHandler); });
@@ -149,6 +163,8 @@ void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
     if (!base)
         return;
 #ifdef _WIN32
+    std::lock_guard lock(vector_regions_mutex);
+    std::erase_if(vector_regions, [base](const auto& r) {return r.first == reinterpret_cast<u64>(base); });
     ASSERT(VirtualFree(base, 0, MEM_RELEASE));
 #else
     ASSERT(munmap(base, size) == 0);

src/common/sparse_large_vector.h

@@ -28,9 +28,9 @@ constexpr u64 HostPageBits = 12;
 constexpr u64 HostPageMask = ~(HostPageSize - 1);
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
 #else
-const u64 HostPageSize = sysconf(_SC_PAGESIZE);
-const u64 HostPageBits = std::countr_zero(HostPageSize);
-const u64 HostPageMask = ~(HostPageSize - 1);
+inline const u64 HostPageSize = sysconf(_SC_PAGESIZE);
+inline const u64 HostPageBits = std::countr_zero(HostPageSize);
+inline const u64 HostPageMask = ~(HostPageSize - 1);
 #endif
 
 void* AllocateMemoryPages(std::size_t size) noexcept;
@@ -81,8 +81,8 @@ public:
             UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", index);
         }
 
-        if (!IsCommittedPage(index)) {
-            CommitPage(index);
+        if (!IsCommittedPage(index) && !CommitPage(index)) {
+            UNREACHABLE_MSG("Cannot access SparseLargeVector index {} with RW permission", index);
         }
         return base_ptr[index];
     }
@@ -103,9 +103,8 @@ public:
             LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
             return;
         }
-        if (!IsCommittedPage(index))
-            CommitPage(index);
-        base_ptr[index] = value;
+        if (IsCommittedPage(index) || CommitPage(index))
+            base_ptr[index] = value;
     }
 
     void ZeroRegion(std::size_t start, std::size_t end_) noexcept {
@@ -177,16 +176,22 @@ private:
         return (val >> (page & 63)) & 1;
     }
 
-    constexpr void CommitPage(std::size_t index) noexcept {
+    constexpr bool CommitPage(std::size_t index) noexcept {
         auto page_index = (index * sizeof(T)) >> HostPageBits;
         auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
 #if defined(_WIN32)
-        CommitVectorPage(page, true);
+        if (!CommitVectorPage(page, true)) {
+            return false;
+        }
 #else
-        mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE);
+        if (mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE) != 0) {
+            LOG_ERROR(Common_Memory, "Failed to commit large buffer region at index {}, error {}", index, strerror(errno));
+            return false;
+        }
 #endif
 
         committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
+        return true;
     }
 
     constexpr void DecommitPage(std::size_t index) noexcept {

src/hid_core/frontend/emulated_controller.cpp

@@ -761,9 +761,6 @@ void EmulatedController::StartMotionCalibration() {
 }
 
 void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index, Common::UUID uuid) {
-    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
-    const auto& player = Settings::values.players.GetValue()[player_index];
-
     if (index >= controller.button_values.size()) {
         return;
     }
@@ -916,21 +913,10 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
         break;
     }
 
-    if (!is_connected) {
-        if (npad_type == NpadStyleIndex::Handheld) {
-            if (npad_id_type == NpadIdType::Handheld) {
-                Connect();
-                controller_connected[player_index] = true;
-            }
-        } else if (npad_type != NpadStyleIndex::Handheld) {
-            if (npad_id_type == NpadIdType::Player1) {
-                Connect();
-                controller_connected[player_index] = true;
-            } else if (player.connected && !controller_connected[player_index]) {
-                Connect();
-                controller_connected[player_index] = true;
-            }
-        }
+    const auto player_index = Service::HID::NpadIdTypeToIndex(npad_id_type);
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    if (player.connected) {
+        Connect();
     }
 
     TriggerOnChange(ControllerTriggerType::Button, true);

src/hid_core/frontend/emulated_controller.h

@@ -22,7 +22,6 @@
 #include "common/settings.h"
 #include "common/vector_math.h"
 #include "hid_core/frontend/motion_input.h"
-#include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
 #include "hid_core/irsensor/irs_types.h"
 
@@ -585,7 +584,6 @@ private:
     std::array<VibrationValue, 2> last_vibration_value{DEFAULT_VIBRATION_VALUE,
                                                        DEFAULT_VIBRATION_VALUE};
     std::array<std::chrono::steady_clock::time_point, 2> last_vibration_timepoint{};
-    std::array<bool, HIDCore::available_controllers> controller_connected{};
 
     // Atomically synched values
     std::atomic<HID::NpadStyleIndex> npad_type{HID::NpadStyleIndex::None};

src/qt_common/config/shared_translation.cpp

@@ -226,9 +226,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
     INSERT(Settings, dma_accuracy, tr("DMA Accuracy:"),
            tr("Controls the DMA read mode.\nUnsafe is faster, while Safe is more stable and can fix issues in some games.\nDefault follows the GPU Accuracy setting."));
     INSERT(Settings, gpu_fence_behavior, tr("GPU Fence Behavior:"),
-           tr("Controls the GPU fence synchronization behavior.\nImmediate is the fastest option, but can introduce some issues.\nBalanced offers better compatibility and may fix issues in some games.\nAccurate further improves compatibility at the cost of some performance.\nStrict is the slowest option, but can fix issues that require stricter synchronization.\nDefault follows the GPU Accuracy setting."));
-    INSERT(Settings, enable_gpu_buffer_readback, tr("Enable GPU buffer readback"),
-           tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
+           tr("Controls the GPU fence synchronization behavior.\nImmediate is the fastest option, but can introduce some issues.\nBalanced offers better compatibility and may fix issues in some games.\nAccurate further improves compatibility at the cost of some performance.\nDefault follows the GPU Mode setting."));
     INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
            tr("May reduce shader stutter."));
     INSERT(Settings, gpu_clock, tr("GPU Clocks"),
@@ -442,7 +440,6 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                               PAIR(GpuFenceBehavior, Immediate, tr("Immediate")),
                               PAIR(GpuFenceBehavior, Balanced, tr("Balanced")),
                               PAIR(GpuFenceBehavior, Accurate, tr("Accurate")),
-                              PAIR(GpuFenceBehavior, Strict, tr("Strict")),
                           }});
     translations->insert(
         {Settings::EnumMetadata<Settings::CpuAccuracy>::Index(),

src/video_core/buffer_cache/buffer_cache.h

@@ -249,6 +249,10 @@ bool BufferCache<P>::DMACopy(GPUVAddr src_address, GPUVAddr dest_address, u64 am
     runtime.CopyBuffer(dest_buffer, src_buffer, copies, true);
     if (has_new_downloads) {
         memory_tracker.MarkRegionAsGpuModified(*cpu_dest_address, amount);
+        const bool should_sync = Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate();
+        if (should_sync) {
+            runtime.Finish();
+        }
     }
 
     Tegra::Memory::DeviceGuestMemoryScoped<u8, Tegra::Memory::GuestMemoryFlags::UnsafeReadWrite>
@@ -1230,7 +1234,7 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
         buffer.MarkUsage(offset, size);
 
         if (is_written) {
-            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size, true);
         }
 
         if constexpr (NEEDS_BIND_STORAGE_INDEX) {
@@ -1516,10 +1520,12 @@ void BufferCache<P>::UpdateComputeTextureBuffers() {
 }
 
 template <class P>
-void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size) {
+void BufferCache<P>::MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size, bool needs_sync) {
     if constexpr (!IS_OPENGL) {
-        Buffer& buffer = slot_buffers[buffer_id];
-        buffer.setWriteTick(runtime.CurrentTick());
+        if (needs_sync) {
+            Buffer& buffer = slot_buffers[buffer_id];
+            buffer.setWriteTick(runtime.CurrentTick());
+        }
     }
     memory_tracker.MarkRegionAsGpuModified(device_addr, size);
     gpu_modified_ranges.Add(device_addr, size);
@@ -1535,8 +1541,11 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
     const BufferId buffer_id = page_table[page];
     if (buffer_id) {
         Buffer& buffer = slot_buffers[buffer_id];
-        WaitForGpuFenceIfNeeded(buffer);
         if (buffer.IsInBounds(device_addr, size)) {
+            const bool should_sync = Settings::IsGPUFenceBehaviorAccurate();
+            if (should_sync) {
+                SynchronizeBufferWrites(buffer);
+            }
             bool usable = true;
             if constexpr (requires { buffer.IsSparseCompatible(); }) {
                 if (sparse_compatible && !buffer.IsSparseCompatible()) {
@@ -1552,17 +1561,11 @@ BufferId BufferCache<P>::FindBuffer(DAddr device_addr, u32 size, bool sparse_com
 }
 
 template <class P>
-void BufferCache<P>::WaitForGpuFenceIfNeeded(Buffer& buffer) {
+void BufferCache<P>::SynchronizeBufferWrites(Buffer& buffer) {
     if constexpr (!IS_OPENGL) {
-        const bool gpu_fence_accurate = Settings::IsGPUFenceBehaviorAccurate();
-        const bool gpu_fence_strict = Settings::IsGPUFenceBehaviorStrict();
-        if (gpu_fence_accurate || gpu_fence_strict) {
-            const u64 gpu_tick_delay = gpu_fence_strict ? 0 : 3;
-            const u64 buffer_tick = buffer.getWriteTick();
-            const u64 gpu_tick = runtime.KnownGpuTick();
-            if (buffer_tick > gpu_tick + gpu_tick_delay) {
-                runtime.Wait(buffer_tick);
-            }
+        const u64 buffer_tick = buffer.getWriteTick();
+        if (!runtime.IsFree(buffer_tick)) {
+            runtime.Wait(buffer_tick);
         }
     }
 }
@@ -1795,9 +1798,6 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
                 if (immediate_buffer.empty()) {
                     immediate_buffer = ImmediateBuffer(largest_copy);
                 }
-                if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-                    DownloadBufferMemory(buffer, device_addr, copy.size);
-                }
                 device_memory.ReadBlockUnsafe(device_addr, immediate_buffer.data(), copy.size);
                 upload_span = immediate_buffer.subspan(0, copy.size);
             }
@@ -1816,9 +1816,6 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
         for (BufferCopy& copy : copies) {
             u8* const src_pointer = staging_pointer.data() + copy.src_offset;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
-            if (Settings::values.enable_gpu_buffer_readback.GetValue()) {
-                DownloadBufferMemory(buffer, device_addr, copy.size);
-            }
             device_memory.ReadBlockUnsafe(device_addr, src_pointer, copy.size);
             // Apply the staging offset
             copy.src_offset += upload_staging.offset;

src/video_core/buffer_cache/buffer_cache_base.h

@@ -430,11 +430,11 @@ private:
 
     void UpdateComputeTextureBuffers();
 
-    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size);
+    void MarkWrittenBuffer(BufferId buffer_id, DAddr device_addr, u32 size, bool needs_sync = false);
 
     [[nodiscard]] BufferId FindBuffer(DAddr device_addr, u32 size, bool sparse_compatible);
 
-    void WaitForGpuFenceIfNeeded(Buffer& buffer);
+    void SynchronizeBufferWrites(Buffer& buffer);
 
     [[nodiscard]] OverlapResult ResolveOverlaps(DAddr device_addr, u32 wanted_size);
 

src/video_core/fence_manager.h

@@ -72,7 +72,7 @@ public:
     }
 
     void SignalFence(std::function<void()>&& func) {
-        const bool delay_fence = Settings::IsGPUFenceBehaviorDefault() ? Settings::IsGPULevelHigh() : Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate() || Settings::IsGPUFenceBehaviorStrict();
+        const bool delay_fence = Settings::IsGPUFenceBehaviorDefault() ? Settings::IsGPULevelHigh() : Settings::IsGPUFenceBehaviorBalanced() || Settings::IsGPUFenceBehaviorAccurate();
         const bool should_flush = ShouldFlush();
         if constexpr (!can_async_check) {
             TryReleasePendingFences<false>();

src/video_core/query_cache/query_cache.h

@@ -260,7 +260,7 @@ void QueryCacheBase<Traits>::CounterReport(GPUVAddr addr, QueryType counter_type
     };
     u8* pointer = impl->device_memory.template GetPointer<u8>(cpu_addr);
     u8* pointer_timestamp = impl->device_memory.template GetPointer<u8>(cpu_addr + 8);
-    bool is_synced = (Settings::IsGPUFenceBehaviorDefault() ? !Settings::IsGPULevelHigh() : !Settings::IsGPUFenceBehaviorBalanced() && !Settings::IsGPUFenceBehaviorAccurate() && !Settings::IsGPUFenceBehaviorStrict()) && is_fence;
+    bool is_synced = (Settings::IsGPUFenceBehaviorDefault() ? !Settings::IsGPULevelHigh() : !Settings::IsGPUFenceBehaviorBalanced() && !Settings::IsGPUFenceBehaviorAccurate()) && is_fence;
     std::function<void()> operation([this, is_synced, streamer, query_base = query, query_location,
                                      pointer, pointer_timestamp] {
         if (True(query_base->flags & QueryFlagBits::IsInvalidated)) {

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -419,15 +419,15 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
 }
 
 u64 BufferCacheRuntime::CurrentTick() {
-    return scheduler.GetMasterSemaphore().CurrentTick();
+    return scheduler.CurrentTick();
 }
 
-u64 BufferCacheRuntime::KnownGpuTick() {
-    return scheduler.GetMasterSemaphore().KnownGpuTick();
+bool BufferCacheRuntime::IsFree(u64 tick) {
+    return scheduler.IsFree(tick);
 }
 
-void BufferCacheRuntime::Wait(u64 buffer_tick) {
-    scheduler.Wait(buffer_tick);
+void BufferCacheRuntime::Wait(u64 tick) {
+    scheduler.Wait(tick);
 }
 
 void BufferCacheRuntime::Finish() {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -112,9 +112,9 @@ public:
 
     u64 CurrentTick();
 
-    u64 KnownGpuTick();
+    bool IsFree(u64 tick);
 
-    void Wait(u64 buffer_tick);
+    void Wait(u64 tick);
 
     void Finish();