glsl_shader_gen: Increase z=0 epsillon

.github/workflows/build.yml

@@ -12,13 +12,13 @@ jobs:
     if: ${{ !github.head_ref }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
       - name: Pack
         run: ./.ci/source.sh
       - name: Upload
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: source
           path: artifacts/
@@ -37,11 +37,11 @@ jobs:
       OS: linux
       TARGET: ${{ matrix.target }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
       - name: Set up cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: ${{ env.CCACHE_DIR }}
           key: ${{ runner.os }}-${{ matrix.target }}-${{ github.sha }}
@@ -53,13 +53,13 @@ jobs:
         run: ./.ci/pack.sh
         if: ${{ matrix.target == 'appimage' }}
       - name: Upload
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         if: ${{ matrix.target == 'appimage' }}
         with:
           name: ${{ env.OS }}-${{ env.TARGET }}
           path: artifacts/
   macos:
-    runs-on: ${{ (matrix.target == 'x86_64' && 'macos-13') || 'macos-14' }}
+    runs-on: macos-13
     strategy:
       matrix:
         target: ["x86_64", "arm64"]
@@ -70,43 +70,43 @@ jobs:
       OS: macos
       TARGET: ${{ matrix.target }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
       - name: Set up cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: ${{ env.CCACHE_DIR }}
           key: ${{ runner.os }}-${{ matrix.target }}-${{ github.sha }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.target }}-
       - name: Install tools
-        run: brew install ccache ninja
+        run: brew install ccache glslang ninja
       - name: Build
         run: ./.ci/macos.sh
       - name: Prepare outputs for caching
         run: mv build/bundle $OS-$TARGET
       - name: Cache outputs for universal build
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v3
         with:
           path: ${{ env.OS }}-${{ env.TARGET }}
           key: ${{ runner.os }}-${{ matrix.target }}-${{ github.sha }}-${{ github.run_id }}-${{ github.run_attempt }}
   macos-universal:
-    runs-on: macos-14
+    runs-on: macos-13
     needs: macos
     env:
       OS: macos
       TARGET: universal
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Download x86_64 build from cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v3
         with:
           path: ${{ env.OS }}-x86_64
           key: ${{ runner.os }}-x86_64-${{ github.sha }}-${{ github.run_id }}-${{ github.run_attempt }}
           fail-on-cache-miss: true
       - name: Download ARM64 build from cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v3
         with:
           path: ${{ env.OS }}-arm64
           key: ${{ runner.os }}-arm64-${{ github.sha }}-${{ github.run_id }}-${{ github.run_attempt }}
@@ -118,7 +118,7 @@ jobs:
       - name: Pack
         run: ./.ci/pack.sh
       - name: Upload
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.OS }}-${{ env.TARGET }}
           path: artifacts/
@@ -137,11 +137,11 @@ jobs:
       OS: windows
       TARGET: ${{ matrix.target }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
       - name: Set up cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: ${{ env.CCACHE_DIR }}
           key: ${{ runner.os }}-${{ matrix.target }}-${{ github.sha }}
@@ -153,6 +153,13 @@ jobs:
       - name: Install extra tools (MSVC)
         run: choco install ccache ninja wget
         if: ${{ matrix.target == 'msvc' }}
+      - name: Set up Vulkan SDK (MSVC)
+        uses: humbletim/setup-vulkan-sdk@v1.2.0
+        if: ${{ matrix.target == 'msvc' }}
+        with:
+          vulkan-query-version: latest
+          vulkan-components: SPIRV-Tools, Glslang
+          vulkan-use-cache: true
       - name: Set up MSYS2
         uses: msys2/setup-msys2@v2
         if: ${{ matrix.target == 'msys2' }}
@@ -161,8 +168,10 @@ jobs:
           update: true
           install: git make p7zip
           pacboy: >-
-            toolchain:p ccache:p cmake:p ninja:p
+            toolchain:p ccache:p cmake:p ninja:p glslang:p
             qt6-base:p qt6-multimedia:p qt6-multimedia-wmf:p qt6-tools:p qt6-translations:p
+      - name: Test glslang
+        run: glslang --version || glslangValidator --version
       - name: Disable line ending translation
         run: git config --global core.autocrlf input
       - name: Build
@@ -170,7 +179,7 @@ jobs:
       - name: Pack
         run: ./.ci/pack.sh
       - name: Upload
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.OS }}-${{ env.TARGET }}
           path: artifacts/
@@ -183,11 +192,11 @@ jobs:
       OS: android
       TARGET: universal
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
       - name: Set up cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: |
             ~/.gradle/caches
@@ -206,7 +215,7 @@ jobs:
         run: |
           sudo add-apt-repository -y ppa:theofficialgman/gpu-tools
           sudo apt-get update -y
-          sudo apt-get install ccache apksigner -y
+          sudo apt-get install ccache glslang-dev glslang-tools apksigner -y
       - name: Build
         run: JAVA_HOME=$JAVA_HOME_17_X64 ./.ci/android.sh
         env:
@@ -219,12 +228,12 @@ jobs:
         env:
           UNPACKED: 1
       - name: Upload
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.OS }}-${{ env.TARGET }}
           path: src/android/app/artifacts/
   ios:
-    runs-on: macos-14
+    runs-on: macos-13
     if: ${{ !startsWith(github.ref, 'refs/tags/') }}
     env:
       CCACHE_DIR: ${{ github.workspace }}/.ccache
@@ -233,18 +242,18 @@ jobs:
       OS: ios
       TARGET: arm64
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
       - name: Set up cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         with:
           path: ${{ env.CCACHE_DIR }}
           key: ${{ runner.os }}-ios-${{ github.sha }}
           restore-keys: |
             ${{ runner.os }}-ios-
       - name: Install tools
-        run: brew install ccache ninja
+        run: brew install ccache glslang ninja
       - name: Build
         run: ./.ci/ios.sh
   release:
@@ -252,7 +261,7 @@ jobs:
     needs: [windows, linux, macos-universal, android, source]
     if: ${{ startsWith(github.ref, 'refs/tags/') }}
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v3
       - name: Create release
         uses: actions/create-release@v1
         env:

.github/workflows/format.yml

@@ -13,7 +13,7 @@ jobs:
       image: citraemu/build-environments:linux-fresh
       options: -u 1001
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Build

.github/workflows/publish.yml

@@ -20,11 +20,11 @@ jobs:
     if: ${{ github.event.inputs.nightly != 'false' && github.repository == 'citra-emu/citra' }}
     steps:
       # this checkout is required to make sure the GitHub Actions scripts are available
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         name: Pre-checkout
         with:
           submodules: false
-      - uses: actions/github-script@v7
+      - uses: actions/github-script@v6
         id: check-changes
         name: 'Check for new changes'
         env:
@@ -38,7 +38,7 @@ jobs:
             return checkBaseChanges(github, context);
       - run: npm install execa@5
         if: ${{ steps.check-changes.outputs.result == 'true' }}
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         name: Checkout
         if: ${{ steps.check-changes.outputs.result == 'true' }}
         with:
@@ -46,7 +46,7 @@ jobs:
           fetch-depth: 0
           submodules: true
           token: ${{ secrets.ALT_GITHUB_TOKEN }}
-      - uses: actions/github-script@v7
+      - uses: actions/github-script@v6
         name: 'Update and tag new commits'
         if: ${{ steps.check-changes.outputs.result == 'true' }}
         env:
@@ -62,11 +62,11 @@ jobs:
     if: ${{ github.event.inputs.canary != 'false' && github.repository == 'citra-emu/citra' }}
     steps:
       # this checkout is required to make sure the GitHub Actions scripts are available
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         name: Pre-checkout
         with:
           submodules: false
-      - uses: actions/github-script@v7
+      - uses: actions/github-script@v6
         id: check-changes
         name: 'Check for new changes'
         env:
@@ -79,7 +79,7 @@ jobs:
             return checkCanaryChanges(github, context);
       - run: npm install execa@5
         if: ${{ steps.check-changes.outputs.result == 'true' }}
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         name: Checkout
         if: ${{ steps.check-changes.outputs.result == 'true' }}
         with:
@@ -87,7 +87,7 @@ jobs:
           fetch-depth: 0
           submodules: true
           token: ${{ secrets.ALT_GITHUB_TOKEN }}
-      - uses: actions/github-script@v7
+      - uses: actions/github-script@v6
         name: 'Check and merge canary changes'
         if: ${{ steps.check-changes.outputs.result == 'true' }}
         env:

.github/workflows/transifex.yml

@@ -10,7 +10,7 @@ jobs:
     container: citraemu/build-environments:linux-fresh
     if: ${{ github.repository == 'citra-emu/citra' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
           fetch-depth: 0

CMakeLists.txt

@@ -74,7 +74,8 @@ CMAKE_DEPENDENT_OPTION(ENABLE_DEDICATED_ROOM "Enable generating dedicated room e
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 option(ENABLE_SCRIPTING "Enable RPC server for scripting" ON)
 
-CMAKE_DEPENDENT_OPTION(ENABLE_CUBEB "Enables the cubeb audio backend" ON "NOT IOS" OFF)
+# TODO: cubeb currently causes issues on macOS, see: https://github.com/mozilla/cubeb/issues/771
+CMAKE_DEPENDENT_OPTION(ENABLE_CUBEB "Enables the cubeb audio backend" ON "NOT APPLE" OFF)
 option(ENABLE_OPENAL "Enables the OpenAL audio backend" ON)
 
 CMAKE_DEPENDENT_OPTION(ENABLE_LIBUSB "Enable libusb for GameCube Adapter support" ON "NOT IOS" OFF)
@@ -85,6 +86,8 @@ option(ENABLE_VULKAN "Enables the Vulkan renderer" ON)
 
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
+CMAKE_DEPENDENT_OPTION(CITRA_ENABLE_BUNDLE_TARGET "Enable the distribution bundling target." ON "NOT ANDROID AND NOT IOS" OFF)
+
 # Compile options
 CMAKE_DEPENDENT_OPTION(COMPILE_WITH_DWARF "Add DWARF debugging information" ${IS_DEBUG_BUILD} "MINGW" OFF)
 option(ENABLE_LTO "Enable link time optimization" ${DEFAULT_ENABLE_LTO})
@@ -247,26 +250,6 @@ if (ENABLE_QT)
     if (ENABLE_QT_TRANSLATION)
         find_package(Qt6 REQUIRED COMPONENTS LinguistTools)
     endif()
-
-    if (NOT DEFINED QT_TARGET_PATH)
-        # Determine the location of the compile target's Qt.
-        get_target_property(qtcore_path Qt6::Core LOCATION_Release)
-        string(FIND "${qtcore_path}" "/bin/" qtcore_path_bin_pos REVERSE)
-        string(FIND "${qtcore_path}" "/lib/" qtcore_path_lib_pos REVERSE)
-        if (qtcore_path_bin_pos GREATER qtcore_path_lib_pos)
-            string(SUBSTRING "${qtcore_path}" 0 ${qtcore_path_bin_pos} QT_TARGET_PATH)
-        else()
-            string(SUBSTRING "${qtcore_path}" 0 ${qtcore_path_lib_pos} QT_TARGET_PATH)
-        endif()
-    endif()
-
-    if (NOT DEFINED QT_HOST_PATH)
-        # Use the same for host Qt if none is defined.
-        set(QT_HOST_PATH "${QT_TARGET_PATH}")
-    endif()
-
-    message(STATUS "Using target Qt at ${QT_TARGET_PATH}")
-    message(STATUS "Using host Qt at ${QT_HOST_PATH}")
 endif()
 
 # Use system tsl::robin_map if available (otherwise we fallback to version bundled with dynarmic)
@@ -442,8 +425,7 @@ else()
 endif()
 
 # Create target for outputting distributable bundles.
-# Not supported for mobile platforms as distributables are built differently.
-if (NOT ANDROID AND NOT IOS)
+if (CITRA_ENABLE_BUNDLE_TARGET)
     include(BundleTarget)
     if (ENABLE_SDL2_FRONTEND)
         bundle_target(citra)

CMakeModules/BundleTarget.cmake

@@ -2,104 +2,37 @@
 if (BUNDLE_TARGET_EXECUTE)
     # --- Bundling method logic ---
 
-    function(symlink_safe_copy from to)
-        if (WIN32)
-            # Use cmake copy for maximum compatibility.
-            execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${from}" "${to}"
-                RESULT_VARIABLE cp_result)
-        else()
-            # Use native copy to turn symlinks into normal files.
-            execute_process(COMMAND cp -L "${from}" "${to}"
-                RESULT_VARIABLE cp_result)
-        endif()
-        if (NOT cp_result EQUAL "0")
-            message(FATAL_ERROR "cp \"${from}\" \"${to}\" failed: ${cp_result}")
-        endif()
-    endfunction()
-
     function(bundle_qt executable_path)
         if (WIN32)
-            # Perform standalone bundling first to copy over all used libraries, as windeployqt does not do this.
-            bundle_standalone("${executable_path}" "${EXECUTABLE_PATH}" "${BUNDLE_LIBRARY_PATHS}")
-
             get_filename_component(executable_parent_dir "${executable_path}" DIRECTORY)
+            find_program(windeployqt_executable windeployqt6)
 
             # Create a qt.conf file pointing to the app directory.
             # This ensures Qt can find its plugins.
-            file(WRITE "${executable_parent_dir}/qt.conf" "[Paths]\nPrefix = .")
-
-            find_program(windeployqt_executable windeployqt6 PATHS "${QT_HOST_PATH}/bin")
-            find_program(qtpaths_executable qtpaths6 PATHS "${QT_HOST_PATH}/bin")
-
-            # TODO: Hack around windeployqt's poor cross-compilation support by
-            # TODO: making a local copy with a prefix pointing to the target Qt.
-            if (NOT "${QT_HOST_PATH}" STREQUAL "${QT_TARGET_PATH}")
-                set(windeployqt_dir "${BINARY_PATH}/windeployqt_copy")
-                file(MAKE_DIRECTORY "${windeployqt_dir}")
-                symlink_safe_copy("${windeployqt_executable}" "${windeployqt_dir}/windeployqt.exe")
-                symlink_safe_copy("${qtpaths_executable}" "${windeployqt_dir}/qtpaths.exe")
-                symlink_safe_copy("${QT_HOST_PATH}/bin/Qt6Core.dll" "${windeployqt_dir}")
-
-                if (EXISTS "${QT_TARGET_PATH}/share")
-                    # Unix-style Qt; we need to wire up the paths manually.
-                    file(WRITE "${windeployqt_dir}/qt.conf" "\
-                        [Paths]\n
-                        Prefix = ${QT_TARGET_PATH}\n \
-                        ArchData = ${QT_TARGET_PATH}/share/qt6\n \
-                        Binaries = ${QT_TARGET_PATH}/bin\n \
-                        Data = ${QT_TARGET_PATH}/share/qt6\n \
-                        Documentation = ${QT_TARGET_PATH}/share/qt6/doc\n \
-                        Headers = ${QT_TARGET_PATH}/include/qt6\n \
-                        Libraries = ${QT_TARGET_PATH}/lib\n \
-                        LibraryExecutables = ${QT_TARGET_PATH}/share/qt6/bin\n \
-                        Plugins = ${QT_TARGET_PATH}/share/qt6/plugins\n \
-                        QmlImports = ${QT_TARGET_PATH}/share/qt6/qml\n \
-                        Translations = ${QT_TARGET_PATH}/share/qt6/translations\n \
-                    ")
-                else()
-                    # Windows-style Qt; the defaults should suffice.
-                    file(WRITE "${windeployqt_dir}/qt.conf" "[Paths]\nPrefix = ${QT_TARGET_PATH}")
-                endif()
-
-                set(windeployqt_executable "${windeployqt_dir}/windeployqt.exe")
-                set(qtpaths_executable "${windeployqt_dir}/qtpaths.exe")
-            endif()
+            file(WRITE "${executable_parent_dir}/qt.conf" "[Paths]\nprefix = .")
 
             message(STATUS "Executing windeployqt for executable ${executable_path}")
             execute_process(COMMAND "${windeployqt_executable}" "${executable_path}"
-                --qtpaths "${qtpaths_executable}"
                 --no-compiler-runtime --no-system-d3d-compiler --no-opengl-sw --no-translations
-                --plugindir "${executable_parent_dir}/plugins"
-                RESULT_VARIABLE windeployqt_result)
-            if (NOT windeployqt_result EQUAL "0")
-                message(FATAL_ERROR "windeployqt failed: ${windeployqt_result}")
-            endif()
+                --plugindir "${executable_parent_dir}/plugins")
 
             # Remove the FFmpeg multimedia plugin as we don't include FFmpeg.
             # We want to use the Windows media plugin instead, which is also included.
             file(REMOVE "${executable_parent_dir}/plugins/multimedia/ffmpegmediaplugin.dll")
         elseif (APPLE)
             get_filename_component(executable_name "${executable_path}" NAME_WE)
-            find_program(macdeployqt_executable macdeployqt6 PATHS "${QT_HOST_PATH}/bin")
+            find_program(MACDEPLOYQT_EXECUTABLE macdeployqt6)
 
-            message(STATUS "Executing macdeployqt at \"${macdeployqt_executable}\" for executable \"${executable_path}\"")
+            message(STATUS "Executing macdeployqt for executable ${executable_path}")
             execute_process(
-                COMMAND "${macdeployqt_executable}"
+                COMMAND "${MACDEPLOYQT_EXECUTABLE}"
                 "${executable_path}"
                 "-executable=${executable_path}/Contents/MacOS/${executable_name}"
-                -always-overwrite
-                RESULT_VARIABLE macdeployqt_result)
-            if (NOT macdeployqt_result EQUAL "0")
-                message(FATAL_ERROR "macdeployqt failed: ${macdeployqt_result}")
-            endif()
+                -always-overwrite)
 
             # Bundling libraries can rewrite path information and break code signatures of system libraries.
             # Perform an ad-hoc re-signing on the whole app bundle to fix this.
-            execute_process(COMMAND codesign --deep -fs - "${executable_path}"
-                            RESULT_VARIABLE codesign_result)
-            if (NOT codesign_result EQUAL "0")
-                message(FATAL_ERROR "codesign failed: ${codesign_result}")
-            endif()
+            execute_process(COMMAND codesign --deep -fs - "${executable_path}")
         else()
             message(FATAL_ERROR "Unsupported OS for Qt bundling.")
         endif()
@@ -111,9 +44,9 @@ if (BUNDLE_TARGET_EXECUTE)
 
         if (enable_qt)
             # Find qmake to make sure the plugin uses the right version of Qt.
-            find_program(qmake_executable qmake6 PATHS "${QT_HOST_PATH}/bin")
+            find_program(QMAKE_EXECUTABLE qmake6)
 
-            set(extra_linuxdeploy_env "QMAKE=${qmake_executable}")
+            set(extra_linuxdeploy_env "QMAKE=${QMAKE_EXECUTABLE}")
             set(extra_linuxdeploy_args --plugin qt)
         endif()
 
@@ -126,11 +59,7 @@ if (BUNDLE_TARGET_EXECUTE)
             --executable "${executable_path}"
             --icon-file "${source_path}/dist/citra.svg"
             --desktop-file "${source_path}/dist/${executable_name}.desktop"
-            --appdir "${appdir_path}"
-            RESULT_VARIABLE linuxdeploy_appdir_result)
-        if (NOT linuxdeploy_appdir_result EQUAL "0")
-            message(FATAL_ERROR "linuxdeploy failed to create AppDir: ${linuxdeploy_appdir_result}")
-        endif()
+            --appdir "${appdir_path}")
 
         if (enable_qt)
             set(qt_hook_file "${appdir_path}/apprun-hooks/linuxdeploy-plugin-qt-hook.sh")
@@ -153,11 +82,7 @@ if (BUNDLE_TARGET_EXECUTE)
             "OUTPUT=${bundle_dir}/${executable_name}.AppImage"
             "${linuxdeploy_executable}"
             --output appimage
-            --appdir "${appdir_path}"
-            RESULT_VARIABLE linuxdeploy_appimage_result)
-        if (NOT linuxdeploy_appimage_result EQUAL "0")
-            message(FATAL_ERROR "linuxdeploy failed to create AppImage: ${linuxdeploy_appimage_result}")
-        endif()
+            --appdir "${appdir_path}")
     endfunction()
 
     function(bundle_standalone executable_path original_executable_path bundle_library_paths)
@@ -184,23 +109,16 @@ if (BUNDLE_TARGET_EXECUTE)
             file(MAKE_DIRECTORY ${lib_dir})
             foreach (lib_file IN LISTS resolved_deps)
                 message(STATUS "Bundling library ${lib_file}")
-                symlink_safe_copy("${lib_file}" "${lib_dir}")
+                # Use native copy to turn symlinks into normal files.
+                execute_process(COMMAND cp -L "${lib_file}" "${lib_dir}")
             endforeach()
         endif()
 
         # Add libs directory to executable rpath where applicable.
         if (APPLE)
-            execute_process(COMMAND install_name_tool -add_rpath "@loader_path/libs" "${executable_path}"
-                            RESULT_VARIABLE install_name_tool_result)
-            if (NOT install_name_tool_result EQUAL "0")
-                message(FATAL_ERROR "install_name_tool failed: ${install_name_tool_result}")
-            endif()
+            execute_process(COMMAND install_name_tool -add_rpath "@loader_path/libs" "${executable_path}")
         elseif (UNIX)
-            execute_process(COMMAND patchelf --set-rpath '$ORIGIN/../libs' "${executable_path}"
-                            RESULT_VARIABLE patchelf_result)
-            if (NOT patchelf_result EQUAL "0")
-                message(FATAL_ERROR "patchelf failed: ${patchelf_result}")
-            endif()
+            execute_process(COMMAND patchelf --set-rpath '$ORIGIN/../libs' "${executable_path}")
         endif()
     endfunction()
 
@@ -209,7 +127,7 @@ if (BUNDLE_TARGET_EXECUTE)
     set(bundle_dir ${BINARY_PATH}/bundle)
 
     # On Linux, always bundle an AppImage.
-    if (CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+    if (DEFINED LINUXDEPLOY)
         if (IN_PLACE)
             message(FATAL_ERROR "Cannot bundle for Linux in-place.")
         endif()
@@ -228,12 +146,14 @@ if (BUNDLE_TARGET_EXECUTE)
 
         if (BUNDLE_QT)
             bundle_qt("${bundled_executable_path}")
-        else()
+        endif()
+
+        if (WIN32 OR NOT BUNDLE_QT)
             bundle_standalone("${bundled_executable_path}" "${EXECUTABLE_PATH}" "${BUNDLE_LIBRARY_PATHS}")
         endif()
     endif()
-elseif (BUNDLE_TARGET_DOWNLOAD_LINUXDEPLOY)
-    # --- linuxdeploy download logic ---
+else()
+    # --- Bundling target creation logic ---
 
     # Downloads and extracts a linuxdeploy component.
     function(download_linuxdeploy_component base_dir name executable_name)
@@ -241,7 +161,7 @@ elseif (BUNDLE_TARGET_DOWNLOAD_LINUXDEPLOY)
         if (NOT EXISTS "${executable_file}")
             message(STATUS "Downloading ${executable_name}")
             file(DOWNLOAD
-                "https://github.com/${name}/releases/download/continuous/${executable_name}"
+                "https://github.com/linuxdeploy/${name}/releases/download/continuous/${executable_name}"
                 "${executable_file}" SHOW_PROGRESS)
             file(CHMOD "${executable_file}" PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE)
 
@@ -250,11 +170,7 @@ elseif (BUNDLE_TARGET_DOWNLOAD_LINUXDEPLOY)
                 message(STATUS "Extracting ${executable_name}")
                 execute_process(
                     COMMAND "${executable_file}" --appimage-extract
-                    WORKING_DIRECTORY "${base_dir}"
-                    RESULT_VARIABLE extract_result)
-                if (NOT extract_result EQUAL "0")
-                    message(FATAL_ERROR "AppImage extract failed: ${extract_result}")
-                endif()
+                    WORKING_DIRECTORY "${base_dir}")
             else()
                 message(STATUS "Copying ${executable_name}")
                 file(COPY "${executable_file}" DESTINATION "${base_dir}/squashfs-root/usr/bin/")
@@ -262,102 +178,89 @@ elseif (BUNDLE_TARGET_DOWNLOAD_LINUXDEPLOY)
         endif()
     endfunction()
 
-    # Download plugins first so they don't overwrite linuxdeploy's AppRun file.
-    download_linuxdeploy_component("${LINUXDEPLOY_PATH}" "linuxdeploy/linuxdeploy-plugin-qt" "linuxdeploy-plugin-qt-${LINUXDEPLOY_ARCH}.AppImage")
-    download_linuxdeploy_component("${LINUXDEPLOY_PATH}" "darealshinji/linuxdeploy-plugin-checkrt" "linuxdeploy-plugin-checkrt.sh")
-    download_linuxdeploy_component("${LINUXDEPLOY_PATH}" "linuxdeploy/linuxdeploy" "linuxdeploy-${LINUXDEPLOY_ARCH}.AppImage")
-else()
-    # --- Bundling target creation logic ---
-
-    # Creates the base bundle target with common files and pre-bundle steps.
-    function(create_base_bundle_target)
-        message(STATUS "Creating base bundle target")
-
-        add_custom_target(bundle)
-        add_custom_command(
-            TARGET bundle
-            COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bundle/")
-        add_custom_command(
-            TARGET bundle
-            COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bundle/dist/")
-        add_custom_command(
-            TARGET bundle
-            COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/dist/icon.png" "${CMAKE_BINARY_DIR}/bundle/dist/citra.png")
-        add_custom_command(
-            TARGET bundle
-            COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/license.txt" "${CMAKE_BINARY_DIR}/bundle/")
-        add_custom_command(
-            TARGET bundle
-            COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/README.md" "${CMAKE_BINARY_DIR}/bundle/")
-        add_custom_command(
-            TARGET bundle
-            COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/dist/scripting" "${CMAKE_BINARY_DIR}/bundle/scripting")
-
-        # On Linux, add a command to prepare linuxdeploy and any required plugins before any bundling occurs.
-        if (CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
-            add_custom_command(
-                TARGET bundle
-                COMMAND ${CMAKE_COMMAND}
-                "-DBUNDLE_TARGET_DOWNLOAD_LINUXDEPLOY=1"
-                "-DLINUXDEPLOY_PATH=${CMAKE_BINARY_DIR}/externals/linuxdeploy"
-                "-DLINUXDEPLOY_ARCH=${CMAKE_HOST_SYSTEM_PROCESSOR}"
-                -P "${CMAKE_SOURCE_DIR}/CMakeModules/BundleTarget.cmake"
-                WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
-        endif()
-    endfunction()
-
     # Adds a target to the bundle target, packing in required libraries.
     # If in_place is true, the bundling will be done in-place as part of the specified target.
     function(bundle_target_internal target_name in_place)
         # Create base bundle target if it does not exist.
         if (NOT in_place AND NOT TARGET bundle)
-            create_base_bundle_target()
+            message(STATUS "Creating base bundle target")
+
+            add_custom_target(bundle)
+            add_custom_command(
+                TARGET bundle
+                COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bundle/")
+            add_custom_command(
+                TARGET bundle
+                COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bundle/dist/")
+            add_custom_command(
+                TARGET bundle
+                COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/dist/icon.png" "${CMAKE_BINARY_DIR}/bundle/dist/citra.png")
+            add_custom_command(
+                TARGET bundle
+                COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/license.txt" "${CMAKE_BINARY_DIR}/bundle/")
+            add_custom_command(
+                TARGET bundle
+                COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_SOURCE_DIR}/README.md" "${CMAKE_BINARY_DIR}/bundle/")
+            add_custom_command(
+                TARGET bundle
+                COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/dist/scripting" "${CMAKE_BINARY_DIR}/bundle/scripting")
         endif()
 
-        set(bundle_executable_path "$<TARGET_FILE:${target_name}>")
+        set(BUNDLE_EXECUTABLE_PATH "$<TARGET_FILE:${target_name}>")
         if (target_name MATCHES ".*qt")
-            set(bundle_qt ON)
+            set(BUNDLE_QT ON)
             if (APPLE)
                 # For Qt targets on Apple, expect an app bundle.
-                set(bundle_executable_path "$<TARGET_BUNDLE_DIR:${target_name}>")
+                set(BUNDLE_EXECUTABLE_PATH "$<TARGET_BUNDLE_DIR:${target_name}>")
             endif()
         else()
-            set(bundle_qt OFF)
+            set(BUNDLE_QT OFF)
         endif()
 
         # Build a list of library search paths from prefix paths.
-        foreach(prefix_path IN LISTS CMAKE_FIND_ROOT_PATH CMAKE_PREFIX_PATH CMAKE_SYSTEM_PREFIX_PATH)
+        foreach(prefix_path IN LISTS CMAKE_PREFIX_PATH CMAKE_SYSTEM_PREFIX_PATH)
             if (WIN32)
-                list(APPEND bundle_library_paths "${prefix_path}/bin")
+                list(APPEND BUNDLE_LIBRARY_PATHS "${prefix_path}/bin")
             endif()
-            list(APPEND bundle_library_paths "${prefix_path}/lib")
+            list(APPEND BUNDLE_LIBRARY_PATHS "${prefix_path}/lib")
         endforeach()
         foreach(library_path IN LISTS CMAKE_SYSTEM_LIBRARY_PATH)
-            list(APPEND bundle_library_paths "${library_path}")
+            list(APPEND BUNDLE_LIBRARY_PATHS "${library_path}")
         endforeach()
 
+        # On Linux, prepare linuxdeploy and any required plugins.
+        if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+            set(LINUXDEPLOY_BASE "${CMAKE_BINARY_DIR}/externals/linuxdeploy")
+
+            # Download plugins first so they don't overwrite linuxdeploy's AppRun file.
+            download_linuxdeploy_component("${LINUXDEPLOY_BASE}" "linuxdeploy-plugin-qt" "linuxdeploy-plugin-qt-x86_64.AppImage")
+            download_linuxdeploy_component("${LINUXDEPLOY_BASE}" "linuxdeploy-plugin-checkrt" "linuxdeploy-plugin-checkrt-x86_64.sh")
+            download_linuxdeploy_component("${LINUXDEPLOY_BASE}" "linuxdeploy" "linuxdeploy-x86_64.AppImage")
+
+            set(EXTRA_BUNDLE_ARGS "-DLINUXDEPLOY=${LINUXDEPLOY_BASE}/squashfs-root/AppRun")
+        endif()
+
         if (in_place)
             message(STATUS "Adding in-place bundling to ${target_name}")
-            set(dest_target ${target_name})
+            set(DEST_TARGET ${target_name})
         else()
             message(STATUS "Adding ${target_name} to bundle target")
-            set(dest_target bundle)
+            set(DEST_TARGET bundle)
             add_dependencies(bundle ${target_name})
         endif()
 
-        add_custom_command(TARGET ${dest_target} POST_BUILD
+        add_custom_command(TARGET ${DEST_TARGET} POST_BUILD
             COMMAND ${CMAKE_COMMAND}
-            "-DQT_HOST_PATH=\"${QT_HOST_PATH}\""
-            "-DQT_TARGET_PATH=\"${QT_TARGET_PATH}\""
+            "-DCMAKE_PREFIX_PATH=\"${CMAKE_PREFIX_PATH}\""
             "-DBUNDLE_TARGET_EXECUTE=1"
             "-DTARGET=${target_name}"
             "-DSOURCE_PATH=${CMAKE_SOURCE_DIR}"
             "-DBINARY_PATH=${CMAKE_BINARY_DIR}"
-            "-DEXECUTABLE_PATH=${bundle_executable_path}"
-            "-DBUNDLE_LIBRARY_PATHS=\"${bundle_library_paths}\""
-            "-DBUNDLE_QT=${bundle_qt}"
+            "-DEXECUTABLE_PATH=${BUNDLE_EXECUTABLE_PATH}"
+            "-DBUNDLE_LIBRARY_PATHS=\"${BUNDLE_LIBRARY_PATHS}\""
+            "-DBUNDLE_QT=${BUNDLE_QT}"
             "-DIN_PLACE=${in_place}"
-            "-DLINUXDEPLOY=${CMAKE_BINARY_DIR}/externals/linuxdeploy/squashfs-root/AppRun"
+            ${EXTRA_BUNDLE_ARGS}
             -P "${CMAKE_SOURCE_DIR}/CMakeModules/BundleTarget.cmake"
             WORKING_DIRECTORY "${CMAKE_BINARY_DIR}")
     endfunction()

CMakeModules/DownloadExternals.cmake

@@ -1,20 +1,21 @@
 
 set(CURRENT_MODULE_DIR ${CMAKE_CURRENT_LIST_DIR})
 
-# Determines parameters based on the host and target for downloading the right Qt binaries.
-function(determine_qt_parameters target host_out type_out arch_out arch_path_out host_type_out host_arch_out host_arch_path_out)
+# This function downloads Qt using aqt. The path of the downloaded content will be added to the CMAKE_PREFIX_PATH.
+# Params:
+#   target: Qt dependency to install. Specify a version number to download Qt, or "tools_(name)" for a specific build tool.
+function(download_qt target)
     if (target MATCHES "tools_.*")
-        set(tool ON)
+        set(DOWNLOAD_QT_TOOL ON)
     else()
-        set(tool OFF)
+        set(DOWNLOAD_QT_TOOL OFF)
     endif()
 
     # Determine installation parameters for OS, architecture, and compiler
     if (WIN32)
         set(host "windows")
         set(type "desktop")
-
-        if (NOT tool)
+        if (NOT DOWNLOAD_QT_TOOL)
             if (MINGW)
                 set(arch "win64_mingw")
                 set(arch_path "mingw_64")
@@ -27,35 +28,21 @@ function(determine_qt_parameters target host_out type_out arch_out arch_path_out
                     message(FATAL_ERROR "Unsupported bundled Qt architecture. Enable USE_SYSTEM_QT and provide your own.")
                 endif()
                 set(arch "win64_${arch_path}")
-
-                # In case we're cross-compiling, prepare to also fetch the correct host Qt tools.
-                if (CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "AMD64")
-                    set(host_arch_path "msvc2019_64")
-                elseif (CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "ARM64")
-                    # TODO: msvc2019_arm64 doesn't include some of the required tools for some reason,
-                    # TODO: so until it does, just use msvc2019_64 under x86_64 emulation.
-                    # set(host_arch_path "msvc2019_arm64")
-                    set(host_arch_path "msvc2019_64")
-                endif()
-                set(host_arch "win64_${host_arch_path}")
             else()
                 message(FATAL_ERROR "Unsupported bundled Qt toolchain. Enable USE_SYSTEM_QT and provide your own.")
             endif()
         endif()
     elseif (APPLE)
         set(host "mac")
-        set(type "desktop")
-        set(arch "clang_64")
-        set(arch_path "macos")
-
-        if (IOS AND NOT tool)
-            set(host_type "${type}")
-            set(host_arch "${arch}")
-            set(host_arch_path "${arch_path}")
-
+        if (IOS AND NOT DOWNLOAD_QT_TOOL)
             set(type "ios")
             set(arch "ios")
             set(arch_path "ios")
+            set(host_arch_path "macos")
+        else()
+            set(type "desktop")
+            set(arch "clang_64")
+            set(arch_path "macos")
         endif()
     else()
         set(host "linux")
@@ -64,64 +51,38 @@ function(determine_qt_parameters target host_out type_out arch_out arch_path_out
         set(arch_path "linux")
     endif()
 
-    set(${host_out} "${host}" PARENT_SCOPE)
-    set(${type_out} "${type}" PARENT_SCOPE)
-    set(${arch_out} "${arch}" PARENT_SCOPE)
-    set(${arch_path_out} "${arch_path}" PARENT_SCOPE)
-    if (DEFINED host_type)
-        set(${host_type_out} "${host_type}" PARENT_SCOPE)
-    else()
-        set(${host_type_out} "${type}" PARENT_SCOPE)
-    endif()
-    if (DEFINED host_arch)
-        set(${host_arch_out} "${host_arch}" PARENT_SCOPE)
-    else()
-        set(${host_arch_out} "${arch}" PARENT_SCOPE)
-    endif()
-    if (DEFINED host_arch_path)
-        set(${host_arch_path_out} "${host_arch_path}" PARENT_SCOPE)
-    else()
-        set(${host_arch_path_out} "${arch_path}" PARENT_SCOPE)
-    endif()
-endfunction()
-
-# Download Qt binaries for a specifc configuration.
-function(download_qt_configuration prefix_out target host type arch arch_path base_path)
-    if (target MATCHES "tools_.*")
-        set(tool ON)
-    else()
-        set(tool OFF)
-    endif()
+    get_external_prefix(qt base_path)
+    file(MAKE_DIRECTORY "${base_path}")
 
     set(install_args -c "${CURRENT_MODULE_DIR}/aqt_config.ini")
-    if (tool)
+    if (DOWNLOAD_QT_TOOL)
         set(prefix "${base_path}/Tools")
         set(install_args ${install_args} install-tool --outputdir ${base_path} ${host} desktop ${target})
     else()
         set(prefix "${base_path}/${target}/${arch_path}")
-        set(install_args ${install_args} install-qt --outputdir ${base_path} ${host} ${type} ${target} ${arch}
-                -m qtmultimedia --archives qttranslations qttools qtsvg qtbase)
+        if (host_arch_path)
+            set(host_flag "--autodesktop")
+            set(host_prefix "${base_path}/${target}/${host_arch_path}")
+        endif()
+        set(install_args ${install_args} install-qt --outputdir ${base_path} ${host} ${type} ${target} ${arch} ${host_flag}
+                                    -m qtmultimedia --archives qttranslations qttools qtsvg qtbase)
     endif()
 
     if (NOT EXISTS "${prefix}")
-        message(STATUS "Downloading Qt binaries for ${target}:${host}:${type}:${arch}:${arch_path}")
+        message(STATUS "Downloading binaries for Qt...")
         set(AQT_PREBUILD_BASE_URL "https://github.com/miurahr/aqtinstall/releases/download/v3.1.9")
         if (WIN32)
             set(aqt_path "${base_path}/aqt.exe")
-            if (NOT EXISTS "${aqt_path}")
-                file(DOWNLOAD
-                        ${AQT_PREBUILD_BASE_URL}/aqt.exe
-                        ${aqt_path} SHOW_PROGRESS)
-            endif()
+            file(DOWNLOAD
+                ${AQT_PREBUILD_BASE_URL}/aqt.exe
+                ${aqt_path} SHOW_PROGRESS)
             execute_process(COMMAND ${aqt_path} ${install_args}
                     WORKING_DIRECTORY ${base_path})
         elseif (APPLE)
             set(aqt_path "${base_path}/aqt-macos")
-            if (NOT EXISTS "${aqt_path}")
-                file(DOWNLOAD
-                        ${AQT_PREBUILD_BASE_URL}/aqt-macos
-                        ${aqt_path} SHOW_PROGRESS)
-            endif()
+            file(DOWNLOAD
+                ${AQT_PREBUILD_BASE_URL}/aqt-macos
+                ${aqt_path} SHOW_PROGRESS)
             execute_process(COMMAND chmod +x ${aqt_path})
             execute_process(COMMAND ${aqt_path} ${install_args}
                     WORKING_DIRECTORY ${base_path})
@@ -135,38 +96,18 @@ function(download_qt_configuration prefix_out target host type arch arch_path ba
             execute_process(COMMAND ${CMAKE_COMMAND} -E env PYTHONPATH=${aqt_install_path} python3 -m aqt ${install_args}
                     WORKING_DIRECTORY ${base_path})
         endif()
-
-        message(STATUS "Downloaded Qt binaries for ${target}:${host}:${type}:${arch}:${arch_path} to ${prefix}")
     endif()
 
-    set(${prefix_out} "${prefix}" PARENT_SCOPE)
-endfunction()
+    message(STATUS "Using downloaded Qt binaries at ${prefix}")
 
-# This function downloads Qt using aqt.
-# The path of the downloaded content will be added to the CMAKE_PREFIX_PATH.
-# QT_TARGET_PATH is set to the Qt for the compile target platform.
-# QT_HOST_PATH is set to a host-compatible Qt, for running tools.
-# Params:
-#   target: Qt dependency to install. Specify a version number to download Qt, or "tools_(name)" for a specific build tool.
-function(download_qt target)
-    determine_qt_parameters("${target}" host type arch arch_path host_type host_arch host_arch_path)
-
-    get_external_prefix(qt base_path)
-    file(MAKE_DIRECTORY "${base_path}")
-
-    download_qt_configuration(prefix "${target}" "${host}" "${type}" "${arch}" "${arch_path}" "${base_path}")
-    if (DEFINED host_arch_path AND NOT "${host_arch_path}" STREQUAL "${arch_path}")
-        download_qt_configuration(host_prefix "${target}" "${host}" "${host_type}" "${host_arch}" "${host_arch_path}" "${base_path}")
-    else()
-        set(host_prefix "${prefix}")
-    endif()
-
-    set(QT_TARGET_PATH "${prefix}" CACHE STRING "")
-    set(QT_HOST_PATH "${host_prefix}" CACHE STRING "")
-
-    # Add the target Qt prefix path so CMake can locate it.
+    # Add the Qt prefix path so CMake can locate it.
     list(APPEND CMAKE_PREFIX_PATH "${prefix}")
     set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} PARENT_SCOPE)
+
+    if (DEFINED host_prefix)
+        message(STATUS "Using downloaded host Qt binaries at ${host_prefix}")
+        set(QT_HOST_PATH "${host_prefix}" CACHE STRING "")
+    endif()
 endfunction()
 
 function(download_moltenvk)

dist/dumpkeys/DumpKeys.gm9

@@ -287,13 +287,5 @@ dumptxt -p $[OUT] "nfcSecret1Seed=$[NFC_SEED_1]"
 dumptxt -p $[OUT] "nfcSecret1HmacKey=$[NFC_HMAC_KEY_1]"
 dumptxt -p $[OUT] "nfcIv=$[NFC_IV]"
 
-# Dump seeddb.bin as well
-
-set SEEDDB_IN "0:/gm9/out/seeddb.bin"
-set SEEDDB_OUT "0:/gm9/seeddb.bin"
-
-sdump -w seeddb.bin
-cp -w $[SEEDDB_IN] $[SEEDDB_OUT]
-
 @Exit
 

dist/dumpkeys/README.md

@@ -6,5 +6,5 @@ Usage:
 1. Copy "DumpKeys.gm9" into the "gm9/scripts/" directory on your SD card.
 2. Launch GodMode9, press the HOME button, select Scripts, and select "DumpKeys" from the list of scripts that appears.
 3. Wait for the script to complete and return you to the GodMode9 main menu.
-4. Power off your system and copy the "gm9/aes_keys.txt" and "gm9/seeddb.bin" files off of your SD card into "(Citra directory)/sysdata/".
+4. Power off your system and copy the "gm9/aes_keys.txt" file off of your SD card into "(Citra directory)/sysdata/".
 

dist/languages/.tx/config

@@ -11,4 +11,3 @@ type        = QT
 file_filter = ../../src/android/app/src/main/res/values-<lang>/strings.xml
 source_file = ../../src/android/app/src/main/res/values/strings.xml
 type = ANDROID
-lang_map = es_ES:es, hu_HU:hu, ru_RU:ru, pt_BR:pt, zh_CN:zh

externals/CMakeLists.txt

@@ -57,12 +57,6 @@ if(USE_SYSTEM_CRYPTOPP)
     add_library(cryptopp INTERFACE)
     target_link_libraries(cryptopp INTERFACE cryptopp::cryptopp)
 else()
-    if (WIN32 AND NOT MSVC AND "arm64" IN_LIST ARCHITECTURE)
-        # TODO: CryptoPP ARM64 ASM does not seem to support Windows unless compiled with MSVC.
-        # TODO: See https://github.com/weidai11/cryptopp/issues/1260
-        set(CRYPTOPP_DISABLE_ASM ON CACHE BOOL "")
-    endif()
-
     set(CRYPTOPP_BUILD_DOCUMENTATION OFF CACHE BOOL "")
     set(CRYPTOPP_BUILD_TESTING OFF CACHE BOOL "")
     set(CRYPTOPP_INSTALL OFF CACHE BOOL "")
@@ -241,18 +235,6 @@ endif()
 
 # DiscordRPC
 if (USE_DISCORD_PRESENCE)
-    # rapidjson used by discord-rpc is old and doesn't correctly detect endianness for some platforms.
-    include(TestBigEndian)
-    test_big_endian(RAPIDJSON_BIG_ENDIAN)
-    if(RAPIDJSON_BIG_ENDIAN)
-        add_compile_definitions(RAPIDJSON_ENDIAN=1)
-    else()
-        add_compile_definitions(RAPIDJSON_ENDIAN=0)
-    endif()
-
-    # Apply a dummy CLANG_FORMAT_SUFFIX to disable discord-rpc's unnecessary automatic clang-format.
-    set(CLANG_FORMAT_SUFFIX "dummy")
-
     add_subdirectory(discord-rpc EXCLUDE_FROM_ALL)
     target_include_directories(discord-rpc INTERFACE ./discord-rpc/include)
 endif()
@@ -294,20 +276,11 @@ endif()
 add_library(httplib INTERFACE)
 if(USE_SYSTEM_CPP_HTTPLIB)
     find_package(CppHttp 0.14.1)
-    # Detect if system cpphttplib is a shared library
-    # this breaks building as Citra relies on functions that are moved
-    # into the shared object.
-    get_target_property(HTTP_LIBS httplib::httplib INTERFACE_LINK_LIBRARIES)
-    if(HTTP_LIBS)
-        message(WARNING "Shared cpp-http (${HTTP_LIBS}) not supported. Falling back to bundled...")
-        target_include_directories(httplib SYSTEM INTERFACE ./httplib)
+    if(CppHttp_FOUND)
+        target_link_libraries(httplib INTERFACE httplib::httplib)
     else()
-        if(CppHttp_FOUND)
-            target_link_libraries(httplib INTERFACE httplib::httplib)
-        else()
-            message(STATUS "Cpp-httplib not found or not suitable version! Falling back to bundled...")
-            target_include_directories(httplib SYSTEM INTERFACE ./httplib)
-        endif()
+        message(STATUS "Cpp-httplib not found or not suitable version! Falling back to bundled...")
+        target_include_directories(httplib SYSTEM INTERFACE ./httplib)
     endif()
 else()
     target_include_directories(httplib SYSTEM INTERFACE ./httplib)
@@ -315,6 +288,11 @@ endif()
 target_compile_options(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
 target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
 
+if(ANDROID)
+    add_subdirectory(android-ifaddrs)
+    target_link_libraries(httplib INTERFACE ifaddrs)
+endif()
+
 if (UNIX AND NOT APPLE)
     add_subdirectory(gamemode)
 endif()

externals/android-ifaddrs/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_library(ifaddrs
+    ifaddrs.c
+    ifaddrs.h
+)
+
+create_target_directory_groups(ifaddrs)
+
+target_include_directories(ifaddrs INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

externals/android-ifaddrs/ifaddrs.c

@@ -0,0 +1,600 @@
+/*
+Copyright (c) 2013, Kenneth MacKay
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ifaddrs.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <net/if_arp.h>
+#include <netinet/in.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+typedef struct NetlinkList
+{
+    struct NetlinkList *m_next;
+    struct nlmsghdr *m_data;
+    unsigned int m_size;
+} NetlinkList;
+
+static int netlink_socket(void)
+{
+    int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+    if(l_socket < 0)
+    {
+        return -1;
+    }
+    
+    struct sockaddr_nl l_addr;
+    memset(&l_addr, 0, sizeof(l_addr));
+    l_addr.nl_family = AF_NETLINK;
+    if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
+    {
+        close(l_socket);
+        return -1;
+    }
+    
+    return l_socket;
+}
+
+static int netlink_send(int p_socket, int p_request)
+{
+    char l_buffer[NLMSG_ALIGN(sizeof(struct nlmsghdr)) + NLMSG_ALIGN(sizeof(struct rtgenmsg))];
+    memset(l_buffer, 0, sizeof(l_buffer));
+    struct nlmsghdr *l_hdr = (struct nlmsghdr *)l_buffer;
+    struct rtgenmsg *l_msg = (struct rtgenmsg *)NLMSG_DATA(l_hdr);
+    
+    l_hdr->nlmsg_len = NLMSG_LENGTH(sizeof(*l_msg));
+    l_hdr->nlmsg_type = p_request;
+    l_hdr->nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
+    l_hdr->nlmsg_pid = 0;
+    l_hdr->nlmsg_seq = p_socket;
+    l_msg->rtgen_family = AF_UNSPEC;
+    
+    struct sockaddr_nl l_addr;
+    memset(&l_addr, 0, sizeof(l_addr));
+    l_addr.nl_family = AF_NETLINK;
+    return (sendto(p_socket, l_hdr, l_hdr->nlmsg_len, 0, (struct sockaddr *)&l_addr, sizeof(l_addr)));
+}
+
+static int netlink_recv(int p_socket, void *p_buffer, size_t p_len)
+{
+    struct msghdr l_msg;
+    struct iovec l_iov = { p_buffer, p_len };
+    struct sockaddr_nl l_addr;
+    int l_result;
+
+    for(;;)
+    {
+        l_msg.msg_name = (void *)&l_addr;
+        l_msg.msg_namelen = sizeof(l_addr);
+        l_msg.msg_iov = &l_iov;
+        l_msg.msg_iovlen = 1;
+        l_msg.msg_control = NULL;
+        l_msg.msg_controllen = 0;
+        l_msg.msg_flags = 0;
+        int l_result = recvmsg(p_socket, &l_msg, 0);
+        
+        if(l_result < 0)
+        {
+            if(errno == EINTR)
+            {
+                continue;
+            }
+            return -2;
+        }
+        
+        if(l_msg.msg_flags & MSG_TRUNC)
+        { // buffer was too small
+            return -1;
+        }
+        return l_result;
+    }
+}
+
+static struct nlmsghdr *getNetlinkResponse(int p_socket, int *p_size, int *p_done)
+{
+    size_t l_size = 4096;
+    void *l_buffer = NULL;
+    
+    for(;;)
+    {
+        free(l_buffer);
+        l_buffer = malloc(l_size);
+        
+        int l_read = netlink_recv(p_socket, l_buffer, l_size);
+        *p_size = l_read;
+        if(l_read == -2)
+        {
+            free(l_buffer);
+            return NULL;
+        }
+        if(l_read >= 0)
+        {
+            pid_t l_pid = getpid();
+            struct nlmsghdr *l_hdr;
+            for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
+            {
+                if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+                {
+                    continue;
+                }
+                
+                if(l_hdr->nlmsg_type == NLMSG_DONE)
+                {
+                    *p_done = 1;
+                    break;
+                }
+                
+                if(l_hdr->nlmsg_type == NLMSG_ERROR)
+                {
+                    free(l_buffer);
+                    return NULL;
+                }
+            }
+            return l_buffer;
+        }
+        
+        l_size *= 2;
+    }
+}
+
+static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size)
+{
+    NetlinkList *l_item = malloc(sizeof(NetlinkList));
+    l_item->m_next = NULL;
+    l_item->m_data = p_data;
+    l_item->m_size = p_size;
+    return l_item;
+}
+
+static void freeResultList(NetlinkList *p_list)
+{
+    NetlinkList *l_cur;
+    while(p_list)
+    {
+        l_cur = p_list;
+        p_list = p_list->m_next;
+        free(l_cur->m_data);
+        free(l_cur);
+    }
+}
+
+static NetlinkList *getResultList(int p_socket, int p_request)
+{
+    if(netlink_send(p_socket, p_request) < 0)
+    {
+        return NULL;
+    }
+
+    NetlinkList *l_list = NULL;
+    NetlinkList *l_end = NULL;
+    int l_size;
+    int l_done = 0;
+    while(!l_done)
+    {
+        struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, &l_size, &l_done);
+        if(!l_hdr)
+        { // error
+            freeResultList(l_list);
+            return NULL;
+        }
+        
+        NetlinkList *l_item = newListItem(l_hdr, l_size);
+        if(!l_list)
+        {
+            l_list = l_item;
+        }
+        else
+        {
+            l_end->m_next = l_item;
+        }
+        l_end = l_item;
+    }
+    return l_list;
+}
+
+static size_t maxSize(size_t a, size_t b)
+{
+    return (a > b ? a : b);
+}
+
+static size_t calcAddrLen(sa_family_t p_family, int p_dataSize)
+{
+    switch(p_family)
+    {
+        case AF_INET:
+            return sizeof(struct sockaddr_in);
+        case AF_INET6:
+            return sizeof(struct sockaddr_in6);
+        case AF_PACKET:
+            return maxSize(sizeof(struct sockaddr_ll), offsetof(struct sockaddr_ll, sll_addr) + p_dataSize);
+        default:
+            return maxSize(sizeof(struct sockaddr), offsetof(struct sockaddr, sa_data) + p_dataSize);
+    }
+}
+
+static void makeSockaddr(sa_family_t p_family, struct sockaddr *p_dest, void *p_data, size_t p_size)
+{
+    switch(p_family)
+    {
+        case AF_INET:
+            memcpy(&((struct sockaddr_in*)p_dest)->sin_addr, p_data, p_size);
+            break;
+        case AF_INET6:
+            memcpy(&((struct sockaddr_in6*)p_dest)->sin6_addr, p_data, p_size);
+            break;
+        case AF_PACKET:
+            memcpy(((struct sockaddr_ll*)p_dest)->sll_addr, p_data, p_size);
+            ((struct sockaddr_ll*)p_dest)->sll_halen = p_size;
+            break;
+        default:
+            memcpy(p_dest->sa_data, p_data, p_size);
+            break;
+    }
+    p_dest->sa_family = p_family;
+}
+
+static void addToEnd(struct ifaddrs **p_resultList, struct ifaddrs *p_entry)
+{
+    if(!*p_resultList)
+    {
+        *p_resultList = p_entry;
+    }
+    else
+    {
+        struct ifaddrs *l_cur = *p_resultList;
+        while(l_cur->ifa_next)
+        {
+            l_cur = l_cur->ifa_next;
+        }
+        l_cur->ifa_next = p_entry;
+    }
+}
+
+static void interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_links, struct ifaddrs **p_resultList)
+{
+    struct ifinfomsg *l_info = (struct ifinfomsg *)NLMSG_DATA(p_hdr);
+
+    size_t l_nameSize = 0;
+    size_t l_addrSize = 0;
+    size_t l_dataSize = 0;
+    
+    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+    struct rtattr *l_rta;
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifinfomsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type)
+        {
+            case IFLA_ADDRESS:
+            case IFLA_BROADCAST:
+                l_addrSize += NLMSG_ALIGN(calcAddrLen(AF_PACKET, l_rtaDataSize));
+                break;
+            case IFLA_IFNAME:
+                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+                break;
+            case IFLA_STATS:
+                l_dataSize += NLMSG_ALIGN(l_rtaSize);
+                break;
+            default:
+                break;
+        }
+    }
+    
+    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize + l_dataSize);
+    memset(l_entry, 0, sizeof(struct ifaddrs));
+    l_entry->ifa_name = "";
+    
+    char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
+    char *l_addr = l_name + l_nameSize;
+    char *l_data = l_addr + l_addrSize;
+    
+    l_entry->ifa_flags = l_info->ifi_flags;
+    
+    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifinfomsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type)
+        {
+            case IFLA_ADDRESS:
+            case IFLA_BROADCAST:
+            {
+                size_t l_addrLen = calcAddrLen(AF_PACKET, l_rtaDataSize);
+                makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+                ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
+                ((struct sockaddr_ll *)l_addr)->sll_hatype = l_info->ifi_type;
+                if(l_rta->rta_type == IFLA_ADDRESS)
+                {
+                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                }
+                else
+                {
+                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+                }
+                l_addr += NLMSG_ALIGN(l_addrLen);
+                break;
+            }
+            case IFLA_IFNAME:
+                strncpy(l_name, l_rtaData, l_rtaDataSize);
+                l_name[l_rtaDataSize] = '\0';
+                l_entry->ifa_name = l_name;
+                break;
+            case IFLA_STATS:
+                memcpy(l_data, l_rtaData, l_rtaDataSize);
+                l_entry->ifa_data = l_data;
+                break;
+            default:
+                break;
+        }
+    }
+    
+    addToEnd(p_resultList, l_entry);
+    p_links[l_info->ifi_index - 1] = l_entry;
+}
+
+static void interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_links, struct ifaddrs **p_resultList)
+{
+    struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
+
+    size_t l_nameSize = 0;
+    size_t l_addrSize = 0;
+    
+    int l_addedNetmask = 0;
+    
+    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+    struct rtattr *l_rta;
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        if(l_info->ifa_family == AF_PACKET)
+        {
+            continue;
+        }
+        
+        switch(l_rta->rta_type)
+        {
+            case IFA_ADDRESS:
+            case IFA_LOCAL:
+                if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
+                { // make room for netmask
+                    l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+                    l_addedNetmask = 1;
+                }
+            case IFA_BROADCAST:
+                l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+                break;
+            case IFA_LABEL:
+                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+                break;
+            default:
+                break;
+        }
+    }
+    
+    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
+    memset(l_entry, 0, sizeof(struct ifaddrs));
+    l_entry->ifa_name = p_links[l_info->ifa_index - 1]->ifa_name;
+    
+    char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
+    char *l_addr = l_name + l_nameSize;
+    
+    l_entry->ifa_flags = l_info->ifa_flags | p_links[l_info->ifa_index - 1]->ifa_flags;
+    
+    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+    for(l_rta = (struct rtattr *)(((char *)l_info) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type)
+        {
+            case IFA_ADDRESS:
+            case IFA_BROADCAST:
+            case IFA_LOCAL:
+            {
+                size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
+                makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+                if(l_info->ifa_family == AF_INET6)
+                {
+                    if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
+                    {
+                        ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
+                    }
+                }
+                
+                if(l_rta->rta_type == IFA_ADDRESS)
+                { // apparently in a point-to-point network IFA_ADDRESS contains the dest address and IFA_LOCAL contains the local address
+                    if(l_entry->ifa_addr)
+                    {
+                        l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
+                    }
+                    else
+                    {
+                        l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                    }
+                }
+                else if(l_rta->rta_type == IFA_LOCAL)
+                {
+                    if(l_entry->ifa_addr)
+                    {
+                        l_entry->ifa_dstaddr = l_entry->ifa_addr;
+                    }
+                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                }
+                else
+                {
+                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+                }
+                l_addr += NLMSG_ALIGN(l_addrLen);
+                break;
+            }
+            case IFA_LABEL:
+                strncpy(l_name, l_rtaData, l_rtaDataSize);
+                l_name[l_rtaDataSize] = '\0';
+                l_entry->ifa_name = l_name;
+                break;
+            default:
+                break;
+        }
+    }
+    
+    if(l_entry->ifa_addr && (l_entry->ifa_addr->sa_family == AF_INET || l_entry->ifa_addr->sa_family == AF_INET6))
+    {
+        unsigned l_maxPrefix = (l_entry->ifa_addr->sa_family == AF_INET ? 32 : 128);
+        unsigned l_prefix = (l_info->ifa_prefixlen > l_maxPrefix ? l_maxPrefix : l_info->ifa_prefixlen);
+        char l_mask[16] = {0};
+        unsigned i;
+        for(i=0; i<(l_prefix/8); ++i)
+        {
+            l_mask[i] = 0xff;
+        }
+        l_mask[i] = 0xff << (8 - (l_prefix % 8));
+        
+        makeSockaddr(l_entry->ifa_addr->sa_family, (struct sockaddr *)l_addr, l_mask, l_maxPrefix / 8);
+        l_entry->ifa_netmask = (struct sockaddr *)l_addr;
+    }
+    
+    addToEnd(p_resultList, l_entry);
+}
+
+static void interpret(int p_socket, NetlinkList *p_netlinkList, struct ifaddrs **p_links, struct ifaddrs **p_resultList)
+{
+    pid_t l_pid = getpid();
+    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+    {
+        unsigned int l_nlsize = p_netlinkList->m_size;
+        struct nlmsghdr *l_hdr;
+        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+        {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            {
+                continue;
+            }
+            
+            if(l_hdr->nlmsg_type == NLMSG_DONE)
+            {
+                break;
+            }
+            
+            if(l_hdr->nlmsg_type == RTM_NEWLINK)
+            {
+                interpretLink(l_hdr, p_links, p_resultList);
+            }
+            else if(l_hdr->nlmsg_type == RTM_NEWADDR)
+            {
+                interpretAddr(l_hdr, p_links, p_resultList);
+            }
+        }
+    }
+}
+
+static unsigned countLinks(int p_socket, NetlinkList *p_netlinkList)
+{
+    unsigned l_links = 0;
+    pid_t l_pid = getpid();
+    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+    {
+        unsigned int l_nlsize = p_netlinkList->m_size;
+        struct nlmsghdr *l_hdr;
+        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+        {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            {
+                continue;
+            }
+            
+            if(l_hdr->nlmsg_type == NLMSG_DONE)
+            {
+                break;
+            }
+            
+            if(l_hdr->nlmsg_type == RTM_NEWLINK)
+            {
+                ++l_links;
+            }
+        }
+    }
+    
+    return l_links;
+}
+
+int getifaddrs(struct ifaddrs **ifap)
+{
+    if(!ifap)
+    {
+        return -1;
+    }
+    *ifap = NULL;
+    
+    int l_socket = netlink_socket();
+    if(l_socket < 0)
+    {
+        return -1;
+    }
+    
+    NetlinkList *l_linkResults = getResultList(l_socket, RTM_GETLINK);
+    if(!l_linkResults)
+    {
+        close(l_socket);
+        return -1;
+    }
+    
+    NetlinkList *l_addrResults = getResultList(l_socket, RTM_GETADDR);
+    if(!l_addrResults)
+    {
+        close(l_socket);
+        freeResultList(l_linkResults);
+        return -1;
+    }
+    
+    unsigned l_numLinks = countLinks(l_socket, l_linkResults) + countLinks(l_socket, l_addrResults);
+    struct ifaddrs *l_links[l_numLinks];
+    memset(l_links, 0, l_numLinks * sizeof(struct ifaddrs *));
+    
+    interpret(l_socket, l_linkResults, l_links, ifap);
+    interpret(l_socket, l_addrResults, l_links, ifap);
+
+    freeResultList(l_linkResults);
+    freeResultList(l_addrResults);
+    close(l_socket);
+    return 0;
+}
+
+void freeifaddrs(struct ifaddrs *ifa)
+{
+    struct ifaddrs *l_cur;
+    while(ifa)
+    {
+        l_cur = ifa;
+        ifa = ifa->ifa_next;
+        free(l_cur);
+    }
+}

externals/android-ifaddrs/ifaddrs.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 1995, 1999
+ *	Berkeley Software Design, Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	BSDI ifaddrs.h,v 2.5 2000/02/23 14:51:59 dab Exp
+ */
+
+#ifndef	_IFADDRS_H_
+#define	_IFADDRS_H_
+
+struct ifaddrs {
+	struct ifaddrs  *ifa_next;
+	char		*ifa_name;
+	unsigned int	 ifa_flags;
+	struct sockaddr	*ifa_addr;
+	struct sockaddr	*ifa_netmask;
+	struct sockaddr	*ifa_dstaddr;
+	void		*ifa_data;
+};
+
+/*
+ * This may have been defined in <net/if.h>.  Note that if <net/if.h> is
+ * to be included it must be included before this header file.
+ */
+#ifndef	ifa_broadaddr
+#define	ifa_broadaddr	ifa_dstaddr	/* broadcast address interface */
+#endif
+
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+extern int getifaddrs(struct ifaddrs **ifap);
+extern void freeifaddrs(struct ifaddrs *ifa);
+__END_DECLS
+
+#endif

externals/cryptopp-cmake

@@ -1 +1 @@
-Subproject commit a99c80c26686e44eddf0432140ae397f3efbd0b3
+Subproject commit 9327192b0095dc1f420b2082d37bd427b5750d48

externals/cubeb

@@ -1 +1 @@
-Subproject commit 799e775484b8fce7e986ee7a4f4b651fec2bca07
+Subproject commit 48689ae7a73caeb747953f9ed664dc71d2f918d8

externals/dynarmic

@@ -1 +1 @@
-Subproject commit 30f1a3c6289075ef4af08f5ec502be2fc8627a0c
+Subproject commit d333a09b3b9152af3cb442902ae8ea18d8416470

externals/oaknut

@@ -1 +1 @@
-Subproject commit 6b1d57ea7ed4882d32a91eeaa6557b0ecb4da152
+Subproject commit e6eecc3f9460728be0a8d3f63e66d31c0362f472

src/android/app/build.gradle.kts

@@ -10,7 +10,7 @@ plugins {
     id("org.jetbrains.kotlin.android")
     id("de.undercouch.download") version "5.5.0"
     id("kotlin-parcelize")
-    kotlin("plugin.serialization") version "1.9.22"
+    kotlin("plugin.serialization") version "1.8.21"
     id("androidx.navigation.safeargs.kotlin")
 }
 
@@ -173,23 +173,23 @@ android {
 
 dependencies {
     implementation("androidx.recyclerview:recyclerview:1.3.2")
-    implementation("androidx.activity:activity-ktx:1.8.2")
+    implementation("androidx.activity:activity-ktx:1.8.0")
     implementation("androidx.fragment:fragment-ktx:1.6.2")
     implementation("androidx.appcompat:appcompat:1.6.1")
     implementation("androidx.documentfile:documentfile:1.0.1")
-    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1")
     implementation("androidx.slidingpanelayout:slidingpanelayout:1.2.0")
     implementation("com.google.android.material:material:1.9.0")
     implementation("androidx.core:core-splashscreen:1.0.1")
-    implementation("androidx.work:work-runtime:2.9.0")
+    implementation("androidx.work:work-runtime:2.8.1")
     implementation("org.ini4j:ini4j:0.5.4")
     implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.1.0")
-    implementation("androidx.navigation:navigation-fragment-ktx:2.7.6")
-    implementation("androidx.navigation:navigation-ui-ktx:2.7.6")
+    implementation("androidx.navigation:navigation-fragment-ktx:2.7.5")
+    implementation("androidx.navigation:navigation-ui-ktx:2.7.5")
     implementation("info.debatty:java-string-similarity:2.0.0")
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0")
     implementation("androidx.preference:preference-ktx:1.2.1")
-    implementation("io.coil-kt:coil:2.5.0")
+    implementation("io.coil-kt:coil:2.2.2")
 }
 
 // Download Vulkan Validation Layers from the KhronosGroup GitHub.

src/android/app/src/main/AndroidManifest.xml

@@ -42,9 +42,6 @@
         android:banner="@mipmap/ic_launcher"
         android:requestLegacyExternalStorage="true">
 
-        <meta-data android:name="android.game_mode_config"
-            android:resource="@xml/game_mode_config" />
-
         <activity
             android:name="org.citra.citra_emu.ui.main.MainActivity"
             android:theme="@style/Theme.Citra.Splash.Main"

src/android/app/src/main/java/org/citra/citra_emu/CitraApplication.kt

@@ -9,13 +9,10 @@ import android.app.Application
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Context
-import android.os.Build
 import org.citra.citra_emu.utils.DirectoryInitialization
 import org.citra.citra_emu.utils.DocumentsTree
 import org.citra.citra_emu.utils.GpuDriverHelper
 import org.citra.citra_emu.utils.PermissionsHandler
-import org.citra.citra_emu.utils.Log
-import org.citra.citra_emu.utils.MemoryUtil
 
 class CitraApplication : Application() {
     private fun createNotificationChannel() {
@@ -56,20 +53,9 @@ class CitraApplication : Application() {
         }
 
         NativeLibrary.logDeviceInfo()
-        logDeviceInfo()
         createNotificationChannel()
     }
 
-    fun logDeviceInfo() {
-        Log.info("Device Manufacturer - ${Build.MANUFACTURER}")
-        Log.info("Device Model - ${Build.MODEL}")
-        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
-            Log.info("SoC Manufacturer - ${Build.SOC_MANUFACTURER}")
-            Log.info("SoC Model - ${Build.SOC_MODEL}")
-        }
-        Log.info("Total System Memory - ${MemoryUtil.getDeviceRAM()}")
-    }
-
     companion object {
         private var application: CitraApplication? = null
 

src/android/app/src/main/java/org/citra/citra_emu/NativeLibrary.kt

@@ -413,12 +413,12 @@ object NativeLibrary {
     }
 
     fun setEmulationActivity(emulationActivity: EmulationActivity?) {
-        Log.debug("[NativeLibrary] Registering EmulationActivity.")
+        Log.verbose("[NativeLibrary] Registering EmulationActivity.")
         sEmulationActivity = WeakReference(emulationActivity)
     }
 
     fun clearEmulationActivity() {
-        Log.debug("[NativeLibrary] Unregistering EmulationActivity.")
+        Log.verbose("[NativeLibrary] Unregistering EmulationActivity.")
         sEmulationActivity.clear()
     }
 

src/android/app/src/main/java/org/citra/citra_emu/utils/DirectoryInitialization.kt

@@ -94,14 +94,14 @@ object DirectoryInitialization {
         val dataPath = PermissionsHandler.citraDirectory
         if (dataPath.toString().isNotEmpty()) {
             userPath = dataPath.toString()
-            android.util.Log.d("[Citra Frontend]", "[DirectoryInitialization] User Dir: $userPath")
+            Log.debug("[DirectoryInitialization] User Dir: $userPath")
             return true
         }
         return false
     }
 
     private fun copyAsset(asset: String, output: File, overwrite: Boolean, context: Context) {
-        Log.debug("[DirectoryInitialization] Copying File $asset to $output")
+        Log.verbose("[DirectoryInitialization] Copying File $asset to $output")
         try {
             if (!output.exists() || overwrite) {
                 val inputStream = context.assets.open(asset)
@@ -121,7 +121,7 @@ object DirectoryInitialization {
         overwrite: Boolean,
         context: Context
     ) {
-        Log.debug("[DirectoryInitialization] Copying Folder $assetFolder to $outputFolder")
+        Log.verbose("[DirectoryInitialization] Copying Folder $assetFolder to $outputFolder")
         try {
             var createdFolder = false
             for (file in context.assets.list(assetFolder)!!) {

src/android/app/src/main/java/org/citra/citra_emu/utils/Log.kt

@@ -4,17 +4,34 @@
 
 package org.citra.citra_emu.utils
 
+import android.util.Log
+import org.citra.citra_emu.BuildConfig
+
+/**
+ * Contains methods that call through to [android.util.Log], but
+ * with the same TAG automatically provided. Also no-ops VERBOSE and DEBUG log
+ * levels in release builds.
+ */
 object Log {
     // Tracks whether we should share the old log or the current log
     var gameLaunched = false
+    private const val TAG = "Citra Frontend"
 
-    external fun debug(message: String)
+    fun verbose(message: String?) {
+        if (BuildConfig.DEBUG) {
+            Log.v(TAG, message!!)
+        }
+    }
 
-    external fun warning(message: String)
+    fun debug(message: String?) {
+        if (BuildConfig.DEBUG) {
+            Log.d(TAG, message!!)
+        }
+    }
 
-    external fun info(message: String)
+    fun info(message: String?) = Log.i(TAG, message!!)
 
-    external fun error(message: String)
+    fun warning(message: String?) = Log.w(TAG, message!!)
 
-    external fun critical(message: String)
+    fun error(message: String?) = Log.e(TAG, message!!)
 }

src/android/app/src/main/java/org/citra/citra_emu/utils/MemoryUtil.kt

@@ -1,108 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package org.citra.citra_emu.utils
-
-import android.app.ActivityManager
-import android.content.Context
-import android.os.Build
-import org.citra.citra_emu.CitraApplication
-import org.citra.citra_emu.R
-import java.util.Locale
-import kotlin.math.ceil
-
-object MemoryUtil {
-    private val context get() = CitraApplication.appContext
-
-    private val Float.hundredths: String
-        get() = String.format(Locale.ROOT, "%.2f", this)
-
-    const val Kb: Float = 1024F
-    const val Mb = Kb * 1024
-    const val Gb = Mb * 1024
-    const val Tb = Gb * 1024
-    const val Pb = Tb * 1024
-    const val Eb = Pb * 1024
-
-    fun bytesToSizeUnit(size: Float, roundUp: Boolean = false): String =
-        when {
-            size < Kb -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    size.hundredths,
-                    context.getString(R.string.memory_byte_shorthand)
-                )
-            }
-            size < Mb -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    if (roundUp) ceil(size / Kb) else (size / Kb).hundredths,
-                    context.getString(R.string.memory_kilobyte)
-                )
-            }
-            size < Gb -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    if (roundUp) ceil(size / Mb) else (size / Mb).hundredths,
-                    context.getString(R.string.memory_megabyte)
-                )
-            }
-            size < Tb -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    if (roundUp) ceil(size / Gb) else (size / Gb).hundredths,
-                    context.getString(R.string.memory_gigabyte)
-                )
-            }
-            size < Pb -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    if (roundUp) ceil(size / Tb) else (size / Tb).hundredths,
-                    context.getString(R.string.memory_terabyte)
-                )
-            }
-            size < Eb -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    if (roundUp) ceil(size / Pb) else (size / Pb).hundredths,
-                    context.getString(R.string.memory_petabyte)
-                )
-            }
-            else -> {
-                context.getString(
-                    R.string.memory_formatted,
-                    if (roundUp) ceil(size / Eb) else (size / Eb).hundredths,
-                    context.getString(R.string.memory_exabyte)
-                )
-            }
-        }
-
-    val totalMemory: Float
-        get() {
-            val memInfo = ActivityManager.MemoryInfo()
-            with(context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager) {
-                getMemoryInfo(memInfo)
-            }
-
-            return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                memInfo.advertisedMem.toFloat()
-            } else {
-                memInfo.totalMem.toFloat()
-            }
-        }
-
-    fun isLessThan(minimum: Int, size: Float): Boolean =
-        when (size) {
-            Kb -> totalMemory < Mb && totalMemory < minimum
-            Mb -> totalMemory < Gb && (totalMemory / Mb) < minimum
-            Gb -> totalMemory < Tb && (totalMemory / Gb) < minimum
-            Tb -> totalMemory < Pb && (totalMemory / Tb) < minimum
-            Pb -> totalMemory < Eb && (totalMemory / Pb) < minimum
-            Eb -> totalMemory / Eb < minimum
-            else -> totalMemory < Kb && totalMemory < minimum
-        }
-
-    // Devices are unlikely to have 0.5GB increments of memory so we'll just round up to account for
-    // the potential error created by memInfo.totalMem
-    fun getDeviceRAM(): String = bytesToSizeUnit(totalMemory, true)
-}

src/android/app/src/main/jni/CMakeLists.txt

@@ -28,7 +28,6 @@ add_library(citra-android SHARED
     ndk_motion.cpp
     ndk_motion.h
     system_save_game.cpp
-    native_log.cpp
 )
 
 target_link_libraries(citra-android PRIVATE audio_core citra_common citra_core input_common network)

src/android/app/src/main/jni/native_log.cpp

@@ -1,30 +0,0 @@
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <common/logging/log.h>
-#include <jni.h>
-#include "android_common/android_common.h"
-
-extern "C" {
-
-void Java_org_citra_citra_1emu_utils_Log_debug(JNIEnv* env, jobject obj, jstring jmessage) {
-    LOG_DEBUG(Frontend, "{}", GetJString(env, jmessage));
-}
-
-void Java_org_citra_citra_1emu_utils_Log_warning(JNIEnv* env, jobject obj, jstring jmessage) {
-    LOG_WARNING(Frontend, "{}", GetJString(env, jmessage));
-}
-
-void Java_org_citra_citra_1emu_utils_Log_info(JNIEnv* env, jobject obj, jstring jmessage) {
-    LOG_INFO(Frontend, "{}", GetJString(env, jmessage));
-}
-
-void Java_org_citra_citra_1emu_utils_Log_error(JNIEnv* env, jobject obj, jstring jmessage) {
-    LOG_ERROR(Frontend, "{}", GetJString(env, jmessage));
-}
-
-void Java_org_citra_citra_1emu_utils_Log_critical(JNIEnv* env, jobject obj, jstring jmessage) {
-    LOG_CRITICAL(Frontend, "{}", GetJString(env, jmessage));
-}
-
-} // extern "C"

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

@@ -442,17 +442,6 @@
     <string name="cia_install_error_encrypted">\"%s\" must be decrypted before being used with Citra.\n A real 3DS is required</string>
     <string name="cia_install_error_unknown">An unknown error occurred while installing \"%s\".\n Please see the log for more details</string>
 
-    <!-- Memory Sizes -->
-    <string name="memory_formatted">%1$s %2$s</string>
-    <string name="memory_byte">Byte</string>
-    <string name="memory_byte_shorthand">B</string>
-    <string name="memory_kilobyte">KB</string>
-    <string name="memory_megabyte">MB</string>
-    <string name="memory_gigabyte">GB</string>
-    <string name="memory_terabyte">TB</string>
-    <string name="memory_petabyte">PB</string>
-    <string name="memory_exabyte">EB</string>
-
     <!-- Theme Modes -->
     <string name="change_theme_mode">Change Theme Mode</string>
     <string name="theme_mode_follow_system">Follow System</string>

src/android/app/src/main/res/xml/game_mode_config.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<game-mode-config
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:supportsBatteryGameMode="true"
-    android:supportsPerformanceGameMode="true"
-    android:allowGameDownscaling="false"
-    android:allowGameFpsOverride="false"/>

src/android/build.gradle.kts

@@ -4,10 +4,10 @@
 
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id("com.android.application") version "8.2.1" apply false
-    id("com.android.library") version "8.2.1" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.22" apply false
-    id("org.jetbrains.kotlin.plugin.serialization") version "1.9.22"
+    id("com.android.application") version "8.1.2" apply false
+    id("com.android.library") version "8.1.2" apply false
+    id("org.jetbrains.kotlin.android") version "1.8.21" apply false
+    id("org.jetbrains.kotlin.plugin.serialization") version "1.8.21"
 }
 
 tasks.register("clean").configure {
@@ -19,6 +19,6 @@ buildscript {
         google()
     }
     dependencies {
-        classpath("androidx.navigation:navigation-safe-args-gradle-plugin:2.7.6")
+        classpath("androidx.navigation:navigation-safe-args-gradle-plugin:2.7.5")
     }
 }

src/android/gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip

src/audio_core/hle/shared_memory.h

@@ -316,7 +316,7 @@ struct SourceStatus {
         u16_le sync_count; ///< Is set by the DSP to the value of SourceConfiguration::sync_count
         u32_dsp buffer_position;  ///< Number of samples into the current buffer
         u16_le current_buffer_id; ///< Updated when a buffer finishes playing
-        u16_le last_buffer_id;    ///< Updated when all buffers in the queue finish playing
+        INSERT_PADDING_DSPWORDS(1);
     };
 
     Status status[num_sources];

src/audio_core/hle/source.cpp

@@ -298,9 +298,9 @@ void Source::ParseConfig(SourceConfiguration::Configuration& config,
                         b.buffer_id,
                         state.mono_or_stereo,
                         state.format,
-                        true,  // from_queue
-                        0,     // play_position
-                        false, // has_played
+                        true,
+                        {}, // 0 in u32_dsp
+                        false,
                     });
                 }
                 LOG_TRACE(Audio_DSP, "enqueuing queued {} addr={:#010x} len={} id={}", i,
@@ -321,19 +321,16 @@ void Source::ParseConfig(SourceConfiguration::Configuration& config,
 void Source::GenerateFrame() {
     current_frame.fill({});
 
-    if (state.current_buffer.empty()) {
-        // TODO(SachinV): Should dequeue happen at the end of the frame generation?
-        if (DequeueBuffer()) {
-            return;
-        }
+    if (state.current_buffer.empty() && !DequeueBuffer()) {
         state.enabled = false;
         state.buffer_update = true;
-        state.last_buffer_id = state.current_buffer_id;
         state.current_buffer_id = 0;
         return;
     }
 
     std::size_t frame_position = 0;
+
+    state.current_sample_number = state.next_sample_number;
     while (frame_position < current_frame.size()) {
         if (state.current_buffer.empty() && !DequeueBuffer()) {
             break;
@@ -360,7 +357,7 @@ void Source::GenerateFrame() {
     }
     // TODO(jroweboy): Keep track of frame_position independently so that it doesn't lose precision
     // over time
-    state.current_sample_number += static_cast<u32>(frame_position * state.rate_multiplier);
+    state.next_sample_number += static_cast<u32>(frame_position * state.rate_multiplier);
 
     state.filters.ProcessFrame(current_frame);
 }
@@ -411,9 +408,9 @@ bool Source::DequeueBuffer() {
 
     // the first playthrough starts at play_position, loops start at the beginning of the buffer
     state.current_sample_number = (!buf.has_played) ? buf.play_position : 0;
+    state.next_sample_number = state.current_sample_number;
     state.current_buffer_physical_address = buf.physical_address;
     state.current_buffer_id = buf.buffer_id;
-    state.last_buffer_id = 0;
     state.buffer_update = buf.from_queue && !buf.has_played;
 
     if (buf.is_looping) {
@@ -421,17 +418,8 @@ bool Source::DequeueBuffer() {
         state.input_queue.push(buf);
     }
 
-    // Because our interpolation consumes samples instead of using an index,
-    // let's just consume the samples up to the current sample number.
-    state.current_buffer.erase(
-        state.current_buffer.begin(),
-        std::next(state.current_buffer.begin(), state.current_sample_number));
-
-    LOG_TRACE(Audio_DSP,
-              "source_id={} buffer_id={} from_queue={} current_buffer.size()={}, "
-              "buf.has_played={}, buf.play_position={}",
-              source_id, buf.buffer_id, buf.from_queue, state.current_buffer.size(), buf.has_played,
-              buf.play_position);
+    LOG_TRACE(Audio_DSP, "source_id={} buffer_id={} from_queue={} current_buffer.size()={}",
+              source_id, buf.buffer_id, buf.from_queue, state.current_buffer.size());
     return true;
 }
 
@@ -444,10 +432,9 @@ SourceStatus::Status Source::GetCurrentStatus() {
     ret.is_enabled = state.enabled;
     ret.current_buffer_id_dirty = state.buffer_update ? 1 : 0;
     state.buffer_update = false;
-    ret.sync_count = state.sync_count;
-    ret.buffer_position = state.current_sample_number;
     ret.current_buffer_id = state.current_buffer_id;
-    ret.last_buffer_id = state.last_buffer_id;
+    ret.buffer_position = state.current_sample_number;
+    ret.sync_count = state.sync_count;
 
     return ret;
 }

src/audio_core/hle/source.h

@@ -87,8 +87,8 @@ private:
         Format format;
 
         bool from_queue;
-        u32 play_position; // = 0;
-        bool has_played;   // = false;
+        u32_dsp play_position; // = 0;
+        bool has_played;       // = false;
 
     private:
         template <class Archive>
@@ -136,14 +136,14 @@ private:
         // Current buffer
 
         u32 current_sample_number = 0;
+        u32 next_sample_number = 0;
         PAddr current_buffer_physical_address = 0;
         AudioInterp::StereoBuffer16 current_buffer = {};
 
         // buffer_id state
 
         bool buffer_update = false;
-        u16 last_buffer_id = 0;
-        u16 current_buffer_id = 0;
+        u32 current_buffer_id = 0;
 
         // Decoding state
 
@@ -170,6 +170,7 @@ private:
             ar& mono_or_stereo;
             ar& format;
             ar& current_sample_number;
+            ar& next_sample_number;
             ar& current_buffer_physical_address;
             ar& current_buffer;
             ar& buffer_update;

src/citra_qt/CMakeLists.txt

@@ -179,8 +179,6 @@ add_executable(citra-qt
     qt_image_interface.h
     util/clickable_label.cpp
     util/clickable_label.h
-    util/graphics_device_info.cpp
-    util/graphics_device_info.h
     util/sequence_dialog/sequence_dialog.cpp
     util/sequence_dialog/sequence_dialog.h
     util/spinbox.cpp
@@ -189,6 +187,13 @@ add_executable(citra-qt
     util/util.h
 )
 
+if (ENABLE_VULKAN)
+    target_sources(citra-qt PRIVATE
+        util/vk_device_info.cpp
+        util/vk_device_info.h
+    )
+endif()
+
 file(GLOB COMPAT_LIST
      ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
      ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)

src/citra_qt/configuration/config.cpp

@@ -54,7 +54,7 @@ const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> Config:
 // This must be in alphabetical order according to action name as it must have the same order as
 // UISetting::values.shortcuts, which is alphabetically ordered.
 // clang-format off
-const std::array<UISettings::Shortcut, 35> Config::default_hotkeys {{
+const std::array<UISettings::Shortcut, 30> Config::default_hotkeys {{
      {QStringLiteral("Advance Frame"),            QStringLiteral("Main Window"), {QStringLiteral(""),       Qt::ApplicationShortcut}},
      {QStringLiteral("Audio Mute/Unmute"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"), Qt::WindowShortcut}},
      {QStringLiteral("Audio Volume Down"),        QStringLiteral("Main Window"), {QStringLiteral(""),       Qt::WindowShortcut}},
@@ -71,11 +71,6 @@ const std::array<UISettings::Shortcut, 35> Config::default_hotkeys {{
      {QStringLiteral("Load Amiibo"),              QStringLiteral("Main Window"), {QStringLiteral("F2"),     Qt::WidgetWithChildrenShortcut}},
      {QStringLiteral("Load File"),                QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"), Qt::WidgetWithChildrenShortcut}},
      {QStringLiteral("Load from Newest Slot"),    QStringLiteral("Main Window"), {QStringLiteral("Ctrl+V"), Qt::WindowShortcut}},
-     {QStringLiteral("Multiplayer Browse Public Game Lobby"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+B"), Qt::ApplicationShortcut}},
-     {QStringLiteral("Multiplayer Create Room"),              QStringLiteral("Main Window"), {QStringLiteral("Ctrl+N"), Qt::ApplicationShortcut}},
-     {QStringLiteral("Multiplayer Direct Connect to Room"),   QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Shift"), Qt::ApplicationShortcut}},
-     {QStringLiteral("Multiplayer Leave Room"),               QStringLiteral("Main Window"), {QStringLiteral("Ctrl+L"), Qt::ApplicationShortcut}},
-     {QStringLiteral("Multiplayer Show Current Room"),        QStringLiteral("Main Window"), {QStringLiteral("Ctrl+R"), Qt::ApplicationShortcut}},
      {QStringLiteral("Remove Amiibo"),            QStringLiteral("Main Window"), {QStringLiteral("F3"),     Qt::ApplicationShortcut}},
      {QStringLiteral("Restart Emulation"),        QStringLiteral("Main Window"), {QStringLiteral("F6"),     Qt::WindowShortcut}},
      {QStringLiteral("Rotate Screens Upright"),   QStringLiteral("Main Window"), {QStringLiteral("F8"),     Qt::WindowShortcut}},
@@ -562,15 +557,6 @@ void Config::ReadMultiplayerValues() {
     UISettings::values.game_id = ReadSetting(QStringLiteral("game_id"), 0).toULongLong();
     UISettings::values.room_description =
         ReadSetting(QStringLiteral("room_description"), QString{}).toString();
-    UISettings::values.multiplayer_filter_text =
-        ReadSetting(QStringLiteral("multiplayer_filter_text"), QString{}).toString();
-    UISettings::values.multiplayer_filter_games_owned =
-        ReadSetting(QStringLiteral("multiplayer_filter_games_owned"), false).toBool();
-    UISettings::values.multiplayer_filter_hide_empty =
-        ReadSetting(QStringLiteral("multiplayer_filter_hide_empty"), false).toBool();
-    UISettings::values.multiplayer_filter_hide_full =
-        ReadSetting(QStringLiteral("multiplayer_filter_hide_full"), false).toBool();
-
     // Read ban list back
     int size = qt_config->beginReadArray(QStringLiteral("username_ban_list"));
     UISettings::values.ban_list.first.resize(size);
@@ -1088,15 +1074,6 @@ void Config::SaveMultiplayerValues() {
     WriteSetting(QStringLiteral("game_id"), UISettings::values.game_id, 0);
     WriteSetting(QStringLiteral("room_description"), UISettings::values.room_description,
                  QString{});
-    WriteSetting(QStringLiteral("multiplayer_filter_text"),
-                 UISettings::values.multiplayer_filter_text, QString{});
-    WriteSetting(QStringLiteral("multiplayer_filter_games_owned"),
-                 UISettings::values.multiplayer_filter_games_owned, false);
-    WriteSetting(QStringLiteral("multiplayer_filter_hide_empty"),
-                 UISettings::values.multiplayer_filter_hide_empty, false);
-    WriteSetting(QStringLiteral("multiplayer_filter_hide_full"),
-                 UISettings::values.multiplayer_filter_hide_full, false);
-
     // Write ban list
     qt_config->beginWriteArray(QStringLiteral("username_ban_list"));
     for (std::size_t i = 0; i < UISettings::values.ban_list.first.size(); ++i) {

src/citra_qt/configuration/config.h

@@ -26,7 +26,7 @@ public:
 
     static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
     static const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs> default_analogs;
-    static const std::array<UISettings::Shortcut, 35> default_hotkeys;
+    static const std::array<UISettings::Shortcut, 30> default_hotkeys;
 
 private:
     void Initialize(const std::string& config_name);

src/citra_qt/configuration/configure_dialog.cpp

@@ -23,16 +23,14 @@
 #include "ui_configure.h"
 
 ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry_, Core::System& system_,
-                                 QString gl_renderer, std::span<const QString> physical_devices,
-                                 bool enable_web_config)
+                                 std::span<const QString> physical_devices, bool enable_web_config)
     : QDialog(parent), ui{std::make_unique<Ui::ConfigureDialog>()}, registry{registry_},
       system{system_}, is_powered_on{system.IsPoweredOn()},
       general_tab{std::make_unique<ConfigureGeneral>(this)},
       system_tab{std::make_unique<ConfigureSystem>(system, this)},
       input_tab{std::make_unique<ConfigureInput>(this)},
       hotkeys_tab{std::make_unique<ConfigureHotkeys>(this)},
-      graphics_tab{
-          std::make_unique<ConfigureGraphics>(gl_renderer, physical_devices, is_powered_on, this)},
+      graphics_tab{std::make_unique<ConfigureGraphics>(physical_devices, is_powered_on, this)},
       enhancements_tab{std::make_unique<ConfigureEnhancements>(this)},
       audio_tab{std::make_unique<ConfigureAudio>(is_powered_on, this)},
       camera_tab{std::make_unique<ConfigureCamera>(this)},

src/citra_qt/configuration/configure_dialog.h

@@ -37,7 +37,7 @@ class ConfigureDialog : public QDialog {
 
 public:
     explicit ConfigureDialog(QWidget* parent, HotkeyRegistry& registry, Core::System& system,
-                             QString gl_renderer, std::span<const QString> physical_devices,
+                             std::span<const QString> physical_devices,
                              bool enable_web_config = true);
     ~ConfigureDialog() override;
 

src/citra_qt/configuration/configure_graphics.cpp

@@ -12,13 +12,17 @@
 #include "video_core/renderer_vulkan/vk_instance.h"
 #endif
 
-ConfigureGraphics::ConfigureGraphics(QString gl_renderer, std::span<const QString> physical_devices,
-                                     bool is_powered_on, QWidget* parent)
+ConfigureGraphics::ConfigureGraphics(std::span<const QString> physical_devices, bool is_powered_on,
+                                     QWidget* parent)
     : QWidget(parent), ui(std::make_unique<Ui::ConfigureGraphics>()) {
     ui->setupUi(this);
 
     SetupPerGameUI();
 
+    for (const QString& name : physical_devices) {
+        ui->physical_device_combo->addItem(name);
+    }
+
     ui->graphics_api_combo->setEnabled(!is_powered_on);
     ui->physical_device_combo->setEnabled(!is_powered_on);
     ui->toggle_async_shaders->setEnabled(!is_powered_on);
@@ -33,15 +37,11 @@ ConfigureGraphics::ConfigureGraphics(QString gl_renderer, std::span<const QStrin
         graphics_api_combo_model->item(static_cast<u32>(Settings::GraphicsAPI::Software));
     software_item->setFlags(software_item->flags() & ~Qt::ItemIsEnabled);
 #endif
-
 #ifndef ENABLE_OPENGL
     const auto opengl_item =
         graphics_api_combo_model->item(static_cast<u32>(Settings::GraphicsAPI::OpenGL));
     opengl_item->setFlags(opengl_item->flags() & ~Qt::ItemIsEnabled);
-#else
-    ui->opengl_renderer_name_label->setText(gl_renderer);
 #endif
-
 #ifndef ENABLE_VULKAN
     const auto vulkan_item =
         graphics_api_combo_model->item(static_cast<u32>(Settings::GraphicsAPI::Vulkan));
@@ -54,10 +54,6 @@ ConfigureGraphics::ConfigureGraphics(QString gl_renderer, std::span<const QStrin
 
         ui->physical_device_combo->setVisible(false);
         ui->spirv_shader_gen->setVisible(false);
-    } else {
-        for (const QString& name : physical_devices) {
-            ui->physical_device_combo->addItem(name);
-        }
     }
 #endif
 
@@ -206,24 +202,24 @@ void ConfigureGraphics::SetupPerGameUI() {
 }
 
 void ConfigureGraphics::SetPhysicalDeviceComboVisibility(int index) {
-    Settings::GraphicsAPI effective_api{};
+    bool is_visible{};
 
     // When configuring per-game the physical device combo should be
     // shown either when the global api is used and that is Vulkan or
     // Vulkan is set as the per-game api.
     if (!Settings::IsConfiguringGlobal()) {
+        const auto global_graphics_api = Settings::values.graphics_api.GetValue(true);
         const bool using_global = index == 0;
-        if (using_global) {
-            effective_api = Settings::values.graphics_api.GetValue(true);
-        } else {
-            effective_api =
-                static_cast<Settings::GraphicsAPI>(index - ConfigurationShared::USE_GLOBAL_OFFSET);
+        if (!using_global) {
+            index -= ConfigurationShared::USE_GLOBAL_OFFSET;
         }
+        const auto graphics_api = static_cast<Settings::GraphicsAPI>(index);
+        is_visible = (using_global && global_graphics_api == Settings::GraphicsAPI::Vulkan) ||
+                     graphics_api == Settings::GraphicsAPI::Vulkan;
     } else {
-        effective_api = static_cast<Settings::GraphicsAPI>(index);
+        const auto graphics_api = static_cast<Settings::GraphicsAPI>(index);
+        is_visible = graphics_api == Settings::GraphicsAPI::Vulkan;
     }
-
-    ui->physical_device_group->setVisible(effective_api == Settings::GraphicsAPI::Vulkan);
-    ui->spirv_shader_gen->setVisible(effective_api == Settings::GraphicsAPI::Vulkan);
-    ui->opengl_renderer_group->setVisible(effective_api == Settings::GraphicsAPI::OpenGL);
+    ui->physical_device_group->setVisible(is_visible);
+    ui->spirv_shader_gen->setVisible(is_visible);
 }

src/citra_qt/configuration/configure_graphics.h

@@ -21,8 +21,8 @@ class ConfigureGraphics : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureGraphics(QString gl_renderer, std::span<const QString> physical_devices,
-                               bool is_powered_on, QWidget* parent = nullptr);
+    explicit ConfigureGraphics(std::span<const QString> physical_devices, bool is_powered_on,
+                               QWidget* parent = nullptr);
     ~ConfigureGraphics() override;
 
     void ApplyConfiguration();

src/citra_qt/configuration/configure_graphics.ui

@@ -101,34 +101,6 @@
         </layout>
        </widget>
       </item>
-      <item>
-       <widget class="QWidget" name="opengl_renderer_group" native="true">
-        <layout class="QHBoxLayout" name="opengl_renderer_group_2">
-         <property name="leftMargin">
-          <number>0</number>
-         </property>
-         <property name="topMargin">
-          <number>0</number>
-         </property>
-         <property name="rightMargin">
-          <number>0</number>
-         </property>
-         <property name="bottomMargin">
-          <number>0</number>
-         </property>
-         <item>
-          <widget class="QLabel" name="opengl_renderer_label">
-           <property name="text">
-            <string>OpenGL Renderer</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="opengl_renderer_name_label"/>
-         </item>
-        </layout>
-       </widget>
-      </item>
       <item>
        <widget class="QCheckBox" name="spirv_shader_gen">
         <property name="text">

src/citra_qt/configuration/configure_per_game.cpp

@@ -24,8 +24,7 @@
 #include "ui_configure_per_game.h"
 
 ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const QString& file_name,
-                                   QString gl_renderer, std::span<const QString> physical_devices,
-                                   Core::System& system_)
+                                   std::span<const QString> physical_devices, Core::System& system_)
     : QDialog(parent), ui(std::make_unique<Ui::ConfigurePerGame>()),
       filename{file_name.toStdString()}, title_id{title_id_}, system{system_} {
     const auto config_file_name = title_id == 0 ? std::string(FileUtil::GetFilename(filename))
@@ -36,8 +35,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id_, const QString
     audio_tab = std::make_unique<ConfigureAudio>(is_powered_on, this);
     general_tab = std::make_unique<ConfigureGeneral>(this);
     enhancements_tab = std::make_unique<ConfigureEnhancements>(this);
-    graphics_tab =
-        std::make_unique<ConfigureGraphics>(gl_renderer, physical_devices, is_powered_on, this);
+    graphics_tab = std::make_unique<ConfigureGraphics>(physical_devices, is_powered_on, this);
     system_tab = std::make_unique<ConfigureSystem>(system, this);
     debug_tab = std::make_unique<ConfigureDebug>(is_powered_on, this);
     cheat_tab = std::make_unique<ConfigureCheats>(system.CheatEngine(), title_id, this);

src/citra_qt/configuration/configure_per_game.h

@@ -38,8 +38,7 @@ class ConfigurePerGame : public QDialog {
 
 public:
     explicit ConfigurePerGame(QWidget* parent, u64 title_id_, const QString& file_name,
-                              QString gl_renderer, std::span<const QString> physical_devices,
-                              Core::System& system_);
+                              std::span<const QString> physical_devices, Core::System& system_);
     ~ConfigurePerGame() override;
 
     /// Loads all button configurations to settings file

src/citra_qt/main.cpp

@@ -64,7 +64,7 @@
 #include "citra_qt/uisettings.h"
 #include "citra_qt/updater/updater.h"
 #include "citra_qt/util/clickable_label.h"
-#include "citra_qt/util/graphics_device_info.h"
+#include "citra_qt/util/vk_device_info.h"
 #include "common/arch.h"
 #include "common/common_paths.h"
 #include "common/detached_tasks.h"
@@ -270,18 +270,6 @@ GMainWindow::GMainWindow(Core::System& system_)
     connect(&mouse_hide_timer, &QTimer::timeout, this, &GMainWindow::HideMouseCursor);
     connect(ui->menubar, &QMenuBar::hovered, this, &GMainWindow::OnMouseActivity);
 
-#ifdef ENABLE_OPENGL
-    gl_renderer = GetOpenGLRenderer();
-#if defined(_WIN32)
-    if (gl_renderer.startsWith(QStringLiteral("D3D12"))) {
-        // OpenGLOn12 supports but does not yet advertise OpenGL 4.0+
-        // We can override the version here to allow Citra to work.
-        // TODO: Remove this when OpenGL 4.0+ is advertised.
-        qputenv("MESA_GL_VERSION_OVERRIDE", "4.6");
-    }
-#endif
-#endif
-
 #ifdef ENABLE_VULKAN
     physical_devices = GetVulkanPhysicalDevices();
     if (physical_devices.empty()) {
@@ -647,13 +635,6 @@ void GMainWindow::InitializeHotkeys() {
     link_action_shortcut(ui->action_Advance_Frame, QStringLiteral("Advance Frame"));
     link_action_shortcut(ui->action_Load_from_Newest_Slot, QStringLiteral("Load from Newest Slot"));
     link_action_shortcut(ui->action_Save_to_Oldest_Slot, QStringLiteral("Save to Oldest Slot"));
-    link_action_shortcut(ui->action_View_Lobby,
-                         QStringLiteral("Multiplayer Browse Public Game Lobby"));
-    link_action_shortcut(ui->action_Start_Room, QStringLiteral("Multiplayer Create Room"));
-    link_action_shortcut(ui->action_Connect_To_Room,
-                         QStringLiteral("Multiplayer Direct Connect to Room"));
-    link_action_shortcut(ui->action_Show_Room, QStringLiteral("Multiplayer Show Current Room"));
-    link_action_shortcut(ui->action_Leave_Room, QStringLiteral("Multiplayer Leave Room"));
 
     const auto add_secondary_window_hotkey = [this](QKeySequence hotkey, const char* slot) {
         // This action will fire specifically when secondary_window is in focus
@@ -2177,7 +2158,7 @@ void GMainWindow::OnLoadState() {
 void GMainWindow::OnConfigure() {
     game_list->SetDirectoryWatcherEnabled(false);
     Settings::SetConfiguringGlobal(true);
-    ConfigureDialog configureDialog(this, hotkey_registry, system, gl_renderer, physical_devices,
+    ConfigureDialog configureDialog(this, hotkey_registry, system, physical_devices,
                                     !multiplayer_state->IsHostingPublicRoom());
     connect(&configureDialog, &ConfigureDialog::LanguageChanged, this,
             &GMainWindow::OnLanguageChanged);
@@ -3025,7 +3006,7 @@ void GMainWindow::OnConfigurePerGame() {
 
 void GMainWindow::OpenPerGameConfiguration(u64 title_id, const QString& file_name) {
     Settings::SetConfiguringGlobal(false);
-    ConfigurePerGame dialog(this, title_id, file_name, gl_renderer, physical_devices, system);
+    ConfigurePerGame dialog(this, title_id, file_name, physical_devices, system);
     const auto result = dialog.exec();
 
     if (result != QDialog::Accepted) {
@@ -3197,10 +3178,8 @@ int main(int argc, char* argv[]) {
     QApplication::setHighDpiScaleFactorRoundingPolicy(rounding_policy);
 
 #ifdef __APPLE__
-    auto bundle_dir = FileUtil::GetBundleDirectory();
-    if (bundle_dir) {
-        FileUtil::SetCurrentDir(bundle_dir.value() + "..");
-    }
+    std::string bin_path = FileUtil::GetBundleDirectory() + DIR_SEP + "..";
+    chdir(bin_path.c_str());
 #endif
 
 #ifdef ENABLE_OPENGL

src/citra_qt/main.h

@@ -344,7 +344,6 @@ private:
     // Whether game was paused due to stopping video dumping
     bool game_paused_for_dumping = false;
 
-    QString gl_renderer;
     std::vector<QString> physical_devices;
 
     // Debugger panes

src/citra_qt/multiplayer/direct_connect.cpp

@@ -80,8 +80,9 @@ void DirectConnectWindow::Connect() {
     // Store settings
     UISettings::values.nickname = ui->nickname->text();
     UISettings::values.ip = ui->ip->text();
-    UISettings::values.port =
-        !ui->port->text().isEmpty() ? ui->port->text() : UISettings::values.port;
+    UISettings::values.port = (ui->port->isModified() && !ui->port->text().isEmpty())
+                                  ? ui->port->text()
+                                  : UISettings::values.port;
 
     // attempt to connect in a different thread
     QFuture<void> f = QtConcurrent::run([&] {

src/citra_qt/multiplayer/lobby.cpp

@@ -63,10 +63,10 @@ Lobby::Lobby(Core::System& system_, QWidget* parent, QStandardItemModel* list,
 
     // UI Buttons
     connect(ui->refresh_list, &QPushButton::clicked, this, &Lobby::RefreshLobby);
-    connect(ui->search, &QLineEdit::textChanged, proxy, &LobbyFilterProxyModel::SetFilterSearch);
     connect(ui->games_owned, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterOwned);
     connect(ui->hide_empty, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterEmpty);
     connect(ui->hide_full, &QCheckBox::toggled, proxy, &LobbyFilterProxyModel::SetFilterFull);
+    connect(ui->search, &QLineEdit::textChanged, proxy, &LobbyFilterProxyModel::SetFilterSearch);
     connect(ui->room_list, &QTreeView::doubleClicked, this, &Lobby::OnJoinRoom);
     connect(ui->room_list, &QTreeView::clicked, this, &Lobby::OnExpandRoom);
 
@@ -74,12 +74,6 @@ Lobby::Lobby(Core::System& system_, QWidget* parent, QStandardItemModel* list,
     connect(&room_list_watcher, &QFutureWatcher<AnnounceMultiplayerRoom::RoomList>::finished, this,
             &Lobby::OnRefreshLobby);
 
-    // Load persistent filters after events are connected to make sure they apply
-    ui->search->setText(UISettings::values.multiplayer_filter_text);
-    ui->games_owned->setChecked(UISettings::values.multiplayer_filter_games_owned);
-    ui->hide_empty->setChecked(UISettings::values.multiplayer_filter_hide_empty);
-    ui->hide_full->setChecked(UISettings::values.multiplayer_filter_hide_full);
-
     // manually start a refresh when the window is opening
     // TODO(jroweboy): if this refresh is slow for people with bad internet, then don't do it as
     // part of the constructor, but offload the refresh until after the window shown. perhaps emit a
@@ -186,10 +180,6 @@ void Lobby::OnJoinRoom(const QModelIndex& source) {
     UISettings::values.nickname = ui->nickname->text();
     UISettings::values.ip = proxy->data(connection_index, LobbyItemHost::HostIPRole).toString();
     UISettings::values.port = proxy->data(connection_index, LobbyItemHost::HostPortRole).toString();
-    UISettings::values.multiplayer_filter_text = ui->search->text();
-    UISettings::values.multiplayer_filter_games_owned = ui->games_owned->isChecked();
-    UISettings::values.multiplayer_filter_hide_empty = ui->hide_empty->isChecked();
-    UISettings::values.multiplayer_filter_hide_full = ui->hide_full->isChecked();
 }
 
 void Lobby::ResetModel() {

src/citra_qt/multiplayer/lobby_p.h

@@ -188,37 +188,12 @@ public:
     }
 
     QVariant data(int role) const override {
-        switch (role) {
-        case Qt::DisplayRole: {
-            auto members = data(MemberListRole).toList();
-            return QStringLiteral("%1 / %2").arg(QString::number(members.size()),
-                                                 data(MaxPlayerRole).toString());
-        }
-        case Qt::ForegroundRole: {
-            auto members = data(MemberListRole).toList();
-            auto max_players = data(MaxPlayerRole).toInt();
-            const QColor room_full_color(255, 48, 32);
-            const QColor room_almost_full_color(255, 140, 32);
-            const QColor room_has_players_color(32, 160, 32);
-            const QColor room_empty_color(128, 128, 128);
-
-            if (members.size() >= max_players) {
-                return QBrush(room_full_color);
-            } else if (members.size() == (max_players - 1)) {
-                return QBrush(room_almost_full_color);
-            } else if (members.size() == 0) {
-                return QBrush(room_empty_color);
-            } else if (members.size() > 0 && members.size() < (max_players - 1)) {
-                return QBrush(room_has_players_color);
-            }
-
-            // FIXME: How to return a value that tells Qt not to modify the
-            // text color from the default (as if Qt::ForegroundRole wasn't overridden)?
-            return QBrush(nullptr);
-        }
-        default:
+        if (role != Qt::DisplayRole) {
             return LobbyItem::data(role);
         }
+        auto members = data(MemberListRole).toList();
+        return QStringLiteral("%1 / %2").arg(QString::number(members.size()),
+                                             data(MaxPlayerRole).toString());
     }
 
     bool operator<(const QStandardItem& other) const override {

src/citra_qt/uisettings.h

@@ -138,11 +138,6 @@ struct Values {
     QString room_description;
     std::pair<std::vector<std::string>, std::vector<std::string>> ban_list;
 
-    QString multiplayer_filter_text;
-    bool multiplayer_filter_games_owned;
-    bool multiplayer_filter_hide_empty;
-    bool multiplayer_filter_hide_full;
-
     // logging
     Settings::Setting<bool> show_console{false, "showConsole"};
 };

src/citra_qt/util/vk_device_info.cpp

@@ -2,34 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "citra_qt/util/graphics_device_info.h"
-
-#ifdef ENABLE_OPENGL
-#include <QOffscreenSurface>
-#include <QOpenGLContext>
-#include <QOpenGLFunctions>
-#endif
-
-#ifdef ENABLE_VULKAN
+#include "citra_qt/util/vk_device_info.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
-#endif
 
-#ifdef ENABLE_OPENGL
-QString GetOpenGLRenderer() {
-    QOffscreenSurface surface;
-    surface.create();
-
-    QOpenGLContext context;
-    if (context.create()) {
-        context.makeCurrent(&surface);
-        return QString::fromUtf8(context.functions()->glGetString(GL_RENDERER));
-    } else {
-        return QStringLiteral("");
-    }
-}
-#endif
-
-#ifdef ENABLE_VULKAN
 std::vector<QString> GetVulkanPhysicalDevices() {
     std::vector<QString> result;
     try {
@@ -46,4 +21,3 @@ std::vector<QString> GetVulkanPhysicalDevices() {
 
     return result;
 }
-#endif

src/citra_qt/util/vk_device_info.h

@@ -7,12 +7,5 @@
 #include <vector>
 #include <QString>
 
-#ifdef ENABLE_OPENGL
-/// Returns the name of the OpenGL renderer.
-QString GetOpenGLRenderer();
-#endif
-
-#ifdef ENABLE_VULKAN
 /// Returns a list of all available vulkan GPUs.
-std::vector<QString> GetVulkanPhysicalDevices();
-#endif
+std::vector<QString> GetVulkanPhysicalDevices();

src/common/aarch64/oaknut_util.h

@@ -20,7 +20,7 @@ inline bool IsWithin128M(uintptr_t ref, uintptr_t target) {
 }
 
 inline bool IsWithin128M(const oaknut::CodeGenerator& code, uintptr_t target) {
-    return IsWithin128M(code.xptr<uintptr_t>(), target);
+    return IsWithin128M(code.ptr<uintptr_t>(), target);
 }
 
 template <typename T>

src/common/common_paths.h

@@ -13,6 +13,7 @@
 #endif
 
 // The user data dir
+#define ROOT_DIR "."
 #define USERDATA_DIR "user"
 #ifdef USER_DIR
 #define EMU_DATA_DIR USER_DIR

src/common/file_util.cpp

@@ -634,10 +634,6 @@ std::optional<std::string> GetCurrentDir() {
     std::string strDir = dir;
 #endif
     free(dir);
-
-    if (!strDir.ends_with(DIR_SEP)) {
-        strDir += DIR_SEP;
-    }
     return strDir;
 } // namespace FileUtil
 
@@ -650,36 +646,17 @@ bool SetCurrentDir(const std::string& directory) {
 }
 
 #if defined(__APPLE__)
-std::optional<std::string> GetBundleDirectory() {
+std::string GetBundleDirectory() {
+    CFURLRef BundleRef;
+    char AppBundlePath[MAXPATHLEN];
     // Get the main bundle for the app
-    CFBundleRef bundle_ref = CFBundleGetMainBundle();
-    if (!bundle_ref) {
-        return {};
-    }
+    BundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
+    CFStringRef BundlePath = CFURLCopyFileSystemPath(BundleRef, kCFURLPOSIXPathStyle);
+    CFStringGetFileSystemRepresentation(BundlePath, AppBundlePath, sizeof(AppBundlePath));
+    CFRelease(BundleRef);
+    CFRelease(BundlePath);
 
-    CFURLRef bundle_url_ref = CFBundleCopyBundleURL(bundle_ref);
-    if (!bundle_url_ref) {
-        return {};
-    }
-    SCOPE_EXIT({ CFRelease(bundle_url_ref); });
-
-    CFStringRef bundle_path_ref = CFURLCopyFileSystemPath(bundle_url_ref, kCFURLPOSIXPathStyle);
-    if (!bundle_path_ref) {
-        return {};
-    }
-    SCOPE_EXIT({ CFRelease(bundle_path_ref); });
-
-    char app_bundle_path[MAXPATHLEN];
-    if (!CFStringGetFileSystemRepresentation(bundle_path_ref, app_bundle_path,
-                                             sizeof(app_bundle_path))) {
-        return {};
-    }
-
-    std::string path_str(app_bundle_path);
-    if (!path_str.ends_with(DIR_SEP)) {
-        path_str += DIR_SEP;
-    }
-    return path_str;
+    return AppBundlePath;
 }
 #endif
 
@@ -755,6 +732,22 @@ static const std::string& GetHomeDirectory() {
 }
 #endif
 
+std::string GetSysDirectory() {
+    std::string sysDir;
+
+#if defined(__APPLE__)
+    sysDir = GetBundleDirectory();
+    sysDir += DIR_SEP;
+    sysDir += SYSDATA_DIR;
+#else
+    sysDir = SYSDATA_DIR;
+#endif
+    sysDir += DIR_SEP;
+
+    LOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
+    return sysDir;
+}
+
 namespace {
 std::unordered_map<UserPath, std::string> g_paths;
 std::unordered_map<UserPath, std::string> g_default_paths;
@@ -784,10 +777,8 @@ void SetUserPath(const std::string& path) {
         g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
         g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
 #else
-        auto current_dir = FileUtil::GetCurrentDir();
-        if (current_dir.has_value() &&
-            FileUtil::Exists(current_dir.value() + USERDATA_DIR DIR_SEP)) {
-            user_path = current_dir.value() + USERDATA_DIR DIR_SEP;
+        if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
+            user_path = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
             g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
             g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
         } else {

src/common/file_util.h

@@ -193,8 +193,11 @@ void SetCurrentRomPath(const std::string& path);
 // Update the Global Path with the new value
 void UpdateUserPath(UserPath path, const std::string& filename);
 
+// Returns the path to where the sys file are
+[[nodiscard]] std::string GetSysDirectory();
+
 #ifdef __APPLE__
-[[nodiscard]] std::optional<std::string> GetBundleDirectory();
+[[nodiscard]] std::string GetBundleDirectory();
 #endif
 
 #ifdef _WIN32

src/common/logging/backend.cpp

@@ -451,7 +451,7 @@ void SetColorConsoleBackendEnabled(bool enabled) {
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
         Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,

src/common/logging/log.h

@@ -24,12 +24,12 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args);
 
 template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, fmt::format_string<Args...> format, const Args&... args) {
+                   const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
                       fmt::make_format_args(args...));
 }

src/core/CMakeLists.txt

@@ -327,10 +327,6 @@ add_library(citra_core STATIC
     hle/service/ldr_ro/cro_helper.h
     hle/service/ldr_ro/ldr_ro.cpp
     hle/service/ldr_ro/ldr_ro.h
-    hle/service/mcu/mcu_hwc.cpp
-    hle/service/mcu/mcu_hwc.h
-    hle/service/mcu/mcu.cpp
-    hle/service/mcu/mcu.h
     hle/service/mic/mic_u.cpp
     hle/service/mic/mic_u.h
     hle/service/mvd/mvd.cpp

src/core/hle/kernel/config_mem.cpp

@@ -14,18 +14,18 @@ namespace ConfigMem {
 Handler::Handler() {
     std::memset(&config_mem, 0, sizeof(config_mem));
 
-    // Values extracted from firmware 11.17.0-50E
-    config_mem.kernel_version_min = 0x3a;
+    // Values extracted from firmware 11.2.0-35E
+    config_mem.kernel_version_min = 0x34;
     config_mem.kernel_version_maj = 0x2;
     config_mem.ns_tid = 0x0004013000008002;
     config_mem.sys_core_ver = 0x2;
     config_mem.unit_info = 0x1; // Bit 0 set for Retail
     config_mem.prev_firm = 0x1;
-    config_mem.ctr_sdk_ver = 0x0000F450;
-    config_mem.firm_version_min = 0x3a;
+    config_mem.ctr_sdk_ver = 0x0000F297;
+    config_mem.firm_version_min = 0x34;
     config_mem.firm_version_maj = 0x2;
     config_mem.firm_sys_core_ver = 0x2;
-    config_mem.firm_ctr_sdk_ver = 0x0000F450;
+    config_mem.firm_ctr_sdk_ver = 0x0000F297;
 }
 
 ConfigMemDef& Handler::GetConfigMem() {

src/core/hle/kernel/process.cpp

@@ -210,10 +210,10 @@ void Process::Set3dsxKernelCaps() {
     };
 
     // Similar to Rosalina, we set kernel version to a recent one.
-    // This is 11.17.0, to be consistent with core/hle/kernel/config_mem.cpp
+    // This is 11.2.0, to be consistent with core/hle/kernel/config_mem.cpp
     // TODO: refactor kernel version out so it is configurable and consistent
     // among all relevant places.
-    kernel_version = 0x23a;
+    kernel_version = 0x234;
 }
 
 void Process::Run(s32 main_thread_priority, u32 stack_size) {

src/core/hle/service/apt/applet_manager.cpp

@@ -373,10 +373,7 @@ ResultVal<AppletManager::InitializeResult> AppletManager::Initialize(AppletId ap
     if (active_slot == AppletSlot::Error) {
         active_slot = slot;
 
-        // APT automatically calls enable on the first registered applet.
-        Enable(attributes);
-
-        // Wake up the applet.
+        // Wake up the application.
         SendParameter({
             .sender_id = AppletId::None,
             .destination_id = app_id,
@@ -401,8 +398,7 @@ Result AppletManager::Enable(AppletAttributes attributes) {
     auto slot_data = GetAppletSlot(slot);
     slot_data->registered = true;
 
-    if (slot_data->applet_id != AppletId::None &&
-        slot_data->attributes.applet_pos == AppletPos::System &&
+    if (slot_data->attributes.applet_pos == AppletPos::System &&
         slot_data->attributes.is_home_menu) {
         slot_data->attributes.raw |= attributes.raw;
         LOG_DEBUG(Service_APT, "Updated home menu attributes to {:08X}.",
@@ -790,23 +786,16 @@ Result AppletManager::PrepareToStartSystemApplet(AppletId applet_id) {
 
 Result AppletManager::StartSystemApplet(AppletId applet_id, std::shared_ptr<Kernel::Object> object,
                                         const std::vector<u8>& buffer) {
-    auto source_applet_id = AppletId::Application;
+    auto source_applet_id = AppletId::None;
     if (last_system_launcher_slot != AppletSlot::Error) {
-        const auto launcher_slot_data = GetAppletSlot(last_system_launcher_slot);
-        source_applet_id = launcher_slot_data->applet_id;
+        const auto slot_data = GetAppletSlot(last_system_launcher_slot);
+        source_applet_id = slot_data->applet_id;
 
-        // APT generally clears and terminates the caller of StartSystemApplet. This helps in
-        // situations such as a system applet launching another system applet, which would
-        // otherwise deadlock.
-        // TODO: In real APT, the check for AppletSlot::Application does not exist; there is
-        // TODO: something wrong with our implementation somewhere that makes this necessary.
-        // TODO: Otherwise, games that attempt to launch system applets will be cleared and
-        // TODO: emulation will crash.
-        if (!launcher_slot_data->registered ||
-            (last_system_launcher_slot != AppletSlot::Application &&
-             !launcher_slot_data->attributes.no_exit_on_system_applet)) {
-            launcher_slot_data->Reset();
-            // TODO: Implement launcher process termination.
+        // If a system applet is launching another system applet, reset the slot to avoid conflicts.
+        // This is needed because system applets won't necessarily call CloseSystemApplet before
+        // exiting.
+        if (last_system_launcher_slot == AppletSlot::SystemApplet) {
+            slot_data->Reset();
         }
     }
 

src/core/hle/service/apt/applet_manager.h

@@ -152,7 +152,6 @@ union AppletAttributes {
     u32 raw;
 
     BitField<0, 3, AppletPos> applet_pos;
-    BitField<28, 1, u32> no_exit_on_system_applet;
     BitField<29, 1, u32> is_home_menu;
 
     AppletAttributes() : raw(0) {}

src/core/hle/service/http/http_c.h

@@ -17,8 +17,10 @@
 #include <boost/serialization/unordered_map.hpp>
 #include <boost/serialization/vector.hpp>
 #include <boost/serialization/weak_ptr.hpp>
+#if defined(__ANDROID__)
+#include <ifaddrs.h>
+#endif
 #include <httplib.h>
-#include "common/thread.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/service.h"
@@ -49,25 +51,12 @@ constexpr u32 TotalRequestMethods = 8;
 
 enum class RequestState : u8 {
     NotStarted = 0x1,             // Request has not started yet.
-    ConnectingToServer = 0x5,     // Request in progress, connecting to server.
-    SendingRequest = 0x6,         // Request in progress, sending HTTP request.
-    ReceivingResponse = 0x7,      // Request in progress, receiving HTTP response.
-    ReadyToDownloadContent = 0x8, // Ready to download the content.
+    InProgress = 0x5,             // Request in progress, sending request over the network.
+    ReadyToDownloadContent = 0x7, // Ready to download the content. (needs verification)
+    ReadyToDownload = 0x8,        // Ready to download?
     TimedOut = 0xA,               // Request timed out?
 };
 
-enum class PostDataEncoding : u8 {
-    Auto = 0x0,
-    AsciiForm = 0x1,
-    MultipartForm = 0x2,
-};
-
-enum class PostDataType : u8 {
-    AsciiForm = 0x0,
-    MultipartForm = 0x1,
-    Raw = 0x2,
-};
-
 enum class ClientCertID : u32 {
     Default = 0x40, // Default client cert
 };
@@ -211,41 +200,6 @@ public:
         friend class boost::serialization::access;
     };
 
-    struct Param {
-        Param(const std::vector<u8>& value)
-            : name(value.begin(), value.end()), value(value.begin(), value.end()){};
-        Param(const std::string& name, const std::string& value) : name(name), value(value){};
-        Param(const std::string& name, const std::vector<u8>& value)
-            : name(name), value(value.begin(), value.end()), is_binary(true){};
-        std::string name;
-        std::string value;
-        bool is_binary = false;
-
-        httplib::MultipartFormData ToMultipartForm() const {
-            httplib::MultipartFormData form;
-            form.name = name;
-            form.content = value;
-            if (is_binary) {
-                form.content_type = "application/octet-stream";
-                // TODO(DaniElectra): httplib doesn't support setting Content-Transfer-Encoding,
-                // while the 3DS sets Content-Transfer-Encoding: binary if a binary value is set
-            }
-
-            return form;
-        }
-
-    private:
-        template <class Archive>
-        void serialize(Archive& ar, const unsigned int) {
-            ar& name;
-            ar& value;
-            ar& is_binary;
-        }
-        friend class boost::serialization::access;
-    };
-
-    using Params = std::multimap<std::string, Param>;
-
     Handle handle;
     u32 session_id;
     std::string url;
@@ -257,14 +211,8 @@ public:
     u32 socket_buffer_size;
     std::vector<RequestHeader> headers;
     const ClCertAData* clcert_data;
-    Params post_data;
+    httplib::Params post_data;
     std::string post_data_raw;
-    PostDataEncoding post_data_encoding = PostDataEncoding::Auto;
-    PostDataType post_data_type;
-    std::string multipart_boundary;
-    bool force_multipart = false;
-    bool chunked_request = false;
-    u32 chunked_content_length;
 
     std::future<void> request_future;
     std::atomic<u64> current_download_size_bytes;
@@ -272,19 +220,12 @@ public:
     std::size_t current_copied_data;
     bool uses_default_client_cert{};
     httplib::Response response;
-    Common::Event finish_post_data;
 
-    void ParseAsciiPostData();
-    std::string ParseMultipartFormData();
     void MakeRequest();
     void MakeRequestNonSSL(httplib::Request& request, const URLInfo& url_info,
                            std::vector<Context::RequestHeader>& pending_headers);
     void MakeRequestSSL(httplib::Request& request, const URLInfo& url_info,
                         std::vector<Context::RequestHeader>& pending_headers);
-    bool ContentProvider(size_t offset, size_t length, httplib::DataSink& sink);
-    bool ChunkedContentProvider(size_t offset, httplib::DataSink& sink);
-    std::size_t HandleHeaderWrite(std::vector<Context::RequestHeader>& pending_headers,
-                                  httplib::Stream& strm, httplib::Headers& httplib_headers);
 };
 
 struct SessionData : public Kernel::SessionRequestHandler::SessionDataBase {
@@ -370,16 +311,6 @@ private:
      */
     void CancelConnection(Kernel::HLERequestContext& ctx);
 
-    /**
-     * HTTP_C::GetRequestState service function
-     *  Inputs:
-     *      1 : Context handle
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     *      2 : Request state
-     */
-    void GetRequestState(Kernel::HLERequestContext& ctx);
-
     /**
      * HTTP_C::GetDownloadSizeState service function
      *  Inputs:
@@ -490,21 +421,6 @@ private:
      */
     void AddPostDataAscii(Kernel::HLERequestContext& ctx);
 
-    /**
-     * HTTP_C::AddPostDataBinary service function
-     *  Inputs:
-     * 1 : Context handle
-     * 2 : Form name buffer size, including null-terminator.
-     * 3 : Form value buffer size
-     * 4 : (FormNameSize<<14) | 0xC02
-     * 5 : Form name data pointer
-     * 6 : (FormValueSize<<4) | 10
-     * 7 : Form value data pointer
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void AddPostDataBinary(Kernel::HLERequestContext& ctx);
-
     /**
      * HTTP_C::AddPostDataRaw service function
      *  Inputs:
@@ -517,140 +433,6 @@ private:
      */
     void AddPostDataRaw(Kernel::HLERequestContext& ctx);
 
-    /**
-     * HTTP_C::SetPostDataType service function
-     *  Inputs:
-     *      1 : Context handle
-     *      2 : Post data type
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SetPostDataType(Kernel::HLERequestContext& ctx);
-
-    /**
-     * HTTP_C::SendPostDataAscii service function
-     *  Inputs:
-     * 1 : Context handle
-     * 2 : Form name buffer size, including null-terminator.
-     * 3 : Form value buffer size, including null-terminator.
-     * 4 : (FormNameSize<<14) | 0xC02
-     * 5 : Form name data pointer
-     * 6 : (FormValueSize<<4) | 10
-     * 7 : Form value data pointer
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SendPostDataAscii(Kernel::HLERequestContext& ctx);
-
-    /**
-     * HTTP_C::SendPostDataAsciiTimeout service function
-     *  Inputs:
-     * 1 : Context handle
-     * 2 : Form name buffer size, including null-terminator.
-     * 3 : Form value buffer size, including null-terminator.
-     * 4-5 : u64 nanoseconds delay
-     * 6 : (FormNameSize<<14) | 0xC02
-     * 7 : Form name data pointer
-     * 8 : (FormValueSize<<4) | 10
-     * 9 : Form value data pointer
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SendPostDataAsciiTimeout(Kernel::HLERequestContext& ctx);
-
-    /**
-     * SendPostDataAsciiImpl:
-     *  Implements SendPostDataAscii and SendPostDataAsciiTimeout service functions
-     */
-    void SendPostDataAsciiImpl(Kernel::HLERequestContext& ctx, bool timeout);
-
-    /**
-     * HTTP_C::SendPostDataBinary service function
-     *  Inputs:
-     * 1 : Context handle
-     * 2 : Form name buffer size, including null-terminator.
-     * 3 : Form value buffer size
-     * 4 : (FormNameSize<<14) | 0xC02
-     * 5 : Form name data pointer
-     * 6 : (FormValueSize<<4) | 10
-     * 7 : Form value data pointer
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SendPostDataBinary(Kernel::HLERequestContext& ctx);
-
-    /**
-     * HTTP_C::SendPostDataBinaryTimeout service function
-     *  Inputs:
-     * 1 : Context handle
-     * 2 : Form name buffer size, including null-terminator.
-     * 3 : Form value buffer size
-     * 4-5 : u64 nanoseconds delay
-     * 6 : (FormNameSize<<14) | 0xC02
-     * 7 : Form name data pointer
-     * 8 : (FormValueSize<<4) | 10
-     * 9 : Form value data pointer
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SendPostDataBinaryTimeout(Kernel::HLERequestContext& ctx);
-
-    /**
-     * SendPostDataBinaryImpl:
-     *  Implements SendPostDataBinary and SendPostDataBinaryTimeout service functions
-     */
-    void SendPostDataBinaryImpl(Kernel::HLERequestContext& ctx, bool timeout);
-
-    /**
-     * HTTP_C::SendPostDataRaw service function
-     *  Inputs:
-     *      1 : Context handle
-     *      2 : Post data length
-     *      3-4: (Mapped buffer) Post data
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     *      2-3: (Mapped buffer) Post data
-     */
-    void SendPostDataRaw(Kernel::HLERequestContext& ctx);
-
-    /**
-     * HTTP_C::SendPostDataRawTimeout service function
-     *  Inputs:
-     *      1 : Context handle
-     *      2 : Post data length
-     *      3-4: u64 nanoseconds delay
-     *      5-6: (Mapped buffer) Post data
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     *      2-3: (Mapped buffer) Post data
-     */
-    void SendPostDataRawTimeout(Kernel::HLERequestContext& ctx);
-
-    /**
-     * SendPostDataRawImpl:
-     *  Implements SendPostDataRaw and SendPostDataRawTimeout service functions
-     */
-    void SendPostDataRawImpl(Kernel::HLERequestContext& ctx, bool timeout);
-
-    /**
-     * HTTP_C::NotifyFinishSendPostData service function
-     *  Inputs:
-     *      1 : Context handle
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void NotifyFinishSendPostData(Kernel::HLERequestContext& ctx);
-
-    /**
-     * HTTP_C::SetPostDataEncoding service function
-     *  Inputs:
-     *      1 : Context handle
-     *      2 : Post data encoding
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SetPostDataEncoding(Kernel::HLERequestContext& ctx);
-
     /**
      * HTTP_C::GetResponseHeader service function
      *  Inputs:
@@ -666,28 +448,6 @@ private:
      */
     void GetResponseHeader(Kernel::HLERequestContext& ctx);
 
-    /**
-     * HTTP_C::GetResponseHeaderTimeout service function
-     *  Inputs:
-     *      1 : Context handle
-     *      2 : Header name length
-     *      3 : Return value length
-     *      4-5 : u64 nanoseconds delay
-     *      6-7 : (Static buffer) Header name
-     *      8-9 : (Mapped buffer) Header value
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     *      2 : Header value copied size
-     *      3-4: (Mapped buffer) Header value
-     */
-    void GetResponseHeaderTimeout(Kernel::HLERequestContext& ctx);
-
-    /**
-     * GetResponseHeaderImpl:
-     *  Implements GetResponseHeader and GetResponseHeaderTimeout service functions
-     */
-    void GetResponseHeaderImpl(Kernel::HLERequestContext& ctx, bool timeout);
-
     /**
      * HTTP_C::GetResponseStatusCode service function
      *  Inputs:
@@ -821,17 +581,6 @@ private:
      */
     void SetKeepAlive(Kernel::HLERequestContext& ctx);
 
-    /**
-     * HTTP_C::SetPostDataTypeSize service function
-     *  Inputs:
-     *      1 : Context handle
-     *      2 : Post data type
-     *      3 : Content length size
-     *  Outputs:
-     *      1 : Result of function, 0 on success, otherwise error code
-     */
-    void SetPostDataTypeSize(Kernel::HLERequestContext& ctx);
-
     /**
      * HTTP_C::Finalize service function
      *  Outputs:

src/core/hle/service/mcu/mcu.cpp

@@ -1,16 +0,0 @@
-// Copyright 2024 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/hle/service/mcu/mcu.h"
-#include "core/hle/service/mcu/mcu_hwc.h"
-
-namespace Service::MCU {
-
-void InstallInterfaces(Core::System& system) {
-    auto& service_manager = system.ServiceManager();
-    std::make_shared<HWC>()->InstallAsService(service_manager);
-}
-
-} // namespace Service::MCU

src/core/hle/service/mcu/mcu.h

@@ -1,15 +0,0 @@
-// Copyright 2024 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-namespace Core {
-class System;
-}
-
-namespace Service::MCU {
-
-void InstallInterfaces(Core::System& system);
-
-} // namespace Service::MCU

src/core/hle/service/mcu/mcu_hwc.cpp

@@ -1,36 +0,0 @@
-// Copyright 2024 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/archives.h"
-#include "core/hle/service/mcu/mcu_hwc.h"
-
-SERIALIZE_EXPORT_IMPL(Service::MCU::HWC)
-
-namespace Service::MCU {
-
-HWC::HWC() : ServiceFramework("mcu::HWC", 1) {
-    static const FunctionInfo functions[] = {
-        // clang-format off
-        {0x0001, nullptr, "ReadRegister"},
-        {0x0002, nullptr, "WriteRegister"},
-        {0x0003, nullptr, "GetInfoRegisters"},
-        {0x0004, nullptr, "GetBatteryVoltage"},
-        {0x0005, nullptr, "GetBatteryLevel"},
-        {0x0006, nullptr, "SetPowerLEDPattern"},
-        {0x0007, nullptr, "SetWifiLEDState"},
-        {0x0008, nullptr, "SetCameraLEDPattern"},
-        {0x0009, nullptr, "Set3DLEDState"},
-        {0x000A, nullptr, "SetInfoLEDPattern"},
-        {0x000B, nullptr, "GetSoundVolume"},
-        {0x000C, nullptr, "SetTopScreenFlicker"},
-        {0x000D, nullptr, "SetBottomScreenFlicker"},
-        {0x000F, nullptr, "GetRtcTime"},
-        {0x0010, nullptr, "GetMcuFwVerHigh"},
-        {0x0011, nullptr, "GetMcuFwVerLow"},
-        // clang-format on
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::MCU

src/core/hle/service/mcu/mcu_hwc.h

@@ -1,21 +0,0 @@
-// Copyright 2024 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Service::MCU {
-
-class HWC final : public ServiceFramework<HWC> {
-public:
-    explicit HWC();
-
-private:
-    SERVICE_SERIALIZATION_SIMPLE
-};
-
-} // namespace Service::MCU
-
-BOOST_CLASS_EXPORT_KEY(Service::MCU::HWC)

src/core/hle/service/service.cpp

@@ -35,7 +35,6 @@
 #include "core/hle/service/http/http_c.h"
 #include "core/hle/service/ir/ir.h"
 #include "core/hle/service/ldr_ro/ldr_ro.h"
-#include "core/hle/service/mcu/mcu.h"
 #include "core/hle/service/mic/mic_u.h"
 #include "core/hle/service/mvd/mvd.h"
 #include "core/hle/service/ndm/ndm_u.h"
@@ -102,7 +101,7 @@ const std::array<ServiceModuleInfo, 41> service_module_map{
      {"CDC", 0x00040130'00001802, nullptr},
      {"GPIO", 0x00040130'00001B02, nullptr},
      {"I2C", 0x00040130'00001E02, nullptr},
-     {"MCU", 0x00040130'00001F02, MCU::InstallInterfaces},
+     {"MCU", 0x00040130'00001F02, nullptr},
      {"MP", 0x00040130'00002A02, nullptr},
      {"PDN", 0x00040130'00002102, nullptr},
      {"SPI", 0x00040130'00002302, nullptr}}};

src/core/hle/service/soc/soc_u.cpp

@@ -598,10 +598,9 @@ static_assert(std::is_trivially_copyable_v<CTRPollFD>,
 union CTRSockAddr {
     /// Structure to represent a raw sockaddr
     struct {
-        u8 len;       ///< The length of the entire structure, only the set fields count
-        u8 sa_family; ///< The address family of the sockaddr
-        std::array<u8, 0x1A>
-            sa_data; ///< The extra data, this varies, depending on the address family
+        u8 len;           ///< The length of the entire structure, only the set fields count
+        u8 sa_family;     ///< The address family of the sockaddr
+        u8 sa_data[0x1A]; ///< The extra data, this varies, depending on the address family
     } raw;
 
     /// Structure to represent the 3ds' sockaddr_in structure
@@ -613,57 +612,36 @@ union CTRSockAddr {
     } in;
     static_assert(sizeof(CTRSockAddrIn) == 8, "Invalid CTRSockAddrIn size");
 
-    struct CTRSockAddrIn6 {
-        u8 len;                         ///< The length of the entire structure
-        u8 sin6_family;                 ///< The address family of the sockaddr_in6
-        u16 sin6_port;                  ///< The port associated with this sockaddr_in6
-        std::array<u8, 0x10> sin6_addr; ///< The actual address of the sockaddr_in6
-        u32 sin6_flowinfo;              ///< The flow info of the sockaddr_in6
-        u32 sin6_scope_id;              ///< The scope ID of the sockaddr_in6
-    } in6;
-    static_assert(sizeof(CTRSockAddrIn6) == 28, "Invalid CTRSockAddrIn6 size");
-
     /// Convert a 3DS CTRSockAddr to a platform-specific sockaddr
-    static std::pair<sockaddr_storage, socklen_t> ToPlatform(CTRSockAddr const& ctr_addr) {
-        sockaddr_storage result{};
-        socklen_t result_len = sizeof(result.ss_family);
-        ASSERT_MSG(ctr_addr.raw.len == sizeof(CTRSockAddrIn) ||
-                       ctr_addr.raw.len == sizeof(CTRSockAddrIn6),
+    static sockaddr ToPlatform(CTRSockAddr const& ctr_addr) {
+        sockaddr result;
+        ASSERT_MSG(ctr_addr.raw.len == sizeof(CTRSockAddrIn),
                    "Unhandled address size (len) in CTRSockAddr::ToPlatform");
-        result.ss_family = SocketDomainToPlatform(ctr_addr.raw.sa_family);
+        result.sa_family = SocketDomainToPlatform(ctr_addr.raw.sa_family);
+        std::memset(result.sa_data, 0, sizeof(result.sa_data));
 
         // We can not guarantee ABI compatibility between platforms so we copy the fields manually
-        switch (result.ss_family) {
+        switch (result.sa_family) {
         case AF_INET: {
             sockaddr_in* result_in = reinterpret_cast<sockaddr_in*>(&result);
             result_in->sin_port = ctr_addr.in.sin_port;
             result_in->sin_addr.s_addr = ctr_addr.in.sin_addr;
-            result_len = sizeof(sockaddr_in);
-            break;
-        }
-        case AF_INET6: {
-            sockaddr_in6* result_in6 = reinterpret_cast<sockaddr_in6*>(&result);
-            result_in6->sin6_port = ctr_addr.in6.sin6_port;
-            memcpy(&result_in6->sin6_addr, ctr_addr.in6.sin6_addr.data(),
-                   sizeof(result_in6->sin6_addr));
-            result_in6->sin6_flowinfo = ctr_addr.in6.sin6_flowinfo;
-            result_in6->sin6_scope_id = ctr_addr.in6.sin6_scope_id;
-            result_len = sizeof(sockaddr_in6);
+            std::memset(result_in->sin_zero, 0, sizeof(result_in->sin_zero));
             break;
         }
         default:
             ASSERT_MSG(false, "Unhandled address family (sa_family) in CTRSockAddr::ToPlatform");
             break;
         }
-        return std::make_pair(result, result_len);
+        return result;
     }
 
     /// Convert a platform-specific sockaddr to a 3DS CTRSockAddr
-    static CTRSockAddr FromPlatform(sockaddr_storage const& addr) {
+    static CTRSockAddr FromPlatform(sockaddr const& addr) {
         CTRSockAddr result;
-        result.raw.sa_family = static_cast<u8>(SocketDomainFromPlatform(addr.ss_family));
+        result.raw.sa_family = static_cast<u8>(SocketDomainFromPlatform(addr.sa_family));
         // We can not guarantee ABI compatibility between platforms so we copy the fields manually
-        switch (addr.ss_family) {
+        switch (addr.sa_family) {
         case AF_INET: {
             sockaddr_in const* addr_in = reinterpret_cast<sockaddr_in const*>(&addr);
             result.raw.len = sizeof(CTRSockAddrIn);
@@ -671,15 +649,6 @@ union CTRSockAddr {
             result.in.sin_addr = addr_in->sin_addr.s_addr;
             break;
         }
-        case AF_INET6: {
-            sockaddr_in6 const* addr_in6 = reinterpret_cast<sockaddr_in6 const*>(&addr);
-            result.raw.len = sizeof(CTRSockAddrIn6);
-            result.in6.sin6_port = addr_in6->sin6_port;
-            memcpy(result.in6.sin6_addr.data(), &addr_in6->sin6_addr, sizeof(result.in6.sin6_addr));
-            result.in6.sin6_flowinfo = addr_in6->sin6_flowinfo;
-            result.in6.sin6_scope_id = addr_in6->sin6_scope_id;
-            break;
-        }
         default:
             ASSERT_MSG(false, "Unhandled address family (sa_family) in CTRSockAddr::ToPlatform");
             break;
@@ -738,8 +707,7 @@ struct CTRAddrInfo {
             .ai_family = static_cast<s32_le>(SocketDomainFromPlatform(addr.ai_family)),
             .ai_socktype = static_cast<s32_le>(SocketTypeFromPlatform(addr.ai_socktype)),
             .ai_protocol = static_cast<s32_le>(SocketProtocolFromPlatform(addr.ai_protocol)),
-            .ai_addr =
-                CTRSockAddr::FromPlatform(*reinterpret_cast<sockaddr_storage*>(addr.ai_addr)),
+            .ai_addr = CTRSockAddr::FromPlatform(*addr.ai_addr),
         };
         ctr_addr.ai_addrlen = static_cast<s32_le>(ctr_addr.ai_addr.raw.len);
         if (addr.ai_canonname)
@@ -872,9 +840,9 @@ void SOC_U::Bind(Kernel::HLERequestContext& ctx) {
     CTRSockAddr ctr_sock_addr;
     std::memcpy(&ctr_sock_addr, sock_addr_buf.data(), std::min<size_t>(len, sizeof(ctr_sock_addr)));
 
-    auto [sock_addr, sock_addr_len] = CTRSockAddr::ToPlatform(ctr_sock_addr);
+    sockaddr sock_addr = CTRSockAddr::ToPlatform(ctr_sock_addr);
 
-    s32 ret = ::bind(holder.socket_fd, reinterpret_cast<sockaddr*>(&sock_addr), sock_addr_len);
+    s32 ret = ::bind(holder.socket_fd, &sock_addr, sizeof(sock_addr));
 
     if (ret != 0)
         ret = TranslateError(GET_ERRNO);
@@ -969,7 +937,7 @@ void SOC_U::Accept(Kernel::HLERequestContext& ctx) {
         // Output
         s32 ret{};
         int accept_error;
-        sockaddr_storage addr;
+        sockaddr addr;
     };
 
     auto async_data = std::make_shared<AsyncData>();
@@ -982,8 +950,7 @@ void SOC_U::Accept(Kernel::HLERequestContext& ctx) {
         [async_data](Kernel::HLERequestContext& ctx) {
             socklen_t addr_len = sizeof(async_data->addr);
             async_data->ret = static_cast<u32>(
-                ::accept(async_data->fd_info->socket_fd,
-                         reinterpret_cast<sockaddr*>(&async_data->addr), &addr_len));
+                ::accept(async_data->fd_info->socket_fd, &async_data->addr, &addr_len));
             async_data->accept_error = (async_data->ret == SOCKET_ERROR_VALUE) ? GET_ERRNO : 0;
             return 0;
         },
@@ -1014,8 +981,8 @@ void SOC_U::Accept(Kernel::HLERequestContext& ctx) {
                 ctr_addr_buf.resize(async_data->max_addr_len);
             }
 
-            LOG_DEBUG(Service_SOC, "called, pid={}, fd={}, ret={}", async_data->pid,
-                      async_data->socket_handle, static_cast<s32>(async_data->ret));
+            LOG_DEBUG(Service_SOC, "called, pid={}, fd={}, ret={}", async_data->socket_handle,
+                      static_cast<s32>(async_data->ret));
 
             IPC::RequestBuilder rb(ctx, 0x04, 2, 2);
             rb.Push(ResultSuccess);
@@ -1142,10 +1109,10 @@ void SOC_U::SendToOther(Kernel::HLERequestContext& ctx) {
         CTRSockAddr ctr_dest_addr;
         std::memcpy(&ctr_dest_addr, dest_addr_buffer.data(),
                     std::min<size_t>(addr_len, sizeof(ctr_dest_addr)));
-        auto [dest_addr, dest_addr_len] = CTRSockAddr::ToPlatform(ctr_dest_addr);
-        ret = static_cast<s32>(
-            ::sendto(holder.socket_fd, reinterpret_cast<const char*>(input_buff.data()), len, flags,
-                     reinterpret_cast<sockaddr*>(&dest_addr), dest_addr_len));
+        sockaddr dest_addr = CTRSockAddr::ToPlatform(ctr_dest_addr);
+        ret = static_cast<s32>(::sendto(holder.socket_fd,
+                                        reinterpret_cast<const char*>(input_buff.data()), len,
+                                        flags, &dest_addr, sizeof(dest_addr)));
     } else {
         ret = static_cast<s32>(::sendto(holder.socket_fd,
                                         reinterpret_cast<const char*>(input_buff.data()), len,
@@ -1192,10 +1159,10 @@ s32 SOC_U::SendToImpl(SocketHolder& holder, u32 len, u32 flags, u32 addr_len,
         CTRSockAddr ctr_dest_addr;
         std::memcpy(&ctr_dest_addr, dest_addr_buff,
                     std::min<size_t>(addr_len, sizeof(ctr_dest_addr)));
-        auto [dest_addr, dest_addr_len] = CTRSockAddr::ToPlatform(ctr_dest_addr);
-        ret = static_cast<s32>(
-            ::sendto(holder.socket_fd, reinterpret_cast<const char*>(input_buff.data()), len, flags,
-                     reinterpret_cast<sockaddr*>(&dest_addr), dest_addr_len));
+        sockaddr dest_addr = CTRSockAddr::ToPlatform(ctr_dest_addr);
+        ret = static_cast<s32>(::sendto(holder.socket_fd,
+                                        reinterpret_cast<const char*>(input_buff.data()), len,
+                                        flags, &dest_addr, sizeof(dest_addr)));
     } else {
         ret = static_cast<s32>(::sendto(holder.socket_fd,
                                         reinterpret_cast<const char*>(input_buff.data()), len,
@@ -1327,7 +1294,7 @@ void SOC_U::RecvFromOther(Kernel::HLERequestContext& ctx) {
 
     ctx.RunAsync(
         [async_data](Kernel::HLERequestContext& ctx) {
-            sockaddr_storage src_addr;
+            sockaddr src_addr;
             socklen_t src_addr_len = sizeof(src_addr);
             CTRSockAddr ctr_src_addr;
             // Windows, why do you have to be so special...
@@ -1335,10 +1302,10 @@ void SOC_U::RecvFromOther(Kernel::HLERequestContext& ctx) {
                 RecvBusyWaitForEvent(*async_data->fd_info);
             }
             if (async_data->addr_len > 0) {
-                async_data->ret = static_cast<s32>(::recvfrom(
-                    async_data->fd_info->socket_fd,
-                    reinterpret_cast<char*>(async_data->output_buff.data()), async_data->len,
-                    async_data->flags, reinterpret_cast<sockaddr*>(&src_addr), &src_addr_len));
+                async_data->ret = static_cast<s32>(
+                    ::recvfrom(async_data->fd_info->socket_fd,
+                               reinterpret_cast<char*>(async_data->output_buff.data()),
+                               async_data->len, async_data->flags, &src_addr, &src_addr_len));
                 if (async_data->ret >= 0 && src_addr_len > 0) {
                     ctr_src_addr = CTRSockAddr::FromPlatform(src_addr);
                     std::memcpy(async_data->addr_buff.data(), &ctr_src_addr,
@@ -1444,7 +1411,7 @@ void SOC_U::RecvFrom(Kernel::HLERequestContext& ctx) {
 
     ctx.RunAsync(
         [async_data](Kernel::HLERequestContext& ctx) {
-            sockaddr_storage src_addr;
+            sockaddr src_addr;
             socklen_t src_addr_len = sizeof(src_addr);
             CTRSockAddr ctr_src_addr;
             if (async_data->is_blocking) {
@@ -1452,10 +1419,10 @@ void SOC_U::RecvFrom(Kernel::HLERequestContext& ctx) {
             }
             if (async_data->addr_len > 0) {
                 // Only get src adr if input adr available
-                async_data->ret = static_cast<s32>(::recvfrom(
-                    async_data->fd_info->socket_fd,
-                    reinterpret_cast<char*>(async_data->output_buff.data()), async_data->len,
-                    async_data->flags, reinterpret_cast<sockaddr*>(&src_addr), &src_addr_len));
+                async_data->ret = static_cast<s32>(
+                    ::recvfrom(async_data->fd_info->socket_fd,
+                               reinterpret_cast<char*>(async_data->output_buff.data()),
+                               async_data->len, async_data->flags, &src_addr, &src_addr_len));
                 if (async_data->ret >= 0 && src_addr_len > 0) {
                     ctr_src_addr = CTRSockAddr::FromPlatform(src_addr);
                     std::memcpy(async_data->addr_buff.data(), &ctr_src_addr,
@@ -1591,10 +1558,9 @@ void SOC_U::GetSockName(Kernel::HLERequestContext& ctx) {
     }
     SocketHolder& holder = socket_holder_optional->get();
 
-    sockaddr_storage dest_addr;
+    sockaddr dest_addr;
     socklen_t dest_addr_len = sizeof(dest_addr);
-    s32 ret =
-        ::getsockname(holder.socket_fd, reinterpret_cast<sockaddr*>(&dest_addr), &dest_addr_len);
+    s32 ret = ::getsockname(holder.socket_fd, &dest_addr, &dest_addr_len);
 
     CTRSockAddr ctr_dest_addr = CTRSockAddr::FromPlatform(dest_addr);
     std::vector<u8> dest_addr_buff(sizeof(ctr_dest_addr));
@@ -1681,11 +1647,10 @@ void SOC_U::GetHostByAddr(Kernel::HLERequestContext& ctx) {
     [[maybe_unused]] u32 out_buf_len = rp.Pop<u32>();
     auto addr = rp.PopStaticBuffer();
 
-    auto [platform_addr, platform_addr_len] =
-        CTRSockAddr::ToPlatform(*reinterpret_cast<CTRSockAddr*>(addr.data()));
+    sockaddr platform_addr = CTRSockAddr::ToPlatform(*reinterpret_cast<CTRSockAddr*>(addr.data()));
 
     struct hostent* result =
-        ::gethostbyaddr(reinterpret_cast<char*>(&platform_addr), platform_addr_len, type);
+        ::gethostbyaddr(reinterpret_cast<char*>(&platform_addr), sizeof(platform_addr), type);
 
     IPC::RequestBuilder rb = rp.MakeBuilder(2, 2);
     rb.Push(ResultSuccess);
@@ -1733,10 +1698,9 @@ void SOC_U::GetPeerName(Kernel::HLERequestContext& ctx) {
     }
     SocketHolder& holder = socket_holder_optional->get();
 
-    sockaddr_storage dest_addr;
+    sockaddr dest_addr;
     socklen_t dest_addr_len = sizeof(dest_addr);
-    const int ret =
-        ::getpeername(holder.socket_fd, reinterpret_cast<sockaddr*>(&dest_addr), &dest_addr_len);
+    const int ret = ::getpeername(holder.socket_fd, &dest_addr, &dest_addr_len);
 
     CTRSockAddr ctr_dest_addr = CTRSockAddr::FromPlatform(dest_addr);
     std::vector<u8> dest_addr_buff(sizeof(ctr_dest_addr));
@@ -1777,7 +1741,7 @@ void SOC_U::Connect(Kernel::HLERequestContext& ctx) {
     struct AsyncData {
         // Input
         SocketHolder* fd_info;
-        std::pair<sockaddr_storage, socklen_t> input_addr;
+        sockaddr input_addr;
         u32 socket_handle;
         u32 pid;
 
@@ -1799,9 +1763,8 @@ void SOC_U::Connect(Kernel::HLERequestContext& ctx) {
 
     ctx.RunAsync(
         [async_data](Kernel::HLERequestContext& ctx) {
-            async_data->ret = ::connect(async_data->fd_info->socket_fd,
-                                        reinterpret_cast<sockaddr*>(&async_data->input_addr.first),
-                                        async_data->input_addr.second);
+            async_data->ret = ::connect(async_data->fd_info->socket_fd, &async_data->input_addr,
+                                        sizeof(async_data->input_addr));
             async_data->connect_error = (async_data->ret == SOCKET_ERROR_VALUE) ? GET_ERRNO : 0;
             return 0;
         },
@@ -2084,15 +2047,14 @@ void SOC_U::GetNameInfoImpl(Kernel::HLERequestContext& ctx) {
 
     CTRSockAddr ctr_sa;
     std::memcpy(&ctr_sa, sa_buff.data(), socklen);
-    auto [sa, sa_len] = CTRSockAddr::ToPlatform(ctr_sa);
+    sockaddr sa = CTRSockAddr::ToPlatform(ctr_sa);
 
     std::vector<u8> host(hostlen);
     std::vector<u8> serv(servlen);
     char* host_data = hostlen > 0 ? reinterpret_cast<char*>(host.data()) : nullptr;
     char* serv_data = servlen > 0 ? reinterpret_cast<char*>(serv.data()) : nullptr;
 
-    s32 ret = getnameinfo(reinterpret_cast<sockaddr*>(&sa), sa_len, host_data, hostlen, serv_data,
-                          servlen, flags);
+    s32 ret = getnameinfo(&sa, sizeof(sa), host_data, hostlen, serv_data, servlen, flags);
     if (ret == SOCKET_ERROR_VALUE) {
         ret = TranslateError(GET_ERRNO);
     }

src/dedicated_room/citra-room.cpp

@@ -152,7 +152,6 @@ static void SaveBanList(const Network::Room::BanList& ban_list, const std::strin
 static void InitializeLogging(const std::string& log_file) {
     Common::Log::Initialize(log_file);
     Common::Log::SetColorConsoleBackendEnabled(true);
-    Common::Log::Start();
 }
 
 /// Application entry point

src/input_common/sdl/sdl_impl.cpp

@@ -429,20 +429,18 @@ Common::ParamPackage SDLState::GetSDLControllerButtonBindByGUID(
 
 #if SDL_VERSION_ATLEAST(2, 0, 6)
         {
-            if (mapped_button != SDL_CONTROLLER_BUTTON_INVALID) {
-                const SDL_ExtendedGameControllerBind extended_bind =
-                    controller->bindings[mapped_button];
-                if (extended_bind.input.axis.axis_max < extended_bind.input.axis.axis_min) {
-                    params.Set("direction", "-");
-                } else {
-                    params.Set("direction", "+");
-                }
-                params.Set("threshold", (extended_bind.input.axis.axis_min +
-                                         (extended_bind.input.axis.axis_max -
-                                          extended_bind.input.axis.axis_min) /
-                                             2.0f) /
-                                            SDL_JOYSTICK_AXIS_MAX);
+            const SDL_ExtendedGameControllerBind extended_bind =
+                controller->bindings[mapped_button];
+            if (extended_bind.input.axis.axis_max < extended_bind.input.axis.axis_min) {
+                params.Set("direction", "-");
+            } else {
+                params.Set("direction", "+");
             }
+            params.Set(
+                "threshold",
+                (extended_bind.input.axis.axis_min +
+                 (extended_bind.input.axis.axis_max - extended_bind.input.axis.axis_min) / 2.0f) /
+                    SDL_JOYSTICK_AXIS_MAX);
         }
 #else
         params.Set("direction", "+"); // lacks extended_bind, so just a guess

src/tests/CMakeLists.txt

@@ -9,7 +9,6 @@ add_executable(tests
     core/memory/vm_manager.cpp
     precompiled_headers.h
     audio_core/hle/hle.cpp
-    audio_core/hle/source.cpp
     audio_core/lle/lle.cpp
     audio_core/audio_fixures.h
     audio_core/decoder_tests.cpp

src/tests/audio_core/hle/source.cpp

@@ -1,379 +0,0 @@
-#include <cstdio>
-#include <catch2/catch_template_test_macros.hpp>
-#include "audio_core/hle/shared_memory.h"
-#include "common/settings.h"
-#include "tests/audio_core/merryhime_3ds_audio/merry_audio/merry_audio.h"
-
-TEST_CASE_METHOD(MerryAudio::MerryAudioFixture, "Verify SourceStatus::Status::last_buffer_id 1",
-                 "[audio_core][hle]") {
-    //  World's worst triangle wave generator.
-    //  Generates PCM16.
-    auto fillBuffer = [this](u32* audio_buffer, size_t size, unsigned freq) {
-        for (size_t i = 0; i < size; i++) {
-            u32 data = (i % freq) * 256;
-            audio_buffer[i] = (data << 16) | (data & 0xFFFF);
-        }
-
-        DSP_FlushDataCache(audio_buffer, size);
-    };
-
-    constexpr size_t NUM_SAMPLES = 160 * 1;
-    u32* audio_buffer = (u32*)linearAlloc(NUM_SAMPLES * sizeof(u32));
-    fillBuffer(audio_buffer, NUM_SAMPLES, 160);
-    u32* audio_buffer2 = (u32*)linearAlloc(NUM_SAMPLES * sizeof(u32));
-    fillBuffer(audio_buffer2, NUM_SAMPLES, 80);
-    u32* audio_buffer3 = (u32*)linearAlloc(NUM_SAMPLES * sizeof(u32));
-    fillBuffer(audio_buffer3, NUM_SAMPLES, 40);
-
-    MerryAudio::AudioState state;
-    {
-        std::vector<u8> dspfirm;
-        SECTION("HLE") {
-            // The test case assumes HLE AudioCore doesn't require a valid firmware
-            InitDspCore(Settings::AudioEmulation::HLE);
-            dspfirm = {0};
-        }
-        SECTION("LLE Sanity") {
-            InitDspCore(Settings::AudioEmulation::LLE);
-            dspfirm = loadDspFirmFromFile();
-        }
-        if (!dspfirm.size()) {
-            SKIP("Couldn't load firmware\n");
-            return;
-        }
-        auto ret = audioInit(dspfirm);
-        if (!ret) {
-            INFO("Couldn't init audio\n");
-            goto end;
-        }
-        state = *ret;
-    }
-
-    state.waitForSync();
-    initSharedMem(state);
-    state.notifyDsp();
-
-    state.waitForSync();
-    state.notifyDsp();
-    state.waitForSync();
-    state.notifyDsp();
-    state.waitForSync();
-    state.notifyDsp();
-    state.waitForSync();
-    state.notifyDsp();
-
-    {
-        u16 buffer_id = 0;
-        size_t next_queue_position = 0;
-
-        state.write().source_configurations->config[0].play_position = 0;
-        state.write().source_configurations->config[0].physical_address =
-            osConvertVirtToPhys(audio_buffer3);
-        state.write().source_configurations->config[0].length = NUM_SAMPLES;
-        state.write().source_configurations->config[0].mono_or_stereo.Assign(
-            AudioCore::HLE::SourceConfiguration::Configuration::MonoOrStereo::Stereo);
-        state.write().source_configurations->config[0].format.Assign(
-            AudioCore::HLE::SourceConfiguration::Configuration::Format::PCM16);
-        state.write().source_configurations->config[0].fade_in.Assign(false);
-        state.write().source_configurations->config[0].adpcm_dirty.Assign(false);
-        state.write().source_configurations->config[0].is_looping.Assign(false);
-        state.write().source_configurations->config[0].buffer_id = ++buffer_id;
-        state.write().source_configurations->config[0].partial_reset_flag.Assign(true);
-        state.write().source_configurations->config[0].play_position_dirty.Assign(true);
-        state.write().source_configurations->config[0].embedded_buffer_dirty.Assign(true);
-
-        state.write()
-            .source_configurations->config[0]
-            .buffers[next_queue_position]
-            .physical_address = osConvertVirtToPhys(buffer_id % 2 ? audio_buffer2 : audio_buffer);
-        state.write().source_configurations->config[0].buffers[next_queue_position].length =
-            NUM_SAMPLES;
-        state.write().source_configurations->config[0].buffers[next_queue_position].adpcm_dirty =
-            false;
-        state.write().source_configurations->config[0].buffers[next_queue_position].is_looping =
-            false;
-        state.write().source_configurations->config[0].buffers[next_queue_position].buffer_id =
-            ++buffer_id;
-        state.write().source_configurations->config[0].buffers_dirty |= 1 << next_queue_position;
-        next_queue_position = (next_queue_position + 1) % 4;
-        state.write().source_configurations->config[0].buffer_queue_dirty.Assign(true);
-        state.write().source_configurations->config[0].enable = true;
-        state.write().source_configurations->config[0].enable_dirty.Assign(true);
-
-        state.notifyDsp();
-
-        for (size_t frame_count = 0; frame_count < 10; frame_count++) {
-            state.waitForSync();
-            if (!state.read().source_statuses->status[0].is_enabled) {
-                state.write().source_configurations->config[0].enable = true;
-                state.write().source_configurations->config[0].enable_dirty.Assign(true);
-            }
-
-            if (state.read().source_statuses->status[0].current_buffer_id_dirty) {
-                if (state.read().source_statuses->status[0].current_buffer_id == buffer_id ||
-                    state.read().source_statuses->status[0].current_buffer_id == 0) {
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .physical_address =
-                        osConvertVirtToPhys(buffer_id % 2 ? audio_buffer2 : audio_buffer);
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .length = NUM_SAMPLES;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .adpcm_dirty = false;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .is_looping = false;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .buffer_id = ++buffer_id;
-                    state.write().source_configurations->config[0].buffers_dirty |=
-                        1 << next_queue_position;
-                    next_queue_position = (next_queue_position + 1) % 4;
-                    state.write().source_configurations->config[0].buffer_queue_dirty.Assign(true);
-                }
-            }
-
-            state.notifyDsp();
-        }
-
-        // current_buffer_id should be 0 if the queue is not empty
-        REQUIRE(state.read().source_statuses->status[0].last_buffer_id == 0);
-
-        // Let the queue finish playing
-        for (size_t frame_count = 0; frame_count < 10; frame_count++) {
-            state.waitForSync();
-            state.notifyDsp();
-        }
-
-        // TODO: There seems to be some nuances with how the LLE firmware runs the buffer queue,
-        // that differs from the HLE implementation
-        // REQUIRE(state.read().source_statuses->status[0].last_buffer_id == 5);
-
-        // current_buffer_id should be equal to buffer_id once the queue is empty
-        REQUIRE(state.read().source_statuses->status[0].last_buffer_id == buffer_id);
-    }
-
-end:
-    audioExit(state);
-}
-
-TEST_CASE_METHOD(MerryAudio::MerryAudioFixture, "Verify SourceStatus::Status::last_buffer_id 2",
-                 "[audio_core][hle]") {
-    //  World's worst triangle wave generator.
-    //  Generates PCM16.
-    auto fillBuffer = [this](u32* audio_buffer, size_t size, unsigned freq) {
-        for (size_t i = 0; i < size; i++) {
-            u32 data = (i % freq) * 256;
-            audio_buffer[i] = (data << 16) | (data & 0xFFFF);
-        }
-
-        DSP_FlushDataCache(audio_buffer, size);
-    };
-
-    constexpr size_t NUM_SAMPLES = 160 * 1;
-    u32* audio_buffer = (u32*)linearAlloc(NUM_SAMPLES * sizeof(u32));
-    fillBuffer(audio_buffer, NUM_SAMPLES, 160);
-    u32* audio_buffer2 = (u32*)linearAlloc(NUM_SAMPLES * sizeof(u32));
-    fillBuffer(audio_buffer2, NUM_SAMPLES, 80);
-    u32* audio_buffer3 = (u32*)linearAlloc(NUM_SAMPLES * sizeof(u32));
-    fillBuffer(audio_buffer3, NUM_SAMPLES, 40);
-
-    MerryAudio::AudioState state;
-    {
-        std::vector<u8> dspfirm;
-        SECTION("HLE") {
-            // The test case assumes HLE AudioCore doesn't require a valid firmware
-            InitDspCore(Settings::AudioEmulation::HLE);
-            dspfirm = {0};
-        }
-        SECTION("LLE Sanity") {
-            InitDspCore(Settings::AudioEmulation::LLE);
-            dspfirm = loadDspFirmFromFile();
-        }
-        if (!dspfirm.size()) {
-            SKIP("Couldn't load firmware\n");
-            return;
-        }
-        auto ret = audioInit(dspfirm);
-        if (!ret) {
-            INFO("Couldn't init audio\n");
-            goto end;
-        }
-        state = *ret;
-    }
-
-    state.waitForSync();
-    initSharedMem(state);
-    state.notifyDsp();
-
-    state.waitForSync();
-    state.notifyDsp();
-    state.waitForSync();
-    state.notifyDsp();
-    state.waitForSync();
-    state.notifyDsp();
-    state.waitForSync();
-    state.notifyDsp();
-
-    {
-        u16 buffer_id = 0;
-        size_t next_queue_position = 0;
-
-        state.write().source_configurations->config[0].play_position = 0;
-        state.write().source_configurations->config[0].physical_address =
-            osConvertVirtToPhys(audio_buffer3);
-        state.write().source_configurations->config[0].length = NUM_SAMPLES;
-        state.write().source_configurations->config[0].mono_or_stereo.Assign(
-            AudioCore::HLE::SourceConfiguration::Configuration::MonoOrStereo::Stereo);
-        state.write().source_configurations->config[0].format.Assign(
-            AudioCore::HLE::SourceConfiguration::Configuration::Format::PCM16);
-        state.write().source_configurations->config[0].fade_in.Assign(false);
-        state.write().source_configurations->config[0].adpcm_dirty.Assign(false);
-        state.write().source_configurations->config[0].is_looping.Assign(false);
-        state.write().source_configurations->config[0].buffer_id = ++buffer_id;
-        state.write().source_configurations->config[0].partial_reset_flag.Assign(true);
-        state.write().source_configurations->config[0].play_position_dirty.Assign(true);
-        state.write().source_configurations->config[0].embedded_buffer_dirty.Assign(true);
-
-        state.write()
-            .source_configurations->config[0]
-            .buffers[next_queue_position]
-            .physical_address = osConvertVirtToPhys(buffer_id % 2 ? audio_buffer2 : audio_buffer);
-        state.write().source_configurations->config[0].buffers[next_queue_position].length =
-            NUM_SAMPLES;
-        state.write().source_configurations->config[0].buffers[next_queue_position].adpcm_dirty =
-            false;
-        state.write().source_configurations->config[0].buffers[next_queue_position].is_looping =
-            false;
-        state.write().source_configurations->config[0].buffers[next_queue_position].buffer_id =
-            ++buffer_id;
-        state.write().source_configurations->config[0].buffers_dirty |= 1 << next_queue_position;
-        next_queue_position = (next_queue_position + 1) % 4;
-        state.write().source_configurations->config[0].buffer_queue_dirty.Assign(true);
-        state.write().source_configurations->config[0].enable = true;
-        state.write().source_configurations->config[0].enable_dirty.Assign(true);
-
-        state.notifyDsp();
-
-        for (size_t frame_count = 0; frame_count < 10; frame_count++) {
-            state.waitForSync();
-            if (!state.read().source_statuses->status[0].is_enabled) {
-                state.write().source_configurations->config[0].enable = true;
-                state.write().source_configurations->config[0].enable_dirty.Assign(true);
-            }
-
-            if (state.read().source_statuses->status[0].current_buffer_id_dirty) {
-                if (state.read().source_statuses->status[0].current_buffer_id == buffer_id ||
-                    state.read().source_statuses->status[0].current_buffer_id == 0) {
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .physical_address =
-                        osConvertVirtToPhys(buffer_id % 2 ? audio_buffer2 : audio_buffer);
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .length = NUM_SAMPLES;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .adpcm_dirty = false;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .is_looping = false;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .buffer_id = ++buffer_id;
-                    state.write().source_configurations->config[0].buffers_dirty |=
-                        1 << next_queue_position;
-                    next_queue_position = (next_queue_position + 1) % 4;
-                    state.write().source_configurations->config[0].buffer_queue_dirty.Assign(true);
-                }
-            }
-
-            state.notifyDsp();
-        }
-
-        // current_buffer_id should be 0 if the queue is not empty
-        REQUIRE(state.read().source_statuses->status[0].last_buffer_id == 0);
-
-        // Let the queue finish playing
-        for (size_t frame_count = 0; frame_count < 10; frame_count++) {
-            state.waitForSync();
-            state.notifyDsp();
-        }
-
-        // TODO: There seems to be some nuances with how the LLE firmware runs the buffer queue,
-        // that differs from the HLE implementation
-        // REQUIRE(state.read().source_statuses->status[0].last_buffer_id == 5);
-
-        // current_buffer_id should be equal to buffer_id once the queue is empty
-        REQUIRE(state.read().source_statuses->status[0].last_buffer_id == buffer_id);
-
-        // Restart Playing
-        for (size_t frame_count = 0; frame_count < 10; frame_count++) {
-            state.waitForSync();
-            if (!state.read().source_statuses->status[0].is_enabled) {
-                state.write().source_configurations->config[0].enable = true;
-                state.write().source_configurations->config[0].enable_dirty.Assign(true);
-            }
-
-            if (state.read().source_statuses->status[0].current_buffer_id_dirty) {
-                if (state.read().source_statuses->status[0].current_buffer_id == buffer_id ||
-                    state.read().source_statuses->status[0].current_buffer_id == 0) {
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .physical_address =
-                        osConvertVirtToPhys(buffer_id % 2 ? audio_buffer2 : audio_buffer);
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .length = NUM_SAMPLES;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .adpcm_dirty = false;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .is_looping = false;
-                    state.write()
-                        .source_configurations->config[0]
-                        .buffers[next_queue_position]
-                        .buffer_id = ++buffer_id;
-                    state.write().source_configurations->config[0].buffers_dirty |=
-                        1 << next_queue_position;
-                    next_queue_position = (next_queue_position + 1) % 4;
-                    state.write().source_configurations->config[0].buffer_queue_dirty.Assign(true);
-                }
-            }
-
-            state.notifyDsp();
-        }
-
-        // current_buffer_id should be 0 if the queue is not empty
-        REQUIRE(state.read().source_statuses->status[0].last_buffer_id == 0);
-
-        // Let the queue finish playing
-        for (size_t frame_count = 0; frame_count < 10; frame_count++) {
-            state.waitForSync();
-            state.notifyDsp();
-        }
-
-        // current_buffer_id should be equal to buffer_id once the queue is empty
-        REQUIRE(state.read().source_statuses->status[0].last_buffer_id == buffer_id);
-    }
-
-end:
-    audioExit(state);
-}

src/video_core/host_shaders/CMakeLists.txt

@@ -26,6 +26,17 @@ set(SHADER_FILES
     vulkan_blit_depth_stencil.frag
 )
 
+find_program(GLSLANG "glslang")
+if ("${GLSLANG}" STREQUAL "GLSLANG-NOTFOUND")
+    find_program(GLSLANG "glslangValidator")
+    if ("${GLSLANG}" STREQUAL "GLSLANG-NOTFOUND")
+        message(FATAL_ERROR "Required program `glslang` (or `glslangValidator`) not found.")
+    endif()
+endif()
+
+set(MACROS "-Dgl_VertexID=gl_VertexIndex")
+set(QUIET_FLAG "--quiet")
+
 set(SHADER_INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/include)
 set(SHADER_DIR ${SHADER_INCLUDE}/video_core/host_shaders)
 set(HOST_SHADERS_INCLUDE ${SHADER_INCLUDE} PARENT_SCOPE)
@@ -33,22 +44,57 @@ set(HOST_SHADERS_INCLUDE ${SHADER_INCLUDE} PARENT_SCOPE)
 set(INPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/source_shader.h.in)
 set(HEADER_GENERATOR ${CMAKE_CURRENT_SOURCE_DIR}/StringShaderHeader.cmake)
 
+# Check if `--quiet` is available on host's glslang version
+# glslang prints to STDERR iff an unrecognized flag is passed to it
+execute_process(
+    COMMAND
+        ${GLSLANG} ${QUIET_FLAG}
+    ERROR_VARIABLE
+        GLSLANG_ERROR
+    # STDOUT variable defined to silence unnecessary output during CMake configuration
+    OUTPUT_VARIABLE
+        GLSLANG_OUTPUT
+)
+
+if (NOT GLSLANG_ERROR STREQUAL "")
+    message(WARNING "Refusing to use unavailable flag `${QUIET_FLAG}` on `${GLSLANG}`")
+    set(QUIET_FLAG "")
+endif()
+
 foreach(FILENAME IN ITEMS ${SHADER_FILES})
     string(REPLACE "." "_" SHADER_NAME ${FILENAME})
     set(SOURCE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME})
-    set(SOURCE_HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}.h)
-    add_custom_command(
-        OUTPUT
-            ${SOURCE_HEADER_FILE}
-        COMMAND
-            ${CMAKE_COMMAND} -P ${HEADER_GENERATOR} ${SOURCE_FILE} ${SOURCE_HEADER_FILE} ${INPUT_FILE}
-        MAIN_DEPENDENCY
-            ${SOURCE_FILE}
-        DEPENDS
-            ${INPUT_FILE}
-            # HEADER_GENERATOR should be included here but msbuild seems to assume it's always modified
-    )
-    set(SHADER_HEADERS ${SHADER_HEADERS} ${SOURCE_HEADER_FILE})
+    # Skip generating source headers on Vulkan exclusive files
+    if (NOT ${FILENAME} MATCHES "vulkan.*")
+        set(SOURCE_HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}.h)
+        add_custom_command(
+            OUTPUT
+                ${SOURCE_HEADER_FILE}
+            COMMAND
+                ${CMAKE_COMMAND} -P ${HEADER_GENERATOR} ${SOURCE_FILE} ${SOURCE_HEADER_FILE} ${INPUT_FILE}
+            MAIN_DEPENDENCY
+                ${SOURCE_FILE}
+            DEPENDS
+                ${INPUT_FILE}
+                # HEADER_GENERATOR should be included here but msbuild seems to assume it's always modified
+        )
+        set(SHADER_HEADERS ${SHADER_HEADERS} ${SOURCE_HEADER_FILE})
+    endif()
+    # Skip compiling to SPIR-V OpenGL exclusive files
+    if (NOT ${FILENAME} MATCHES "opengl.*")
+        get_filename_component(FILE_NAME ${SHADER_NAME} NAME)
+        string(TOUPPER ${FILE_NAME}_SPV SPIRV_VARIABLE_NAME)
+        set(SPIRV_HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}_spv.h)
+        add_custom_command(
+            OUTPUT
+                ${SPIRV_HEADER_FILE}
+            COMMAND
+                ${GLSLANG} --target-env vulkan1.1 --glsl-version 450 ${QUIET_FLAG} ${MACROS} --variable-name ${SPIRV_VARIABLE_NAME} -o ${SPIRV_HEADER_FILE} ${SOURCE_FILE}
+            MAIN_DEPENDENCY
+                ${SOURCE_FILE}
+        )
+        set(SHADER_HEADERS ${SHADER_HEADERS} ${SPIRV_HEADER_FILE})
+    endif()
 endforeach()
 
 set(SHADER_SOURCES ${SHADER_FILES})

src/video_core/host_shaders/format_reinterpreter/fullscreen_quad.vert

@@ -8,10 +8,6 @@ layout(location = 0) out vec2 dst_coord;
 
 layout(location = 0) uniform mediump ivec2 dst_size;
 
-#ifdef VULKAN
-#define gl_VertexID gl_VertexIndex
-#endif
-
 const vec2 vertices[4] =
 vec2[4](vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0), vec2(1.0, 1.0));
 

src/video_core/host_shaders/full_screen_triangle.vert

@@ -10,7 +10,6 @@ out gl_PerVertex {
 layout(location = 0) out vec2 texcoord;
 
 #ifdef VULKAN
-#define gl_VertexID gl_VertexIndex
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)