2026-09-28 14:38:09

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

cpmfile.json

@@ -79,7 +79,7 @@
         "name": "ffmpeg",
         "package": "FFmpeg",
         "repo": "crueter-ci/FFmpeg",
-        "version": "9.0.2-1790726865-946fcce07b"
+        "version": "9.0.1-1788120736-bf1b838f2a"
     },
     "fmt": {
         "hash": "f0da82c545b01692e9fd30fdfb613dbb8dd9716983dcd0ff19ac2a8d36f74beb5540ef38072fdecc1e34191b3682a8542ecbf3a61ef287dbba0a2679d4e023f2",

externals/ffmpeg/CMakeLists.txt

@@ -11,9 +11,11 @@ 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?
+        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")
@@ -26,16 +28,14 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
                 --sysroot="${SYSROOT}"
                 --target-os=android
                 --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
-            --extra-ldflags="-nostdlib"
+                --extra-ldflags="-nostdlib")
-        )
             set(FFmpeg_IS_CROSS_COMPILING TRUE)
-    # User attempts to do a FFmpeg cross compilation because...
+        else()
-    # 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")
+            # 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?
@@ -43,78 +43,117 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
                 --enable-cross-compile
                 --arch="${CMAKE_SYSTEM_PROCESSOR}"
                 --target-os="${FFmpeg_SYSTEM_NAME}"
-            --sysroot="${CMAKE_SYSROOT}"
+                --sysroot="${CMAKE_SYSROOT}")
-        )
             if (DEFINED FFmpeg_CROSS_PREFIX)
                 list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --cross-prefix="${FFmpeg_CROSS_PREFIX}")
             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}-")
+                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()
     endif()
+endif()
 
-if (OPENORBIS OR MANAGARM)
+if (WIN32)
-    # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
+    list(APPEND FFmpeg_HWACCEL_FLAGS
-    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        --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
-    )
+        --enable-decoder=h264_mediacodec
-elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
+        --enable-decoder=vp8_mediacodec
-    find_package(PkgConfig REQUIRED)
+        --enable-decoder=vp9_mediacodec)
-    pkg_check_modules(LIBVA libva)
+elseif (APPLE)
-    pkg_check_modules(CUDA cuda)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
-    pkg_check_modules(FFNVCODEC ffnvcodec)
+        --enable-videotoolbox
-    pkg_check_modules(VDPAU vdpau)
+        --enable-hwaccel=videotoolbox_h264
+        --enable-hwaccel=videotoolbox_vp9)
+endif()
 
 find_package(X11)
 if(X11_FOUND)
-        if (NOT APPLE)
+    # Include X11 if possible, VDPAU lists it as complementary
-            # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
+    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
                 "${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_LIBRARIES
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBDRM_INCLUDE_DIRS})
-                    ${LIBDRM_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBDRM_LDFLAGS})
-                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                    ${LIBDRM_INCLUDE_DIRS})
         endif()
-            list(APPEND FFmpeg_HWACCEL_FLAGS
+        list(APPEND FFmpeg_HWACCEL_FLAGS --enable-libdrm)
-                --enable-libdrm)
     endif()
+
+    pkg_check_modules(LIBVA libva)
     if(LIBVA_FOUND)
-            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA_LIBRARIES})
-            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA_LDFLAGS})
-                ${X11_LIBRARIES}
-                ${LIBVA-DRM_LIBRARIES}
-                ${LIBVA-X11_LIBRARIES}
-                ${LIBVA_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_FLAGS
+            --enable-vaapi
             --enable-hwaccel=h264_vaapi
             --enable-hwaccel=vp8_vaapi
             --enable-hwaccel=vp9_vaapi)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+        # Logically, they can only exist if libva itself exists
-                ${X11_INCLUDE_DIRS}
+        pkg_check_modules(LIBVA-DRM libva-drm)
-                ${LIBVA-DRM_INCLUDE_DIRS}
+        if (LIBVA-DRM_FOUND)
-                ${LIBVA-X11_INCLUDE_DIRS}
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA-DRM_LIBRARIES})
-                ${LIBVA_INCLUDE_DIRS}
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA-DRM_INCLUDE_DIRS})
-            )
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA-DRM_LDFLAGS})
-            message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
+        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)
-            message(WARNING "ffmpeg: libva-dev not found, disabling Video Acceleration API (VA-API)...")
-        endif()
-    else()
-        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        message(WARNING "ffmpeg: X11 libraries not found, disabling VA-API...")
     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)
+        find_package(CUDAToolkit)
-            # This line causes build error if CUDA_INCLUDE_DIRS is anything but a single non-empty value
+        if (CUDAToolkit_FOUND)
-            #list(APPEND FFmpeg_HWACCEL_FLAGS --extra-cflags=-I${CUDA_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDAToolkit_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDA_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDAToolkit_LDFLAGS})
-            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()
+        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}")
 
-    if (VDPAU_FOUND AND NOT APPLE)
+find_package(Vulkan)
+if (Vulkan_FOUND)
     list(APPEND FFmpeg_HWACCEL_FLAGS
-            --enable-vdpau
+        --enable-vulkan
-            --enable-hwaccel=h264_vdpau
+        --enable-hwaccel=h264_vulkan
-            --enable-hwaccel=vp9_vdpau
+        --enable-hwaccel=vp9_vulkan)
-        )
+    list(APPEND FFmpeg_HWACCEL_LIBRARIES ${Vulkan_LIBRARIES})
-        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
+    list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${Vulkan_INCLUDE_DIRS})
-        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)...")
 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 
         --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)
@@ -252,6 +291,13 @@ else()
     # `--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_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(
+    cmake_host_system_information(RESULT SYSTEM_THREADS QUERY NUMBER_OF_LOGICAL_CORES)
-        COMMAND
+    set(FFmpeg_MAKE_ARGS "")
-            nproc
+    if (DEFINED SYSTEM_THREADS)
-        OUTPUT_VARIABLE
+        set(FFmpeg_MAKE_ARGS -j ${SYSTEM_THREADS})
-            SYSTEM_THREADS)
+    endif()
 
     set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
 
-    # BSD make or Solaris make don't support ffmpeg make-j8
+    # Most distros use 'gmake', Arch uses 'make'
-    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
+    find_program(MAKE NAMES gmake make REQUIRED)
-        set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
-    else()
-        set(FFmpeg_MAKE_ARGS "")
-    endif()
-
     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)
+endif()
+unset(FFmpeg_COMPONENTS)
 
-    if (FFmpeg_FOUND)
+if (NOT FFmpeg_FOUND)
-        message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
-    else()
     message(FATAL_ERROR "FFmpeg not found")
 endif()
-endif()
+message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
-
-unset(FFmpeg_COMPONENTS)

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/DriverViewModel.kt

@@ -23,7 +23,6 @@ import org.yuzu.yuzu_emu.model.Driver.Companion.toDriver
 import org.yuzu.yuzu_emu.utils.GpuDriverHelper
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.utils.GpuDriverMetadata
-import org.yuzu.yuzu_emu.utils.DirectoryInitialization
 import org.yuzu.yuzu_emu.utils.NativeConfig
 import java.io.File
 
@@ -147,11 +146,11 @@ class DriverViewModel : ViewModel() {
     private fun wipeGameShaders(game: Game) {
         viewModelScope.launch {
             withContext(Dispatchers.IO) {
-                val userDirectory = DirectoryInitialization.userDirectory
+                val externalFilesDir = YuzuApplication.appContext.getExternalFilesDir(null)
                     ?: return@withContext
                 val shaderDir = File(
-                    userDirectory +
+                    externalFilesDir.absolutePath +
-                    "/cache/shader/" + game.settingsName.lowercase()
+                    "/shader/" + game.settingsName.lowercase()
                 )
                 if (shaderDir.exists()) {
                     shaderDir.deleteRecursively()

src/common/settings_enums.h

@@ -150,7 +150,7 @@ ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, Lanczos, Scale
 ENUM(AntiAliasing, None, Fxaa, Smaa);
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
 ENUM(ConsoleMode, Handheld, Docked);
-ENUM(AppletMode, HLE, LLE, Disabled);
+ENUM(AppletMode, HLE, LLE);
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 ENUM(GpuClock, Normal, Boost, Overclock)
 ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)

src/core/hle/service/ro/ro.cpp

@@ -16,10 +16,6 @@
 #include "core/hle/service/ro/ro_types.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#ifdef HAS_NCE
-#include "core/arm/nce/patcher.h"
-#include "core/hle/kernel/k_shared_memory.h"
-#endif
 
 namespace Service::RO {
 
@@ -390,7 +386,7 @@ public:
         R_SUCCEED();
     }
 
-    Result MapManualLoadModuleMemory(Kernel::KernelCore& kernel, u64* out_address, size_t context_id, u64 nro_address,
+    Result MapManualLoadModuleMemory(u64* out_address, size_t context_id, u64 nro_address,
                                      u64 nro_size, u64 bss_address, u64 bss_size) {
         // Get context.
         ProcessContext* context = this->GetContextById(context_id);
@@ -425,31 +421,7 @@ public:
         R_TRY(context->ValidateNro(std::addressof(nro_info->module_id), std::addressof(rx_size),
                                    std::addressof(ro_size), std::addressof(rw_size),
                                    nro_info->base_address, nro_size, bss_size));
-#ifdef HAS_NCE
-        if (Settings::IsNceEnabled()) {
-            auto* process = context->GetProcess();
-            auto& memory = process->GetMemory();
 
-            std::vector<u8> image(total_size);
-            memory.ReadBlock(nro_info->base_address, image.data(), rx_size);
-
-            Kernel::CodeSet::Segment code{.size = static_cast<u32>(rx_size)};
-            Core::NCE::Patcher patch;
-            patch.PatchText(image, code);
-            patch.RelocateAndCopy(nro_info->base_address, code, image, nullptr);
-
-            const u64 patch_address = nro_info->base_address + total_size;
-            const size_t patch_size = patch.GetSectionSize();
-            constexpr auto permission = Kernel::Svc::MemoryPermission::ReadExecute;
-
-            auto* patch_memory = Kernel::KSharedMemory::Create(kernel);
-            R_TRY(patch_memory->Initialize(kernel, kernel.System().DeviceMemory(), process, permission, permission, patch_size));
-            std::memcpy(patch_memory->GetPointer(), image.data() + total_size, patch_size);
-            R_TRY(process->AddSharedMemory(kernel, patch_memory, patch_address, patch_size));
-            R_TRY(patch_memory->Map(*process, patch_address, patch_size, permission));
-            memory.WriteBlock(nro_info->base_address, image.data(), rx_size);
-        }
-#endif
         // Set NRO perms.
         R_TRY(SetNroPerms(context->GetProcess(), nro_info->base_address, rx_size, ro_size,
                           rw_size + bss_size));
@@ -559,7 +531,7 @@ public:
     Result MapManualLoadModuleMemory(Out<u64> out_load_address, ClientProcessId client_pid,
                                      u64 nro_address, u64 nro_size, u64 bss_address, u64 bss_size) {
         R_TRY(m_ro->ValidateProcess(m_context_id, *client_pid));
-        R_RETURN(m_ro->MapManualLoadModuleMemory(system.Kernel(), out_load_address.Get(), m_context_id, nro_address,
+        R_RETURN(m_ro->MapManualLoadModuleMemory(out_load_address.Get(), m_context_id, nro_address,
                                                  nro_size, bss_address, bss_size));
     }
 

src/core/memory.cpp

@@ -757,7 +757,7 @@ struct Memory::Impl {
         };
         auto& gpu = system.GPU();
         gpu_device_memory->ApplyOpOnPointer(
-            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size, true); });
+            p, scratch_buffers[core], [&](DAddr address) { gpu.InvalidateRegion(address, size); });
     }
 
     Core::System& system;

src/qt_common/config/shared_translation.cpp

@@ -342,6 +342,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
               "it bypasses such prompts and directly exits the emulation."));
     INSERT(UISettings, hide_mouse, tr("Hide mouse on inactivity"),
            tr("Hides the mouse after 2.5s of inactivity."));
+    INSERT(UISettings, controller_applet_disabled, tr("Disable controller applet"),
+           tr("Forcibly disables the use of the controller applet in emulated programs.\n"
+              "When a program attempts to open the controller applet, it is immediately closed."));
     INSERT(UISettings, check_for_updates, tr("Check for updates"),
            tr("Whether or not to check for updates upon startup."));
 
@@ -377,7 +380,6 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                           {
                               PAIR(AppletMode, HLE, tr("Custom frontend")),
                               PAIR(AppletMode, LLE, tr("Real applet")),
-                              PAIR(AppletMode, Disabled, tr("Disabled")),
                           }});
 
     translations->insert({Settings::EnumMetadata<Settings::SpirvOptimizeMode>::Index(),

src/qt_common/config/uisettings.h

@@ -127,6 +127,8 @@ struct Values {
     Setting<bool> hide_mouse{
         linkage, true, "hideInactiveMouse", Category::UiGeneral, Settings::Specialization::Default,
         true,    true};
+    Setting<bool> controller_applet_disabled{linkage, false, "disableControllerApplet",
+                                             Category::UiGeneral};
     // Set when Vulkan is known to crash the application
     bool has_broken_vulkan = false;
 

src/video_core/gpu.cpp

@@ -226,17 +226,7 @@ struct GPU::Impl {
     }
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
+    void InvalidateRegion(DAddr addr, u64 size) {
-        VideoCore::RasterizerInterface* rasterizer = renderer->ReadRasterizer();
-        if (preserve_gpu_writes && rasterizer->MustFlushRegion(addr, size, VideoCommon::CacheType::BufferCache)) {
-            const u64 fence = RequestSyncOperation([rasterizer, addr, size] {
-                rasterizer->FlushRegion(addr, size, VideoCommon::CacheType::BufferCache);
-                rasterizer->OnCacheInvalidation(addr, size);
-            });
-            gpu_thread.TickGPU(is_async);
-            WaitForSyncOperation(fence);
-            return;
-        }
         gpu_thread.InvalidateRegion(addr, size);
     }
 
@@ -528,8 +518,8 @@ void GPU::FlushRegion(DAddr addr, u64 size) {
     impl->FlushRegion(addr, size);
 }
 
-void GPU::InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes) {
+void GPU::InvalidateRegion(DAddr addr, u64 size) {
-    impl->InvalidateRegion(addr, size, preserve_gpu_writes);
+    impl->InvalidateRegion(addr, size);
 }
 
 bool GPU::OnCPUWrite(DAddr addr, u64 size) {

src/video_core/gpu.h

@@ -248,7 +248,7 @@ public:
     void FlushRegion(DAddr addr, u64 size);
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(DAddr addr, u64 size, bool preserve_gpu_writes = false);
+    void InvalidateRegion(DAddr addr, u64 size);
 
     /// Notify rasterizer that CPU is trying to write this area. It returns true if the area is
     /// sensible, false otherwise, addr and size must be a valid combination

src/yuzu/configuration/configure_applets.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,6 +8,7 @@
 
 class QCheckBox;
 class QLineEdit;
+class QComboBox;
 class QDateTimeEdit;
 namespace Core {
 class System;

src/yuzu/configuration/shared_widget.cpp

@@ -140,12 +140,7 @@ QWidget* Widget::CreateCombobox(std::function<std::string()>& serializer,
     if (combobox_enumerations.contains(type)) {
         enumeration = &combobox_enumerations.at(type);
         for (const auto& [id, name] : *enumeration) {
-            if (type == Settings::EnumMetadata<Settings::AppletMode>::Index() &&
+            combobox->addItem(name);
-                id == static_cast<u32>(Settings::AppletMode::Disabled) &&
-                setting.Id() != Settings::values.controller_applet_mode.Id()) {
-                continue;
-            }
-            combobox->addItem(name, id);
         }
     } else {
         return combobox;
@@ -163,8 +158,9 @@ QWidget* Widget::CreateCombobox(std::function<std::string()>& serializer,
     const u32 setting_value = std::strtoul(setting.ToString().c_str(), nullptr, 0);
     combobox->setCurrentIndex(find_index(setting_value));
 
-    serializer = [this]() {
+    serializer = [this, enumeration]() {
-        return std::to_string(combobox->currentData().toUInt());
+        int current = combobox->currentIndex();
+        return std::to_string(enumeration->at(current).first);
     };
 
     restore_func = [this, find_index]() {

src/yuzu/game/common.h

@@ -12,29 +12,25 @@ namespace Yuzu {
 
 inline bool ContainsAllWords(const QString& haystack, const QString& userinput) {
     const QStringList userinput_split = userinput.split(QLatin1Char{' '}, Qt::SkipEmptyParts);
-    return std::all_of(userinput_split.begin(), userinput_split.end(), [&haystack](const QString& s) {
+    return std::all_of(userinput_split.begin(), userinput_split.end(),
-        return haystack.contains(s);
+                       [&haystack](const QString& s) { return haystack.contains(s); });
-    });
 }
 
 inline bool FilterMatches(const QString& filter, const QStandardItem* item) {
     if (filter.isEmpty())
         return true;
 
-    auto const sluggify = [](const QString& s) {
-        QString o(s.normalized(QString::NormalizationForm_D).toLower());
-        return o.replace(QRegularExpression(QStringLiteral("[^a-z\\s]")), QStringLiteral(""));
-    };
-
-    const auto norm_filter = sluggify(filter);
     const auto program_id = item->data(GameListItemPath::ProgramIdRole).toULongLong();
-    const QString file_path = sluggify(item->data(GameListItemPath::FullPathRole).toString());
+
-    const QString file_title = sluggify(item->data(GameListItemPath::TitleRole).toString());
+    const QString file_path = item->data(GameListItemPath::FullPathRole).toString().toLower();
+    const QString file_title = item->data(GameListItemPath::TitleRole).toString().toLower();
     const QString file_program_id = QStringLiteral("%1").arg(program_id, 16, 16, QLatin1Char{'0'});
-    const QString file_name = sluggify(file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) + QLatin1Char{' '} + file_title);
+
-    return (ContainsAllWords(file_name, norm_filter)
+    const QString file_name =
-        || ContainsAllWords(file_title, norm_filter))
+        file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) + QLatin1Char{' '} + file_title;
-        || (file_program_id.size() == 16 && file_program_id.contains(norm_filter));
+
+    return Yuzu::ContainsAllWords(file_name, filter) ||
+           (file_program_id.size() == 16 && file_program_id.contains(filter));
 }
 
 } // namespace Yuzu

src/yuzu/main_window.cpp

@@ -1786,7 +1786,7 @@ bool MainWindow::LoadROM(const QString& filename, Service::AM::FrontendAppletPar
 
     QtCommon::system->SetFrontendAppletSet({
         std::make_unique<QtAmiiboSettings>(*this), // Amiibo Settings
-        (Settings::values.controller_applet_mode.GetValue() == Settings::AppletMode::Disabled)
+        (UISettings::values.controller_applet_disabled.GetValue() == true)
             ? nullptr
             : std::make_unique<QtControllerSelector>(*this), // Controller Selector
         std::make_unique<QtErrorDisplay>(*this),             // Error Display