Android #79

android: Adjust valid user data check

CMakeLists.txt

@@ -49,6 +49,8 @@ option(YUZU_TESTS "Compile tests" "${BUILD_TESTING}")
 
 option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
 
+option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)
+
 CMAKE_DEPENDENT_OPTION(YUZU_ROOM "Compile LDN room server" ON "NOT ANDROID" OFF)
 
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)
@@ -61,6 +63,8 @@ option(YUZU_ENABLE_LTO "Enable link-time optimization" OFF)
 
 option(YUZU_DOWNLOAD_TIME_ZONE_DATA "Always download time zone binaries" OFF)
 
+option(YUZU_ENABLE_PORTABLE "Allow yuzu to enable portable mode if a user folder is found in the CWD" ON)
+
 CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
 
 CMAKE_DEPENDENT_OPTION(USE_SYSTEM_MOLTENVK "Use the system MoltenVK lib (instead of the bundled one)" OFF "APPLE" OFF)
@@ -77,6 +81,24 @@ if (ANDROID OR WIN32 OR APPLE)
 endif()
 option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
 
+if (ANDROID AND YUZU_DOWNLOAD_ANDROID_VVL)
+    set(vvl_version "sdk-1.3.261.1")
+    set(vvl_zip_file "${CMAKE_BINARY_DIR}/externals/vvl-android.zip")
+    if (NOT EXISTS "${vvl_zip_file}")
+        # Download and extract validation layer release to externals directory
+        set(vvl_base_url "https://github.com/KhronosGroup/Vulkan-ValidationLayers/releases/download")
+        file(DOWNLOAD "${vvl_base_url}/${vvl_version}/android-binaries-${vvl_version}-android.zip"
+            "${vvl_zip_file}" SHOW_PROGRESS)
+        execute_process(COMMAND ${CMAKE_COMMAND} -E tar xf "${vvl_zip_file}"
+                        WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/externals")
+    endif()
+
+    # Copy the arm64 binary to src/android/app/main/jniLibs
+    set(vvl_lib_path "${CMAKE_CURRENT_SOURCE_DIR}/src/android/app/src/main/jniLibs/arm64-v8a/")
+    file(COPY "${CMAKE_BINARY_DIR}/externals/android-binaries-${vvl_version}/arm64-v8a/libVkLayer_khronos_validation.so"
+            DESTINATION "${vvl_lib_path}")
+endif()
+
 # On Android, fetch and compile libcxx before doing anything else
 if (ANDROID)
     set(CMAKE_SKIP_INSTALL_RULES ON)
@@ -311,6 +333,7 @@ find_package(LLVM 17 MODULE COMPONENTS Demangle)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
 find_package(Opus 1.3 MODULE)
+find_package(RenderDoc MODULE)
 find_package(VulkanMemoryAllocator CONFIG)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)

CMakeModules/FindRenderDoc.cmake

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2023 Alexandre Bouvier <contact@amb.tf>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+find_path(RenderDoc_INCLUDE_DIR renderdoc_app.h)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(RenderDoc
+    REQUIRED_VARS RenderDoc_INCLUDE_DIR
+)
+
+if (RenderDoc_FOUND AND NOT TARGET RenderDoc::API)
+    add_library(RenderDoc::API INTERFACE IMPORTED)
+    set_target_properties(RenderDoc::API PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${RenderDoc_INCLUDE_DIR}"
+    )
+endif()
+
+mark_as_advanced(RenderDoc_INCLUDE_DIR)

README.md

@@ -1,3 +1,11 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

externals/CMakeLists.txt

@@ -174,6 +174,12 @@ target_include_directories(stb PUBLIC ./stb)
 add_library(bc_decoder bc_decoder/bc_decoder.cpp)
 target_include_directories(bc_decoder PUBLIC ./bc_decoder)
 
+if (NOT TARGET RenderDoc::API)
+    add_library(renderdoc INTERFACE)
+    target_include_directories(renderdoc SYSTEM INTERFACE ./renderdoc)
+    add_library(RenderDoc::API ALIAS renderdoc)
+endif()
+
 if (ANDROID)
    if (ARCHITECTURE_arm64)
        add_subdirectory(libadrenotools)

externals/renderdoc/renderdoc_app.h

@@ -0,0 +1,744 @@
+// SPDX-FileCopyrightText: Baldur Karlsson
+// SPDX-License-Identifier: MIT
+
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019-2023 Baldur Karlsson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ******************************************************************************/
+
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Documentation for the API is available at https://renderdoc.org/docs/in_application_api.html
+//
+
+#if !defined(RENDERDOC_NO_STDINT)
+#include <stdint.h>
+#endif
+
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define RENDERDOC_CC __cdecl
+#elif defined(__linux__)
+#define RENDERDOC_CC
+#elif defined(__APPLE__)
+#define RENDERDOC_CC
+#else
+#error "Unknown platform"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// Constants not used directly in below API
+
+// This is a GUID/magic value used for when applications pass a path where shader debug
+// information can be found to match up with a stripped shader.
+// the define can be used like so: const GUID RENDERDOC_ShaderDebugMagicValue =
+// RENDERDOC_ShaderDebugMagicValue_value
+#define RENDERDOC_ShaderDebugMagicValue_struct                                \
+  {                                                                           \
+    0xeab25520, 0x6670, 0x4865, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
+  }
+
+// as an alternative when you want a byte array (assuming x86 endianness):
+#define RENDERDOC_ShaderDebugMagicValue_bytearray                                                 \
+  {                                                                                               \
+    0x20, 0x55, 0xb2, 0xea, 0x70, 0x66, 0x65, 0x48, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
+  }
+
+// truncated version when only a uint64_t is available (e.g. Vulkan tags):
+#define RENDERDOC_ShaderDebugMagicValue_truncated 0x48656670eab25520ULL
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc capture options
+//
+
+typedef enum RENDERDOC_CaptureOption
+{
+  // Allow the application to enable vsync
+  //
+  // Default - enabled
+  //
+  // 1 - The application can enable or disable vsync at will
+  // 0 - vsync is force disabled
+  eRENDERDOC_Option_AllowVSync = 0,
+
+  // Allow the application to enable fullscreen
+  //
+  // Default - enabled
+  //
+  // 1 - The application can enable or disable fullscreen at will
+  // 0 - fullscreen is force disabled
+  eRENDERDOC_Option_AllowFullscreen = 1,
+
+  // Record API debugging events and messages
+  //
+  // Default - disabled
+  //
+  // 1 - Enable built-in API debugging features and records the results into
+  //     the capture, which is matched up with events on replay
+  // 0 - no API debugging is forcibly enabled
+  eRENDERDOC_Option_APIValidation = 2,
+  eRENDERDOC_Option_DebugDeviceMode = 2,    // deprecated name of this enum
+
+  // Capture CPU callstacks for API events
+  //
+  // Default - disabled
+  //
+  // 1 - Enables capturing of callstacks
+  // 0 - no callstacks are captured
+  eRENDERDOC_Option_CaptureCallstacks = 3,
+
+  // When capturing CPU callstacks, only capture them from actions.
+  // This option does nothing without the above option being enabled
+  //
+  // Default - disabled
+  //
+  // 1 - Only captures callstacks for actions.
+  //     Ignored if CaptureCallstacks is disabled
+  // 0 - Callstacks, if enabled, are captured for every event.
+  eRENDERDOC_Option_CaptureCallstacksOnlyDraws = 4,
+  eRENDERDOC_Option_CaptureCallstacksOnlyActions = 4,
+
+  // Specify a delay in seconds to wait for a debugger to attach, after
+  // creating or injecting into a process, before continuing to allow it to run.
+  //
+  // 0 indicates no delay, and the process will run immediately after injection
+  //
+  // Default - 0 seconds
+  //
+  eRENDERDOC_Option_DelayForDebugger = 5,
+
+  // Verify buffer access. This includes checking the memory returned by a Map() call to
+  // detect any out-of-bounds modification, as well as initialising buffers with undefined contents
+  // to a marker value to catch use of uninitialised memory.
+  //
+  // NOTE: This option is only valid for OpenGL and D3D11. Explicit APIs such as D3D12 and Vulkan do
+  // not do the same kind of interception & checking and undefined contents are really undefined.
+  //
+  // Default - disabled
+  //
+  // 1 - Verify buffer access
+  // 0 - No verification is performed, and overwriting bounds may cause crashes or corruption in
+  //     RenderDoc.
+  eRENDERDOC_Option_VerifyBufferAccess = 6,
+
+  // The old name for eRENDERDOC_Option_VerifyBufferAccess was eRENDERDOC_Option_VerifyMapWrites.
+  // This option now controls the filling of uninitialised buffers with 0xdddddddd which was
+  // previously always enabled
+  eRENDERDOC_Option_VerifyMapWrites = eRENDERDOC_Option_VerifyBufferAccess,
+
+  // Hooks any system API calls that create child processes, and injects
+  // RenderDoc into them recursively with the same options.
+  //
+  // Default - disabled
+  //
+  // 1 - Hooks into spawned child processes
+  // 0 - Child processes are not hooked by RenderDoc
+  eRENDERDOC_Option_HookIntoChildren = 7,
+
+  // By default RenderDoc only includes resources in the final capture necessary
+  // for that frame, this allows you to override that behaviour.
+  //
+  // Default - disabled
+  //
+  // 1 - all live resources at the time of capture are included in the capture
+  //     and available for inspection
+  // 0 - only the resources referenced by the captured frame are included
+  eRENDERDOC_Option_RefAllResources = 8,
+
+  // **NOTE**: As of RenderDoc v1.1 this option has been deprecated. Setting or
+  // getting it will be ignored, to allow compatibility with older versions.
+  // In v1.1 the option acts as if it's always enabled.
+  //
+  // By default RenderDoc skips saving initial states for resources where the
+  // previous contents don't appear to be used, assuming that writes before
+  // reads indicate previous contents aren't used.
+  //
+  // Default - disabled
+  //
+  // 1 - initial contents at the start of each captured frame are saved, even if
+  //     they are later overwritten or cleared before being used.
+  // 0 - unless a read is detected, initial contents will not be saved and will
+  //     appear as black or empty data.
+  eRENDERDOC_Option_SaveAllInitials = 9,
+
+  // In APIs that allow for the recording of command lists to be replayed later,
+  // RenderDoc may choose to not capture command lists before a frame capture is
+  // triggered, to reduce overheads. This means any command lists recorded once
+  // and replayed many times will not be available and may cause a failure to
+  // capture.
+  //
+  // NOTE: This is only true for APIs where multithreading is difficult or
+  // discouraged. Newer APIs like Vulkan and D3D12 will ignore this option
+  // and always capture all command lists since the API is heavily oriented
+  // around it and the overheads have been reduced by API design.
+  //
+  // 1 - All command lists are captured from the start of the application
+  // 0 - Command lists are only captured if their recording begins during
+  //     the period when a frame capture is in progress.
+  eRENDERDOC_Option_CaptureAllCmdLists = 10,
+
+  // Mute API debugging output when the API validation mode option is enabled
+  //
+  // Default - enabled
+  //
+  // 1 - Mute any API debug messages from being displayed or passed through
+  // 0 - API debugging is displayed as normal
+  eRENDERDOC_Option_DebugOutputMute = 11,
+
+  // Option to allow vendor extensions to be used even when they may be
+  // incompatible with RenderDoc and cause corrupted replays or crashes.
+  //
+  // Default - inactive
+  //
+  // No values are documented, this option should only be used when absolutely
+  // necessary as directed by a RenderDoc developer.
+  eRENDERDOC_Option_AllowUnsupportedVendorExtensions = 12,
+
+  // Define a soft memory limit which some APIs may aim to keep overhead under where
+  // possible. Anything above this limit will where possible be saved directly to disk during
+  // capture.
+  // This will cause increased disk space use (which may cause a capture to fail if disk space is
+  // exhausted) as well as slower capture times.
+  //
+  // Not all memory allocations may be deferred like this so it is not a guarantee of a memory
+  // limit.
+  //
+  // Units are in MBs, suggested values would range from 200MB to 1000MB.
+  //
+  // Default - 0 Megabytes
+  eRENDERDOC_Option_SoftMemoryLimit = 13,
+} RENDERDOC_CaptureOption;
+
+// Sets an option that controls how RenderDoc behaves on capture.
+//
+// Returns 1 if the option and value are valid
+// Returns 0 if either is invalid and the option is unchanged
+typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionU32)(RENDERDOC_CaptureOption opt, uint32_t val);
+typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionF32)(RENDERDOC_CaptureOption opt, float val);
+
+// Gets the current value of an option as a uint32_t
+//
+// If the option is invalid, 0xffffffff is returned
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionU32)(RENDERDOC_CaptureOption opt);
+
+// Gets the current value of an option as a float
+//
+// If the option is invalid, -FLT_MAX is returned
+typedef float(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionF32)(RENDERDOC_CaptureOption opt);
+
+typedef enum RENDERDOC_InputButton
+{
+  // '0' - '9' matches ASCII values
+  eRENDERDOC_Key_0 = 0x30,
+  eRENDERDOC_Key_1 = 0x31,
+  eRENDERDOC_Key_2 = 0x32,
+  eRENDERDOC_Key_3 = 0x33,
+  eRENDERDOC_Key_4 = 0x34,
+  eRENDERDOC_Key_5 = 0x35,
+  eRENDERDOC_Key_6 = 0x36,
+  eRENDERDOC_Key_7 = 0x37,
+  eRENDERDOC_Key_8 = 0x38,
+  eRENDERDOC_Key_9 = 0x39,
+
+  // 'A' - 'Z' matches ASCII values
+  eRENDERDOC_Key_A = 0x41,
+  eRENDERDOC_Key_B = 0x42,
+  eRENDERDOC_Key_C = 0x43,
+  eRENDERDOC_Key_D = 0x44,
+  eRENDERDOC_Key_E = 0x45,
+  eRENDERDOC_Key_F = 0x46,
+  eRENDERDOC_Key_G = 0x47,
+  eRENDERDOC_Key_H = 0x48,
+  eRENDERDOC_Key_I = 0x49,
+  eRENDERDOC_Key_J = 0x4A,
+  eRENDERDOC_Key_K = 0x4B,
+  eRENDERDOC_Key_L = 0x4C,
+  eRENDERDOC_Key_M = 0x4D,
+  eRENDERDOC_Key_N = 0x4E,
+  eRENDERDOC_Key_O = 0x4F,
+  eRENDERDOC_Key_P = 0x50,
+  eRENDERDOC_Key_Q = 0x51,
+  eRENDERDOC_Key_R = 0x52,
+  eRENDERDOC_Key_S = 0x53,
+  eRENDERDOC_Key_T = 0x54,
+  eRENDERDOC_Key_U = 0x55,
+  eRENDERDOC_Key_V = 0x56,
+  eRENDERDOC_Key_W = 0x57,
+  eRENDERDOC_Key_X = 0x58,
+  eRENDERDOC_Key_Y = 0x59,
+  eRENDERDOC_Key_Z = 0x5A,
+
+  // leave the rest of the ASCII range free
+  // in case we want to use it later
+  eRENDERDOC_Key_NonPrintable = 0x100,
+
+  eRENDERDOC_Key_Divide,
+  eRENDERDOC_Key_Multiply,
+  eRENDERDOC_Key_Subtract,
+  eRENDERDOC_Key_Plus,
+
+  eRENDERDOC_Key_F1,
+  eRENDERDOC_Key_F2,
+  eRENDERDOC_Key_F3,
+  eRENDERDOC_Key_F4,
+  eRENDERDOC_Key_F5,
+  eRENDERDOC_Key_F6,
+  eRENDERDOC_Key_F7,
+  eRENDERDOC_Key_F8,
+  eRENDERDOC_Key_F9,
+  eRENDERDOC_Key_F10,
+  eRENDERDOC_Key_F11,
+  eRENDERDOC_Key_F12,
+
+  eRENDERDOC_Key_Home,
+  eRENDERDOC_Key_End,
+  eRENDERDOC_Key_Insert,
+  eRENDERDOC_Key_Delete,
+  eRENDERDOC_Key_PageUp,
+  eRENDERDOC_Key_PageDn,
+
+  eRENDERDOC_Key_Backspace,
+  eRENDERDOC_Key_Tab,
+  eRENDERDOC_Key_PrtScrn,
+  eRENDERDOC_Key_Pause,
+
+  eRENDERDOC_Key_Max,
+} RENDERDOC_InputButton;
+
+// Sets which key or keys can be used to toggle focus between multiple windows
+//
+// If keys is NULL or num is 0, toggle keys will be disabled
+typedef void(RENDERDOC_CC *pRENDERDOC_SetFocusToggleKeys)(RENDERDOC_InputButton *keys, int num);
+
+// Sets which key or keys can be used to capture the next frame
+//
+// If keys is NULL or num is 0, captures keys will be disabled
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureKeys)(RENDERDOC_InputButton *keys, int num);
+
+typedef enum RENDERDOC_OverlayBits
+{
+  // This single bit controls whether the overlay is enabled or disabled globally
+  eRENDERDOC_Overlay_Enabled = 0x1,
+
+  // Show the average framerate over several seconds as well as min/max
+  eRENDERDOC_Overlay_FrameRate = 0x2,
+
+  // Show the current frame number
+  eRENDERDOC_Overlay_FrameNumber = 0x4,
+
+  // Show a list of recent captures, and how many captures have been made
+  eRENDERDOC_Overlay_CaptureList = 0x8,
+
+  // Default values for the overlay mask
+  eRENDERDOC_Overlay_Default = (eRENDERDOC_Overlay_Enabled | eRENDERDOC_Overlay_FrameRate |
+                                eRENDERDOC_Overlay_FrameNumber | eRENDERDOC_Overlay_CaptureList),
+
+  // Enable all bits
+  eRENDERDOC_Overlay_All = ~0U,
+
+  // Disable all bits
+  eRENDERDOC_Overlay_None = 0,
+} RENDERDOC_OverlayBits;
+
+// returns the overlay bits that have been set
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetOverlayBits)();
+// sets the overlay bits with an and & or mask
+typedef void(RENDERDOC_CC *pRENDERDOC_MaskOverlayBits)(uint32_t And, uint32_t Or);
+
+// this function will attempt to remove RenderDoc's hooks in the application.
+//
+// Note: that this can only work correctly if done immediately after
+// the module is loaded, before any API work happens. RenderDoc will remove its
+// injected hooks and shut down. Behaviour is undefined if this is called
+// after any API functions have been called, and there is still no guarantee of
+// success.
+typedef void(RENDERDOC_CC *pRENDERDOC_RemoveHooks)();
+
+// DEPRECATED: compatibility for code compiled against pre-1.4.1 headers.
+typedef pRENDERDOC_RemoveHooks pRENDERDOC_Shutdown;
+
+// This function will unload RenderDoc's crash handler.
+//
+// If you use your own crash handler and don't want RenderDoc's handler to
+// intercede, you can call this function to unload it and any unhandled
+// exceptions will pass to the next handler.
+typedef void(RENDERDOC_CC *pRENDERDOC_UnloadCrashHandler)();
+
+// Sets the capture file path template
+//
+// pathtemplate is a UTF-8 string that gives a template for how captures will be named
+// and where they will be saved.
+//
+// Any extension is stripped off the path, and captures are saved in the directory
+// specified, and named with the filename and the frame number appended. If the
+// directory does not exist it will be created, including any parent directories.
+//
+// If pathtemplate is NULL, the template will remain unchanged
+//
+// Example:
+//
+// SetCaptureFilePathTemplate("my_captures/example");
+//
+// Capture #1 -> my_captures/example_frame123.rdc
+// Capture #2 -> my_captures/example_frame456.rdc
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFilePathTemplate)(const char *pathtemplate);
+
+// returns the current capture path template, see SetCaptureFileTemplate above, as a UTF-8 string
+typedef const char *(RENDERDOC_CC *pRENDERDOC_GetCaptureFilePathTemplate)();
+
+// DEPRECATED: compatibility for code compiled against pre-1.1.2 headers.
+typedef pRENDERDOC_SetCaptureFilePathTemplate pRENDERDOC_SetLogFilePathTemplate;
+typedef pRENDERDOC_GetCaptureFilePathTemplate pRENDERDOC_GetLogFilePathTemplate;
+
+// returns the number of captures that have been made
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetNumCaptures)();
+
+// This function returns the details of a capture, by index. New captures are added
+// to the end of the list.
+//
+// filename will be filled with the absolute path to the capture file, as a UTF-8 string
+// pathlength will be written with the length in bytes of the filename string
+// timestamp will be written with the time of the capture, in seconds since the Unix epoch
+//
+// Any of the parameters can be NULL and they'll be skipped.
+//
+// The function will return 1 if the capture index is valid, or 0 if the index is invalid
+// If the index is invalid, the values will be unchanged
+//
+// Note: when captures are deleted in the UI they will remain in this list, so the
+// capture path may not exist anymore.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCapture)(uint32_t idx, char *filename,
+                                                      uint32_t *pathlength, uint64_t *timestamp);
+
+// Sets the comments associated with a capture file. These comments are displayed in the
+// UI program when opening.
+//
+// filePath should be a path to the capture file to add comments to. If set to NULL or ""
+// the most recent capture file created made will be used instead.
+// comments should be a NULL-terminated UTF-8 string to add as comments.
+//
+// Any existing comments will be overwritten.
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFileComments)(const char *filePath,
+                                                              const char *comments);
+
+// returns 1 if the RenderDoc UI is connected to this application, 0 otherwise
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsTargetControlConnected)();
+
+// DEPRECATED: compatibility for code compiled against pre-1.1.1 headers.
+// This was renamed to IsTargetControlConnected in API 1.1.1, the old typedef is kept here for
+// backwards compatibility with old code, it is castable either way since it's ABI compatible
+// as the same function pointer type.
+typedef pRENDERDOC_IsTargetControlConnected pRENDERDOC_IsRemoteAccessConnected;
+
+// This function will launch the Replay UI associated with the RenderDoc library injected
+// into the running application.
+//
+// if connectTargetControl is 1, the Replay UI will be launched with a command line parameter
+// to connect to this application
+// cmdline is the rest of the command line, as a UTF-8 string. E.g. a captures to open
+// if cmdline is NULL, the command line will be empty.
+//
+// returns the PID of the replay UI if successful, 0 if not successful.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_LaunchReplayUI)(uint32_t connectTargetControl,
+                                                          const char *cmdline);
+
+// RenderDoc can return a higher version than requested if it's backwards compatible,
+// this function returns the actual version returned. If a parameter is NULL, it will be
+// ignored and the others will be filled out.
+typedef void(RENDERDOC_CC *pRENDERDOC_GetAPIVersion)(int *major, int *minor, int *patch);
+
+// Requests that the replay UI show itself (if hidden or not the current top window). This can be
+// used in conjunction with IsTargetControlConnected and LaunchReplayUI to intelligently handle
+// showing the UI after making a capture.
+//
+// This will return 1 if the request was successfully passed on, though it's not guaranteed that
+// the UI will be on top in all cases depending on OS rules. It will return 0 if there is no current
+// target control connection to make such a request, or if there was another error
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_ShowReplayUI)();
+
+//////////////////////////////////////////////////////////////////////////
+// Capturing functions
+//
+
+// A device pointer is a pointer to the API's root handle.
+//
+// This would be an ID3D11Device, HGLRC/GLXContext, ID3D12Device, etc
+typedef void *RENDERDOC_DevicePointer;
+
+// A window handle is the OS's native window handle
+//
+// This would be an HWND, GLXDrawable, etc
+typedef void *RENDERDOC_WindowHandle;
+
+// A helper macro for Vulkan, where the device handle cannot be used directly.
+//
+// Passing the VkInstance to this macro will return the RENDERDOC_DevicePointer to use.
+//
+// Specifically, the value needed is the dispatch table pointer, which sits as the first
+// pointer-sized object in the memory pointed to by the VkInstance. Thus we cast to a void** and
+// indirect once.
+#define RENDERDOC_DEVICEPOINTER_FROM_VKINSTANCE(inst) (*((void **)(inst)))
+
+// This sets the RenderDoc in-app overlay in the API/window pair as 'active' and it will
+// respond to keypresses. Neither parameter can be NULL
+typedef void(RENDERDOC_CC *pRENDERDOC_SetActiveWindow)(RENDERDOC_DevicePointer device,
+                                                       RENDERDOC_WindowHandle wndHandle);
+
+// capture the next frame on whichever window and API is currently considered active
+typedef void(RENDERDOC_CC *pRENDERDOC_TriggerCapture)();
+
+// capture the next N frames on whichever window and API is currently considered active
+typedef void(RENDERDOC_CC *pRENDERDOC_TriggerMultiFrameCapture)(uint32_t numFrames);
+
+// When choosing either a device pointer or a window handle to capture, you can pass NULL.
+// Passing NULL specifies a 'wildcard' match against anything. This allows you to specify
+// any API rendering to a specific window, or a specific API instance rendering to any window,
+// or in the simplest case of one window and one API, you can just pass NULL for both.
+//
+// In either case, if there are two or more possible matching (device,window) pairs it
+// is undefined which one will be captured.
+//
+// Note: for headless rendering you can pass NULL for the window handle and either specify
+// a device pointer or leave it NULL as above.
+
+// Immediately starts capturing API calls on the specified device pointer and window handle.
+//
+// If there is no matching thing to capture (e.g. no supported API has been initialised),
+// this will do nothing.
+//
+// The results are undefined (including crashes) if two captures are started overlapping,
+// even on separate devices and/oror windows.
+typedef void(RENDERDOC_CC *pRENDERDOC_StartFrameCapture)(RENDERDOC_DevicePointer device,
+                                                         RENDERDOC_WindowHandle wndHandle);
+
+// Returns whether or not a frame capture is currently ongoing anywhere.
+//
+// This will return 1 if a capture is ongoing, and 0 if there is no capture running
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsFrameCapturing)();
+
+// Ends capturing immediately.
+//
+// This will return 1 if the capture succeeded, and 0 if there was an error capturing.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_EndFrameCapture)(RENDERDOC_DevicePointer device,
+                                                           RENDERDOC_WindowHandle wndHandle);
+
+// Ends capturing immediately and discard any data stored without saving to disk.
+//
+// This will return 1 if the capture was discarded, and 0 if there was an error or no capture
+// was in progress
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_DiscardFrameCapture)(RENDERDOC_DevicePointer device,
+                                                               RENDERDOC_WindowHandle wndHandle);
+
+// Only valid to be called between a call to StartFrameCapture and EndFrameCapture. Gives a custom
+// title to the capture produced which will be displayed in the UI.
+//
+// If multiple captures are ongoing, this title will be applied to the first capture to end after
+// this call. The second capture to end will have no title, unless this function is called again.
+//
+// Calling this function has no effect if no capture is currently running, and if it is called
+// multiple times only the last title will be used.
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureTitle)(const char *title);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc API versions
+//
+
+// RenderDoc uses semantic versioning (http://semver.org/).
+//
+// MAJOR version is incremented when incompatible API changes happen.
+// MINOR version is incremented when functionality is added in a backwards-compatible manner.
+// PATCH version is incremented when backwards-compatible bug fixes happen.
+//
+// Note that this means the API returned can be higher than the one you might have requested.
+// e.g. if you are running against a newer RenderDoc that supports 1.0.1, it will be returned
+// instead of 1.0.0. You can check this with the GetAPIVersion entry point
+typedef enum RENDERDOC_Version
+{
+  eRENDERDOC_API_Version_1_0_0 = 10000,    // RENDERDOC_API_1_0_0 = 1 00 00
+  eRENDERDOC_API_Version_1_0_1 = 10001,    // RENDERDOC_API_1_0_1 = 1 00 01
+  eRENDERDOC_API_Version_1_0_2 = 10002,    // RENDERDOC_API_1_0_2 = 1 00 02
+  eRENDERDOC_API_Version_1_1_0 = 10100,    // RENDERDOC_API_1_1_0 = 1 01 00
+  eRENDERDOC_API_Version_1_1_1 = 10101,    // RENDERDOC_API_1_1_1 = 1 01 01
+  eRENDERDOC_API_Version_1_1_2 = 10102,    // RENDERDOC_API_1_1_2 = 1 01 02
+  eRENDERDOC_API_Version_1_2_0 = 10200,    // RENDERDOC_API_1_2_0 = 1 02 00
+  eRENDERDOC_API_Version_1_3_0 = 10300,    // RENDERDOC_API_1_3_0 = 1 03 00
+  eRENDERDOC_API_Version_1_4_0 = 10400,    // RENDERDOC_API_1_4_0 = 1 04 00
+  eRENDERDOC_API_Version_1_4_1 = 10401,    // RENDERDOC_API_1_4_1 = 1 04 01
+  eRENDERDOC_API_Version_1_4_2 = 10402,    // RENDERDOC_API_1_4_2 = 1 04 02
+  eRENDERDOC_API_Version_1_5_0 = 10500,    // RENDERDOC_API_1_5_0 = 1 05 00
+  eRENDERDOC_API_Version_1_6_0 = 10600,    // RENDERDOC_API_1_6_0 = 1 06 00
+} RENDERDOC_Version;
+
+// API version changelog:
+//
+// 1.0.0 - initial release
+// 1.0.1 - Bugfix: IsFrameCapturing() was returning false for captures that were triggered
+//         by keypress or TriggerCapture, instead of Start/EndFrameCapture.
+// 1.0.2 - Refactor: Renamed eRENDERDOC_Option_DebugDeviceMode to eRENDERDOC_Option_APIValidation
+// 1.1.0 - Add feature: TriggerMultiFrameCapture(). Backwards compatible with 1.0.x since the new
+//         function pointer is added to the end of the struct, the original layout is identical
+// 1.1.1 - Refactor: Renamed remote access to target control (to better disambiguate from remote
+//         replay/remote server concept in replay UI)
+// 1.1.2 - Refactor: Renamed "log file" in function names to just capture, to clarify that these
+//         are captures and not debug logging files. This is the first API version in the v1.0
+//         branch.
+// 1.2.0 - Added feature: SetCaptureFileComments() to add comments to a capture file that will be
+//         displayed in the UI program on load.
+// 1.3.0 - Added feature: New capture option eRENDERDOC_Option_AllowUnsupportedVendorExtensions
+//         which allows users to opt-in to allowing unsupported vendor extensions to function.
+//         Should be used at the user's own risk.
+//         Refactor: Renamed eRENDERDOC_Option_VerifyMapWrites to
+//         eRENDERDOC_Option_VerifyBufferAccess, which now also controls initialisation to
+//         0xdddddddd of uninitialised buffer contents.
+// 1.4.0 - Added feature: DiscardFrameCapture() to discard a frame capture in progress and stop
+//         capturing without saving anything to disk.
+// 1.4.1 - Refactor: Renamed Shutdown to RemoveHooks to better clarify what is happening
+// 1.4.2 - Refactor: Renamed 'draws' to 'actions' in callstack capture option.
+// 1.5.0 - Added feature: ShowReplayUI() to request that the replay UI show itself if connected
+// 1.6.0 - Added feature: SetCaptureTitle() which can be used to set a title for a
+//         capture made with StartFrameCapture() or EndFrameCapture()
+
+typedef struct RENDERDOC_API_1_6_0
+{
+  pRENDERDOC_GetAPIVersion GetAPIVersion;
+
+  pRENDERDOC_SetCaptureOptionU32 SetCaptureOptionU32;
+  pRENDERDOC_SetCaptureOptionF32 SetCaptureOptionF32;
+
+  pRENDERDOC_GetCaptureOptionU32 GetCaptureOptionU32;
+  pRENDERDOC_GetCaptureOptionF32 GetCaptureOptionF32;
+
+  pRENDERDOC_SetFocusToggleKeys SetFocusToggleKeys;
+  pRENDERDOC_SetCaptureKeys SetCaptureKeys;
+
+  pRENDERDOC_GetOverlayBits GetOverlayBits;
+  pRENDERDOC_MaskOverlayBits MaskOverlayBits;
+
+  // Shutdown was renamed to RemoveHooks in 1.4.1.
+  // These unions allow old code to continue compiling without changes
+  union
+  {
+    pRENDERDOC_Shutdown Shutdown;
+    pRENDERDOC_RemoveHooks RemoveHooks;
+  };
+  pRENDERDOC_UnloadCrashHandler UnloadCrashHandler;
+
+  // Get/SetLogFilePathTemplate was renamed to Get/SetCaptureFilePathTemplate in 1.1.2.
+  // These unions allow old code to continue compiling without changes
+  union
+  {
+    // deprecated name
+    pRENDERDOC_SetLogFilePathTemplate SetLogFilePathTemplate;
+    // current name
+    pRENDERDOC_SetCaptureFilePathTemplate SetCaptureFilePathTemplate;
+  };
+  union
+  {
+    // deprecated name
+    pRENDERDOC_GetLogFilePathTemplate GetLogFilePathTemplate;
+    // current name
+    pRENDERDOC_GetCaptureFilePathTemplate GetCaptureFilePathTemplate;
+  };
+
+  pRENDERDOC_GetNumCaptures GetNumCaptures;
+  pRENDERDOC_GetCapture GetCapture;
+
+  pRENDERDOC_TriggerCapture TriggerCapture;
+
+  // IsRemoteAccessConnected was renamed to IsTargetControlConnected in 1.1.1.
+  // This union allows old code to continue compiling without changes
+  union
+  {
+    // deprecated name
+    pRENDERDOC_IsRemoteAccessConnected IsRemoteAccessConnected;
+    // current name
+    pRENDERDOC_IsTargetControlConnected IsTargetControlConnected;
+  };
+  pRENDERDOC_LaunchReplayUI LaunchReplayUI;
+
+  pRENDERDOC_SetActiveWindow SetActiveWindow;
+
+  pRENDERDOC_StartFrameCapture StartFrameCapture;
+  pRENDERDOC_IsFrameCapturing IsFrameCapturing;
+  pRENDERDOC_EndFrameCapture EndFrameCapture;
+
+  // new function in 1.1.0
+  pRENDERDOC_TriggerMultiFrameCapture TriggerMultiFrameCapture;
+
+  // new function in 1.2.0
+  pRENDERDOC_SetCaptureFileComments SetCaptureFileComments;
+
+  // new function in 1.4.0
+  pRENDERDOC_DiscardFrameCapture DiscardFrameCapture;
+
+  // new function in 1.5.0
+  pRENDERDOC_ShowReplayUI ShowReplayUI;
+
+  // new function in 1.6.0
+  pRENDERDOC_SetCaptureTitle SetCaptureTitle;
+} RENDERDOC_API_1_6_0;
+
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_0_0;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_0_1;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_0_2;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_1_0;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_1_1;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_1_2;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_2_0;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_3_0;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_4_0;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_4_1;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_4_2;
+typedef RENDERDOC_API_1_6_0 RENDERDOC_API_1_5_0;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc API entry point
+//
+// This entry point can be obtained via GetProcAddress/dlsym if RenderDoc is available.
+//
+// The name is the same as the typedef - "RENDERDOC_GetAPI"
+//
+// This function is not thread safe, and should not be called on multiple threads at once.
+// Ideally, call this once as early as possible in your application's startup, before doing
+// any API work, since some configuration functionality etc has to be done also before
+// initialising any APIs.
+//
+// Parameters:
+//   version is a single value from the RENDERDOC_Version above.
+//
+//   outAPIPointers will be filled out with a pointer to the corresponding struct of function
+//   pointers.
+//
+// Returns:
+//   1 - if the outAPIPointers has been filled with a pointer to the API struct requested
+//   0 - if the requested version is not supported or the arguments are invalid.
+//
+typedef int(RENDERDOC_CC *pRENDERDOC_GetAPI)(RENDERDOC_Version version, void **outAPIPointers);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif

src/CMakeLists.txt

@@ -85,6 +85,7 @@ if (MSVC)
         /wd4100 # 'identifier': unreferenced formal parameter
         /wd4324 # 'struct_name': structure was padded due to __declspec(align())
         /wd4201 # nonstandard extension used : nameless struct/union
+        /wd4702 # unreachable code (when used with LTO)
     )
 
     if (USE_CCACHE OR YUZU_USE_PRECOMPILED_HEADERS)

src/android/.gitignore

@@ -63,3 +63,6 @@ fastlane/Preview.html
 fastlane/screenshots
 fastlane/test_output
 fastlane/readme.md
+
+# Autogenerated library for vulkan validation layers
+libVkLayer_khronos_validation.so

src/android/app/build.gradle.kts

@@ -77,13 +77,30 @@ android {
         buildConfigField("String", "BRANCH", "\"${getBranch()}\"")
     }
 
+    val keystoreFile = System.getenv("ANDROID_KEYSTORE_FILE")
+    if (keystoreFile != null) {
+        signingConfigs {
+            create("release") {
+                storeFile = file(keystoreFile)
+                storePassword = System.getenv("ANDROID_KEYSTORE_PASS")
+                keyAlias = System.getenv("ANDROID_KEY_ALIAS")
+                keyPassword = System.getenv("ANDROID_KEYSTORE_PASS")
+            }
+        }
+    }
+
     // Define build types, which are orthogonal to product flavors.
     buildTypes {
 
         // Signed by release key, allowing for upload to Play Store.
         release {
+            signingConfig = if (keystoreFile != null) {
+                signingConfigs.getByName("release")
+            } else {
+                signingConfigs.getByName("debug")
+            }
+
             resValue("string", "app_name_suffixed", "yuzu")
-            signingConfig = signingConfigs.getByName("debug")
             isMinifyEnabled = true
             isDebuggable = false
             proguardFiles(
@@ -197,7 +214,7 @@ dependencies {
     implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1")
     implementation("io.coil-kt:coil:2.2.2")
     implementation("androidx.core:core-splashscreen:1.0.1")
-    implementation("androidx.window:window:1.1.0")
+    implementation("androidx.window:window:1.2.0-beta03")
     implementation("org.ini4j:ini4j:0.5.4")
     implementation("androidx.constraintlayout:constraintlayout:2.1.4")
     implementation("androidx.swiperefreshlayout:swiperefreshlayout:1.1.0")

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -307,21 +307,6 @@ object NativeLibrary {
      */
     external fun isPaused(): Boolean
 
-    /**
-     * Mutes emulation sound
-     */
-    external fun muteAudio(): Boolean
-
-    /**
-     * Unmutes emulation sound
-     */
-    external fun unmuteAudio(): Boolean
-
-    /**
-     * Returns true if emulation audio is muted.
-     */
-    external fun isMuted(): Boolean
-
     /**
      * Returns the performance stats for the current game
      */

src/android/app/src/main/java/org/yuzu/yuzu_emu/activities/EmulationActivity.kt

@@ -3,6 +3,7 @@
 
 package org.yuzu.yuzu_emu.activities
 
+import android.annotation.SuppressLint
 import android.app.Activity
 import android.app.PendingIntent
 import android.app.PictureInPictureParams
@@ -332,7 +333,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
             pictureInPictureActions.add(pauseRemoteAction)
         }
 
-        if (NativeLibrary.isMuted()) {
+        if (BooleanSetting.AUDIO_MUTED.boolean) {
             val unmuteIcon = Icon.createWithResource(
                 this@EmulationActivity,
                 R.drawable.ic_pip_unmute
@@ -389,14 +390,15 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
                 if (!NativeLibrary.isPaused()) NativeLibrary.pauseEmulation()
             }
             if (intent.action == actionUnmute) {
-                if (NativeLibrary.isMuted()) NativeLibrary.unmuteAudio()
+                if (BooleanSetting.AUDIO_MUTED.boolean) BooleanSetting.AUDIO_MUTED.setBoolean(false)
             } else if (intent.action == actionMute) {
-                if (!NativeLibrary.isMuted()) NativeLibrary.muteAudio()
+                if (!BooleanSetting.AUDIO_MUTED.boolean) BooleanSetting.AUDIO_MUTED.setBoolean(true)
             }
             buildPictureInPictureParams()
         }
     }
 
+    @SuppressLint("UnspecifiedRegisterReceiverFlag")
     override fun onPictureInPictureModeChanged(
         isInPictureInPictureMode: Boolean,
         newConfig: Configuration
@@ -409,7 +411,11 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
                 addAction(actionMute)
                 addAction(actionUnmute)
             }.also {
-                registerReceiver(pictureInPictureReceiver, it)
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    registerReceiver(pictureInPictureReceiver, it, RECEIVER_EXPORTED)
+                } else {
+                    registerReceiver(pictureInPictureReceiver, it)
+                }
             }
         } else {
             try {
@@ -417,7 +423,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
             } catch (ignored: Exception) {
             }
             // Always resume audio, since there is no UI button
-            if (NativeLibrary.isMuted()) NativeLibrary.unmuteAudio()
+            if (BooleanSetting.AUDIO_MUTED.boolean) BooleanSetting.AUDIO_MUTED.setBoolean(false)
         }
     }
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt

@@ -4,7 +4,8 @@
 package org.yuzu.yuzu_emu.adapters
 
 import android.content.Intent
-import android.graphics.drawable.BitmapDrawable
+import android.graphics.Bitmap
+import android.graphics.drawable.LayerDrawable
 import android.net.Uri
 import android.text.TextUtils
 import android.view.LayoutInflater
@@ -15,7 +16,10 @@ import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.pm.ShortcutInfoCompat
 import androidx.core.content.pm.ShortcutManagerCompat
+import androidx.core.content.res.ResourcesCompat
 import androidx.core.graphics.drawable.IconCompat
+import androidx.core.graphics.drawable.toBitmap
+import androidx.core.graphics.drawable.toDrawable
 import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.ViewModelProvider
 import androidx.navigation.findNavController
@@ -87,11 +91,24 @@ class GameAdapter(private val activity: AppCompatActivity) :
             action = Intent.ACTION_VIEW
             data = Uri.parse(holder.game.path)
         }
+
+        val layerDrawable = ResourcesCompat.getDrawable(
+            YuzuApplication.appContext.resources,
+            R.drawable.shortcut,
+            null
+        ) as LayerDrawable
+        layerDrawable.setDrawableByLayerId(
+            R.id.shortcut_foreground,
+            GameIconUtils.getGameIcon(holder.game).toDrawable(YuzuApplication.appContext.resources)
+        )
+        val inset = YuzuApplication.appContext.resources
+            .getDimensionPixelSize(R.dimen.icon_inset)
+        layerDrawable.setLayerInset(1, inset, inset, inset, inset)
         val shortcut = ShortcutInfoCompat.Builder(YuzuApplication.appContext, holder.game.path)
             .setShortLabel(holder.game.title)
             .setIcon(
-                IconCompat.createWithBitmap(
-                    (holder.binding.imageGameScreen.drawable as BitmapDrawable).bitmap
+                IconCompat.createWithAdaptiveBitmap(
+                    layerDrawable.toBitmap(config = Bitmap.Config.ARGB_8888)
                 )
             )
             .setIntent(openIntent)

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/HomeSettingAdapter.kt

@@ -10,8 +10,12 @@ import android.view.ViewGroup
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
 import androidx.core.content.res.ResourcesCompat
+import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.recyclerview.widget.RecyclerView
+import kotlinx.coroutines.launch
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.CardHomeOptionBinding
 import org.yuzu.yuzu_emu.fragments.MessageDialogFragment
@@ -45,6 +49,7 @@ class HomeSettingAdapter(
             holder.option.onClick.invoke()
         } else {
             MessageDialogFragment.newInstance(
+                activity,
                 titleId = holder.option.disabledTitleId,
                 descriptionId = holder.option.disabledMessageId
             ).show(activity.supportFragmentManager, MessageDialogFragment.TAG)
@@ -86,7 +91,11 @@ class HomeSettingAdapter(
                 binding.optionIcon.alpha = 0.5f
             }
 
-            option.details.observe(viewLifecycle) { updateOptionDetails(it) }
+            viewLifecycle.lifecycleScope.launch {
+                viewLifecycle.repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    option.details.collect { updateOptionDetails(it) }
+                }
+            }
             binding.optionDetail.postDelayed(
                 {
                     binding.optionDetail.ellipsize = TextUtils.TruncateAt.MARQUEE

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

@@ -10,6 +10,7 @@ enum class BooleanSetting(
     override val category: Settings.Category,
     override val androidDefault: Boolean? = null
 ) : AbstractBooleanSetting {
+    AUDIO_MUTED("audio_muted", Settings.Category.Audio),
     CPU_DEBUG_MODE("cpu_debug_mode", Settings.Category.Cpu),
     FASTMEM("cpuopt_fastmem", Settings.Category.Cpu),
     FASTMEM_EXCLUSIVES("cpuopt_fastmem_exclusives", Settings.Category.Cpu),

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

@@ -80,6 +80,17 @@ object Settings {
     const val SECTION_THEME = "Theme"
     const val SECTION_DEBUG = "Debug"
 
+    enum class MenuTag(val titleId: Int) {
+        SECTION_ROOT(R.string.advanced_settings),
+        SECTION_GENERAL(R.string.preferences_general),
+        SECTION_SYSTEM(R.string.preferences_system),
+        SECTION_RENDERER(R.string.preferences_graphics),
+        SECTION_AUDIO(R.string.preferences_audio),
+        SECTION_CPU(R.string.cpu),
+        SECTION_THEME(R.string.preferences_theme),
+        SECTION_DEBUG(R.string.preferences_debug);
+    }
+
     const val PREF_MEMORY_WARNING_SHOWN = "MemoryWarningShown"
 
     const val PREF_OVERLAY_VERSION = "OverlayVersion"

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

@@ -3,10 +3,12 @@
 
 package org.yuzu.yuzu_emu.features.settings.model.view
 
+import org.yuzu.yuzu_emu.features.settings.model.Settings
+
 class SubmenuSetting(
     titleId: Int,
     descriptionId: Int,
-    val menuKey: String
+    val menuKey: Settings.MenuTag
 ) : SettingsItem(emptySetting, titleId, descriptionId) {
     override val type = TYPE_SUBMENU
 }

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

@@ -13,9 +13,14 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation.fragment.NavHostFragment
 import androidx.navigation.navArgs
 import com.google.android.material.color.MaterialColors
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
 import java.io.IOException
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.ActivitySettingsBinding
@@ -66,25 +71,39 @@ class SettingsActivity : AppCompatActivity() {
             )
         }
 
-        settingsViewModel.shouldRecreate.observe(this) {
-            if (it) {
-                settingsViewModel.setShouldRecreate(false)
-                recreate()
+        lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    settingsViewModel.shouldRecreate.collectLatest {
+                        if (it) {
+                            settingsViewModel.setShouldRecreate(false)
+                            recreate()
+                        }
+                    }
+                }
             }
-        }
-        settingsViewModel.shouldNavigateBack.observe(this) {
-            if (it) {
-                settingsViewModel.setShouldNavigateBack(false)
-                navigateBack()
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    settingsViewModel.shouldNavigateBack.collectLatest {
+                        if (it) {
+                            settingsViewModel.setShouldNavigateBack(false)
+                            navigateBack()
+                        }
+                    }
+                }
             }
-        }
-        settingsViewModel.shouldShowResetSettingsDialog.observe(this) {
-            if (it) {
-                settingsViewModel.setShouldShowResetSettingsDialog(false)
-                ResetSettingsDialogFragment().show(
-                    supportFragmentManager,
-                    ResetSettingsDialogFragment.TAG
-                )
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    settingsViewModel.shouldShowResetSettingsDialog.collectLatest {
+                        if (it) {
+                            settingsViewModel.setShouldShowResetSettingsDialog(false)
+                            ResetSettingsDialogFragment().show(
+                                supportFragmentManager,
+                                ResetSettingsDialogFragment.TAG
+                            )
+                        }
+                    }
+                }
             }
         }
 

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

@@ -3,6 +3,7 @@
 
 package org.yuzu.yuzu_emu.features.settings.ui
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -13,14 +14,19 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation.findNavController
 import androidx.navigation.fragment.navArgs
 import androidx.recyclerview.widget.LinearLayoutManager
 import com.google.android.material.divider.MaterialDividerItemDecoration
 import com.google.android.material.transition.MaterialSharedAxis
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.FragmentSettingsBinding
-import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
+import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.model.SettingsViewModel
 
 class SettingsFragment : Fragment() {
@@ -51,15 +57,17 @@ class SettingsFragment : Fragment() {
         return binding.root
     }
 
+    // This is using the correct scope, lint is just acting up
+    @SuppressLint("UnsafeRepeatOnLifecycleDetector")
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         settingsAdapter = SettingsAdapter(this, requireContext())
         presenter = SettingsFragmentPresenter(
             settingsViewModel,
             settingsAdapter!!,
-            args.menuTag,
-            args.game?.gameId ?: ""
+            args.menuTag
         )
 
+        binding.toolbarSettingsLayout.title = getString(args.menuTag.titleId)
         val dividerDecoration = MaterialDividerItemDecoration(
             requireContext(),
             LinearLayoutManager.VERTICAL
@@ -75,28 +83,31 @@ class SettingsFragment : Fragment() {
             settingsViewModel.setShouldNavigateBack(true)
         }
 
-        settingsViewModel.toolbarTitle.observe(viewLifecycleOwner) {
-            if (it.isNotEmpty()) binding.toolbarSettingsLayout.title = it
-        }
-
-        settingsViewModel.shouldReloadSettingsList.observe(viewLifecycleOwner) {
-            if (it) {
-                settingsViewModel.setShouldReloadSettingsList(false)
-                presenter.loadSettingsList()
+        viewLifecycleOwner.lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    settingsViewModel.shouldReloadSettingsList.collectLatest {
+                        if (it) {
+                            settingsViewModel.setShouldReloadSettingsList(false)
+                            presenter.loadSettingsList()
+                        }
+                    }
+                }
+            }
+            launch {
+                settingsViewModel.isUsingSearch.collectLatest {
+                    if (it) {
+                        reenterTransition = MaterialSharedAxis(MaterialSharedAxis.Z, true)
+                        exitTransition = MaterialSharedAxis(MaterialSharedAxis.Z, false)
+                    } else {
+                        reenterTransition = MaterialSharedAxis(MaterialSharedAxis.X, false)
+                        exitTransition = MaterialSharedAxis(MaterialSharedAxis.X, true)
+                    }
+                }
             }
         }
 
-        settingsViewModel.isUsingSearch.observe(viewLifecycleOwner) {
-            if (it) {
-                reenterTransition = MaterialSharedAxis(MaterialSharedAxis.Z, true)
-                exitTransition = MaterialSharedAxis(MaterialSharedAxis.Z, false)
-            } else {
-                reenterTransition = MaterialSharedAxis(MaterialSharedAxis.X, false)
-                exitTransition = MaterialSharedAxis(MaterialSharedAxis.X, true)
-            }
-        }
-
-        if (args.menuTag == SettingsFile.FILE_NAME_CONFIG) {
+        if (args.menuTag == Settings.MenuTag.SECTION_ROOT) {
             binding.toolbarSettings.inflateMenu(R.menu.menu_settings)
             binding.toolbarSettings.setOnMenuItemClickListener {
                 when (it.itemId) {

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

@@ -6,7 +6,6 @@ package org.yuzu.yuzu_emu.features.settings.ui
 import android.content.Context
 import android.content.SharedPreferences
 import android.os.Build
-import android.text.TextUtils
 import android.widget.Toast
 import androidx.preference.PreferenceManager
 import org.yuzu.yuzu_emu.R
@@ -20,15 +19,13 @@ import org.yuzu.yuzu_emu.features.settings.model.LongSetting
 import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.view.*
-import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
 import org.yuzu.yuzu_emu.model.SettingsViewModel
 import org.yuzu.yuzu_emu.utils.NativeConfig
 
 class SettingsFragmentPresenter(
     private val settingsViewModel: SettingsViewModel,
     private val adapter: SettingsAdapter,
-    private var menuTag: String,
-    private var gameId: String
+    private var menuTag: Settings.MenuTag
 ) {
     private var settingsList = ArrayList<SettingsItem>()
 
@@ -53,24 +50,15 @@ class SettingsFragmentPresenter(
     }
 
     fun loadSettingsList() {
-        if (!TextUtils.isEmpty(gameId)) {
-            settingsViewModel.setToolbarTitle(
-                context.getString(
-                    R.string.advanced_settings_game,
-                    gameId
-                )
-            )
-        }
-
         val sl = ArrayList<SettingsItem>()
         when (menuTag) {
-            SettingsFile.FILE_NAME_CONFIG -> addConfigSettings(sl)
-            Settings.SECTION_GENERAL -> addGeneralSettings(sl)
-            Settings.SECTION_SYSTEM -> addSystemSettings(sl)
-            Settings.SECTION_RENDERER -> addGraphicsSettings(sl)
-            Settings.SECTION_AUDIO -> addAudioSettings(sl)
-            Settings.SECTION_THEME -> addThemeSettings(sl)
-            Settings.SECTION_DEBUG -> addDebugSettings(sl)
+            Settings.MenuTag.SECTION_ROOT -> addConfigSettings(sl)
+            Settings.MenuTag.SECTION_GENERAL -> addGeneralSettings(sl)
+            Settings.MenuTag.SECTION_SYSTEM -> addSystemSettings(sl)
+            Settings.MenuTag.SECTION_RENDERER -> addGraphicsSettings(sl)
+            Settings.MenuTag.SECTION_AUDIO -> addAudioSettings(sl)
+            Settings.MenuTag.SECTION_THEME -> addThemeSettings(sl)
+            Settings.MenuTag.SECTION_DEBUG -> addDebugSettings(sl)
             else -> {
                 val context = YuzuApplication.appContext
                 Toast.makeText(
@@ -86,13 +74,12 @@ class SettingsFragmentPresenter(
     }
 
     private fun addConfigSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.advanced_settings))
         sl.apply {
-            add(SubmenuSetting(R.string.preferences_general, 0, Settings.SECTION_GENERAL))
-            add(SubmenuSetting(R.string.preferences_system, 0, Settings.SECTION_SYSTEM))
-            add(SubmenuSetting(R.string.preferences_graphics, 0, Settings.SECTION_RENDERER))
-            add(SubmenuSetting(R.string.preferences_audio, 0, Settings.SECTION_AUDIO))
-            add(SubmenuSetting(R.string.preferences_debug, 0, Settings.SECTION_DEBUG))
+            add(SubmenuSetting(R.string.preferences_general, 0, Settings.MenuTag.SECTION_GENERAL))
+            add(SubmenuSetting(R.string.preferences_system, 0, Settings.MenuTag.SECTION_SYSTEM))
+            add(SubmenuSetting(R.string.preferences_graphics, 0, Settings.MenuTag.SECTION_RENDERER))
+            add(SubmenuSetting(R.string.preferences_audio, 0, Settings.MenuTag.SECTION_AUDIO))
+            add(SubmenuSetting(R.string.preferences_debug, 0, Settings.MenuTag.SECTION_DEBUG))
             add(
                 RunnableSetting(R.string.reset_to_default, 0, false) {
                     settingsViewModel.setShouldShowResetSettingsDialog(true)
@@ -102,7 +89,6 @@ class SettingsFragmentPresenter(
     }
 
     private fun addGeneralSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.preferences_general))
         sl.apply {
             add(BooleanSetting.RENDERER_USE_SPEED_LIMIT.key)
             add(ShortSetting.RENDERER_SPEED_LIMIT.key)
@@ -112,7 +98,6 @@ class SettingsFragmentPresenter(
     }
 
     private fun addSystemSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.preferences_system))
         sl.apply {
             add(BooleanSetting.USE_DOCKED_MODE.key)
             add(IntSetting.REGION_INDEX.key)
@@ -123,7 +108,6 @@ class SettingsFragmentPresenter(
     }
 
     private fun addGraphicsSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.preferences_graphics))
         sl.apply {
             add(IntSetting.RENDERER_ACCURACY.key)
             add(IntSetting.RENDERER_RESOLUTION.key)
@@ -140,7 +124,6 @@ class SettingsFragmentPresenter(
     }
 
     private fun addAudioSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.preferences_audio))
         sl.apply {
             add(IntSetting.AUDIO_OUTPUT_ENGINE.key)
             add(ByteSetting.AUDIO_VOLUME.key)
@@ -148,7 +131,6 @@ class SettingsFragmentPresenter(
     }
 
     private fun addThemeSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.preferences_theme))
         sl.apply {
             val theme: AbstractIntSetting = object : AbstractIntSetting {
                 override val int: Int
@@ -261,7 +243,6 @@ class SettingsFragmentPresenter(
     }
 
     private fun addDebugSettings(sl: ArrayList<SettingsItem>) {
-        settingsViewModel.setToolbarTitle(context.getString(R.string.preferences_debug))
         sl.apply {
             add(HeaderSetting(R.string.gpu))
             add(IntSetting.RENDERER_BACKEND.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AboutFragment.kt

@@ -26,6 +26,7 @@ import org.yuzu.yuzu_emu.BuildConfig
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.FragmentAboutBinding
 import org.yuzu.yuzu_emu.model.HomeViewModel
+import org.yuzu.yuzu_emu.ui.main.MainActivity
 
 class AboutFragment : Fragment() {
     private var _binding: FragmentAboutBinding? = null
@@ -92,6 +93,12 @@ class AboutFragment : Fragment() {
             }
         }
 
+        val mainActivity = requireActivity() as MainActivity
+        binding.buttonExport.setOnClickListener { mainActivity.exportUserData.launch("export.zip") }
+        binding.buttonImport.setOnClickListener {
+            mainActivity.importUserData.launch(arrayOf("application/zip"))
+        }
+
         binding.buttonDiscord.setOnClickListener { openLink(getString(R.string.support_link)) }
         binding.buttonWebsite.setOnClickListener { openLink(getString(R.string.website_link)) }
         binding.buttonGithub.setOnClickListener { openLink(getString(R.string.github_link)) }

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -15,7 +15,6 @@ import android.net.Uri
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
-import android.util.Rational
 import android.view.*
 import android.widget.TextView
 import androidx.activity.OnBackPressedCallback
@@ -39,6 +38,7 @@ import androidx.window.layout.WindowLayoutInfo
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.slider.Slider
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 import org.yuzu.yuzu_emu.HomeNavigationDirections
 import org.yuzu.yuzu_emu.NativeLibrary
@@ -49,7 +49,6 @@ import org.yuzu.yuzu_emu.databinding.DialogOverlayAdjustBinding
 import org.yuzu.yuzu_emu.databinding.FragmentEmulationBinding
 import org.yuzu.yuzu_emu.features.settings.model.IntSetting
 import org.yuzu.yuzu_emu.features.settings.model.Settings
-import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
 import org.yuzu.yuzu_emu.model.Game
 import org.yuzu.yuzu_emu.model.EmulationViewModel
 import org.yuzu.yuzu_emu.overlay.InputOverlay
@@ -129,6 +128,8 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         return binding.root
     }
 
+    // This is using the correct scope, lint is just acting up
+    @SuppressLint("UnsafeRepeatOnLifecycleDetector")
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         binding.surfaceEmulation.holder.addCallback(this)
         binding.showFpsText.setTextColor(Color.YELLOW)
@@ -163,7 +164,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                 R.id.menu_settings -> {
                     val action = HomeNavigationDirections.actionGlobalSettingsActivity(
                         null,
-                        SettingsFile.FILE_NAME_CONFIG
+                        Settings.MenuTag.SECTION_ROOT
                     )
                     binding.root.findNavController().navigate(action)
                     true
@@ -205,78 +206,98 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             }
         )
 
-        viewLifecycleOwner.lifecycleScope.launch(Dispatchers.Main) {
-            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                WindowInfoTracker.getOrCreate(requireContext())
-                    .windowLayoutInfo(requireActivity())
-                    .collect { updateFoldableLayout(requireActivity() as EmulationActivity, it) }
-            }
-        }
-
         GameIconUtils.loadGameIcon(game, binding.loadingImage)
         binding.loadingTitle.text = game.title
         binding.loadingTitle.isSelected = true
         binding.loadingText.isSelected = true
 
-        emulationViewModel.shaderProgress.observe(viewLifecycleOwner) {
-            if (it > 0 && it != emulationViewModel.totalShaders.value!!) {
-                binding.loadingProgressIndicator.isIndeterminate = false
-
-                if (it < binding.loadingProgressIndicator.max) {
-                    binding.loadingProgressIndicator.progress = it
+        viewLifecycleOwner.lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.STARTED) {
+                    WindowInfoTracker.getOrCreate(requireContext())
+                        .windowLayoutInfo(requireActivity())
+                        .collect {
+                            updateFoldableLayout(requireActivity() as EmulationActivity, it)
+                        }
                 }
             }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    emulationViewModel.shaderProgress.collectLatest {
+                        if (it > 0 && it != emulationViewModel.totalShaders.value) {
+                            binding.loadingProgressIndicator.isIndeterminate = false
 
-            if (it == emulationViewModel.totalShaders.value!!) {
-                binding.loadingText.setText(R.string.loading)
-                binding.loadingProgressIndicator.isIndeterminate = true
+                            if (it < binding.loadingProgressIndicator.max) {
+                                binding.loadingProgressIndicator.progress = it
+                            }
+                        }
+
+                        if (it == emulationViewModel.totalShaders.value) {
+                            binding.loadingText.setText(R.string.loading)
+                            binding.loadingProgressIndicator.isIndeterminate = true
+                        }
+                    }
+                }
             }
-        }
-        emulationViewModel.totalShaders.observe(viewLifecycleOwner) {
-            binding.loadingProgressIndicator.max = it
-        }
-        emulationViewModel.shaderMessage.observe(viewLifecycleOwner) {
-            if (it.isNotEmpty()) {
-                binding.loadingText.text = it
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    emulationViewModel.totalShaders.collectLatest {
+                        binding.loadingProgressIndicator.max = it
+                    }
+                }
             }
-        }
-
-        emulationViewModel.emulationStarted.observe(viewLifecycleOwner) { started ->
-            if (started) {
-                binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
-                ViewUtils.showView(binding.surfaceInputOverlay)
-                ViewUtils.hideView(binding.loadingIndicator)
-
-                // Setup overlay
-                updateShowFpsOverlay()
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    emulationViewModel.shaderMessage.collectLatest {
+                        if (it.isNotEmpty()) {
+                            binding.loadingText.text = it
+                        }
+                    }
+                }
             }
-        }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    emulationViewModel.emulationStarted.collectLatest {
+                        if (it) {
+                            binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
+                            ViewUtils.showView(binding.surfaceInputOverlay)
+                            ViewUtils.hideView(binding.loadingIndicator)
 
-        emulationViewModel.isEmulationStopping.observe(viewLifecycleOwner) {
-            if (it) {
-                binding.loadingText.setText(R.string.shutting_down)
-                ViewUtils.showView(binding.loadingIndicator)
-                ViewUtils.hideView(binding.inputContainer)
-                ViewUtils.hideView(binding.showFpsText)
+                            // Setup overlay
+                            updateShowFpsOverlay()
+                        }
+                    }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    emulationViewModel.isEmulationStopping.collectLatest {
+                        if (it) {
+                            binding.loadingText.setText(R.string.shutting_down)
+                            ViewUtils.showView(binding.loadingIndicator)
+                            ViewUtils.hideView(binding.inputContainer)
+                            ViewUtils.hideView(binding.showFpsText)
+                        }
+                    }
+                }
             }
         }
     }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
+        updateScreenLayout()
         if (emulationActivity?.isInPictureInPictureMode == true) {
             if (binding.drawerLayout.isOpen) {
                 binding.drawerLayout.close()
             }
             if (EmulationMenuSettings.showOverlay) {
                 binding.surfaceInputOverlay.post {
-                    binding.surfaceInputOverlay.visibility = View.VISIBLE
+                    binding.surfaceInputOverlay.visibility = View.INVISIBLE
                 }
             }
         } else {
-            if (EmulationMenuSettings.showOverlay &&
-                emulationViewModel.emulationStarted.value == true
-            ) {
+            if (EmulationMenuSettings.showOverlay && emulationViewModel.emulationStarted.value) {
                 binding.surfaceInputOverlay.post {
                     binding.surfaceInputOverlay.visibility = View.VISIBLE
                 }
@@ -307,7 +328,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
     }
 
     override fun onPause() {
-        if (emulationState.isRunning) {
+        if (emulationState.isRunning && emulationActivity?.isInPictureInPictureMode != true) {
             emulationState.pause()
         }
         super.onPause()
@@ -373,16 +394,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
     }
 
     private fun updateScreenLayout() {
-        binding.surfaceEmulation.setAspectRatio(
-            when (IntSetting.RENDERER_ASPECT_RATIO.int) {
-                0 -> Rational(16, 9)
-                1 -> Rational(4, 3)
-                2 -> Rational(21, 9)
-                3 -> Rational(16, 10)
-                4 -> null // Stretch
-                else -> Rational(16, 9)
-            }
-        )
+        binding.surfaceEmulation.setAspectRatio(null)
         emulationActivity?.buildPictureInPictureParams()
         updateOrientation()
     }
@@ -672,7 +684,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
     private class EmulationState(private val gamePath: String) {
         private var state: State
         private var surface: Surface? = null
-        private var runWhenSurfaceIsValid = false
 
         init {
             // Starting state is stopped.
@@ -730,8 +741,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             // If the surface is set, run now. Otherwise, wait for it to get set.
             if (surface != null) {
                 runWithValidSurface()
-            } else {
-                runWhenSurfaceIsValid = true
             }
         }
 
@@ -739,7 +748,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         @Synchronized
         fun newSurface(surface: Surface?) {
             this.surface = surface
-            if (runWhenSurfaceIsValid) {
+            if (this.surface != null) {
                 runWithValidSurface()
             }
         }
@@ -767,10 +776,9 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
 
         private fun runWithValidSurface() {
-            runWhenSurfaceIsValid = false
+            NativeLibrary.surfaceChanged(surface)
             when (state) {
                 State.STOPPED -> {
-                    NativeLibrary.surfaceChanged(surface)
                     val emulationThread = Thread({
                         Log.debug("[EmulationFragment] Starting emulation thread.")
                         NativeLibrary.run(gamePath)
@@ -780,7 +788,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
                 State.PAUSED -> {
                     Log.debug("[EmulationFragment] Resuming emulation.")
-                    NativeLibrary.surfaceChanged(surface)
                     NativeLibrary.unpauseEmulation()
                 }
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt

@@ -37,7 +37,6 @@ import org.yuzu.yuzu_emu.adapters.HomeSettingAdapter
 import org.yuzu.yuzu_emu.databinding.FragmentHomeSettingsBinding
 import org.yuzu.yuzu_emu.features.DocumentProvider
 import org.yuzu.yuzu_emu.features.settings.model.Settings
-import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
 import org.yuzu.yuzu_emu.model.HomeSetting
 import org.yuzu.yuzu_emu.model.HomeViewModel
 import org.yuzu.yuzu_emu.ui.main.MainActivity
@@ -78,7 +77,7 @@ class HomeSettingsFragment : Fragment() {
                     {
                         val action = HomeNavigationDirections.actionGlobalSettingsActivity(
                             null,
-                            SettingsFile.FILE_NAME_CONFIG
+                            Settings.MenuTag.SECTION_ROOT
                         )
                         binding.root.findNavController().navigate(action)
                     }
@@ -100,7 +99,7 @@ class HomeSettingsFragment : Fragment() {
                     {
                         val action = HomeNavigationDirections.actionGlobalSettingsActivity(
                             null,
-                            Settings.SECTION_THEME
+                            Settings.MenuTag.SECTION_THEME
                         )
                         binding.root.findNavController().navigate(action)
                     }

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/ImportExportSavesFragment.kt

@@ -187,6 +187,7 @@ class ImportExportSavesFragment : DialogFragment() {
                 withContext(Dispatchers.Main) {
                     if (!validZip) {
                         MessageDialogFragment.newInstance(
+                            requireActivity(),
                             titleId = R.string.save_file_invalid_zip_structure,
                             descriptionId = R.string.save_file_invalid_zip_structure_description
                         ).show(activity.supportFragmentManager, MessageDialogFragment.TAG)

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/IndeterminateProgressDialogFragment.kt

@@ -4,64 +4,117 @@
 package org.yuzu.yuzu_emu.fragments
 
 import android.app.Dialog
+import android.content.DialogInterface
 import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
 import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.DialogFragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.coroutines.launch
+import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.DialogProgressBarBinding
 import org.yuzu.yuzu_emu.model.TaskViewModel
 
 class IndeterminateProgressDialogFragment : DialogFragment() {
     private val taskViewModel: TaskViewModel by activityViewModels()
 
+    private lateinit var binding: DialogProgressBarBinding
+
     override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
         val titleId = requireArguments().getInt(TITLE)
+        val cancellable = requireArguments().getBoolean(CANCELLABLE)
 
-        val progressBinding = DialogProgressBarBinding.inflate(layoutInflater)
-        progressBinding.progressBar.isIndeterminate = true
+        binding = DialogProgressBarBinding.inflate(layoutInflater)
+        binding.progressBar.isIndeterminate = true
         val dialog = MaterialAlertDialogBuilder(requireContext())
             .setTitle(titleId)
-            .setView(progressBinding.root)
-            .create()
-        dialog.setCanceledOnTouchOutside(false)
+            .setView(binding.root)
 
-        taskViewModel.isComplete.observe(this) { complete ->
-            if (complete) {
-                dialog.dismiss()
-                when (val result = taskViewModel.result.value) {
-                    is String -> Toast.makeText(requireContext(), result, Toast.LENGTH_LONG).show()
-                    is MessageDialogFragment -> result.show(
-                        requireActivity().supportFragmentManager,
-                        MessageDialogFragment.TAG
-                    )
-                }
-                taskViewModel.clear()
+        if (cancellable) {
+            dialog.setNegativeButton(android.R.string.cancel) { _: DialogInterface, _: Int ->
+                taskViewModel.setCancelled(true)
             }
         }
 
-        if (taskViewModel.isRunning.value == false) {
+        val alertDialog = dialog.create()
+        alertDialog.setCanceledOnTouchOutside(false)
+
+        if (!taskViewModel.isRunning.value) {
             taskViewModel.runTask()
         }
-        return dialog
+        return alertDialog
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        return binding.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        viewLifecycleOwner.lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    taskViewModel.isComplete.collect {
+                        if (it) {
+                            dismiss()
+                            when (val result = taskViewModel.result.value) {
+                                is String -> Toast.makeText(
+                                    requireContext(),
+                                    result,
+                                    Toast.LENGTH_LONG
+                                ).show()
+
+                                is MessageDialogFragment -> result.show(
+                                    requireActivity().supportFragmentManager,
+                                    MessageDialogFragment.TAG
+                                )
+                            }
+                            taskViewModel.clear()
+                        }
+                    }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    taskViewModel.cancelled.collect {
+                        if (it) {
+                            dialog?.setTitle(R.string.cancelling)
+                        }
+                    }
+                }
+            }
+        }
     }
 
     companion object {
         const val TAG = "IndeterminateProgressDialogFragment"
 
         private const val TITLE = "Title"
+        private const val CANCELLABLE = "Cancellable"
 
         fun newInstance(
             activity: AppCompatActivity,
             titleId: Int,
+            cancellable: Boolean = false,
             task: () -> Any
         ): IndeterminateProgressDialogFragment {
             val dialog = IndeterminateProgressDialogFragment()
             val args = Bundle()
             ViewModelProvider(activity)[TaskViewModel::class.java].task = task
             args.putInt(TITLE, titleId)
+            args.putBoolean(CANCELLABLE, cancellable)
             dialog.arguments = args
             return dialog
         }

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/MessageDialogFragment.kt

@@ -4,14 +4,21 @@
 package org.yuzu.yuzu_emu.fragments
 
 import android.app.Dialog
+import android.content.DialogInterface
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
 import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.ViewModelProvider
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.yuzu.yuzu_emu.R
+import org.yuzu.yuzu_emu.model.MessageDialogViewModel
 
 class MessageDialogFragment : DialogFragment() {
+    private val messageDialogViewModel: MessageDialogViewModel by activityViewModels()
+
     override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
         val titleId = requireArguments().getInt(TITLE_ID)
         val titleString = requireArguments().getString(TITLE_STRING)!!
@@ -37,6 +44,12 @@ class MessageDialogFragment : DialogFragment() {
         return dialog.show()
     }
 
+    override fun onDismiss(dialog: DialogInterface) {
+        super.onDismiss(dialog)
+        messageDialogViewModel.dismissAction.invoke()
+        messageDialogViewModel.clear()
+    }
+
     private fun openLink(link: String) {
         val intent = Intent(Intent.ACTION_VIEW, Uri.parse(link))
         startActivity(intent)
@@ -52,11 +65,13 @@ class MessageDialogFragment : DialogFragment() {
         private const val HELP_LINK = "Link"
 
         fun newInstance(
+            activity: FragmentActivity,
             titleId: Int = 0,
             titleString: String = "",
             descriptionId: Int = 0,
             descriptionString: String = "",
-            helpLinkId: Int = 0
+            helpLinkId: Int = 0,
+            dismissAction: () -> Unit = {}
         ): MessageDialogFragment {
             val dialog = MessageDialogFragment()
             val bundle = Bundle()
@@ -67,6 +82,8 @@ class MessageDialogFragment : DialogFragment() {
                 putString(DESCRIPTION_STRING, descriptionString)
                 putInt(HELP_LINK, helpLinkId)
             }
+            ViewModelProvider(activity)[MessageDialogViewModel::class.java].dismissAction =
+                dismissAction
             dialog.arguments = bundle
             return dialog
         }

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SearchFragment.kt

@@ -3,6 +3,7 @@
 
 package org.yuzu.yuzu_emu.fragments
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.content.SharedPreferences
 import android.os.Bundle
@@ -17,9 +18,13 @@ import androidx.core.view.updatePadding
 import androidx.core.widget.doOnTextChanged
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.preference.PreferenceManager
 import info.debatty.java.stringsimilarity.Jaccard
 import info.debatty.java.stringsimilarity.JaroWinkler
+import kotlinx.coroutines.launch
 import java.util.Locale
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
@@ -52,6 +57,8 @@ class SearchFragment : Fragment() {
         return binding.root
     }
 
+    // This is using the correct scope, lint is just acting up
+    @SuppressLint("UnsafeRepeatOnLifecycleDetector")
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         homeViewModel.setNavigationVisibility(visible = true, animated = false)
         preferences = PreferenceManager.getDefaultSharedPreferences(YuzuApplication.appContext)
@@ -79,21 +86,32 @@ class SearchFragment : Fragment() {
             filterAndSearch()
         }
 
-        gamesViewModel.apply {
-            searchFocused.observe(viewLifecycleOwner) { searchFocused ->
-                if (searchFocused) {
-                    focusSearch()
-                    gamesViewModel.setSearchFocused(false)
+        viewLifecycleOwner.lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    gamesViewModel.searchFocused.collect {
+                        if (it) {
+                            focusSearch()
+                            gamesViewModel.setSearchFocused(false)
+                        }
+                    }
                 }
             }
-
-            games.observe(viewLifecycleOwner) { filterAndSearch() }
-            searchedGames.observe(viewLifecycleOwner) {
-                (binding.gridGamesSearch.adapter as GameAdapter).submitList(it)
-                if (it.isEmpty()) {
-                    binding.noResultsView.visibility = View.VISIBLE
-                } else {
-                    binding.noResultsView.visibility = View.GONE
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    gamesViewModel.games.collect { filterAndSearch() }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    gamesViewModel.searchedGames.collect {
+                        (binding.gridGamesSearch.adapter as GameAdapter).submitList(it)
+                        if (it.isEmpty()) {
+                            binding.noResultsView.visibility = View.VISIBLE
+                        } else {
+                            binding.noResultsView.visibility = View.GONE
+                        }
+                    }
                 }
             }
         }
@@ -109,7 +127,7 @@ class SearchFragment : Fragment() {
     private inner class ScoredGame(val score: Double, val item: Game)
 
     private fun filterAndSearch() {
-        val baseList = gamesViewModel.games.value!!
+        val baseList = gamesViewModel.games.value
         val filteredList: List<Game> = when (binding.chipGroup.checkedChipId) {
             R.id.chip_recently_played -> {
                 baseList.filter {

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SettingsSearchFragment.kt

@@ -15,10 +15,14 @@ import androidx.core.view.updatePadding
 import androidx.core.widget.doOnTextChanged
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.recyclerview.widget.LinearLayoutManager
 import com.google.android.material.divider.MaterialDividerItemDecoration
 import com.google.android.material.transition.MaterialSharedAxis
 import info.debatty.java.stringsimilarity.Cosine
+import kotlinx.coroutines.launch
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.FragmentSettingsSearchBinding
 import org.yuzu.yuzu_emu.features.settings.model.view.SettingsItem
@@ -79,10 +83,14 @@ class SettingsSearchFragment : Fragment() {
             search()
             binding.settingsList.smoothScrollToPosition(0)
         }
-        settingsViewModel.shouldReloadSettingsList.observe(viewLifecycleOwner) {
-            if (it) {
-                settingsViewModel.setShouldReloadSettingsList(false)
-                search()
+        viewLifecycleOwner.lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.CREATED) {
+                settingsViewModel.shouldReloadSettingsList.collect {
+                    if (it) {
+                        settingsViewModel.setShouldReloadSettingsList(false)
+                        search()
+                    }
+                }
             }
         }
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt

@@ -22,10 +22,14 @@ import androidx.core.view.isVisible
 import androidx.core.view.updatePadding
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation.findNavController
 import androidx.preference.PreferenceManager
 import androidx.viewpager2.widget.ViewPager2.OnPageChangeCallback
 import com.google.android.material.transition.MaterialFadeThrough
+import kotlinx.coroutines.launch
 import java.io.File
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
@@ -206,10 +210,14 @@ class SetupFragment : Fragment() {
             )
         }
 
-        homeViewModel.shouldPageForward.observe(viewLifecycleOwner) {
-            if (it) {
-                pageForward()
-                homeViewModel.setShouldPageForward(false)
+        viewLifecycleOwner.lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.CREATED) {
+                homeViewModel.shouldPageForward.collect {
+                    if (it) {
+                        pageForward()
+                        homeViewModel.setShouldPageForward(false)
+                    }
+                }
             }
         }
 

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

@@ -3,28 +3,28 @@
 
 package org.yuzu.yuzu_emu.model
 
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 
 class EmulationViewModel : ViewModel() {
-    private val _emulationStarted = MutableLiveData(false)
-    val emulationStarted: LiveData<Boolean> get() = _emulationStarted
+    val emulationStarted: StateFlow<Boolean> get() = _emulationStarted
+    private val _emulationStarted = MutableStateFlow(false)
 
-    private val _isEmulationStopping = MutableLiveData(false)
-    val isEmulationStopping: LiveData<Boolean> get() = _isEmulationStopping
+    val isEmulationStopping: StateFlow<Boolean> get() = _isEmulationStopping
+    private val _isEmulationStopping = MutableStateFlow(false)
 
-    private val _shaderProgress = MutableLiveData(0)
-    val shaderProgress: LiveData<Int> get() = _shaderProgress
+    val shaderProgress: StateFlow<Int> get() = _shaderProgress
+    private val _shaderProgress = MutableStateFlow(0)
 
-    private val _totalShaders = MutableLiveData(0)
-    val totalShaders: LiveData<Int> get() = _totalShaders
+    val totalShaders: StateFlow<Int> get() = _totalShaders
+    private val _totalShaders = MutableStateFlow(0)
 
-    private val _shaderMessage = MutableLiveData("")
-    val shaderMessage: LiveData<String> get() = _shaderMessage
+    val shaderMessage: StateFlow<String> get() = _shaderMessage
+    private val _shaderMessage = MutableStateFlow("")
 
     fun setEmulationStarted(started: Boolean) {
-        _emulationStarted.postValue(started)
+        _emulationStarted.value = started
     }
 
     fun setIsEmulationStopping(value: Boolean) {
@@ -50,10 +50,18 @@ class EmulationViewModel : ViewModel() {
     }
 
     fun clear() {
-        _emulationStarted.value = false
-        _isEmulationStopping.value = false
-        _shaderProgress.value = 0
-        _totalShaders.value = 0
-        _shaderMessage.value = ""
+        setEmulationStarted(false)
+        setIsEmulationStopping(false)
+        setShaderProgress(0)
+        setTotalShaders(0)
+        setShaderMessage("")
+    }
+
+    companion object {
+        const val KEY_EMULATION_STARTED = "EmulationStarted"
+        const val KEY_IS_EMULATION_STOPPING = "IsEmulationStarting"
+        const val KEY_SHADER_PROGRESS = "ShaderProgress"
+        const val KEY_TOTAL_SHADERS = "TotalShaders"
+        const val KEY_SHADER_MESSAGE = "ShaderMessage"
     }
 }

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

@@ -5,13 +5,13 @@ package org.yuzu.yuzu_emu.model
 
 import android.net.Uri
 import androidx.documentfile.provider.DocumentFile
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.preference.PreferenceManager
 import java.util.Locale
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.ExperimentalSerializationApi
@@ -24,23 +24,23 @@ import org.yuzu.yuzu_emu.utils.GameHelper
 
 @OptIn(ExperimentalSerializationApi::class)
 class GamesViewModel : ViewModel() {
-    private val _games = MutableLiveData<List<Game>>(emptyList())
-    val games: LiveData<List<Game>> get() = _games
+    val games: StateFlow<List<Game>> get() = _games
+    private val _games = MutableStateFlow(emptyList<Game>())
 
-    private val _searchedGames = MutableLiveData<List<Game>>(emptyList())
-    val searchedGames: LiveData<List<Game>> get() = _searchedGames
+    val searchedGames: StateFlow<List<Game>> get() = _searchedGames
+    private val _searchedGames = MutableStateFlow(emptyList<Game>())
 
-    private val _isReloading = MutableLiveData(false)
-    val isReloading: LiveData<Boolean> get() = _isReloading
+    val isReloading: StateFlow<Boolean> get() = _isReloading
+    private val _isReloading = MutableStateFlow(false)
 
-    private val _shouldSwapData = MutableLiveData(false)
-    val shouldSwapData: LiveData<Boolean> get() = _shouldSwapData
+    val shouldSwapData: StateFlow<Boolean> get() = _shouldSwapData
+    private val _shouldSwapData = MutableStateFlow(false)
 
-    private val _shouldScrollToTop = MutableLiveData(false)
-    val shouldScrollToTop: LiveData<Boolean> get() = _shouldScrollToTop
+    val shouldScrollToTop: StateFlow<Boolean> get() = _shouldScrollToTop
+    private val _shouldScrollToTop = MutableStateFlow(false)
 
-    private val _searchFocused = MutableLiveData(false)
-    val searchFocused: LiveData<Boolean> get() = _searchFocused
+    val searchFocused: StateFlow<Boolean> get() = _searchFocused
+    private val _searchFocused = MutableStateFlow(false)
 
     init {
         // Ensure keys are loaded so that ROM metadata can be decrypted.
@@ -79,36 +79,36 @@ class GamesViewModel : ViewModel() {
             )
         )
 
-        _games.postValue(sortedList)
+        _games.value = sortedList
     }
 
     fun setSearchedGames(games: List<Game>) {
-        _searchedGames.postValue(games)
+        _searchedGames.value = games
     }
 
     fun setShouldSwapData(shouldSwap: Boolean) {
-        _shouldSwapData.postValue(shouldSwap)
+        _shouldSwapData.value = shouldSwap
     }
 
     fun setShouldScrollToTop(shouldScroll: Boolean) {
-        _shouldScrollToTop.postValue(shouldScroll)
+        _shouldScrollToTop.value = shouldScroll
     }
 
     fun setSearchFocused(searchFocused: Boolean) {
-        _searchFocused.postValue(searchFocused)
+        _searchFocused.value = searchFocused
     }
 
     fun reloadGames(directoryChanged: Boolean) {
-        if (isReloading.value == true) {
+        if (isReloading.value) {
             return
         }
-        _isReloading.postValue(true)
+        _isReloading.value = true
 
         viewModelScope.launch {
             withContext(Dispatchers.IO) {
                 NativeLibrary.resetRomMetadata()
                 setGames(GameHelper.getGames())
-                _isReloading.postValue(false)
+                _isReloading.value = false
 
                 if (directoryChanged) {
                     setShouldSwapData(true)

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

@@ -3,8 +3,8 @@
 
 package org.yuzu.yuzu_emu.model
 
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 
 data class HomeSetting(
     val titleId: Int,
@@ -14,5 +14,5 @@ data class HomeSetting(
     val isEnabled: () -> Boolean = { true },
     val disabledTitleId: Int = 0,
     val disabledMessageId: Int = 0,
-    val details: LiveData<String> = MutableLiveData("")
+    val details: StateFlow<String> = MutableStateFlow("")
 )

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

@@ -5,47 +5,43 @@ package org.yuzu.yuzu_emu.model
 
 import android.net.Uri
 import androidx.fragment.app.FragmentActivity
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.preference.PreferenceManager
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.utils.GameHelper
 
 class HomeViewModel : ViewModel() {
-    private val _navigationVisible = MutableLiveData<Pair<Boolean, Boolean>>()
-    val navigationVisible: LiveData<Pair<Boolean, Boolean>> get() = _navigationVisible
+    val navigationVisible: StateFlow<Pair<Boolean, Boolean>> get() = _navigationVisible
+    private val _navigationVisible = MutableStateFlow(Pair(false, false))
 
-    private val _statusBarShadeVisible = MutableLiveData(true)
-    val statusBarShadeVisible: LiveData<Boolean> get() = _statusBarShadeVisible
+    val statusBarShadeVisible: StateFlow<Boolean> get() = _statusBarShadeVisible
+    private val _statusBarShadeVisible = MutableStateFlow(true)
 
-    private val _shouldPageForward = MutableLiveData(false)
-    val shouldPageForward: LiveData<Boolean> get() = _shouldPageForward
+    val shouldPageForward: StateFlow<Boolean> get() = _shouldPageForward
+    private val _shouldPageForward = MutableStateFlow(false)
 
-    private val _gamesDir = MutableLiveData(
+    val gamesDir: StateFlow<String> get() = _gamesDir
+    private val _gamesDir = MutableStateFlow(
         Uri.parse(
             PreferenceManager.getDefaultSharedPreferences(YuzuApplication.appContext)
                 .getString(GameHelper.KEY_GAME_PATH, "")
         ).path ?: ""
     )
-    val gamesDir: LiveData<String> get() = _gamesDir
 
     var navigatedToSetup = false
 
-    init {
-        _navigationVisible.value = Pair(false, false)
-    }
-
     fun setNavigationVisibility(visible: Boolean, animated: Boolean) {
-        if (_navigationVisible.value?.first == visible) {
+        if (navigationVisible.value.first == visible) {
             return
         }
         _navigationVisible.value = Pair(visible, animated)
     }
 
     fun setStatusBarShadeVisibility(visible: Boolean) {
-        if (_statusBarShadeVisible.value == visible) {
+        if (statusBarShadeVisible.value == visible) {
             return
         }
         _statusBarShadeVisible.value = visible

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

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package org.yuzu.yuzu_emu.model
+
+import androidx.lifecycle.ViewModel
+
+class MessageDialogViewModel : ViewModel() {
+    var dismissAction: () -> Unit = {}
+
+    fun clear() {
+        dismissAction = {}
+    }
+}

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

@@ -3,48 +3,43 @@
 
 package org.yuzu.yuzu_emu.model
 
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
-import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.features.settings.model.view.SettingsItem
 
-class SettingsViewModel(private val savedStateHandle: SavedStateHandle) : ViewModel() {
+class SettingsViewModel : ViewModel() {
     var game: Game? = null
 
     var shouldSave = false
 
     var clickedItem: SettingsItem? = null
 
-    private val _toolbarTitle = MutableLiveData("")
-    val toolbarTitle: LiveData<String> get() = _toolbarTitle
+    val shouldRecreate: StateFlow<Boolean> get() = _shouldRecreate
+    private val _shouldRecreate = MutableStateFlow(false)
 
-    private val _shouldRecreate = MutableLiveData(false)
-    val shouldRecreate: LiveData<Boolean> get() = _shouldRecreate
+    val shouldNavigateBack: StateFlow<Boolean> get() = _shouldNavigateBack
+    private val _shouldNavigateBack = MutableStateFlow(false)
 
-    private val _shouldNavigateBack = MutableLiveData(false)
-    val shouldNavigateBack: LiveData<Boolean> get() = _shouldNavigateBack
+    val shouldShowResetSettingsDialog: StateFlow<Boolean> get() = _shouldShowResetSettingsDialog
+    private val _shouldShowResetSettingsDialog = MutableStateFlow(false)
 
-    private val _shouldShowResetSettingsDialog = MutableLiveData(false)
-    val shouldShowResetSettingsDialog: LiveData<Boolean> get() = _shouldShowResetSettingsDialog
+    val shouldReloadSettingsList: StateFlow<Boolean> get() = _shouldReloadSettingsList
+    private val _shouldReloadSettingsList = MutableStateFlow(false)
 
-    private val _shouldReloadSettingsList = MutableLiveData(false)
-    val shouldReloadSettingsList: LiveData<Boolean> get() = _shouldReloadSettingsList
+    val isUsingSearch: StateFlow<Boolean> get() = _isUsingSearch
+    private val _isUsingSearch = MutableStateFlow(false)
 
-    private val _isUsingSearch = MutableLiveData(false)
-    val isUsingSearch: LiveData<Boolean> get() = _isUsingSearch
+    val sliderProgress: StateFlow<Int> get() = _sliderProgress
+    private val _sliderProgress = MutableStateFlow(-1)
 
-    val sliderProgress = savedStateHandle.getStateFlow(KEY_SLIDER_PROGRESS, -1)
+    val sliderTextValue: StateFlow<String> get() = _sliderTextValue
+    private val _sliderTextValue = MutableStateFlow("")
 
-    val sliderTextValue = savedStateHandle.getStateFlow(KEY_SLIDER_TEXT_VALUE, "")
-
-    val adapterItemChanged = savedStateHandle.getStateFlow(KEY_ADAPTER_ITEM_CHANGED, -1)
-
-    fun setToolbarTitle(value: String) {
-        _toolbarTitle.value = value
-    }
+    val adapterItemChanged: StateFlow<Int> get() = _adapterItemChanged
+    private val _adapterItemChanged = MutableStateFlow(-1)
 
     fun setShouldRecreate(value: Boolean) {
         _shouldRecreate.value = value
@@ -67,8 +62,8 @@ class SettingsViewModel(private val savedStateHandle: SavedStateHandle) : ViewMo
     }
 
     fun setSliderTextValue(value: Float, units: String) {
-        savedStateHandle[KEY_SLIDER_PROGRESS] = value
-        savedStateHandle[KEY_SLIDER_TEXT_VALUE] = String.format(
+        _sliderProgress.value = value.toInt()
+        _sliderTextValue.value = String.format(
             YuzuApplication.appContext.getString(R.string.value_with_units),
             value.toInt().toString(),
             units
@@ -76,21 +71,15 @@ class SettingsViewModel(private val savedStateHandle: SavedStateHandle) : ViewMo
     }
 
     fun setSliderProgress(value: Float) {
-        savedStateHandle[KEY_SLIDER_PROGRESS] = value
+        _sliderProgress.value = value.toInt()
     }
 
     fun setAdapterItemChanged(value: Int) {
-        savedStateHandle[KEY_ADAPTER_ITEM_CHANGED] = value
+        _adapterItemChanged.value = value
     }
 
     fun clear() {
         game = null
         shouldSave = false
     }
-
-    companion object {
-        const val KEY_SLIDER_TEXT_VALUE = "SliderTextValue"
-        const val KEY_SLIDER_PROGRESS = "SliderProgress"
-        const val KEY_ADAPTER_ITEM_CHANGED = "AdapterItemChanged"
-    }
 }

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

@@ -3,45 +3,50 @@
 
 package org.yuzu.yuzu_emu.model
 
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 
 class TaskViewModel : ViewModel() {
-    private val _result = MutableLiveData<Any>()
-    val result: LiveData<Any> = _result
+    val result: StateFlow<Any> get() = _result
+    private val _result = MutableStateFlow(Any())
 
-    private val _isComplete = MutableLiveData<Boolean>()
-    val isComplete: LiveData<Boolean> = _isComplete
+    val isComplete: StateFlow<Boolean> get() = _isComplete
+    private val _isComplete = MutableStateFlow(false)
 
-    private val _isRunning = MutableLiveData<Boolean>()
-    val isRunning: LiveData<Boolean> = _isRunning
+    val isRunning: StateFlow<Boolean> get() = _isRunning
+    private val _isRunning = MutableStateFlow(false)
+
+    val cancelled: StateFlow<Boolean> get() = _cancelled
+    private val _cancelled = MutableStateFlow(false)
 
     lateinit var task: () -> Any
 
-    init {
-        clear()
-    }
-
     fun clear() {
         _result.value = Any()
         _isComplete.value = false
         _isRunning.value = false
+        _cancelled.value = false
+    }
+
+    fun setCancelled(value: Boolean) {
+        _cancelled.value = value
     }
 
     fun runTask() {
-        if (_isRunning.value == true) {
+        if (isRunning.value) {
             return
         }
         _isRunning.value = true
 
         viewModelScope.launch(Dispatchers.IO) {
             val res = task()
-            _result.postValue(res)
-            _isComplete.postValue(true)
+            _result.value = res
+            _isComplete.value = true
+            _isRunning.value = false
         }
     }
 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/GamesFragment.kt

@@ -3,6 +3,7 @@
 
 package org.yuzu.yuzu_emu.ui
 
+import android.annotation.SuppressLint
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -14,8 +15,12 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import com.google.android.material.color.MaterialColors
 import com.google.android.material.transition.MaterialFadeThrough
+import kotlinx.coroutines.launch
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.adapters.GameAdapter
 import org.yuzu.yuzu_emu.databinding.FragmentGamesBinding
@@ -44,6 +49,8 @@ class GamesFragment : Fragment() {
         return binding.root
     }
 
+    // This is using the correct scope, lint is just acting up
+    @SuppressLint("UnsafeRepeatOnLifecycleDetector")
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         homeViewModel.setNavigationVisibility(visible = true, animated = false)
 
@@ -80,37 +87,48 @@ class GamesFragment : Fragment() {
                 if (_binding == null) {
                     return@post
                 }
-                binding.swipeRefresh.isRefreshing = gamesViewModel.isReloading.value!!
+                binding.swipeRefresh.isRefreshing = gamesViewModel.isReloading.value
             }
         }
 
-        gamesViewModel.apply {
-            // Watch for when we get updates to any of our games lists
-            isReloading.observe(viewLifecycleOwner) { isReloading ->
-                binding.swipeRefresh.isRefreshing = isReloading
-            }
-            games.observe(viewLifecycleOwner) {
-                (binding.gridGames.adapter as GameAdapter).submitList(it)
-                if (it.isEmpty()) {
-                    binding.noticeText.visibility = View.VISIBLE
-                } else {
-                    binding.noticeText.visibility = View.GONE
+        viewLifecycleOwner.lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                    gamesViewModel.isReloading.collect { binding.swipeRefresh.isRefreshing = it }
                 }
             }
-            shouldSwapData.observe(viewLifecycleOwner) { shouldSwapData ->
-                if (shouldSwapData) {
-                    (binding.gridGames.adapter as GameAdapter).submitList(
-                        gamesViewModel.games.value!!
-                    )
-                    gamesViewModel.setShouldSwapData(false)
+            launch {
+                repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                    gamesViewModel.games.collect {
+                        (binding.gridGames.adapter as GameAdapter).submitList(it)
+                        if (it.isEmpty()) {
+                            binding.noticeText.visibility = View.VISIBLE
+                        } else {
+                            binding.noticeText.visibility = View.GONE
+                        }
+                    }
                 }
             }
-
-            // Check if the user reselected the games menu item and then scroll to top of the list
-            shouldScrollToTop.observe(viewLifecycleOwner) { shouldScroll ->
-                if (shouldScroll) {
-                    scrollToTop()
-                    gamesViewModel.setShouldScrollToTop(false)
+            launch {
+                repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                    gamesViewModel.shouldSwapData.collect {
+                        if (it) {
+                            (binding.gridGames.adapter as GameAdapter).submitList(
+                                gamesViewModel.games.value
+                            )
+                            gamesViewModel.setShouldSwapData(false)
+                        }
+                    }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                    gamesViewModel.shouldScrollToTop.collect {
+                        if (it) {
+                            scrollToTop()
+                            gamesViewModel.setShouldScrollToTop(false)
+                        }
+                    }
                 }
             }
         }

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/main/MainActivity.kt

@@ -19,7 +19,9 @@ import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
+import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import androidx.navigation.NavController
 import androidx.navigation.fragment.NavHostFragment
 import androidx.navigation.ui.setupWithNavController
@@ -40,18 +42,25 @@ import org.yuzu.yuzu_emu.activities.EmulationActivity
 import org.yuzu.yuzu_emu.databinding.ActivityMainBinding
 import org.yuzu.yuzu_emu.databinding.DialogProgressBarBinding
 import org.yuzu.yuzu_emu.features.settings.model.Settings
-import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
 import org.yuzu.yuzu_emu.fragments.IndeterminateProgressDialogFragment
 import org.yuzu.yuzu_emu.fragments.MessageDialogFragment
 import org.yuzu.yuzu_emu.model.GamesViewModel
 import org.yuzu.yuzu_emu.model.HomeViewModel
+import org.yuzu.yuzu_emu.model.TaskViewModel
 import org.yuzu.yuzu_emu.utils.*
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
 
 class MainActivity : AppCompatActivity(), ThemeProvider {
     private lateinit var binding: ActivityMainBinding
 
     private val homeViewModel: HomeViewModel by viewModels()
     private val gamesViewModel: GamesViewModel by viewModels()
+    private val taskViewModel: TaskViewModel by viewModels()
 
     override var themeId: Int = 0
 
@@ -107,7 +116,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                 R.id.homeSettingsFragment -> {
                     val action = HomeNavigationDirections.actionGlobalSettingsActivity(
                         null,
-                        SettingsFile.FILE_NAME_CONFIG
+                        Settings.MenuTag.SECTION_ROOT
                     )
                     navHostFragment.navController.navigate(action)
                 }
@@ -115,16 +124,22 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
         }
 
         // Prevents navigation from being drawn for a short time on recreation if set to hidden
-        if (!homeViewModel.navigationVisible.value?.first!!) {
+        if (!homeViewModel.navigationVisible.value.first) {
             binding.navigationView.visibility = View.INVISIBLE
             binding.statusBarShade.visibility = View.INVISIBLE
         }
 
-        homeViewModel.navigationVisible.observe(this) {
-            showNavigation(it.first, it.second)
-        }
-        homeViewModel.statusBarShadeVisible.observe(this) { visible ->
-            showStatusBarShade(visible)
+        lifecycleScope.apply {
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    homeViewModel.navigationVisible.collect { showNavigation(it.first, it.second) }
+                }
+            }
+            launch {
+                repeatOnLifecycle(Lifecycle.State.CREATED) {
+                    homeViewModel.statusBarShadeVisible.collect { showStatusBarShade(it) }
+                }
+            }
         }
 
         // Dismiss previous notifications (should not happen unless a crash occurred)
@@ -300,6 +315,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
     fun processKey(result: Uri): Boolean {
         if (FileUtil.getExtension(result) != "keys") {
             MessageDialogFragment.newInstance(
+                this,
                 titleId = R.string.reading_keys_failure,
                 descriptionId = R.string.install_prod_keys_failure_extension_description
             ).show(supportFragmentManager, MessageDialogFragment.TAG)
@@ -329,6 +345,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                 return true
             } else {
                 MessageDialogFragment.newInstance(
+                    this,
                     titleId = R.string.invalid_keys_error,
                     descriptionId = R.string.install_keys_failure_description,
                     helpLinkId = R.string.dumping_keys_quickstart_link
@@ -369,6 +386,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     val filteredNumOfFiles = cacheFirmwareDir.list(filterNCA)?.size ?: -2
                     messageToShow = if (unfilteredNumOfFiles != filteredNumOfFiles) {
                         MessageDialogFragment.newInstance(
+                            this,
                             titleId = R.string.firmware_installed_failure,
                             descriptionId = R.string.firmware_installed_failure_description
                         )
@@ -388,7 +406,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             IndeterminateProgressDialogFragment.newInstance(
                 this,
                 R.string.firmware_installing,
-                task
+                task = task
             ).show(supportFragmentManager, IndeterminateProgressDialogFragment.TAG)
         }
 
@@ -400,6 +418,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
             if (FileUtil.getExtension(result) != "bin") {
                 MessageDialogFragment.newInstance(
+                    this,
                     titleId = R.string.reading_keys_failure,
                     descriptionId = R.string.install_amiibo_keys_failure_extension_description
                 ).show(supportFragmentManager, MessageDialogFragment.TAG)
@@ -427,6 +446,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     ).show()
                 } else {
                     MessageDialogFragment.newInstance(
+                        this,
                         titleId = R.string.invalid_keys_error,
                         descriptionId = R.string.install_keys_failure_description,
                         helpLinkId = R.string.dumping_keys_quickstart_link
@@ -576,12 +596,14 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                         installResult.append(separator)
                     }
                     return@newInstance MessageDialogFragment.newInstance(
+                        this,
                         titleId = R.string.install_game_content_failure,
                         descriptionString = installResult.toString().trim(),
                         helpLinkId = R.string.install_game_content_help_link
                     )
                 } else {
                     return@newInstance MessageDialogFragment.newInstance(
+                        this,
                         titleId = R.string.install_game_content_success,
                         descriptionString = installResult.toString().trim()
                     )
@@ -589,4 +611,111 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             }.show(supportFragmentManager, IndeterminateProgressDialogFragment.TAG)
         }
     }
+
+    val exportUserData = registerForActivityResult(
+        ActivityResultContracts.CreateDocument("application/zip")
+    ) { result ->
+        if (result == null) {
+            return@registerForActivityResult
+        }
+
+        IndeterminateProgressDialogFragment.newInstance(
+            this,
+            R.string.exporting_user_data,
+            true
+        ) {
+            val zos = ZipOutputStream(
+                BufferedOutputStream(contentResolver.openOutputStream(result))
+            )
+            zos.use { stream ->
+                File(DirectoryInitialization.userDirectory!!).walkTopDown().forEach { file ->
+                    if (taskViewModel.cancelled.value) {
+                        return@newInstance R.string.user_data_export_cancelled
+                    }
+
+                    if (!file.isDirectory) {
+                        val newPath = file.path.substring(
+                            DirectoryInitialization.userDirectory!!.length,
+                            file.path.length
+                        )
+                        stream.putNextEntry(ZipEntry(newPath))
+                        stream.write(file.readBytes())
+                        stream.closeEntry()
+                    }
+                }
+            }
+            return@newInstance getString(R.string.user_data_export_success)
+        }.show(supportFragmentManager, IndeterminateProgressDialogFragment.TAG)
+    }
+
+    val importUserData =
+        registerForActivityResult(ActivityResultContracts.OpenDocument()) { result ->
+            if (result == null) {
+                return@registerForActivityResult
+            }
+
+            IndeterminateProgressDialogFragment.newInstance(
+                this,
+                R.string.importing_user_data
+            ) {
+                val checkStream =
+                    ZipInputStream(BufferedInputStream(contentResolver.openInputStream(result)))
+                var isYuzuBackup = false
+                checkStream.use { stream ->
+                    var ze: ZipEntry? = null
+                    while (stream.nextEntry?.also { ze = it } != null) {
+                        val itemName = ze!!.name.trim()
+                        if (itemName == "/config/config.ini" || itemName == "config/config.ini") {
+                            isYuzuBackup = true
+                            return@use
+                        }
+                    }
+                }
+                if (!isYuzuBackup) {
+                    return@newInstance getString(R.string.invalid_yuzu_backup)
+                }
+
+                File(DirectoryInitialization.userDirectory!!).deleteRecursively()
+
+                val zis =
+                    ZipInputStream(BufferedInputStream(contentResolver.openInputStream(result)))
+                val userDirectory = File(DirectoryInitialization.userDirectory!!)
+                val canonicalPath = userDirectory.canonicalPath + '/'
+                zis.use { stream ->
+                    var ze: ZipEntry? = stream.nextEntry
+                    while (ze != null) {
+                        val newFile = File(userDirectory, ze!!.name)
+                        val destinationDirectory =
+                            if (ze!!.isDirectory) newFile else newFile.parentFile
+
+                        if (!newFile.canonicalPath.startsWith(canonicalPath)) {
+                            throw SecurityException(
+                                "Zip file attempted path traversal! ${ze!!.name}"
+                            )
+                        }
+
+                        if (!destinationDirectory.isDirectory && !destinationDirectory.mkdirs()) {
+                            throw IOException("Failed to create directory $destinationDirectory")
+                        }
+
+                        if (!ze!!.isDirectory) {
+                            val buffer = ByteArray(8096)
+                            var read: Int
+                            BufferedOutputStream(FileOutputStream(newFile)).use { bos ->
+                                while (zis.read(buffer).also { read = it } != -1) {
+                                    bos.write(buffer, 0, read)
+                                }
+                            }
+                        }
+                        ze = stream.nextEntry
+                    }
+                }
+
+                // Reinitialize relevant data
+                NativeLibrary.initializeEmulation()
+                gamesViewModel.reloadGames(false)
+
+                return@newInstance getString(R.string.user_data_import_success)
+            }.show(supportFragmentManager, IndeterminateProgressDialogFragment.TAG)
+        }
 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameIconUtils.kt

@@ -6,9 +6,11 @@ package org.yuzu.yuzu_emu.utils
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.widget.ImageView
+import androidx.core.graphics.drawable.toBitmap
 import androidx.core.graphics.drawable.toDrawable
 import coil.ImageLoader
 import coil.decode.DataSource
+import coil.executeBlocking
 import coil.fetch.DrawableResult
 import coil.fetch.FetchResult
 import coil.fetch.Fetcher
@@ -74,4 +76,13 @@ object GameIconUtils {
             .build()
         imageLoader.enqueue(request)
     }
+
+    fun getGameIcon(game: Game): Bitmap {
+        val request = ImageRequest.Builder(YuzuApplication.appContext)
+            .data(game)
+            .error(R.drawable.default_icon)
+            .build()
+        return imageLoader.executeBlocking(request)
+            .drawable!!.toBitmap(config = Bitmap.Config.ARGB_8888)
+    }
 }

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

@@ -282,7 +282,7 @@ void Config::ReadValues() {
     std::stringstream ss(title_list);
     std::string line;
     while (std::getline(ss, line, '|')) {
-        const auto title_id = std::stoul(line, nullptr, 16);
+        const auto title_id = std::strtoul(line.c_str(), nullptr, 16);
         const auto disabled_list = config->Get("AddOns", "disabled_" + line, "");
 
         std::stringstream inner_ss(disabled_list);

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

@@ -11,6 +11,12 @@
 #include "jni/emu_window/emu_window.h"
 
 void EmuWindow_Android::OnSurfaceChanged(ANativeWindow* surface) {
+    m_window_width = ANativeWindow_getWidth(surface);
+    m_window_height = ANativeWindow_getHeight(surface);
+
+    // Ensures that we emulate with the correct aspect ratio.
+    UpdateCurrentFramebufferLayout(m_window_width, m_window_height);
+
     window_info.render_surface = reinterpret_cast<void*>(surface);
 }
 
@@ -62,14 +68,8 @@ EmuWindow_Android::EmuWindow_Android(InputCommon::InputSubsystem* input_subsyste
         return;
     }
 
-    m_window_width = ANativeWindow_getWidth(surface);
-    m_window_height = ANativeWindow_getHeight(surface);
-
-    // Ensures that we emulate with the correct aspect ratio.
-    UpdateCurrentFramebufferLayout(m_window_width, m_window_height);
-
+    OnSurfaceChanged(surface);
     window_info.type = Core::Frontend::WindowSystemType::Android;
-    window_info.render_surface = reinterpret_cast<void*>(surface);
 
     m_input_subsystem->Initialize();
 }

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

@@ -262,14 +262,12 @@ public:
     Core::SystemResultStatus InitializeEmulation(const std::string& filepath) {
         std::scoped_lock lock(m_mutex);
 
-        // Loads the configuration.
-        Config{};
-
         // Create the render window.
         m_window = std::make_unique<EmuWindow_Android>(&m_input_subsystem, m_native_window,
                                                        m_vulkan_library);
 
         m_system.SetFilesystem(m_vfs);
+        m_system.GetUserChannel().clear();
 
         // Initialize system.
         jauto android_keyboard = std::make_unique<SoftwareKeyboard::AndroidKeyboard>();
@@ -329,12 +327,13 @@ public:
             m_system.ShutdownMainProcess();
             m_detached_tasks.WaitForAllTasks();
             m_load_result = Core::SystemResultStatus::ErrorNotInitialized;
+            m_window.reset();
+            OnEmulationStopped(Core::SystemResultStatus::Success);
+            return;
         }
 
         // Tear down the render window.
         m_window.reset();
-
-        OnEmulationStopped(m_load_result);
     }
 
     void PauseEmulation() {
@@ -671,18 +670,6 @@ jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isPaused(JNIEnv* env, jclass claz
     return static_cast<jboolean>(EmulationSession::GetInstance().IsPaused());
 }
 
-void Java_org_yuzu_yuzu_1emu_NativeLibrary_muteAduio(JNIEnv* env, jclass clazz) {
-    Settings::values.audio_muted = true;
-}
-
-void Java_org_yuzu_yuzu_1emu_NativeLibrary_unmuteAudio(JNIEnv* env, jclass clazz) {
-    Settings::values.audio_muted = false;
-}
-
-jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isMuted(JNIEnv* env, jclass clazz) {
-    return static_cast<jboolean>(Settings::values.audio_muted.GetValue());
-}
-
 jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isHandheldOnly(JNIEnv* env, jclass clazz) {
     return EmulationSession::GetInstance().IsHandheldOnly();
 }

src/android/app/src/main/res/drawable/ic_export.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M9,16h6v-6h4l-7,-7 -7,7h4zM5,18h14v2L5,20z" />
+</vector>

src/android/app/src/main/res/drawable/ic_import.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M19,9h-4V3H9v6H5l7,7 7,-7zM5,18v2h14v-2H5z" />
+</vector>

src/android/app/src/main/res/drawable/shortcut.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item>
+        <color android:color="@android:color/white" />
+    </item>
+    <item android:id="@+id/shortcut_foreground">
+        <bitmap android:src="@drawable/default_icon" />
+    </item>
+
+</layer-list>

src/android/app/src/main/res/layout/dialog_progress_bar.xml

@@ -1,24 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
+<com.google.android.material.progressindicator.LinearProgressIndicator xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:orientation="vertical">
-
-    <com.google.android.material.progressindicator.LinearProgressIndicator
-        android:id="@+id/progress_bar"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_margin="24dp"
-        app:trackCornerRadius="4dp" />
-
-    <TextView
-        android:id="@+id/progress_text"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:layout_marginLeft="24dp"
-        android:layout_marginRight="24dp"
-        android:layout_marginBottom="24dp"
-        android:gravity="end" />
-
-</LinearLayout>
+    android:id="@+id/progress_bar"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:padding="24dp"
+    app:trackCornerRadius="4dp" />

src/android/app/src/main/res/layout/fragment_about.xml

@@ -176,6 +176,67 @@
 
             </LinearLayout>
 
+            <com.google.android.material.divider.MaterialDivider
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginHorizontal="20dp" />
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal">
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:paddingVertical="16dp"
+                    android:paddingHorizontal="16dp"
+                    android:orientation="vertical"
+                    android:layout_weight="1">
+
+                    <com.google.android.material.textview.MaterialTextView
+                        style="@style/TextAppearance.Material3.TitleMedium"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginHorizontal="24dp"
+                        android:textAlignment="viewStart"
+                        android:text="@string/user_data" />
+
+                    <com.google.android.material.textview.MaterialTextView
+                        style="@style/TextAppearance.Material3.BodyMedium"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginHorizontal="24dp"
+                        android:layout_marginTop="6dp"
+                        android:textAlignment="viewStart"
+                        android:text="@string/user_data_description" />
+
+                </LinearLayout>
+
+                <Button
+                    android:id="@+id/button_import"
+                    style="@style/Widget.Material3.Button.IconButton.Filled.Tonal"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_gravity="center_vertical"
+                    android:contentDescription="@string/string_import"
+                    android:tooltipText="@string/string_import"
+                    app:icon="@drawable/ic_import" />
+
+                <Button
+                    android:id="@+id/button_export"
+                    style="@style/Widget.Material3.Button.IconButton.Filled.Tonal"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginStart="12dp"
+                    android:layout_marginEnd="24dp"
+                    android:layout_gravity="center_vertical"
+                    android:contentDescription="@string/export"
+                    android:tooltipText="@string/export"
+                    app:icon="@drawable/ic_export" />
+
+            </LinearLayout>
+
             <com.google.android.material.divider.MaterialDivider
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"

src/android/app/src/main/res/navigation/emulation_navigation.xml

@@ -27,7 +27,7 @@
             app:nullable="true" />
         <argument
             android:name="menuTag"
-            app:argType="string" />
+            app:argType="org.yuzu.yuzu_emu.features.settings.model.Settings$MenuTag" />
     </activity>
 
     <action

src/android/app/src/main/res/navigation/home_navigation.xml

@@ -82,7 +82,7 @@
             app:nullable="true" />
         <argument
             android:name="menuTag"
-            app:argType="string" />
+            app:argType="org.yuzu.yuzu_emu.features.settings.model.Settings$MenuTag" />
     </activity>
 
     <action

src/android/app/src/main/res/navigation/settings_navigation.xml

@@ -10,7 +10,7 @@
         android:label="SettingsFragment">
         <argument
             android:name="menuTag"
-            app:argType="string" />
+            app:argType="org.yuzu.yuzu_emu.features.settings.model.Settings$MenuTag" />
         <argument
             android:name="game"
             app:argType="org.yuzu.yuzu_emu.model.Game"

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

@@ -12,6 +12,7 @@
     <dimen name="spacing_refresh_end">72dp</dimen>
     <dimen name="menu_width">256dp</dimen>
     <dimen name="card_width">165dp</dimen>
+    <dimen name="icon_inset">24dp</dimen>
 
     <dimen name="dialog_margin">20dp</dimen>
     <dimen name="elevated_app_bar">3dp</dimen>

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

@@ -128,6 +128,15 @@
     <string name="contributors_link">https://github.com/yuzu-emu/yuzu/graphs/contributors</string>
     <string name="licenses_description">Projects that make yuzu for Android possible</string>
     <string name="build">Build</string>
+    <string name="user_data">User data</string>
+    <string name="user_data_description">Import/export all app data.\n\nWhen importing user data, all existing user data will be deleted!</string>
+    <string name="exporting_user_data">Exporting user data…</string>
+    <string name="importing_user_data">Importing user data…</string>
+    <string name="import_user_data">Import user data</string>
+    <string name="invalid_yuzu_backup">Invalid yuzu backup</string>
+    <string name="user_data_export_success">User data exported successfully</string>
+    <string name="user_data_import_success">User data imported successfully</string>
+    <string name="user_data_export_cancelled">Export cancelled</string>
     <string name="support_link">https://discord.gg/u77vRWY</string>
     <string name="website_link">https://yuzu-emu.org/</string>
     <string name="github_link">https://github.com/yuzu-emu</string>
@@ -215,6 +224,9 @@
     <string name="auto">Auto</string>
     <string name="submit">Submit</string>
     <string name="string_null">Null</string>
+    <string name="string_import">Import</string>
+    <string name="export">Export</string>
+    <string name="cancelling">Cancelling</string>
 
     <!-- GPU driver installation -->
     <string name="select_gpu_driver">Select GPU driver</string>

src/audio_core/CMakeLists.txt

@@ -10,6 +10,13 @@ add_library(audio_core STATIC
     adsp/apps/audio_renderer/command_buffer.h
     adsp/apps/audio_renderer/command_list_processor.cpp
     adsp/apps/audio_renderer/command_list_processor.h
+    adsp/apps/opus/opus_decoder.cpp
+    adsp/apps/opus/opus_decoder.h
+    adsp/apps/opus/opus_decode_object.cpp
+    adsp/apps/opus/opus_decode_object.h
+    adsp/apps/opus/opus_multistream_decode_object.cpp
+    adsp/apps/opus/opus_multistream_decode_object.h
+    adsp/apps/opus/shared_memory.h
     audio_core.cpp
     audio_core.h
     audio_event.h
@@ -35,6 +42,13 @@ add_library(audio_core STATIC
     in/audio_in.h
     in/audio_in_system.cpp
     in/audio_in_system.h
+    opus/hardware_opus.cpp
+    opus/hardware_opus.h
+    opus/decoder_manager.cpp
+    opus/decoder_manager.h
+    opus/decoder.cpp
+    opus/decoder.h
+    opus/parameters.h
     out/audio_out.cpp
     out/audio_out.h
     out/audio_out_system.cpp
@@ -214,7 +228,7 @@ else()
     )
 endif()
 
-target_link_libraries(audio_core PUBLIC common core)
+target_link_libraries(audio_core PUBLIC common core Opus::opus)
 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
     target_link_libraries(audio_core PRIVATE dynarmic::dynarmic)
 endif()

src/audio_core/adsp/adsp.cpp

@@ -7,12 +7,21 @@
 namespace AudioCore::ADSP {
 
 ADSP::ADSP(Core::System& system, Sink::Sink& sink) {
-    audio_renderer =
-        std::make_unique<AudioRenderer::AudioRenderer>(system, system.ApplicationMemory(), sink);
+    audio_renderer = std::make_unique<AudioRenderer::AudioRenderer>(system, sink);
+    opus_decoder = std::make_unique<OpusDecoder::OpusDecoder>(system);
+    opus_decoder->Send(Direction::DSP, OpusDecoder::Message::Start);
+    if (opus_decoder->Receive(Direction::Host) != OpusDecoder::Message::StartOK) {
+        LOG_ERROR(Service_Audio, "OpusDeocder failed to initialize.");
+        return;
+    }
 }
 
 AudioRenderer::AudioRenderer& ADSP::AudioRenderer() {
     return *audio_renderer.get();
 }
 
+OpusDecoder::OpusDecoder& ADSP::OpusDecoder() {
+    return *opus_decoder.get();
+}
+
 } // namespace AudioCore::ADSP

src/audio_core/adsp/adsp.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "audio_core/adsp/apps/audio_renderer/audio_renderer.h"
+#include "audio_core/adsp/apps/opus/opus_decoder.h"
 #include "common/common_types.h"
 
 namespace Core {
@@ -40,10 +41,12 @@ public:
     ~ADSP() = default;
 
     AudioRenderer::AudioRenderer& AudioRenderer();
+    OpusDecoder::OpusDecoder& OpusDecoder();
 
 private:
     /// AudioRenderer app
     std::unique_ptr<AudioRenderer::AudioRenderer> audio_renderer{};
+    std::unique_ptr<OpusDecoder::OpusDecoder> opus_decoder{};
 };
 
 } // namespace ADSP

src/audio_core/adsp/apps/audio_renderer/audio_renderer.cpp

@@ -14,13 +14,12 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 
-MICROPROFILE_DEFINE(Audio_Renderer, "Audio", "DSP", MP_RGB(60, 19, 97));
+MICROPROFILE_DEFINE(Audio_Renderer, "Audio", "DSP_AudioRenderer", MP_RGB(60, 19, 97));
 
 namespace AudioCore::ADSP::AudioRenderer {
 
-AudioRenderer::AudioRenderer(Core::System& system_, Core::Memory::Memory& memory_,
-                             Sink::Sink& sink_)
-    : system{system_}, memory{memory_}, sink{sink_} {}
+AudioRenderer::AudioRenderer(Core::System& system_, Sink::Sink& sink_)
+    : system{system_}, sink{sink_} {}
 
 AudioRenderer::~AudioRenderer() {
     Stop();
@@ -33,8 +32,8 @@ void AudioRenderer::Start() {
 
     main_thread = std::jthread([this](std::stop_token stop_token) { Main(stop_token); });
 
-    mailbox.Send(Direction::DSP, {Message::InitializeOK, {}});
-    if (mailbox.Receive(Direction::Host).msg != Message::InitializeOK) {
+    mailbox.Send(Direction::DSP, Message::InitializeOK);
+    if (mailbox.Receive(Direction::Host) != Message::InitializeOK) {
         LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown "
                                  "message response from ADSP!");
         return;
@@ -47,8 +46,8 @@ void AudioRenderer::Stop() {
         return;
     }
 
-    mailbox.Send(Direction::DSP, {Message::Shutdown, {}});
-    if (mailbox.Receive(Direction::Host).msg != Message::Shutdown) {
+    mailbox.Send(Direction::DSP, Message::Shutdown);
+    if (mailbox.Receive(Direction::Host) != Message::Shutdown) {
         LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown "
                                  "message response from ADSP!");
     }
@@ -67,29 +66,34 @@ void AudioRenderer::Stop() {
 
 void AudioRenderer::Signal() {
     signalled_tick = system.CoreTiming().GetGlobalTimeNs().count();
-    Send(Direction::DSP, {Message::Render, {}});
+    Send(Direction::DSP, Message::Render);
 }
 
 void AudioRenderer::Wait() {
-    auto received = Receive(Direction::Host);
-    if (received.msg != Message::RenderResponse) {
+    auto msg = Receive(Direction::Host);
+    if (msg != Message::RenderResponse) {
         LOG_ERROR(Service_Audio,
                   "Did not receive the expected render response from the AudioRenderer! Expected "
                   "{}, got {}",
-                  Message::RenderResponse, received.msg);
+                  Message::RenderResponse, msg);
     }
 }
 
-void AudioRenderer::Send(Direction dir, MailboxMessage message) {
+void AudioRenderer::Send(Direction dir, u32 message) {
     mailbox.Send(dir, std::move(message));
 }
 
-MailboxMessage AudioRenderer::Receive(Direction dir, bool block) {
-    return mailbox.Receive(dir, block);
+u32 AudioRenderer::Receive(Direction dir) {
+    return mailbox.Receive(dir);
 }
 
-void AudioRenderer::SetCommandBuffer(s32 session_id, CommandBuffer& buffer) noexcept {
-    command_buffers[session_id] = buffer;
+void AudioRenderer::SetCommandBuffer(s32 session_id, CpuAddr buffer, u64 size, u64 time_limit,
+                                     u64 applet_resource_user_id, bool reset) noexcept {
+    command_buffers[session_id].buffer = buffer;
+    command_buffers[session_id].size = size;
+    command_buffers[session_id].time_limit = time_limit;
+    command_buffers[session_id].applet_resource_user_id = applet_resource_user_id;
+    command_buffers[session_id].reset_buffer = reset;
 }
 
 u32 AudioRenderer::GetRemainCommandCount(s32 session_id) const noexcept {
@@ -115,7 +119,7 @@ void AudioRenderer::CreateSinkStreams() {
 }
 
 void AudioRenderer::Main(std::stop_token stop_token) {
-    static constexpr char name[]{"AudioRenderer"};
+    static constexpr char name[]{"DSP_AudioRenderer_Main"};
     MicroProfileOnThreadCreate(name);
     Common::SetCurrentThreadName(name);
     Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
@@ -123,28 +127,28 @@ void AudioRenderer::Main(std::stop_token stop_token) {
     // TODO: Create buffer map/unmap thread + mailbox
     // TODO: Create gMix devices, initialize them here
 
-    if (mailbox.Receive(Direction::DSP).msg != Message::InitializeOK) {
+    if (mailbox.Receive(Direction::DSP) != Message::InitializeOK) {
         LOG_ERROR(Service_Audio,
                   "ADSP Audio Renderer -- Failed to receive initialize message from host!");
         return;
     }
 
-    mailbox.Send(Direction::Host, {Message::InitializeOK, {}});
+    mailbox.Send(Direction::Host, Message::InitializeOK);
 
     // 0.12 seconds (2,304,000 / 19,200,000)
     constexpr u64 max_process_time{2'304'000ULL};
 
     while (!stop_token.stop_requested()) {
-        auto received{mailbox.Receive(Direction::DSP)};
-        switch (received.msg) {
+        auto msg{mailbox.Receive(Direction::DSP)};
+        switch (msg) {
         case Message::Shutdown:
-            mailbox.Send(Direction::Host, {Message::Shutdown, {}});
+            mailbox.Send(Direction::Host, Message::Shutdown);
             return;
 
         case Message::Render: {
             if (system.IsShuttingDown()) [[unlikely]] {
                 std::this_thread::sleep_for(std::chrono::milliseconds(5));
-                mailbox.Send(Direction::Host, {Message::RenderResponse, {}});
+                mailbox.Send(Direction::Host, Message::RenderResponse);
                 continue;
             }
             std::array<bool, MaxRendererSessions> buffers_reset{};
@@ -200,13 +204,12 @@ void AudioRenderer::Main(std::stop_token stop_token) {
                 }
             }
 
-            mailbox.Send(Direction::Host, {Message::RenderResponse, {}});
+            mailbox.Send(Direction::Host, Message::RenderResponse);
         } break;
 
         default:
             LOG_WARNING(Service_Audio,
-                        "ADSP AudioRenderer received an invalid message, msg={:02X}!",
-                        received.msg);
+                        "ADSP AudioRenderer received an invalid message, msg={:02X}!", msg);
             break;
         }
     }

src/audio_core/adsp/apps/audio_renderer/audio_renderer.h

@@ -17,13 +17,6 @@
 
 namespace Core {
 class System;
-namespace Timing {
-struct EventType;
-}
-namespace Memory {
-class Memory;
-}
-class System;
 } // namespace Core
 
 namespace AudioCore {
@@ -34,19 +27,19 @@ class Sink;
 namespace ADSP::AudioRenderer {
 
 enum Message : u32 {
-    Invalid = 0x00,
-    MapUnmap_Map = 0x01,
-    MapUnmap_MapResponse = 0x02,
-    MapUnmap_Unmap = 0x03,
-    MapUnmap_UnmapResponse = 0x04,
-    MapUnmap_InvalidateCache = 0x05,
-    MapUnmap_InvalidateCacheResponse = 0x06,
-    MapUnmap_Shutdown = 0x07,
-    MapUnmap_ShutdownResponse = 0x08,
-    InitializeOK = 0x16,
-    RenderResponse = 0x20,
-    Render = 0x2A,
-    Shutdown = 0x34,
+    Invalid = 0,
+    MapUnmap_Map = 1,
+    MapUnmap_MapResponse = 2,
+    MapUnmap_Unmap = 3,
+    MapUnmap_UnmapResponse = 4,
+    MapUnmap_InvalidateCache = 5,
+    MapUnmap_InvalidateCacheResponse = 6,
+    MapUnmap_Shutdown = 7,
+    MapUnmap_ShutdownResponse = 8,
+    InitializeOK = 22,
+    RenderResponse = 32,
+    Render = 42,
+    Shutdown = 52,
 };
 
 /**
@@ -54,7 +47,7 @@ enum Message : u32 {
  */
 class AudioRenderer {
 public:
-    explicit AudioRenderer(Core::System& system, Core::Memory::Memory& memory, Sink::Sink& sink);
+    explicit AudioRenderer(Core::System& system, Sink::Sink& sink);
     ~AudioRenderer();
 
     /**
@@ -72,10 +65,11 @@ public:
     void Signal();
     void Wait();
 
-    void Send(Direction dir, MailboxMessage message);
-    MailboxMessage Receive(Direction dir, bool block = true);
+    void Send(Direction dir, u32 message);
+    u32 Receive(Direction dir);
 
-    void SetCommandBuffer(s32 session_id, CommandBuffer& buffer) noexcept;
+    void SetCommandBuffer(s32 session_id, CpuAddr buffer, u64 size, u64 time_limit,
+                          u64 applet_resource_user_id, bool reset) noexcept;
     u32 GetRemainCommandCount(s32 session_id) const noexcept;
     void ClearRemainCommandCount(s32 session_id) noexcept;
     u64 GetRenderingStartTick(s32 session_id) const noexcept;
@@ -93,9 +87,7 @@ private:
 
     /// Core system
     Core::System& system;
-    /// Memory
-    Core::Memory::Memory& memory;
-    /// The output sink the AudioRenderer will use
+    /// The output sink the AudioRenderer will send samples to
     Sink::Sink& sink;
     /// The active mailbox
     Mailbox mailbox;
@@ -103,11 +95,13 @@ private:
     std::jthread main_thread{};
     /// The current state
     std::atomic<bool> running{};
+    /// Shared memory of input command buffers, set by host, read by DSP
     std::array<CommandBuffer, MaxRendererSessions> command_buffers{};
     /// The command lists to process
     std::array<CommandListProcessor, MaxRendererSessions> command_list_processors{};
     /// The streams which will receive the processed samples
     std::array<Sink::SinkStream*, MaxRendererSessions> streams{};
+    /// CPU Tick when the DSP was signalled to process, uses time rather than tick
     u64 signalled_tick{0};
 };
 

src/audio_core/adsp/apps/audio_renderer/command_list_processor.cpp

@@ -37,11 +37,6 @@ u32 CommandListProcessor::GetRemainingCommandCount() const {
     return command_count - processed_command_count;
 }
 
-void CommandListProcessor::SetBuffer(const CpuAddr buffer, const u64 size) {
-    commands = reinterpret_cast<u8*>(buffer + sizeof(Renderer::CommandListHeader));
-    commands_buffer_size = size;
-}
-
 Sink::SinkStream* CommandListProcessor::GetOutputSinkStream() const {
     return stream;
 }

src/audio_core/adsp/apps/audio_renderer/command_list_processor.h

@@ -56,14 +56,6 @@ public:
      */
     u32 GetRemainingCommandCount() const;
 
-    /**
-     * Set the command buffer.
-     *
-     * @param buffer - The buffer to use.
-     * @param size   - The size of the buffer.
-     */
-    void SetBuffer(CpuAddr buffer, u64 size);
-
     /**
      * Get the stream for this command list.
      *

src/audio_core/adsp/apps/opus/opus_decode_object.cpp

@@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "audio_core/adsp/apps/opus/opus_decode_object.h"
+#include "common/assert.h"
+
+namespace AudioCore::ADSP::OpusDecoder {
+namespace {
+bool IsValidChannelCount(u32 channel_count) {
+    return channel_count == 1 || channel_count == 2;
+}
+} // namespace
+
+u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
+    if (!IsValidChannelCount(channel_count)) {
+        return 0;
+    }
+    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
+}
+
+OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {
+    auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);
+    auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);
+
+    if (new_decoder->magic == DecodeObjectMagic) {
+        if (!new_decoder->initialized ||
+            (new_decoder->initialized && new_decoder->self == comparison)) {
+            new_decoder->state_valid = true;
+        }
+    } else {
+        new_decoder->initialized = false;
+        new_decoder->state_valid = true;
+    }
+    return *new_decoder;
+}
+
+s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
+    if (!state_valid) {
+        return OPUS_INVALID_STATE;
+    }
+
+    if (initialized) {
+        return OPUS_OK;
+    }
+
+    // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include
+    // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer
+    // provided.
+    // We could use _create and have libopus allocate it for us, but then we have to separately
+    // track which decoder is being used between this and multistream in order to call the correct
+    // destroy from the host side.
+    // This is a bit cringe, but is safe as these objects are only ever initialized inside the given
+    // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.
+    decoder = (LibOpusDecoder*)(this + 1);
+    s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);
+    if (ret == OPUS_OK) {
+        magic = DecodeObjectMagic;
+        initialized = true;
+        state_valid = true;
+        self = this;
+        final_range = 0;
+    }
+    return ret;
+}
+
+s32 OpusDecodeObject::Shutdown() {
+    if (!state_valid) {
+        return OPUS_INVALID_STATE;
+    }
+
+    if (initialized) {
+        magic = 0x0;
+        initialized = false;
+        state_valid = false;
+        self = nullptr;
+        final_range = 0;
+        decoder = nullptr;
+    }
+    return OPUS_OK;
+}
+
+s32 OpusDecodeObject::ResetDecoder() {
+    return opus_decoder_ctl(decoder, OPUS_RESET_STATE);
+}
+
+s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,
+                             u64 input_data, u64 input_data_size) {
+    ASSERT(initialized);
+    out_sample_count = 0;
+
+    if (!state_valid) {
+        return OPUS_INVALID_STATE;
+    }
+
+    auto ret_code_or_samples = opus_decode(
+        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
+        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
+
+    if (ret_code_or_samples < OPUS_OK) {
+        return ret_code_or_samples;
+    }
+
+    out_sample_count = ret_code_or_samples;
+    return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
+}
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_decode_object.h

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <opus.h>
+
+#include "common/common_types.h"
+
+namespace AudioCore::ADSP::OpusDecoder {
+using LibOpusDecoder = ::OpusDecoder;
+static constexpr u32 DecodeObjectMagic = 0xDEADBEEF;
+
+class OpusDecodeObject {
+public:
+    static u32 GetWorkBufferSize(u32 channel_count);
+    static OpusDecodeObject& Initialize(u64 buffer, u64 buffer2);
+
+    s32 InitializeDecoder(u32 sample_rate, u32 channel_count);
+    s32 Shutdown();
+    s32 ResetDecoder();
+    s32 Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data,
+               u64 input_data_size);
+    u32 GetFinalRange() const noexcept {
+        return final_range;
+    }
+
+private:
+    u32 magic;
+    bool initialized;
+    bool state_valid;
+    OpusDecodeObject* self;
+    u32 final_range;
+    LibOpusDecoder* decoder;
+};
+static_assert(std::is_trivially_constructible_v<OpusDecodeObject>);
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_decoder.cpp

@@ -0,0 +1,269 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <array>
+#include <chrono>
+
+#include "audio_core/adsp/apps/opus/opus_decode_object.h"
+#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
+#include "audio_core/adsp/apps/opus/shared_memory.h"
+#include "audio_core/audio_core.h"
+#include "audio_core/common/common.h"
+#include "common/logging/log.h"
+#include "common/microprofile.h"
+#include "common/thread.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+
+MICROPROFILE_DEFINE(OpusDecoder, "Audio", "DSP_OpusDecoder", MP_RGB(60, 19, 97));
+
+namespace AudioCore::ADSP::OpusDecoder {
+
+namespace {
+constexpr size_t OpusStreamCountMax = 255;
+
+bool IsValidChannelCount(u32 channel_count) {
+    return channel_count == 1 || channel_count == 2;
+}
+
+bool IsValidMultiStreamChannelCount(u32 channel_count) {
+    return channel_count <= OpusStreamCountMax;
+}
+
+bool IsValidMultiStreamStreamCounts(s32 total_stream_count, s32 sterero_stream_count) {
+    return IsValidMultiStreamChannelCount(total_stream_count) && total_stream_count > 0 &&
+           sterero_stream_count > 0 && sterero_stream_count <= total_stream_count;
+}
+} // namespace
+
+OpusDecoder::OpusDecoder(Core::System& system_) : system{system_} {
+    init_thread = std::jthread([this](std::stop_token stop_token) { Init(stop_token); });
+}
+
+OpusDecoder::~OpusDecoder() {
+    if (!running) {
+        init_thread.request_stop();
+        return;
+    }
+
+    // Shutdown the thread
+    Send(Direction::DSP, Message::Shutdown);
+    auto msg = Receive(Direction::Host);
+    ASSERT_MSG(msg == Message::ShutdownOK, "Expected Opus shutdown code {}, got {}",
+               Message::ShutdownOK, msg);
+    main_thread.request_stop();
+    main_thread.join();
+    running = false;
+}
+
+void OpusDecoder::Send(Direction dir, u32 message) {
+    mailbox.Send(dir, std::move(message));
+}
+
+u32 OpusDecoder::Receive(Direction dir, std::stop_token stop_token) {
+    return mailbox.Receive(dir, stop_token);
+}
+
+void OpusDecoder::Init(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("DSP_OpusDecoder_Init");
+
+    if (Receive(Direction::DSP, stop_token) != Message::Start) {
+        LOG_ERROR(Service_Audio,
+                  "DSP OpusDecoder failed to receive Start message. Opus initialization failed.");
+        return;
+    }
+    main_thread = std::jthread([this](std::stop_token st) { Main(st); });
+    running = true;
+    Send(Direction::Host, Message::StartOK);
+}
+
+void OpusDecoder::Main(std::stop_token stop_token) {
+    Common::SetCurrentThreadName("DSP_OpusDecoder_Main");
+
+    while (!stop_token.stop_requested()) {
+        auto msg = Receive(Direction::DSP, stop_token);
+        switch (msg) {
+        case Shutdown:
+            Send(Direction::Host, Message::ShutdownOK);
+            return;
+
+        case GetWorkBufferSize: {
+            auto channel_count = static_cast<s32>(shared_memory->host_send_data[0]);
+
+            ASSERT(IsValidChannelCount(channel_count));
+
+            shared_memory->dsp_return_data[0] = OpusDecodeObject::GetWorkBufferSize(channel_count);
+            Send(Direction::Host, Message::GetWorkBufferSizeOK);
+        } break;
+
+        case InitializeDecodeObject: {
+            auto buffer = shared_memory->host_send_data[0];
+            auto buffer_size = shared_memory->host_send_data[1];
+            auto sample_rate = static_cast<s32>(shared_memory->host_send_data[2]);
+            auto channel_count = static_cast<s32>(shared_memory->host_send_data[3]);
+
+            ASSERT(sample_rate >= 0);
+            ASSERT(IsValidChannelCount(channel_count));
+            ASSERT(buffer_size >= OpusDecodeObject::GetWorkBufferSize(channel_count));
+
+            auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);
+            shared_memory->dsp_return_data[0] =
+                decoder_object.InitializeDecoder(sample_rate, channel_count);
+
+            Send(Direction::Host, Message::InitializeDecodeObjectOK);
+        } break;
+
+        case ShutdownDecodeObject: {
+            auto buffer = shared_memory->host_send_data[0];
+            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+
+            auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);
+            shared_memory->dsp_return_data[0] = decoder_object.Shutdown();
+
+            Send(Direction::Host, Message::ShutdownDecodeObjectOK);
+        } break;
+
+        case DecodeInterleaved: {
+            auto start_time = system.CoreTiming().GetGlobalTimeUs();
+
+            auto buffer = shared_memory->host_send_data[0];
+            auto input_data = shared_memory->host_send_data[1];
+            auto input_data_size = shared_memory->host_send_data[2];
+            auto output_data = shared_memory->host_send_data[3];
+            auto output_data_size = shared_memory->host_send_data[4];
+            auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
+            auto reset_requested = shared_memory->host_send_data[6];
+
+            u32 decoded_samples{0};
+
+            auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);
+            s32 error_code{OPUS_OK};
+            if (reset_requested) {
+                error_code = decoder_object.ResetDecoder();
+            }
+
+            if (error_code == OPUS_OK) {
+                error_code = decoder_object.Decode(decoded_samples, output_data, output_data_size,
+                                                   input_data, input_data_size);
+            }
+
+            if (error_code == OPUS_OK) {
+                if (final_range && decoder_object.GetFinalRange() != final_range) {
+                    error_code = OPUS_INVALID_PACKET;
+                }
+            }
+
+            auto end_time = system.CoreTiming().GetGlobalTimeUs();
+            shared_memory->dsp_return_data[0] = error_code;
+            shared_memory->dsp_return_data[1] = decoded_samples;
+            shared_memory->dsp_return_data[2] = (end_time - start_time).count();
+
+            Send(Direction::Host, Message::DecodeInterleavedOK);
+        } break;
+
+        case MapMemory: {
+            [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
+            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+            Send(Direction::Host, Message::MapMemoryOK);
+        } break;
+
+        case UnmapMemory: {
+            [[maybe_unused]] auto buffer = shared_memory->host_send_data[0];
+            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+            Send(Direction::Host, Message::UnmapMemoryOK);
+        } break;
+
+        case GetWorkBufferSizeForMultiStream: {
+            auto total_stream_count = static_cast<s32>(shared_memory->host_send_data[0]);
+            auto stereo_stream_count = static_cast<s32>(shared_memory->host_send_data[1]);
+
+            ASSERT(IsValidMultiStreamStreamCounts(total_stream_count, stereo_stream_count));
+
+            shared_memory->dsp_return_data[0] = OpusMultiStreamDecodeObject::GetWorkBufferSize(
+                total_stream_count, stereo_stream_count);
+            Send(Direction::Host, Message::GetWorkBufferSizeForMultiStreamOK);
+        } break;
+
+        case InitializeMultiStreamDecodeObject: {
+            auto buffer = shared_memory->host_send_data[0];
+            auto buffer_size = shared_memory->host_send_data[1];
+            auto sample_rate = static_cast<s32>(shared_memory->host_send_data[2]);
+            auto channel_count = static_cast<s32>(shared_memory->host_send_data[3]);
+            auto total_stream_count = static_cast<s32>(shared_memory->host_send_data[4]);
+            auto stereo_stream_count = static_cast<s32>(shared_memory->host_send_data[5]);
+            // Nintendo seem to have a bug here, they try to use &host_send_data[6] for the channel
+            // mappings, but [6] is never set, and there is not enough room in the argument data for
+            // more than 40 channels, when 255 are possible.
+            // It also means the mapping values are undefined, though likely always 0,
+            // and the mappings given by the game are ignored. The mappings are copied to this
+            // dedicated buffer host side, so let's do as intended.
+            auto mappings = shared_memory->channel_mapping.data();
+
+            ASSERT(IsValidMultiStreamStreamCounts(total_stream_count, stereo_stream_count));
+            ASSERT(sample_rate >= 0);
+            ASSERT(buffer_size >= OpusMultiStreamDecodeObject::GetWorkBufferSize(
+                                      total_stream_count, stereo_stream_count));
+
+            auto& decoder_object = OpusMultiStreamDecodeObject::Initialize(buffer, buffer);
+            shared_memory->dsp_return_data[0] = decoder_object.InitializeDecoder(
+                sample_rate, total_stream_count, channel_count, stereo_stream_count, mappings);
+
+            Send(Direction::Host, Message::InitializeMultiStreamDecodeObjectOK);
+        } break;
+
+        case ShutdownMultiStreamDecodeObject: {
+            auto buffer = shared_memory->host_send_data[0];
+            [[maybe_unused]] auto buffer_size = shared_memory->host_send_data[1];
+
+            auto& decoder_object = OpusMultiStreamDecodeObject::Initialize(buffer, buffer);
+            shared_memory->dsp_return_data[0] = decoder_object.Shutdown();
+
+            Send(Direction::Host, Message::ShutdownMultiStreamDecodeObjectOK);
+        } break;
+
+        case DecodeInterleavedForMultiStream: {
+            auto start_time = system.CoreTiming().GetGlobalTimeUs();
+
+            auto buffer = shared_memory->host_send_data[0];
+            auto input_data = shared_memory->host_send_data[1];
+            auto input_data_size = shared_memory->host_send_data[2];
+            auto output_data = shared_memory->host_send_data[3];
+            auto output_data_size = shared_memory->host_send_data[4];
+            auto final_range = static_cast<u32>(shared_memory->host_send_data[5]);
+            auto reset_requested = shared_memory->host_send_data[6];
+
+            u32 decoded_samples{0};
+
+            auto& decoder_object = OpusMultiStreamDecodeObject::Initialize(buffer, buffer);
+            s32 error_code{OPUS_OK};
+            if (reset_requested) {
+                error_code = decoder_object.ResetDecoder();
+            }
+
+            if (error_code == OPUS_OK) {
+                error_code = decoder_object.Decode(decoded_samples, output_data, output_data_size,
+                                                   input_data, input_data_size);
+            }
+
+            if (error_code == OPUS_OK) {
+                if (final_range && decoder_object.GetFinalRange() != final_range) {
+                    error_code = OPUS_INVALID_PACKET;
+                }
+            }
+
+            auto end_time = system.CoreTiming().GetGlobalTimeUs();
+            shared_memory->dsp_return_data[0] = error_code;
+            shared_memory->dsp_return_data[1] = decoded_samples;
+            shared_memory->dsp_return_data[2] = (end_time - start_time).count();
+
+            Send(Direction::Host, Message::DecodeInterleavedForMultiStreamOK);
+        } break;
+
+        default:
+            LOG_ERROR(Service_Audio, "Invalid OpusDecoder command {}", msg);
+            continue;
+        }
+    }
+}
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_decoder.h

@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <thread>
+
+#include "audio_core/adsp/apps/opus/shared_memory.h"
+#include "audio_core/adsp/mailbox.h"
+#include "common/common_types.h"
+
+namespace Core {
+class System;
+} // namespace Core
+
+namespace AudioCore::ADSP::OpusDecoder {
+
+enum Message : u32 {
+    Invalid = 0,
+    Start = 1,
+    Shutdown = 2,
+    StartOK = 11,
+    ShutdownOK = 12,
+    GetWorkBufferSize = 21,
+    InitializeDecodeObject = 22,
+    ShutdownDecodeObject = 23,
+    DecodeInterleaved = 24,
+    MapMemory = 25,
+    UnmapMemory = 26,
+    GetWorkBufferSizeForMultiStream = 27,
+    InitializeMultiStreamDecodeObject = 28,
+    ShutdownMultiStreamDecodeObject = 29,
+    DecodeInterleavedForMultiStream = 30,
+
+    GetWorkBufferSizeOK = 41,
+    InitializeDecodeObjectOK = 42,
+    ShutdownDecodeObjectOK = 43,
+    DecodeInterleavedOK = 44,
+    MapMemoryOK = 45,
+    UnmapMemoryOK = 46,
+    GetWorkBufferSizeForMultiStreamOK = 47,
+    InitializeMultiStreamDecodeObjectOK = 48,
+    ShutdownMultiStreamDecodeObjectOK = 49,
+    DecodeInterleavedForMultiStreamOK = 50,
+};
+
+/**
+ * The AudioRenderer application running on the ADSP.
+ */
+class OpusDecoder {
+public:
+    explicit OpusDecoder(Core::System& system);
+    ~OpusDecoder();
+
+    bool IsRunning() const noexcept {
+        return running;
+    }
+
+    void Send(Direction dir, u32 message);
+    u32 Receive(Direction dir, std::stop_token stop_token = {});
+
+    void SetSharedMemory(SharedMemory& shared_memory_) {
+        shared_memory = &shared_memory_;
+    }
+
+private:
+    /**
+     * Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.
+     */
+    void Init(std::stop_token stop_token);
+    /**
+     * Main OpusDecoder thread, responsible for processing the incoming Opus packets.
+     */
+    void Main(std::stop_token stop_token);
+
+    /// Core system
+    Core::System& system;
+    /// Mailbox to communicate messages with the host, drives the main thread
+    Mailbox mailbox;
+    /// Init thread
+    std::jthread init_thread{};
+    /// Main thread
+    std::jthread main_thread{};
+    /// The current state
+    bool running{};
+    /// Structure shared with the host, input data set by the host before sending a mailbox message,
+    /// and the responses are written back by the OpusDecoder.
+    SharedMemory* shared_memory{};
+};
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp

@@ -0,0 +1,111 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
+#include "common/assert.h"
+
+namespace AudioCore::ADSP::OpusDecoder {
+
+namespace {
+bool IsValidChannelCount(u32 channel_count) {
+    return channel_count == 1 || channel_count == 2;
+}
+
+bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
+    return total_stream_count > 0 && stereo_stream_count > 0 &&
+           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
+}
+} // namespace
+
+u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,
+                                                   u32 stereo_stream_count) {
+    if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {
+        return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) +
+               opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);
+    }
+    return 0;
+}
+
+OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {
+    auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);
+    auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);
+
+    if (new_decoder->magic == DecodeMultiStreamObjectMagic) {
+        if (!new_decoder->initialized ||
+            (new_decoder->initialized && new_decoder->self == comparison)) {
+            new_decoder->state_valid = true;
+        }
+    } else {
+        new_decoder->initialized = false;
+        new_decoder->state_valid = true;
+    }
+    return *new_decoder;
+}
+
+s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,
+                                                   u32 channel_count, u32 stereo_stream_count,
+                                                   u8* mappings) {
+    if (!state_valid) {
+        return OPUS_INVALID_STATE;
+    }
+
+    if (initialized) {
+        return OPUS_OK;
+    }
+
+    // See OpusDecodeObject::InitializeDecoder for an explanation of this
+    decoder = (LibOpusMSDecoder*)(this + 1);
+    s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,
+                                            stereo_stream_count, mappings);
+    if (ret == OPUS_OK) {
+        magic = DecodeMultiStreamObjectMagic;
+        initialized = true;
+        state_valid = true;
+        self = this;
+        final_range = 0;
+    }
+    return ret;
+}
+
+s32 OpusMultiStreamDecodeObject::Shutdown() {
+    if (!state_valid) {
+        return OPUS_INVALID_STATE;
+    }
+
+    if (initialized) {
+        magic = 0x0;
+        initialized = false;
+        state_valid = false;
+        self = nullptr;
+        final_range = 0;
+        decoder = nullptr;
+    }
+    return OPUS_OK;
+}
+
+s32 OpusMultiStreamDecodeObject::ResetDecoder() {
+    return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);
+}
+
+s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,
+                                        u64 output_data_size, u64 input_data, u64 input_data_size) {
+    ASSERT(initialized);
+    out_sample_count = 0;
+
+    if (!state_valid) {
+        return OPUS_INVALID_STATE;
+    }
+
+    auto ret_code_or_samples = opus_multistream_decode(
+        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
+        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
+
+    if (ret_code_or_samples < OPUS_OK) {
+        return ret_code_or_samples;
+    }
+
+    out_sample_count = ret_code_or_samples;
+    return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
+}
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <opus_multistream.h>
+
+#include "common/common_types.h"
+
+namespace AudioCore::ADSP::OpusDecoder {
+using LibOpusMSDecoder = ::OpusMSDecoder;
+static constexpr u32 DecodeMultiStreamObjectMagic = 0xDEADBEEF;
+
+class OpusMultiStreamDecodeObject {
+public:
+    static u32 GetWorkBufferSize(u32 total_stream_count, u32 stereo_stream_count);
+    static OpusMultiStreamDecodeObject& Initialize(u64 buffer, u64 buffer2);
+
+    s32 InitializeDecoder(u32 sample_rate, u32 total_stream_count, u32 channel_count,
+                          u32 stereo_stream_count, u8* mappings);
+    s32 Shutdown();
+    s32 ResetDecoder();
+    s32 Decode(u32& out_sample_count, u64 output_data, u64 output_data_size, u64 input_data,
+               u64 input_data_size);
+    u32 GetFinalRange() const noexcept {
+        return final_range;
+    }
+
+private:
+    u32 magic;
+    bool initialized;
+    bool state_valid;
+    OpusMultiStreamDecodeObject* self;
+    u32 final_range;
+    LibOpusMSDecoder* decoder;
+};
+static_assert(std::is_trivially_constructible_v<OpusMultiStreamDecodeObject>);
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/shared_memory.h

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+
+namespace AudioCore::ADSP::OpusDecoder {
+
+struct SharedMemory {
+    std::array<u8, 0x100> channel_mapping{};
+    std::array<u64, 16> host_send_data{};
+    std::array<u64, 16> dsp_return_data{};
+};
+
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/mailbox.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <span>
+
 #include "common/bounded_threadsafe_queue.h"
 #include "common/common_types.h"
 
@@ -19,11 +21,6 @@ enum class Direction : u32 {
     DSP,
 };
 
-struct MailboxMessage {
-    u32 msg;
-    std::span<u8> data;
-};
-
 class Mailbox {
 public:
     void Initialize(AppMailboxId id_) {
@@ -35,25 +32,19 @@ public:
         return id;
     }
 
-    void Send(Direction dir, MailboxMessage&& message) {
+    void Send(Direction dir, u32 message) {
         auto& queue = dir == Direction::Host ? host_queue : adsp_queue;
-        queue.EmplaceWait(std::move(message));
+        queue.EmplaceWait(message);
     }
 
-    MailboxMessage Receive(Direction dir, bool block = true) {
+    u32 Receive(Direction dir, std::stop_token stop_token = {}) {
         auto& queue = dir == Direction::Host ? host_queue : adsp_queue;
-        MailboxMessage t;
-        if (block) {
-            queue.PopWait(t);
-        } else {
-            queue.TryPop(t);
-        }
-        return t;
+        return queue.PopWait(stop_token);
     }
 
     void Reset() {
         id = AppMailboxId::Invalid;
-        MailboxMessage t;
+        u32 t{};
         while (host_queue.TryPop(t)) {
         }
         while (adsp_queue.TryPop(t)) {
@@ -62,8 +53,8 @@ public:
 
 private:
     AppMailboxId id{0};
-    Common::SPSCQueue<MailboxMessage> host_queue;
-    Common::SPSCQueue<MailboxMessage> adsp_queue;
+    Common::SPSCQueue<u32> host_queue;
+    Common::SPSCQueue<u32> adsp_queue;
 };
 
 } // namespace AudioCore::ADSP

src/audio_core/opus/decoder.cpp

@@ -0,0 +1,179 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "audio_core/opus/decoder.h"
+#include "audio_core/opus/hardware_opus.h"
+#include "audio_core/opus/parameters.h"
+#include "common/alignment.h"
+#include "common/swap.h"
+#include "core/core.h"
+
+namespace AudioCore::OpusDecoder {
+using namespace Service::Audio;
+namespace {
+OpusPacketHeader ReverseHeader(OpusPacketHeader header) {
+    OpusPacketHeader out;
+    out.size = Common::swap32(header.size);
+    out.final_range = Common::swap32(header.final_range);
+    return out;
+}
+} // namespace
+
+OpusDecoder::OpusDecoder(Core::System& system_, HardwareOpus& hardware_opus_)
+    : system{system_}, hardware_opus{hardware_opus_} {}
+
+OpusDecoder::~OpusDecoder() {
+    if (decode_object_initialized) {
+        hardware_opus.ShutdownDecodeObject(shared_buffer.get(), shared_buffer_size);
+    }
+}
+
+Result OpusDecoder::Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
+                               u64 transfer_memory_size) {
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    shared_buffer_size = transfer_memory_size;
+    shared_buffer = std::make_unique<u8[]>(shared_buffer_size);
+    shared_memory_mapped = true;
+
+    buffer_size =
+        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);
+
+    out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};
+    size_t in_data_size{0x600u};
+    in_data = {out_data.data() - in_data_size, in_data_size};
+
+    ON_RESULT_FAILURE {
+        if (shared_memory_mapped) {
+            shared_memory_mapped = false;
+            ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));
+        }
+    };
+
+    R_TRY(hardware_opus.InitializeDecodeObject(params.sample_rate, params.channel_count,
+                                               shared_buffer.get(), shared_buffer_size));
+
+    sample_rate = params.sample_rate;
+    channel_count = params.channel_count;
+    use_large_frame_size = params.use_large_frame_size;
+    decode_object_initialized = true;
+    R_SUCCEED();
+}
+
+Result OpusDecoder::Initialize(OpusMultiStreamParametersEx& params,
+                               Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size) {
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    shared_buffer_size = transfer_memory_size;
+    shared_buffer = std::make_unique<u8[]>(shared_buffer_size);
+    shared_memory_mapped = true;
+
+    buffer_size =
+        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);
+
+    out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};
+    size_t in_data_size{Common::AlignUp(1500ull * params.total_stream_count, 64u)};
+    in_data = {out_data.data() - in_data_size, in_data_size};
+
+    ON_RESULT_FAILURE {
+        if (shared_memory_mapped) {
+            shared_memory_mapped = false;
+            ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));
+        }
+    };
+
+    R_TRY(hardware_opus.InitializeMultiStreamDecodeObject(
+        params.sample_rate, params.channel_count, params.total_stream_count,
+        params.stereo_stream_count, params.mappings.data(), shared_buffer.get(),
+        shared_buffer_size));
+
+    sample_rate = params.sample_rate;
+    channel_count = params.channel_count;
+    total_stream_count = params.total_stream_count;
+    stereo_stream_count = params.stereo_stream_count;
+    use_large_frame_size = params.use_large_frame_size;
+    decode_object_initialized = true;
+    R_SUCCEED();
+}
+
+Result OpusDecoder::DecodeInterleaved(u32* out_data_size, u64* out_time_taken,
+                                      u32* out_sample_count, std::span<const u8> input_data,
+                                      std::span<u8> output_data, bool reset) {
+    u32 out_samples;
+    u64 time_taken{};
+
+    R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);
+
+    auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
+    OpusPacketHeader header{ReverseHeader(*header_p)};
+
+    R_UNLESS(in_data.size_bytes() >= header.size &&
+                 header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),
+             ResultBufferTooSmall);
+
+    if (!shared_memory_mapped) {
+        R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
+        shared_memory_mapped = true;
+    }
+
+    std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);
+
+    R_TRY(hardware_opus.DecodeInterleaved(out_samples, out_data.data(), out_data.size_bytes(),
+                                          channel_count, in_data.data(), header.size,
+                                          shared_buffer.get(), time_taken, reset));
+
+    std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));
+
+    *out_data_size = header.size + sizeof(OpusPacketHeader);
+    *out_sample_count = out_samples;
+    if (out_time_taken) {
+        *out_time_taken = time_taken / 1000;
+    }
+    R_SUCCEED();
+}
+
+Result OpusDecoder::SetContext([[maybe_unused]] std::span<const u8> context) {
+    R_SUCCEED_IF(shared_memory_mapped);
+    shared_memory_mapped = true;
+    R_RETURN(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
+}
+
+Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,
+                                                    u32* out_sample_count,
+                                                    std::span<const u8> input_data,
+                                                    std::span<u8> output_data, bool reset) {
+    u32 out_samples;
+    u64 time_taken{};
+
+    R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);
+
+    auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
+    OpusPacketHeader header{ReverseHeader(*header_p)};
+
+    LOG_ERROR(Service_Audio, "header size 0x{:X} input data size 0x{:X} in_data size 0x{:X}",
+              header.size, input_data.size_bytes(), in_data.size_bytes());
+
+    R_UNLESS(in_data.size_bytes() >= header.size &&
+                 header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),
+             ResultBufferTooSmall);
+
+    if (!shared_memory_mapped) {
+        R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
+        shared_memory_mapped = true;
+    }
+
+    std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);
+
+    R_TRY(hardware_opus.DecodeInterleavedForMultiStream(
+        out_samples, out_data.data(), out_data.size_bytes(), channel_count, in_data.data(),
+        header.size, shared_buffer.get(), time_taken, reset));
+
+    std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));
+
+    *out_data_size = header.size + sizeof(OpusPacketHeader);
+    *out_sample_count = out_samples;
+    if (out_time_taken) {
+        *out_time_taken = time_taken / 1000;
+    }
+    R_SUCCEED();
+}
+
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/decoder.h

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <span>
+
+#include "audio_core/opus/parameters.h"
+#include "common/common_types.h"
+#include "core/hle/kernel/k_transfer_memory.h"
+#include "core/hle/service/audio/errors.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::OpusDecoder {
+class HardwareOpus;
+
+class OpusDecoder {
+public:
+    explicit OpusDecoder(Core::System& system, HardwareOpus& hardware_opus_);
+    ~OpusDecoder();
+
+    Result Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
+                      u64 transfer_memory_size);
+    Result Initialize(OpusMultiStreamParametersEx& params, Kernel::KTransferMemory* transfer_memory,
+                      u64 transfer_memory_size);
+    Result DecodeInterleaved(u32* out_data_size, u64* out_time_taken, u32* out_sample_count,
+                             std::span<const u8> input_data, std::span<u8> output_data, bool reset);
+    Result SetContext([[maybe_unused]] std::span<const u8> context);
+    Result DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,
+                                           u32* out_sample_count, std::span<const u8> input_data,
+                                           std::span<u8> output_data, bool reset);
+
+private:
+    Core::System& system;
+    HardwareOpus& hardware_opus;
+    std::unique_ptr<u8[]> shared_buffer{};
+    u64 shared_buffer_size;
+    std::span<u8> in_data{};
+    std::span<u8> out_data{};
+    u64 buffer_size{};
+    s32 sample_rate{};
+    s32 channel_count{};
+    bool use_large_frame_size{false};
+    s32 total_stream_count{};
+    s32 stereo_stream_count{};
+    bool shared_memory_mapped{false};
+    bool decode_object_initialized{false};
+};
+
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/decoder_manager.cpp

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "audio_core/adsp/apps/opus/opus_decoder.h"
+#include "audio_core/opus/decoder_manager.h"
+#include "common/alignment.h"
+#include "core/core.h"
+
+namespace AudioCore::OpusDecoder {
+using namespace Service::Audio;
+
+namespace {
+bool IsValidChannelCount(u32 channel_count) {
+    return channel_count == 1 || channel_count == 2;
+}
+
+bool IsValidMultiStreamChannelCount(u32 channel_count) {
+    return channel_count > 0 && channel_count <= OpusStreamCountMax;
+}
+
+bool IsValidSampleRate(u32 sample_rate) {
+    return sample_rate == 8'000 || sample_rate == 12'000 || sample_rate == 16'000 ||
+           sample_rate == 24'000 || sample_rate == 48'000;
+}
+
+bool IsValidStreamCount(u32 channel_count, u32 total_stream_count, u32 stereo_stream_count) {
+    return total_stream_count > 0 && stereo_stream_count > 0 &&
+           stereo_stream_count <= total_stream_count &&
+           total_stream_count + stereo_stream_count <= channel_count;
+}
+
+} // namespace
+
+OpusDecoderManager::OpusDecoderManager(Core::System& system_)
+    : system{system_}, hardware_opus{system} {
+    for (u32 i = 0; i < MaxChannels; i++) {
+        required_workbuffer_sizes[i] = hardware_opus.GetWorkBufferSize(1 + i);
+    }
+}
+
+Result OpusDecoderManager::GetWorkBufferSize(OpusParameters& params, u64& out_size) {
+    OpusParametersEx ex{
+        .sample_rate = params.sample_rate,
+        .channel_count = params.channel_count,
+        .use_large_frame_size = false,
+    };
+    R_RETURN(GetWorkBufferSizeExEx(ex, out_size));
+}
+
+Result OpusDecoderManager::GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size) {
+    R_RETURN(GetWorkBufferSizeExEx(params, out_size));
+}
+
+Result OpusDecoderManager::GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size) {
+    R_UNLESS(IsValidChannelCount(params.channel_count), ResultInvalidOpusChannelCount);
+    R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);
+
+    auto work_buffer_size{required_workbuffer_sizes[params.channel_count - 1]};
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    work_buffer_size +=
+        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);
+    out_size = work_buffer_size + 0x600;
+    R_SUCCEED();
+}
+
+Result OpusDecoderManager::GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params,
+                                                           u64& out_size) {
+    OpusMultiStreamParametersEx ex{
+        .sample_rate = params.sample_rate,
+        .channel_count = params.channel_count,
+        .total_stream_count = params.total_stream_count,
+        .stereo_stream_count = params.stereo_stream_count,
+        .use_large_frame_size = false,
+        .mappings = {},
+    };
+    R_RETURN(GetWorkBufferSizeForMultiStreamExEx(ex, out_size));
+}
+
+Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params,
+                                                             u64& out_size) {
+    R_RETURN(GetWorkBufferSizeForMultiStreamExEx(params, out_size));
+}
+
+Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params,
+                                                               u64& out_size) {
+    R_UNLESS(IsValidMultiStreamChannelCount(params.channel_count), ResultInvalidOpusChannelCount);
+    R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);
+    R_UNLESS(IsValidStreamCount(params.channel_count, params.total_stream_count,
+                                params.stereo_stream_count),
+             ResultInvalidOpusSampleRate);
+
+    auto work_buffer_size{hardware_opus.GetWorkBufferSizeForMultiStream(
+        params.total_stream_count, params.stereo_stream_count)};
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    work_buffer_size += Common::AlignUp(1500 * params.total_stream_count, 64);
+    work_buffer_size +=
+        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);
+    out_size = work_buffer_size;
+    R_SUCCEED();
+}
+
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/decoder_manager.h

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "audio_core/opus/hardware_opus.h"
+#include "audio_core/opus/parameters.h"
+#include "common/common_types.h"
+#include "core/hle/service/audio/errors.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::OpusDecoder {
+
+class OpusDecoderManager {
+public:
+    OpusDecoderManager(Core::System& system);
+
+    HardwareOpus& GetHardwareOpus() {
+        return hardware_opus;
+    }
+
+    Result GetWorkBufferSize(OpusParameters& params, u64& out_size);
+    Result GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params, u64& out_size);
+    Result GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params, u64& out_size);
+
+private:
+    Core::System& system;
+    HardwareOpus hardware_opus;
+    std::array<u64, MaxChannels> required_workbuffer_sizes{};
+};
+
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/hardware_opus.cpp

@@ -0,0 +1,241 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <array>
+
+#include "audio_core/audio_core.h"
+#include "audio_core/opus/hardware_opus.h"
+#include "core/core.h"
+
+namespace AudioCore::OpusDecoder {
+namespace {
+using namespace Service::Audio;
+
+static constexpr Result ResultCodeFromLibOpusErrorCode(u64 error_code) {
+    s32 error{static_cast<s32>(error_code)};
+    ASSERT(error <= OPUS_OK);
+    switch (error) {
+    case OPUS_ALLOC_FAIL:
+        R_THROW(ResultLibOpusAllocFail);
+    case OPUS_INVALID_STATE:
+        R_THROW(ResultLibOpusInvalidState);
+    case OPUS_UNIMPLEMENTED:
+        R_THROW(ResultLibOpusUnimplemented);
+    case OPUS_INVALID_PACKET:
+        R_THROW(ResultLibOpusInvalidPacket);
+    case OPUS_INTERNAL_ERROR:
+        R_THROW(ResultLibOpusInternalError);
+    case OPUS_BUFFER_TOO_SMALL:
+        R_THROW(ResultBufferTooSmall);
+    case OPUS_BAD_ARG:
+        R_THROW(ResultLibOpusBadArg);
+    case OPUS_OK:
+        R_RETURN(ResultSuccess);
+    }
+    UNREACHABLE();
+}
+
+} // namespace
+
+HardwareOpus::HardwareOpus(Core::System& system_)
+    : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {
+    opus_decoder.SetSharedMemory(shared_memory);
+}
+
+u64 HardwareOpus::GetWorkBufferSize(u32 channel) {
+    if (!opus_decoder.IsRunning()) {
+        return 0;
+    }
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = channel;
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::GetWorkBufferSize);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::GetWorkBufferSizeOK, msg);
+        return 0;
+    }
+    return shared_memory.dsp_return_data[0];
+}
+
+u64 HardwareOpus::GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = total_stream_count;
+    shared_memory.host_send_data[1] = stereo_stream_count;
+    opus_decoder.Send(ADSP::Direction::DSP,
+                      ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStream);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK, msg);
+        return 0;
+    }
+    return shared_memory.dsp_return_data[0];
+}
+
+Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,
+                                            u64 buffer_size) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[2] = sample_rate;
+    shared_memory.host_send_data[3] = channel_count;
+
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::InitializeDecodeObject);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::InitializeDecodeObjectOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::InitializeDecodeObjectOK, msg);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
+    }
+
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+}
+
+Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
+                                                       u32 total_stream_count,
+                                                       u32 stereo_stream_count, void* mappings,
+                                                       void* buffer, u64 buffer_size) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[2] = sample_rate;
+    shared_memory.host_send_data[3] = channel_count;
+    shared_memory.host_send_data[4] = total_stream_count;
+    shared_memory.host_send_data[5] = stereo_stream_count;
+
+    ASSERT(channel_count <= MaxChannels);
+    std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));
+
+    opus_decoder.Send(ADSP::Direction::DSP,
+                      ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObject);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK, msg);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
+    }
+
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+}
+
+Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = buffer_size;
+
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::ShutdownDecodeObject);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK,
+               "Expected Opus shutdown code {}, got {}",
+               ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);
+
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+}
+
+Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = buffer_size;
+
+    opus_decoder.Send(ADSP::Direction::DSP,
+                      ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObject);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK,
+               "Expected Opus shutdown code {}, got {}",
+               ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);
+
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+}
+
+Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
+                                       u64 output_data_size, u32 channel_count, void* input_data,
+                                       u64 input_data_size, void* buffer, u64& out_time_taken,
+                                       bool reset) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = (u64)input_data;
+    shared_memory.host_send_data[2] = input_data_size;
+    shared_memory.host_send_data[3] = (u64)output_data;
+    shared_memory.host_send_data[4] = output_data_size;
+    shared_memory.host_send_data[5] = 0;
+    shared_memory.host_send_data[6] = reset;
+
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::DecodeInterleaved);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::DecodeInterleavedOK, msg);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
+    }
+
+    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
+    if (error_code == OPUS_OK) {
+        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
+        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
+    }
+    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
+}
+
+Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
+                                                     u64 output_data_size, u32 channel_count,
+                                                     void* input_data, u64 input_data_size,
+                                                     void* buffer, u64& out_time_taken,
+                                                     bool reset) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = (u64)input_data;
+    shared_memory.host_send_data[2] = input_data_size;
+    shared_memory.host_send_data[3] = (u64)output_data;
+    shared_memory.host_send_data[4] = output_data_size;
+    shared_memory.host_send_data[5] = 0;
+    shared_memory.host_send_data[6] = reset;
+
+    opus_decoder.Send(ADSP::Direction::DSP,
+                      ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
+    }
+
+    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
+    if (error_code == OPUS_OK) {
+        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
+        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
+    }
+    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
+}
+
+Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = buffer_size;
+
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::MapMemoryOK, msg);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
+    }
+    R_SUCCEED();
+}
+
+Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {
+    std::scoped_lock l{mutex};
+    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[1] = buffer_size;
+
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+                  ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
+    }
+    R_SUCCEED();
+}
+
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/hardware_opus.h

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <mutex>
+#include <opus.h>
+
+#include "audio_core/adsp/apps/opus/opus_decoder.h"
+#include "audio_core/adsp/apps/opus/shared_memory.h"
+#include "audio_core/adsp/mailbox.h"
+#include "core/hle/service/audio/errors.h"
+
+namespace AudioCore::OpusDecoder {
+class HardwareOpus {
+public:
+    HardwareOpus(Core::System& system);
+
+    u64 GetWorkBufferSize(u32 channel);
+    u64 GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count);
+
+    Result InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,
+                                  u64 buffer_size);
+    Result InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
+                                             u32 totaL_stream_count, u32 stereo_stream_count,
+                                             void* mappings, void* buffer, u64 buffer_size);
+    Result ShutdownDecodeObject(void* buffer, u64 buffer_size);
+    Result ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size);
+    Result DecodeInterleaved(u32& out_sample_count, void* output_data, u64 output_data_size,
+                             u32 channel_count, void* input_data, u64 input_data_size, void* buffer,
+                             u64& out_time_taken, bool reset);
+    Result DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
+                                           u64 output_data_size, u32 channel_count,
+                                           void* input_data, u64 input_data_size, void* buffer,
+                                           u64& out_time_taken, bool reset);
+    Result MapMemory(void* buffer, u64 buffer_size);
+    Result UnmapMemory(void* buffer, u64 buffer_size);
+
+private:
+    Core::System& system;
+    std::mutex mutex;
+    ADSP::OpusDecoder::OpusDecoder& opus_decoder;
+    ADSP::OpusDecoder::SharedMemory shared_memory;
+};
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/parameters.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+
+namespace AudioCore::OpusDecoder {
+constexpr size_t OpusStreamCountMax = 255;
+constexpr size_t MaxChannels = 2;
+
+struct OpusParameters {
+    /* 0x00 */ u32 sample_rate;
+    /* 0x04 */ u32 channel_count;
+}; // size = 0x8
+static_assert(sizeof(OpusParameters) == 0x8, "OpusParameters has the wrong size!");
+
+struct OpusParametersEx {
+    /* 0x00 */ u32 sample_rate;
+    /* 0x04 */ u32 channel_count;
+    /* 0x08 */ bool use_large_frame_size;
+    /* 0x09 */ INSERT_PADDING_BYTES(7);
+}; // size = 0x10
+static_assert(sizeof(OpusParametersEx) == 0x10, "OpusParametersEx has the wrong size!");
+
+struct OpusMultiStreamParameters {
+    /* 0x00 */ u32 sample_rate;
+    /* 0x04 */ u32 channel_count;
+    /* 0x08 */ u32 total_stream_count;
+    /* 0x0C */ u32 stereo_stream_count;
+    /* 0x10 */ std::array<u8, OpusStreamCountMax + 1> mappings;
+}; // size = 0x110
+static_assert(sizeof(OpusMultiStreamParameters) == 0x110,
+              "OpusMultiStreamParameters has the wrong size!");
+
+struct OpusMultiStreamParametersEx {
+    /* 0x00 */ u32 sample_rate;
+    /* 0x04 */ u32 channel_count;
+    /* 0x08 */ u32 total_stream_count;
+    /* 0x0C */ u32 stereo_stream_count;
+    /* 0x10 */ bool use_large_frame_size;
+    /* 0x11 */ INSERT_PADDING_BYTES(7);
+    /* 0x18 */ std::array<u8, OpusStreamCountMax + 1> mappings;
+}; // size = 0x118
+static_assert(sizeof(OpusMultiStreamParametersEx) == 0x118,
+              "OpusMultiStreamParametersEx has the wrong size!");
+
+struct OpusPacketHeader {
+    /* 0x00 */ u32 size;
+    /* 0x04 */ u32 final_range;
+}; // size = 0x8
+static_assert(sizeof(OpusPacketHeader) == 0x8, "OpusPacketHeader has the wrong size!");
+} // namespace AudioCore::OpusDecoder

src/audio_core/renderer/command/command_processing_time_estimator.cpp

@@ -27,12 +27,12 @@ u32 CommandProcessingTimeEstimatorVersion1::Estimate(
 
 u32 CommandProcessingTimeEstimatorVersion1::Estimate(
     const AdpcmDataSourceVersion1Command& command) const {
-    return static_cast<u32>(command.pitch * 0.25f * 1.2f);
+    return static_cast<u32>(command.pitch * 0.46f * 1.2f);
 }
 
 u32 CommandProcessingTimeEstimatorVersion1::Estimate(
     const AdpcmDataSourceVersion2Command& command) const {
-    return static_cast<u32>(command.pitch * 0.25f * 1.2f);
+    return static_cast<u32>(command.pitch * 0.46f * 1.2f);
 }
 
 u32 CommandProcessingTimeEstimatorVersion1::Estimate(

src/audio_core/renderer/command/data_source/adpcm.cpp

@@ -20,6 +20,12 @@ void AdpcmDataSourceVersion1Command::Process(const AudioRenderer::CommandListPro
     auto out_buffer{processor.mix_buffers.subspan(output_index * processor.sample_count,
                                                   processor.sample_count)};
 
+    for (auto& wave_buffer : wave_buffers) {
+        wave_buffer.loop_start_offset = wave_buffer.start_offset;
+        wave_buffer.loop_end_offset = wave_buffer.end_offset;
+        wave_buffer.loop_count = wave_buffer.loop ? -1 : 0;
+    }
+
     DecodeFromWaveBuffersArgs args{
         .sample_format{SampleFormat::Adpcm},
         .output{out_buffer},

src/audio_core/renderer/command/data_source/decode.cpp

@@ -123,11 +123,13 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
         return 0;
     }
 
-    auto samples_to_process{
-        std::min(req.end_offset - req.start_offset - req.offset, req.samples_to_read)};
+    auto start_pos{req.start_offset + req.offset};
+    auto samples_to_process{std::min(req.end_offset - start_pos, req.samples_to_read)};
+    if (samples_to_process == 0) {
+        return 0;
+    }
 
     auto samples_to_read{samples_to_process};
-    auto start_pos{req.start_offset + req.offset};
     auto samples_remaining_in_frame{start_pos % SamplesPerFrame};
     auto position_in_frame{(start_pos / SamplesPerFrame) * NibblesPerFrame +
                            samples_remaining_in_frame};
@@ -225,13 +227,24 @@ static u32 DecodeAdpcm(Core::Memory::Memory& memory, std::span<s16> out_buffer,
  * @param args   - The wavebuffer data, and information for how to decode it.
  */
 void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuffersArgs& args) {
+    static constexpr auto EndWaveBuffer = [](auto& voice_state, auto& wavebuffer, auto& index,
+                                             auto& played_samples, auto& consumed) -> void {
+        voice_state.wave_buffer_valid[index] = false;
+        voice_state.loop_count = 0;
+
+        if (wavebuffer.stream_ended) {
+            played_samples = 0;
+        }
+
+        index = (index + 1) % MaxWaveBuffers;
+        consumed++;
+    };
     auto& voice_state{*args.voice_state};
     auto remaining_sample_count{args.sample_count};
     auto fraction{voice_state.fraction};
 
-    const auto sample_rate_ratio{
-        (Common::FixedPoint<49, 15>(args.source_sample_rate) / args.target_sample_rate) *
-        args.pitch};
+    const auto sample_rate_ratio{Common::FixedPoint<49, 15>(
+        (f32)args.source_sample_rate / (f32)args.target_sample_rate * (f32)args.pitch)};
     const auto size_required{fraction + remaining_sample_count * sample_rate_ratio};
 
     if (size_required < 0) {
@@ -298,22 +311,23 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
             auto end_offset{wavebuffer.end_offset};
 
             if (wavebuffer.loop && voice_state.loop_count > 0 &&
-                wavebuffer.loop_start_offset != 0 && wavebuffer.loop_end_offset != 0 &&
                 wavebuffer.loop_start_offset <= wavebuffer.loop_end_offset) {
                 start_offset = wavebuffer.loop_start_offset;
                 end_offset = wavebuffer.loop_end_offset;
             }
 
-            DecodeArg decode_arg{.buffer{wavebuffer.buffer},
-                                 .buffer_size{wavebuffer.buffer_size},
-                                 .start_offset{start_offset},
-                                 .end_offset{end_offset},
-                                 .channel_count{args.channel_count},
-                                 .coefficients{},
-                                 .adpcm_context{nullptr},
-                                 .target_channel{args.channel},
-                                 .offset{offset},
-                                 .samples_to_read{samples_to_read - samples_read}};
+            DecodeArg decode_arg{
+                .buffer{wavebuffer.buffer},
+                .buffer_size{wavebuffer.buffer_size},
+                .start_offset{start_offset},
+                .end_offset{end_offset},
+                .channel_count{args.channel_count},
+                .coefficients{},
+                .adpcm_context{nullptr},
+                .target_channel{args.channel},
+                .offset{offset},
+                .samples_to_read{samples_to_read - samples_read},
+            };
 
             s32 samples_decoded{0};
 
@@ -350,42 +364,30 @@ void DecodeFromWaveBuffers(Core::Memory::Memory& memory, const DecodeFromWaveBuf
             temp_buffer_pos += samples_decoded;
             offset += samples_decoded;
 
-            if (samples_decoded == 0 || offset >= end_offset - start_offset) {
-                offset = 0;
-                if (!wavebuffer.loop) {
-                    voice_state.wave_buffer_valid[wavebuffer_index] = false;
-                    voice_state.loop_count = 0;
+            if (samples_decoded && offset < end_offset - start_offset) {
+                continue;
+            }
 
-                    if (wavebuffer.stream_ended) {
-                        played_sample_count = 0;
-                    }
-
-                    wavebuffer_index = (wavebuffer_index + 1) % MaxWaveBuffers;
-                    wavebuffers_consumed++;
-                } else {
-                    voice_state.loop_count++;
-                    if (wavebuffer.loop_count >= 0 &&
-                        (voice_state.loop_count > wavebuffer.loop_count || samples_decoded == 0)) {
-                        voice_state.wave_buffer_valid[wavebuffer_index] = false;
-                        voice_state.loop_count = 0;
-
-                        if (wavebuffer.stream_ended) {
-                            played_sample_count = 0;
-                        }
-
-                        wavebuffer_index = (wavebuffer_index + 1) % MaxWaveBuffers;
-                        wavebuffers_consumed++;
-                    }
-
-                    if (samples_decoded == 0) {
-                        is_buffer_starved = true;
-                        break;
-                    }
-
-                    if (args.IsVoicePlayedSampleCountResetAtLoopPointSupported) {
-                        played_sample_count = 0;
-                    }
+            offset = 0;
+            if (wavebuffer.loop) {
+                voice_state.loop_count++;
+                if (wavebuffer.loop_count >= 0 &&
+                    (voice_state.loop_count > wavebuffer.loop_count || samples_decoded == 0)) {
+                    EndWaveBuffer(voice_state, wavebuffer, wavebuffer_index, played_sample_count,
+                                  wavebuffers_consumed);
                 }
+
+                if (samples_decoded == 0) {
+                    is_buffer_starved = true;
+                    break;
+                }
+
+                if (args.IsVoicePlayedSampleCountResetAtLoopPointSupported) {
+                    played_sample_count = 0;
+                }
+            } else {
+                EndWaveBuffer(voice_state, wavebuffer, wavebuffer_index, played_sample_count,
+                              wavebuffers_consumed);
             }
         }
 

src/audio_core/renderer/command/data_source/pcm_float.cpp

@@ -21,6 +21,12 @@ void PcmFloatDataSourceVersion1Command::Process(
     auto out_buffer = processor.mix_buffers.subspan(output_index * processor.sample_count,
                                                     processor.sample_count);
 
+    for (auto& wave_buffer : wave_buffers) {
+        wave_buffer.loop_start_offset = wave_buffer.start_offset;
+        wave_buffer.loop_end_offset = wave_buffer.end_offset;
+        wave_buffer.loop_count = wave_buffer.loop ? -1 : 0;
+    }
+
     DecodeFromWaveBuffersArgs args{
         .sample_format{SampleFormat::PcmFloat},
         .output{out_buffer},

src/audio_core/renderer/command/data_source/pcm_int16.cpp

@@ -23,6 +23,12 @@ void PcmInt16DataSourceVersion1Command::Process(
     auto out_buffer = processor.mix_buffers.subspan(output_index * processor.sample_count,
                                                     processor.sample_count);
 
+    for (auto& wave_buffer : wave_buffers) {
+        wave_buffer.loop_start_offset = wave_buffer.start_offset;
+        wave_buffer.loop_end_offset = wave_buffer.end_offset;
+        wave_buffer.loop_count = wave_buffer.loop ? -1 : 0;
+    }
+
     DecodeFromWaveBuffersArgs args{
         .sample_format{SampleFormat::PcmInt16},
         .output{out_buffer},

src/audio_core/renderer/system.cpp

@@ -609,17 +609,11 @@ void System::SendCommandToDsp() {
                 time_limit_percent = 70.0f;
             }
 
-            AudioRenderer::CommandBuffer command_buffer{
-                .buffer{translated_addr},
-                .size{command_size},
-                .time_limit{
-                    static_cast<u64>((time_limit_percent / 100) * 2'880'000.0 *
-                                     (static_cast<f32>(render_time_limit_percent) / 100.0f))},
-                .applet_resource_user_id{applet_resource_user_id},
-                .reset_buffer{reset_command_buffers},
-            };
-
-            audio_renderer.SetCommandBuffer(session_id, command_buffer);
+            auto time_limit{
+                static_cast<u64>((time_limit_percent / 100) * 2'880'000.0 *
+                                 (static_cast<f32>(render_time_limit_percent) / 100.0f))};
+            audio_renderer.SetCommandBuffer(session_id, translated_addr, command_size, time_limit,
+                                            applet_resource_user_id, reset_command_buffers);
             reset_command_buffers = false;
             command_buffer_size = command_size;
             if (remaining_command_count == 0) {
@@ -690,11 +684,11 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
                                        sink_context,   splitter_context,     perf_manager};
 
     voice_context.SortInfo();
+    command_generator.GenerateVoiceCommands();
 
     const auto start_estimated_time{drop_voice_param *
                                     static_cast<f32>(command_buffer.estimated_process_time)};
 
-    command_generator.GenerateVoiceCommands();
     command_generator.GenerateSubMixCommands();
     command_generator.GenerateFinalMixCommands();
     command_generator.GenerateSinkCommands();
@@ -714,11 +708,13 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
 
         const auto end_estimated_time{drop_voice_param *
                                       static_cast<f32>(command_buffer.estimated_process_time)};
+
+        const auto dsp_time_limit{((time_limit_percent / 100.0f) * 2'880'000.0f) *
+                                  (static_cast<f32>(render_time_limit_percent) / 100.0f)};
+
         const auto estimated_time{start_estimated_time - end_estimated_time};
 
-        const auto time_limit{static_cast<u32>(
-            estimated_time + (((time_limit_percent / 100.0f) * 2'880'000.0) *
-                              (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
+        const auto time_limit{static_cast<u32>(std::max(dsp_time_limit + estimated_time, 0.0f))};
         num_voices_dropped =
             DropVoices(command_buffer, static_cast<u32>(start_estimated_time), time_limit);
     }

src/common/CMakeLists.txt

@@ -26,12 +26,11 @@ add_library(common STATIC
     assert.h
     atomic_helpers.h
     atomic_ops.h
-    detached_tasks.cpp
-    detached_tasks.h
     bit_cast.h
     bit_field.h
     bit_set.h
     bit_util.h
+    bounded_threadsafe_queue.h
     cityhash.cpp
     cityhash.h
     common_funcs.h
@@ -41,6 +40,8 @@ add_library(common STATIC
     container_hash.h
     demangle.cpp
     demangle.h
+    detached_tasks.cpp
+    detached_tasks.h
     div_ceil.h
     dynamic_library.cpp
     dynamic_library.h
@@ -151,6 +152,10 @@ add_library(common STATIC
     zstd_compression.h
 )
 
+if (YUZU_ENABLE_PORTABLE)
+    add_compile_definitions(YUZU_ENABLE_PORTABLE)
+endif()
+
 if (WIN32)
   target_sources(common PRIVATE
     windows/timer_resolution.cpp

src/common/bounded_threadsafe_queue.h

@@ -45,13 +45,13 @@ public:
     }
 
     T PopWait() {
-        T t;
+        T t{};
         Pop<PopMode::Wait>(t);
         return t;
     }
 
     T PopWait(std::stop_token stop_token) {
-        T t;
+        T t{};
         Pop<PopMode::WaitWithStopToken>(t, stop_token);
         return t;
     }

src/common/fs/fs.cpp

@@ -528,38 +528,41 @@ void IterateDirEntriesRecursively(const std::filesystem::path& path,
 // Generic Filesystem Operations
 
 bool Exists(const fs::path& path) {
+    std::error_code ec;
 #ifdef ANDROID
     if (Android::IsContentUri(path)) {
         return Android::Exists(path);
     } else {
-        return fs::exists(path);
+        return fs::exists(path, ec);
     }
 #else
-    return fs::exists(path);
+    return fs::exists(path, ec);
 #endif
 }
 
 bool IsFile(const fs::path& path) {
+    std::error_code ec;
 #ifdef ANDROID
     if (Android::IsContentUri(path)) {
         return !Android::IsDirectory(path);
     } else {
-        return fs::is_regular_file(path);
+        return fs::is_regular_file(path, ec);
     }
 #else
-    return fs::is_regular_file(path);
+    return fs::is_regular_file(path, ec);
 #endif
 }
 
 bool IsDir(const fs::path& path) {
+    std::error_code ec;
 #ifdef ANDROID
     if (Android::IsContentUri(path)) {
         return Android::IsDirectory(path);
     } else {
-        return fs::is_directory(path);
+        return fs::is_directory(path, ec);
     }
 #else
-    return fs::is_directory(path);
+    return fs::is_directory(path, ec);
 #endif
 }
 

src/common/fs/path_util.cpp

@@ -88,8 +88,9 @@ public:
         fs::path yuzu_path_config;
 
 #ifdef _WIN32
+#ifdef YUZU_ENABLE_PORTABLE
         yuzu_path = GetExeDirectory() / PORTABLE_DIR;
-
+#endif
         if (!IsDir(yuzu_path)) {
             yuzu_path = GetAppDataRoamingDirectory() / YUZU_DIR;
         }
@@ -101,8 +102,9 @@ public:
         yuzu_path_cache = yuzu_path / CACHE_DIR;
         yuzu_path_config = yuzu_path / CONFIG_DIR;
 #else
+#ifdef YUZU_ENABLE_PORTABLE
         yuzu_path = GetCurrentDir() / PORTABLE_DIR;
-
+#endif
         if (Exists(yuzu_path) && IsDir(yuzu_path)) {
             yuzu_path_cache = yuzu_path / CACHE_DIR;
             yuzu_path_config = yuzu_path / CONFIG_DIR;

src/common/logging/filter.cpp

@@ -112,7 +112,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Service, NCM)                                                                              \
     SUB(Service, NFC)                                                                              \
     SUB(Service, NFP)                                                                              \
-    SUB(Service, NGCT)                                                                             \
+    SUB(Service, NGC)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NIM)                                                                              \
     SUB(Service, NOTIF)                                                                            \

src/common/logging/types.h

@@ -80,7 +80,7 @@ enum class Class : u8 {
     Service_NCM,        ///< The NCM service
     Service_NFC,        ///< The NFC (Near-field communication) service
     Service_NFP,        ///< The NFP service
-    Service_NGCT,       ///< The NGCT (No Good Content for Terra) service
+    Service_NGC,        ///< The NGC (No Good Content) service
     Service_NIFM,       ///< The NIFM (Network interface) service
     Service_NIM,        ///< The NIM service
     Service_NOTIF,      ///< The NOTIF (Notification) service

src/common/polyfill_thread.h

@@ -19,8 +19,8 @@
 namespace Common {
 
 template <typename Condvar, typename Lock, typename Pred>
-void CondvarWait(Condvar& cv, Lock& lock, std::stop_token token, Pred&& pred) {
-    cv.wait(lock, token, std::move(pred));
+void CondvarWait(Condvar& cv, std::unique_lock<Lock>& lk, std::stop_token token, Pred&& pred) {
+    cv.wait(lk, token, std::move(pred));
 }
 
 template <typename Rep, typename Period>
@@ -332,13 +332,17 @@ private:
 namespace Common {
 
 template <typename Condvar, typename Lock, typename Pred>
-void CondvarWait(Condvar& cv, Lock& lock, std::stop_token token, Pred pred) {
+void CondvarWait(Condvar& cv, std::unique_lock<Lock>& lk, std::stop_token token, Pred pred) {
     if (token.stop_requested()) {
         return;
     }
 
-    std::stop_callback callback(token, [&] { cv.notify_all(); });
-    cv.wait(lock, [&] { return pred() || token.stop_requested(); });
+    std::stop_callback callback(token, [&] {
+        { std::scoped_lock lk2{*lk.mutex()}; }
+        cv.notify_all();
+    });
+
+    cv.wait(lk, [&] { return pred() || token.stop_requested(); });
 }
 
 template <typename Rep, typename Period>
@@ -353,8 +357,10 @@ bool StoppableTimedWait(std::stop_token token, const std::chrono::duration<Rep,
 
     std::stop_callback cb(token, [&] {
         // Wake up the waiting thread.
-        std::unique_lock lk{m};
-        stop_requested = true;
+        {
+            std::scoped_lock lk{m};
+            stop_requested = true;
+        }
         cv.notify_one();
     });
 

src/common/settings.h

@@ -348,6 +348,8 @@ struct Values {
                                           Category::RendererDebug};
     Setting<bool> disable_shader_loop_safety_checks{
         linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
+    Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
+                                          Category::RendererDebug};
 
     // System
     SwitchableSetting<Language, true> language_index{linkage,

src/common/settings_common.h

@@ -225,6 +225,16 @@ public:
      */
     [[nodiscard]] virtual constexpr u32 EnumIndex() const = 0;
 
+    /**
+     * @returns True if the underlying type is a floating point storage
+     */
+    [[nodiscard]] virtual constexpr bool IsFloatingPoint() const = 0;
+
+    /**
+     * @returns True if the underlying type is an integer storage
+     */
+    [[nodiscard]] virtual constexpr bool IsIntegral() const = 0;
+
     /*
      * Switchable settings
      */

src/common/settings_setting.h

@@ -10,6 +10,7 @@
 #include <string>
 #include <typeindex>
 #include <typeinfo>
+#include <fmt/core.h>
 #include "common/common_types.h"
 #include "common/settings_common.h"
 #include "common/settings_enums.h"
@@ -115,8 +116,12 @@ protected:
         } else if constexpr (std::is_same_v<Type, AudioEngine>) {
             // Compatibility with old AudioEngine setting being a string
             return CanonicalizeEnum(value_);
+        } else if constexpr (std::is_floating_point_v<Type>) {
+            return fmt::format("{:f}", value_);
+        } else if constexpr (std::is_enum_v<Type>) {
+            return std::to_string(static_cast<u32>(value_));
         } else {
-            return std::to_string(static_cast<u64>(value_));
+            return std::to_string(value_);
         }
     }
 
@@ -180,13 +185,15 @@ public:
                 this->SetValue(static_cast<u32>(std::stoul(input)));
             } else if constexpr (std::is_same_v<Type, bool>) {
                 this->SetValue(input == "true");
-            } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-                this->SetValue(ToEnum<Type>(input));
+            } else if constexpr (std::is_same_v<Type, float>) {
+                this->SetValue(std::stof(input));
             } else {
                 this->SetValue(static_cast<Type>(std::stoll(input)));
             }
         } catch (std::invalid_argument&) {
             this->SetValue(this->GetDefault());
+        } catch (std::out_of_range&) {
+            this->SetValue(this->GetDefault());
         }
     }
 
@@ -215,11 +222,27 @@ public:
         }
     }
 
+    [[nodiscard]] constexpr bool IsFloatingPoint() const final {
+        return std::is_floating_point_v<Type>;
+    }
+
+    [[nodiscard]] constexpr bool IsIntegral() const final {
+        return std::is_integral_v<Type>;
+    }
+
     [[nodiscard]] std::string MinVal() const override final {
-        return this->ToString(minimum);
+        if constexpr (std::is_arithmetic_v<Type> && !ranged) {
+            return this->ToString(std::numeric_limits<Type>::min());
+        } else {
+            return this->ToString(minimum);
+        }
     }
     [[nodiscard]] std::string MaxVal() const override final {
-        return this->ToString(maximum);
+        if constexpr (std::is_arithmetic_v<Type> && !ranged) {
+            return this->ToString(std::numeric_limits<Type>::max());
+        } else {
+            return this->ToString(maximum);
+        }
     }
 
     [[nodiscard]] constexpr bool Ranged() const override {

src/core/CMakeLists.txt

@@ -584,13 +584,27 @@ add_library(core STATIC
     hle/service/lm/lm.h
     hle/service/mig/mig.cpp
     hle/service/mig/mig.h
+    hle/service/mii/types/char_info.cpp
+    hle/service/mii/types/char_info.h
+    hle/service/mii/types/core_data.cpp
+    hle/service/mii/types/core_data.h
+    hle/service/mii/types/raw_data.cpp
+    hle/service/mii/types/raw_data.h
+    hle/service/mii/types/store_data.cpp
+    hle/service/mii/types/store_data.h
+    hle/service/mii/types/ver3_store_data.cpp
+    hle/service/mii/types/ver3_store_data.h
     hle/service/mii/mii.cpp
     hle/service/mii/mii.h
+    hle/service/mii/mii_database.cpp
+    hle/service/mii/mii_database.h
+    hle/service/mii/mii_database_manager.cpp
+    hle/service/mii/mii_database_manager.h
     hle/service/mii/mii_manager.cpp
     hle/service/mii/mii_manager.h
-    hle/service/mii/raw_data.cpp
-    hle/service/mii/raw_data.h
-    hle/service/mii/types.h
+    hle/service/mii/mii_result.h
+    hle/service/mii/mii_types.h
+    hle/service/mii/mii_util.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
     hle/service/mnpp/mnpp_app.cpp
@@ -617,8 +631,8 @@ add_library(core STATIC
     hle/service/nfp/nfp_interface.h
     hle/service/nfp/nfp_result.h
     hle/service/nfp/nfp_types.h
-    hle/service/ngct/ngct.cpp
-    hle/service/ngct/ngct.h
+    hle/service/ngc/ngc.cpp
+    hle/service/ngc/ngc.h
     hle/service/nifm/nifm.cpp
     hle/service/nifm/nifm.h
     hle/service/nim/nim.cpp
@@ -854,6 +868,8 @@ add_library(core STATIC
     telemetry_session.h
     tools/freezer.cpp
     tools/freezer.h
+    tools/renderdoc.cpp
+    tools/renderdoc.h
 )
 
 if (MSVC)
@@ -869,6 +885,7 @@ else()
         -Werror=conversion
 
         -Wno-sign-conversion
+        -Wno-cast-function-type
 
         $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
     )
@@ -877,7 +894,7 @@ endif()
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core network video_core nx_tzdb)
-target_link_libraries(core PUBLIC Boost::headers PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::opus)
+target_link_libraries(core PUBLIC Boost::headers PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls RenderDoc::API)
 if (MINGW)
     target_link_libraries(core PRIVATE ${MSWSOCK_LIBRARY})
 endif()

src/core/core.cpp

@@ -51,6 +51,7 @@
 #include "core/reporter.h"
 #include "core/telemetry_session.h"
 #include "core/tools/freezer.h"
+#include "core/tools/renderdoc.h"
 #include "network/network.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
@@ -281,6 +282,10 @@ struct System::Impl {
         microprofile_cpu[2] = MICROPROFILE_TOKEN(ARM_CPU2);
         microprofile_cpu[3] = MICROPROFILE_TOKEN(ARM_CPU3);
 
+        if (Settings::values.enable_renderdoc_hotkey) {
+            renderdoc_api = std::make_unique<Tools::RenderdocAPI>();
+        }
+
         LOG_DEBUG(Core, "Initialized OK");
 
         return SystemResultStatus::Success;
@@ -406,6 +411,7 @@ struct System::Impl {
             gpu_core->NotifyShutdown();
         }
 
+        Network::CancelPendingSocketOperations();
         kernel.SuspendApplication(true);
         if (services) {
             services->KillNVNFlinger();
@@ -427,6 +433,7 @@ struct System::Impl {
         debugger.reset();
         kernel.Shutdown();
         memory.Reset();
+        Network::RestartSocketOperations();
 
         if (auto room_member = room_network.GetRoomMember().lock()) {
             Network::GameInfo game_info{};
@@ -519,6 +526,8 @@ struct System::Impl {
     std::unique_ptr<Tools::Freezer> memory_freezer;
     std::array<u8, 0x20> build_id{};
 
+    std::unique_ptr<Tools::RenderdocAPI> renderdoc_api;
+
     /// Frontend applets
     Service::AM::Applets::AppletManager applet_manager;
 
@@ -562,6 +571,8 @@ struct System::Impl {
 
     std::array<Core::GPUDirtyMemoryManager, Core::Hardware::NUM_CPU_CORES>
         gpu_dirty_memory_write_manager{};
+
+    std::deque<std::vector<u8>> user_channel;
 };
 
 System::System() : impl{std::make_unique<Impl>(*this)} {}
@@ -1020,6 +1031,10 @@ const Network::RoomNetwork& System::GetRoomNetwork() const {
     return impl->room_network;
 }
 
+Tools::RenderdocAPI& System::GetRenderdocAPI() {
+    return *impl->renderdoc_api;
+}
+
 void System::RunServer(std::unique_ptr<Service::ServerManager>&& server_manager) {
     return impl->kernel.RunServer(std::move(server_manager));
 }
@@ -1036,6 +1051,10 @@ void System::ExecuteProgram(std::size_t program_index) {
     }
 }
 
+std::deque<std::vector<u8>>& System::GetUserChannel() {
+    return impl->user_channel;
+}
+
 void System::RegisterExitCallback(ExitCallback&& callback) {
     impl->exit_callback = std::move(callback);
 }

src/core/core.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <cstddef>
+#include <deque>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -101,6 +102,10 @@ namespace Network {
 class RoomNetwork;
 }
 
+namespace Tools {
+class RenderdocAPI;
+}
+
 namespace Core {
 
 class ARM_Interface;
@@ -412,6 +417,8 @@ public:
     /// Gets an immutable reference to the Room Network.
     [[nodiscard]] const Network::RoomNetwork& GetRoomNetwork() const;
 
+    [[nodiscard]] Tools::RenderdocAPI& GetRenderdocAPI();
+
     void SetExitLocked(bool locked);
     bool GetExitLocked() const;
 
@@ -459,6 +466,12 @@ public:
      */
     void ExecuteProgram(std::size_t program_index);
 
+    /**
+     * Gets a reference to the user channel stack.
+     * It is used to transfer data between programs.
+     */
+    [[nodiscard]] std::deque<std::vector<u8>>& GetUserChannel();
+
     /// Type used for the frontend to designate a callback for System to exit the application.
     using ExitCallback = std::function<void()>;
 

src/core/crypto/key_manager.cpp

@@ -724,14 +724,14 @@ void KeyManager::LoadFromFile(const std::filesystem::path& file_path, bool is_ti
                     continue;
                 }
 
-                const auto index = std::stoul(out[0].substr(8, 2), nullptr, 16);
+                const auto index = std::strtoul(out[0].substr(8, 2).c_str(), nullptr, 16);
                 keyblobs[index] = Common::HexStringToArray<0x90>(out[1]);
             } else if (out[0].compare(0, 18, "encrypted_keyblob_") == 0) {
                 if (!ValidCryptoRevisionString(out[0], 18, 2)) {
                     continue;
                 }
 
-                const auto index = std::stoul(out[0].substr(18, 2), nullptr, 16);
+                const auto index = std::strtoul(out[0].substr(18, 2).c_str(), nullptr, 16);
                 encrypted_keyblobs[index] = Common::HexStringToArray<0xB0>(out[1]);
             } else if (out[0].compare(0, 20, "eticket_extended_kek") == 0) {
                 eticket_extended_kek = Common::HexStringToArray<576>(out[1]);
@@ -750,7 +750,7 @@ void KeyManager::LoadFromFile(const std::filesystem::path& file_path, bool is_ti
                     }
                     if (out[0].compare(0, kv.second.size(), kv.second) == 0) {
                         const auto index =
-                            std::stoul(out[0].substr(kv.second.size(), 2), nullptr, 16);
+                            std::strtoul(out[0].substr(kv.second.size(), 2).c_str(), nullptr, 16);
                         const auto sub = kv.first.second;
                         if (sub == 0) {
                             s128_keys[{kv.first.first, index, 0}] =
@@ -770,7 +770,7 @@ void KeyManager::LoadFromFile(const std::filesystem::path& file_path, bool is_ti
                     const auto& match = kak_names[j];
                     if (out[0].compare(0, std::strlen(match), match) == 0) {
                         const auto index =
-                            std::stoul(out[0].substr(std::strlen(match), 2), nullptr, 16);
+                            std::strtoul(out[0].substr(std::strlen(match), 2).c_str(), nullptr, 16);
                         s128_keys[{S128KeyType::KeyArea, index, j}] =
                             Common::HexStringToArray<16>(out[1]);
                     }

src/core/file_sys/ips_layer.cpp

@@ -165,7 +165,7 @@ static std::string EscapeStringSequences(std::string in) {
 void IPSwitchCompiler::ParseFlag(const std::string& line) {
     if (StartsWith(line, "@flag offset_shift ")) {
         // Offset Shift Flag
-        offset_shift = std::stoll(line.substr(19), nullptr, 0);
+        offset_shift = std::strtoll(line.substr(19).c_str(), nullptr, 0);
     } else if (StartsWith(line, "@little-endian")) {
         // Set values to read as little endian
         is_little_endian = true;
@@ -263,7 +263,7 @@ void IPSwitchCompiler::Parse() {
                 // 11 - 8 hex digit offset + space + minimum two digit overwrite val
                 if (patch_line.length() < 11)
                     break;
-                auto offset = std::stoul(patch_line.substr(0, 8), nullptr, 16);
+                auto offset = std::strtoul(patch_line.substr(0, 8).c_str(), nullptr, 16);
                 offset += static_cast<unsigned long>(offset_shift);
 
                 std::vector<u8> replace;

src/core/file_sys/nca_metadata.cpp

@@ -45,6 +45,10 @@ CNMT::CNMT(CNMTHeader header_, OptionalHeader opt_header_,
 
 CNMT::~CNMT() = default;
 
+const CNMTHeader& CNMT::GetHeader() const {
+    return header;
+}
+
 u64 CNMT::GetTitleID() const {
     return header.title_id;
 }

src/core/file_sys/nca_metadata.h

@@ -89,6 +89,7 @@ public:
          std::vector<ContentRecord> content_records_, std::vector<MetaRecord> meta_records_);
     ~CNMT();
 
+    const CNMTHeader& GetHeader() const;
     u64 GetTitleID() const;
     u32 GetTitleVersion() const;
     TitleType GetType() const;

src/core/file_sys/partition_filesystem.cpp

@@ -47,6 +47,7 @@ PartitionFilesystem::PartitionFilesystem(VirtualFile file) {
     // Actually read in now...
     std::vector<u8> file_data = file->ReadBytes(metadata_size);
     const std::size_t total_size = file_data.size();
+    file_data.push_back(0);
 
     if (total_size != metadata_size) {
         status = Loader::ResultStatus::ErrorIncorrectPFSFileSize;

src/core/file_sys/patch_manager.cpp

@@ -294,11 +294,11 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     return out;
 }
 
-bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
+bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name) const {
     const auto build_id_raw = Common::HexToString(build_id_);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
-    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
+    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}, name={}", build_id, name);
 
     const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {

src/core/file_sys/patch_manager.h

@@ -52,7 +52,7 @@ public:
 
     // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
     // Used to prevent expensive copies in NSO loader.
-    [[nodiscard]] bool HasNSOPatch(const BuildID& build_id) const;
+    [[nodiscard]] bool HasNSOPatch(const BuildID& build_id, std::string_view name) const;
 
     // Creates a CheatList object with all
     [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(

src/core/file_sys/registered_cache.cpp

@@ -9,6 +9,7 @@
 #include "common/fs/path_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
+#include "common/scope_exit.h"
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/common_funcs.h"
@@ -625,7 +626,7 @@ InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_ex
             nca->GetTitleId() != title_id) {
             // Create fake cnmt for patch to multiprogram application
             const auto sub_nca_result =
-                InstallEntry(*nca, TitleType::Update, overwrite_if_exists, copy);
+                InstallEntry(*nca, cnmt.GetHeader(), record, overwrite_if_exists, copy);
             if (sub_nca_result != InstallResult::Success) {
                 return sub_nca_result;
             }
@@ -672,6 +673,31 @@ InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
     return RawInstallNCA(nca, copy, overwrite_if_exists, c_rec.nca_id);
 }
 
+InstallResult RegisteredCache::InstallEntry(const NCA& nca, const CNMTHeader& base_header,
+                                            const ContentRecord& base_record,
+                                            bool overwrite_if_exists, const VfsCopyFunction& copy) {
+    const CNMTHeader header{
+        .title_id = nca.GetTitleId(),
+        .title_version = base_header.title_version,
+        .type = base_header.type,
+        .reserved = {},
+        .table_offset = 0x10,
+        .number_content_entries = 1,
+        .number_meta_entries = 0,
+        .attributes = 0,
+        .reserved2 = {},
+        .is_committed = 0,
+        .required_download_system_version = 0,
+        .reserved3 = {},
+    };
+    const OptionalHeader opt_header{0, 0};
+    const CNMT new_cnmt(header, opt_header, {base_record}, {});
+    if (!RawInstallYuzuMeta(new_cnmt)) {
+        return InstallResult::ErrorMetaFailed;
+    }
+    return RawInstallNCA(nca, copy, overwrite_if_exists, base_record.nca_id);
+}
+
 bool RegisteredCache::RemoveExistingEntry(u64 title_id) const {
     bool removed_data = false;
 
@@ -726,7 +752,9 @@ bool RegisteredCache::RemoveExistingEntry(u64 title_id) const {
     for (u8 i = 0; i < 0x10; i++) {
         const auto meta_dir = dir->CreateDirectoryRelative("yuzu_meta");
         const auto filename = GetCNMTName(TitleType::Update, title_id + i);
-        removed_data |= meta_dir->DeleteFile(filename);
+        if (meta_dir->GetFile(filename)) {
+            removed_data |= meta_dir->DeleteFile(filename);
+        }
     }
 
     return removed_data;

src/core/file_sys/registered_cache.h

@@ -24,6 +24,7 @@ enum class NCAContentType : u8;
 enum class TitleType : u8;
 
 struct ContentRecord;
+struct CNMTHeader;
 struct MetaRecord;
 class RegisteredCache;
 
@@ -169,6 +170,10 @@ public:
     InstallResult InstallEntry(const NCA& nca, TitleType type, bool overwrite_if_exists = false,
                                const VfsCopyFunction& copy = &VfsRawCopy);
 
+    InstallResult InstallEntry(const NCA& nca, const CNMTHeader& base_header,
+                               const ContentRecord& base_record, bool overwrite_if_exists = false,
+                               const VfsCopyFunction& copy = &VfsRawCopy);
+
     // Removes an existing entry based on title id
     bool RemoveExistingEntry(u64 title_id) const;