2026-09-28 14:39:30

Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-09-28 19:38:47 +00:00 · 2026-09-28 14:39:30 +00:00
6 changed files with 245 additions and 224 deletions
@@ -0,0 +1,40 @@
+diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
+index 3012e05..2ae23ff 100644
+--- a/cmake/ConfigureOpenSSL.cmake
+++ b/cmake/ConfigureOpenSSL.cmake
+@@ -108,7 +108,8 @@ function(configure_openssl)
+     )
+ 
+     if(NOT "${CONFIGURE_OPTIONS_OLD}" STREQUAL "")
+-        if(CONFIGURE_OPTIONS STREQUAL CONFIGURE_OPTIONS_OLD)
+        # TODO(lizzie): Emscripten has issues with rebuilding due to the wrapper it uses
+        if(CMAKE_SYSTEM_NAME MATCHES "Emscripten" OR CONFIGURE_OPTIONS STREQUAL CONFIGURE_OPTIONS_OLD)
+             message(STATUS "Found previous configure results. Don't perform configuration")
+             return()
+         endif()
+@@ -134,10 +135,24 @@ function(configure_openssl)
+         set(VERBOSE_OPTION OUTPUT_QUIET)
+     endif()
+ 
+    if (CMAKE_SYSTEM_NAME MATCHES "Emscripten")
+        set(EMSCRIPTEN_CMAKE_WRAPPER "emcmake")
+        find_program(EMCC emcc REQUIRED)
+        set(EMSCRIPTEN_LINKER ${EMCC})
+        list(APPEND CONFIGURE_COMMAND wasm64)
+    else()
+        set(EMSCRIPTEN_CMAKE_WRAPPER "")
+        set(EMSCRIPTEN_LINKER ${CMAKE_LINKER})
+    endif ()
+
+     execute_process(
+-        COMMAND ${CMAKE_COMMAND} -E env
+        COMMAND ${EMSCRIPTEN_CMAKE_WRAPPER} ${CMAKE_COMMAND} -E env
+             "CFLAGS=${CMAKE_C_FLAGS}"
+             "CXXFLAGS=${CMAKE_CXX_FLAGS}"
+            "LDFLAGS=${CMAKE_CXX_LINK_FLAGS}"
+            "CC=${CMAKE_C_COMPILER}"
+            "CXX=${CMAKE_CXX_COMPILER}"
+            "LD=${EMSCRIPTEN_LINKER}"
+             ${CONFIGURE_COMMAND}
+         WORKING_DIRECTORY ${CONFIGURE_BUILD_DIR}
+         ${VERBOSE_OPTION}
@@ -202,7 +202,8 @@
            "0001-cpmutil-compat.patch",
            "0002-use-ccache.patch",
            "0003-use-cmake-compiler-flags.patch",
-            "0004-use-shell-wrapper.patch"
+            "0004-use-shell-wrapper.patch",
+            "0005-cross-compile.patch"
        ],
        "repo": "jimmy-park/openssl-cmake",
        "version": "3.6.2"
@@ -6,10 +6,31 @@ General guide for cross compiling.

 A painless guide for cross compilation (or to test NCE) from a x86_64 system without polluting your main.

- Install QEMU: `sudo pkg install qemu`
- Download Debian 13: `wget https://cdimage.debian.org/debian-cd/current/arm64/iso-cd/debian-13.0.0-arm64-netinst.iso`
- Create a system disk: `qemu-img create -f qcow2 debian-13-arm64-ci.qcow2 30G`
- Run the VM: `qemu-system-aarch64 -M virt -m 2G -cpu max -bios /usr/local/share/qemu/edk2-aarch64-code.fd -drive if=none,file=debian-13.0.0-arm64-netinst.iso,format=raw,id=cdrom -device scsi-cd,drive=cdrom -drive if=none,file=debian-13-arm64-ci.qcow2,id=hd0,format=qcow2 -device virtio-blk-device,drive=hd0 -device virtio-gpu-pci -device usb-ehci -device usb-kbd -device intel-hda -device hda-output -nic user,model=virtio-net-pci`
+```sh
+#!/bin/sh
+ISO_FILE="debian-13.0.0-arm64-netinst.iso"
+DISK_FILE="debian-13-arm64-ci.qcow2"
+which -- qemu-system-aarch64 || sudo pkg install qemu
+[ -f "$ISO_FILE" ] || wget https://cdimage.debian.org/debian-cd/current/arm64/iso-cd/$ISO_FILE
+[ -f "$DISK_FILE" ] || qemu-img create -f qcow2 "$DISK_FILE" 30G
+QEMU_FLAGS=(
+    -M virt
+    -m 2G
+    -cpu max
+    -bios /usr/local/share/qemu/edk2-aarch64-code.fd
+    -drive if=none,file=$ISO_FILE,format=raw,id=cdrom
+    -drive if=none,file=$DISK_FILE,id=hd0,format=qcow2
+    -device scsi-cd,drive=cdrom
+    -device virtio-blk-device,drive=hd0
+    -device virtio-gpu-pci
+    -device usb-ehci
+    -device usb-kbd
+    -device intel-hda
+    -device hda-output
+    -nic user,model=virtio-net-pci
+)
+qemu-system-aarch64 "${QEMU_FLAGS[@]}"
+```

 ## Gentoo

@@ -101,6 +101,11 @@ endfunction()
 # ia64 exists
 # the rest exist, but are probably less popular than ia64

+detect_architecture_symbols(
+    ARCH wasm
+    SYMBOLS
+        "__EMSCRIPTEN__")
+
 detect_architecture_symbols(
    ARCH arm64
    SYMBOLS
@@ -203,11 +208,6 @@ detect_architecture_symbols(
        "__loongarch__"
        "__loongarch64")

-detect_architecture_symbols(
-    ARCH wasm
-    SYMBOLS
-        "__EMSCRIPTEN__")
-
 # "generic" target
 # If you have reached this point, you're on some as-of-yet unsupported architecture.
 # See the docs up above for known unsupported architectures
@@ -11,149 +11,110 @@ set(FFmpeg_HWACCEL_LDFLAGS)

 if (NOT YUZU_USE_BUNDLED_FFMPEG)
    set(FFmpeg_CROSS_COMPILE_FLAGS "")
-    if (CMAKE_CROSSCOMPILING)
-        message(STATUS "ffmpeg: Enabling cross compilation ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
+    if (ANDROID)
        # 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")
-            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()
-            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)
+        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}")
+        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}-")
+        endif()
+        set(FFmpeg_IS_CROSS_COMPILING TRUE)
    endif()
 endif()

-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)
+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)
 elseif (ANDROID)
    list(APPEND FFmpeg_HWACCEL_FLAGS
        --enable-mediacodec
        --enable-jni
-        --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)
-    # 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
-                "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
-        else()
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBDRM_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBDRM_INCLUDE_DIRS})
-            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBDRM_LDFLAGS})
-        endif()
-        list(APPEND FFmpeg_HWACCEL_FLAGS --enable-libdrm)
-    endif()
-
+    )
+elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
+    find_package(PkgConfig REQUIRED)
    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})
+    pkg_check_modules(CUDA cuda)
+    pkg_check_modules(FFNVCODEC ffnvcodec)
+    pkg_check_modules(VDPAU vdpau)
+
+    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()
-        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})
+        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)
+            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")
+        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-X11 ${LIBVA-X11_FOUND} ${LIBVA-X11_VERSION}")
    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
@@ -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 (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}")
+        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()
-    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})
+    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)...")
+    endif()
 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 
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
        --disable-pthreads
-        --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})
+        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
+    )
 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)
-    
-    set(FFmpeg_FOUND YES)
+        PARENT_SCOPE
+    )
 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()
    endif()
-    find_program(AUTOCONF autoconf REQUIRED)
+
+    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})
@@ -289,15 +250,8 @@ 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_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
+    set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER}  ${CMAKE_C_COMPILER})
+    set(FFmpeg_CXX ${CMAKE_CXX_COMPILER_LAUNCHER}  ${CMAKE_CXX_COMPILER})
    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}"
-                --host-cc=${FFmpeg_HOST_CC}
+                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
                ${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)
-    set(FFmpeg_MAKE_ARGS "")
-    if (DEFINED SYSTEM_THREADS)
-        set(FFmpeg_MAKE_ARGS -j ${SYSTEM_THREADS})
-    endif()
+    execute_process(
+        COMMAND
+            nproc
+        OUTPUT_VARIABLE
+            SYSTEM_THREADS)

    set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})

-    # Most distros use 'gmake', Arch uses 'make'
-    find_program(MAKE NAMES gmake make REQUIRED)
+    # 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()
+
    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)
-    message(FATAL_ERROR "FFmpeg not found")
+    if (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)
@@ -197,15 +197,15 @@ void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::CheckHa

 void EmitA32LeafTerminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::LeafTerminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
    if (auto const x = std::get_if<IR::Term::ReturnToDispatch>(&terminal))
-        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
    if (auto const x = std::get_if<IR::Term::LinkBlock>(&terminal))
-        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
    if (auto const x = std::get_if<IR::Term::LinkBlockFast>(&terminal))
-        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
    if (auto const x = std::get_if<IR::Term::PopRSBHint>(&terminal))
-        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
    if (auto const x = std::get_if<IR::Term::FastDispatchHint>(&terminal))
-        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
    UNREACHABLE();
 }