2026-09-14 00:57:14

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

.patch/ffmpeg/0001-steamdeck.patch

@@ -0,0 +1,34 @@
+diff --git a/libavutil/hwcontext_vulkan.c b/libavutil/hwcontext_vulkan.c
+index 2859ee1..766961f 100644
+--- a/libavutil/hwcontext_vulkan.c
++++ b/libavutil/hwcontext_vulkan.c
+@@ -1688,10 +1688,12 @@ static int setup_queue_families(AVHWDeviceContext *ctx, VkDeviceCreateInfo *cd)
+ 
+     hwctx->nb_qf = 0;
+     hwctx->queue_flags = 0;
++/* SD gamemode vkroots crash
+ #ifdef VK_KHR_internally_synchronized_queues
+     if (p->vkctx.extensions & FF_VK_EXT_INTERNAL_QUEUE_SYNC)
+         hwctx->queue_flags |= VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR;
+ #endif
++*/
+ 
+     /* Pick each queue family to use. */
+ #define PICK_QF(type, vid_op)                                            \
+diff --git a/libavutil/vulkan.c b/libavutil/vulkan.c
+index b2e575c..5b3c9cf 100644
+--- a/libavutil/vulkan.c
++++ b/libavutil/vulkan.c
+@@ -574,10 +574,12 @@ int ff_vk_exec_pool_init(FFVulkanContext *s, AVVulkanDeviceQueueFamily *qf,
+         e->qf = qf->idx;
+         VkDeviceQueueInfo2 qinfo = {
+             .sType            = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
++/* SD gamemode vkroots crash
+ #ifdef VK_KHR_internally_synchronized_queues
+             .flags            = internal_queue_sync ?
+                                 VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR : 0,
+ #endif
++*/
+             .queueFamilyIndex = qf->idx,
+             .queueIndex       = e->qi,
+         };

cpmfile.json

@@ -70,9 +70,9 @@
         "version": "v1.3.18"
     },
     "ffmpeg": {
-        "hash": "ed177621176b3961bdcaa339187d3a7688c1c8b060b79c4bb0257cbc67ad7021ae5d5adca5303b45625abbbe3d9aafdd87ce777b8690ac295290d744c875489a",
+        "hash": "68f46abf0d5dc47ab95083d59e273131a8df7948b82e62db00f00fa416e1d0bd24b799671b5a60752209bb2ac0f75295055ed0085c89a98113323cde23b69710",
         "repo": "FFmpeg/FFmpeg",
-        "version": "c7b5f1537d"
+        "version": "6efe500d2e"
     },
     "ffmpeg-ci": {
         "ci": true,

externals/ffmpeg/CMakeLists.txt

@@ -11,11 +11,9 @@ set(FFmpeg_HWACCEL_LDFLAGS)
 
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
     set(FFmpeg_CROSS_COMPILE_FLAGS "")
-    if (CMAKE_CROSSCOMPILING)
+    if (ANDROID)
-        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")
@@ -28,14 +26,16 @@ 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)
-        else()
+    # 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)
-            # systems FFmpeg natively supports
+        if (FFmpeg_SYSTEM_NAME STREQUAL "openorbis" OR FFmpeg_SYSTEM_NAME STREQUAL "managarm")
-            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,117 +43,78 @@ 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(FATAL_ERROR "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: \${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}-")
+            message(WARNING "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 (WIN32)
+if (OPENORBIS OR MANAGARM)
-    list(APPEND FFmpeg_HWACCEL_FLAGS
+    # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
-        --enable-d3d11va
+    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        --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
+    )
-        --enable-decoder=vp8_mediacodec
+elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
-        --enable-decoder=vp9_mediacodec)
+    find_package(PkgConfig REQUIRED)
-elseif (APPLE)
+    pkg_check_modules(LIBVA libva)
-    list(APPEND FFmpeg_HWACCEL_FLAGS
+    pkg_check_modules(CUDA cuda)
-        --enable-videotoolbox
+    pkg_check_modules(FFNVCODEC ffnvcodec)
-        --enable-hwaccel=videotoolbox_h264
+    pkg_check_modules(VDPAU vdpau)
-        --enable-hwaccel=videotoolbox_vp9)
-endif()
 
     find_package(X11)
     if(X11_FOUND)
-    # Include X11 if possible, VDPAU lists it as complementary
+        if (NOT APPLE)
-    list(APPEND FFmpeg_HWACCEL_LIBRARIES ${X11_LIBRARIES})
+            # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
-    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()
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBDRM_LIBRARIES})
+                pkg_check_modules(LIBDRM libdrm REQUIRED)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBDRM_INCLUDE_DIRS})
+                list(APPEND FFmpeg_HWACCEL_LIBRARIES
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBDRM_LDFLAGS})
+                    ${LIBDRM_LIBRARIES})
+                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                    ${LIBDRM_INCLUDE_DIRS})
             endif()
-        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-libdrm)
+        endif()
+        if(LIBVA_FOUND)
+            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
+            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
+            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)
-        # Logically, they can only exist if libva itself exists
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-        pkg_check_modules(LIBVA-DRM libva-drm)
+                ${X11_INCLUDE_DIRS}
-        if (LIBVA-DRM_FOUND)
+                ${LIBVA-DRM_INCLUDE_DIRS}
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA-DRM_LIBRARIES})
+                ${LIBVA-X11_INCLUDE_DIRS}
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA-DRM_INCLUDE_DIRS})
+                ${LIBVA_INCLUDE_DIRS}
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA-DRM_LDFLAGS})
+            )
-        endif()
+            message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
-        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()
-    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)
+        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        message(WARNING "ffmpeg: X11 libraries not found, disabling VA-API...")
     endif()
-    message(STATUS "ffmpeg: VDPAU ${VDPAU_FOUND} ${VDPAU_VERSION}")
 
-    pkg_check_modules(FFNVCODEC ffnvcodec)
     if (FFNVCODEC_FOUND)
         list(APPEND FFmpeg_HWACCEL_FLAGS
             --enable-cuvid
@@ -161,42 +122,39 @@ if (PkgConfig_FOUND)
             --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
-        find_package(CUDAToolkit)
+        if (CUDA_FOUND)
-        if (CUDAToolkit_FOUND)
+            # This line causes build error if CUDA_INCLUDE_DIRS is anything but a single non-empty value
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDAToolkit_LIBRARIES})
+            #list(APPEND FFmpeg_HWACCEL_FLAGS --extra-cflags=-I${CUDA_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDAToolkit_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDA_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDAToolkit_LDFLAGS})
+            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()
-        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 (VDPAU_FOUND AND NOT APPLE)
-if (Vulkan_FOUND)
         list(APPEND FFmpeg_HWACCEL_FLAGS
-        --enable-vulkan
+            --enable-vdpau
-        --enable-hwaccel=h264_vulkan
+            --enable-hwaccel=h264_vdpau
-        --enable-hwaccel=vp9_vulkan)
+            --enable-hwaccel=vp9_vdpau
-    list(APPEND FFmpeg_HWACCEL_LIBRARIES ${Vulkan_LIBRARIES})
+        )
-    list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${Vulkan_INCLUDE_DIRS})
+        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)...")
     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
@@ -204,28 +162,20 @@ 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)
@@ -233,32 +183,43 @@ 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")
-    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)
+        # 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()
-    find_program(AUTOCONF autoconf REQUIRED)
+    endif()
+
+    find_program(AUTOCONF autoconf)
+    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
+        message(FATAL_ERROR "Required program `autoconf` not found.")
+    endif()
+
+    AddJsonPackage(ffmpeg)
 
     set(FFmpeg_PREFIX ${ffmpeg_SOURCE_DIR})
     set(FFmpeg_BUILD_DIR ${ffmpeg_BINARY_DIR})
@@ -291,13 +252,6 @@ 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}
@@ -307,12 +261,10 @@ 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
@@ -320,40 +272,45 @@ else()
                 --enable-pic
                 --cc=${FFmpeg_CC}
                 --cxx=${FFmpeg_CXX}
+                --ld=${CMAKE_LINKER}
                 --extra-cflags=${CMAKE_C_FLAGS}
                 --extra-cxxflags=${CMAKE_CXX_FLAGS}
-                --extra-ldflags="${FFmpeg_HWACCEL_LDFLAGS}"
+                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
-                --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.
-    cmake_host_system_information(RESULT SYSTEM_THREADS QUERY NUMBER_OF_LOGICAL_CORES)
+    execute_process(
-    set(FFmpeg_MAKE_ARGS "")
+        COMMAND
-    if (DEFINED SYSTEM_THREADS)
+            nproc
-        set(FFmpeg_MAKE_ARGS -j ${SYSTEM_THREADS})
+        OUTPUT_VARIABLE
-    endif()
+            SYSTEM_THREADS)
 
     set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
 
-    # Most distros use 'gmake', Arch uses 'make'
+    # BSD make or Solaris make don't support ffmpeg make-j8
-    find_program(MAKE NAMES gmake make REQUIRED)
+    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
+        set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
+    else()
+        set(FFmpeg_MAKE_ARGS "")
+    endif()
+
     add_custom_command(
         OUTPUT
             ${FFmpeg_BUILD_LIBRARIES}
         COMMAND
-            ${MAKE} ${FFmpeg_MAKE_ARGS}
+            gmake ${FFmpeg_MAKE_ARGS}
         WORKING_DIRECTORY
-            ${FFmpeg_BUILD_DIR})
+            ${FFmpeg_BUILD_DIR}
+    )
 
     set(FFmpeg_INCLUDE_DIR
         "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR};${FFmpeg_HWACCEL_INCLUDE_DIRS}"
@@ -375,10 +332,12 @@ else()
     unset(FFmpeg_HWACCEL_INCLUDE_DIRS)
     unset(FFmpeg_HWACCEL_LDFLAGS)
     unset(FFmpeg_HWACCEL_LIBRARIES)
-endif()
-unset(FFmpeg_COMPONENTS)
 
-if (NOT FFmpeg_FOUND)
+    if (FFmpeg_FOUND)
+        message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
+    else()
         message(FATAL_ERROR "FFmpeg not found")
     endif()
-message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")
+endif()
+
+unset(FFmpeg_COMPONENTS)

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);
+ENUM(AppletMode, HLE, LLE, Disabled);
 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,6 +16,10 @@
 #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 {
 
@@ -386,7 +390,7 @@ public:
         R_SUCCEED();
     }
 
-    Result MapManualLoadModuleMemory(u64* out_address, size_t context_id, u64 nro_address,
+    Result MapManualLoadModuleMemory(Kernel::KernelCore& kernel, 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);
@@ -421,7 +425,31 @@ 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));
@@ -531,7 +559,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(out_load_address.Get(), m_context_id, nro_address,
+        R_RETURN(m_ro->MapManualLoadModuleMemory(system.Kernel(), out_load_address.Get(), m_context_id, nro_address,
                                                  nro_size, bss_address, bss_size));
     }
 

src/qt_common/config/shared_translation.cpp

@@ -342,9 +342,6 @@ 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."));
 
@@ -380,6 +377,7 @@ 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,8 +127,6 @@ 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/yuzu/configuration/configure_applets.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -8,7 +11,6 @@
 
 class QCheckBox;
 class QLineEdit;
-class QComboBox;
 class QDateTimeEdit;
 namespace Core {
 class System;

src/yuzu/configuration/shared_widget.cpp

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

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
-        (UISettings::values.controller_applet_disabled.GetValue() == true)
+        (Settings::values.controller_applet_mode.GetValue() == Settings::AppletMode::Disabled)
             ? nullptr
             : std::make_unique<QtControllerSelector>(*this), // Controller Selector
         std::make_unique<QtErrorDisplay>(*this),             // Error Display