Android #71

2023-09-15 00:57:25 +00:00
89 changed files with 677 additions and 3299 deletions
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@ -174,9 +174,6 @@ target_include_directories(stb PUBLIC ./stb)
 add_library(bc_decoder bc_decoder/bc_decoder.cpp)
 target_include_directories(bc_decoder PUBLIC ./bc_decoder)
 add_library(renderdoc INTERFACE)
 target_include_directories(renderdoc SYSTEM INTERFACE ./renderdoc)
 if (ANDROID)
   if (ARCHITECTURE_arm64)
       add_subdirectory(libadrenotools)
--- a/externals/renderdoc/renderdoc_app.h
+++ b/externals/renderdoc/renderdoc_app.h
@ -1,744 +0,0 @@
 // 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
--- a/src/android/app/build.gradle.kts
+++ b/src/android/app/build.gradle.kts
@ -77,30 +77,13 @@ 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(
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt
@ -307,6 +307,21 @@ 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
     */
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/activities/EmulationActivity.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/activities/EmulationActivity.kt
@ -332,7 +332,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
            pictureInPictureActions.add(pauseRemoteAction)
        }
-        if (BooleanSetting.AUDIO_MUTED.boolean) {
+        if (NativeLibrary.isMuted()) {
            val unmuteIcon = Icon.createWithResource(
                this@EmulationActivity,
                R.drawable.ic_pip_unmute
@ -389,9 +389,9 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
                if (!NativeLibrary.isPaused()) NativeLibrary.pauseEmulation()
            }
            if (intent.action == actionUnmute) {
-                if (BooleanSetting.AUDIO_MUTED.boolean) BooleanSetting.AUDIO_MUTED.setBoolean(false)
+                if (NativeLibrary.isMuted()) NativeLibrary.unmuteAudio()
            } else if (intent.action == actionMute) {
-                if (!BooleanSetting.AUDIO_MUTED.boolean) BooleanSetting.AUDIO_MUTED.setBoolean(true)
+                if (!NativeLibrary.isMuted()) NativeLibrary.muteAudio()
            }
            buildPictureInPictureParams()
        }
@ -417,7 +417,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
            } catch (ignored: Exception) {
            }
            // Always resume audio, since there is no UI button
-            if (BooleanSetting.AUDIO_MUTED.boolean) BooleanSetting.AUDIO_MUTED.setBoolean(false)
+            if (NativeLibrary.isMuted()) NativeLibrary.unmuteAudio()
        }
    }
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt
@ -4,8 +4,7 @@
 package org.yuzu.yuzu_emu.adapters
 import android.content.Intent
-import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.LayerDrawable
 import android.net.Uri
 import android.text.TextUtils
 import android.view.LayoutInflater
@ -16,10 +15,7 @@ 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
@ -91,24 +87,11 @@ 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.createWithAdaptiveBitmap(
+                IconCompat.createWithBitmap(
-                    layerDrawable.toBitmap(config = Bitmap.Config.ARGB_8888)
+                    (holder.binding.imageGameScreen.drawable as BitmapDrawable).bitmap
                )
            )
            .setIntent(openIntent)
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt
@ -10,7 +10,6 @@ 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),
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/IndeterminateProgressDialogFragment.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/IndeterminateProgressDialogFragment.kt
@ -5,9 +5,6 @@ package org.yuzu.yuzu_emu.fragments
 import android.app.Dialog
 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
@ -24,40 +21,22 @@ 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)
-        binding = DialogProgressBarBinding.inflate(layoutInflater)
+        val progressBinding = DialogProgressBarBinding.inflate(layoutInflater)
-        binding.progressBar.isIndeterminate = true
+        progressBinding.progressBar.isIndeterminate = true
        val dialog = MaterialAlertDialogBuilder(requireContext())
            .setTitle(titleId)
-            .setView(binding.root)
+            .setView(progressBinding.root)
            .create()
        dialog.setCanceledOnTouchOutside(false)
        if (!taskViewModel.isRunning.value) {
            taskViewModel.runTask()
        }
        return dialog
    }
    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.launch {
            repeatOnLifecycle(Lifecycle.State.CREATED) {
                taskViewModel.isComplete.collect {
                    if (it) {
-                        dismiss()
+                        dialog.dismiss()
                        when (val result = taskViewModel.result.value) {
                            is String -> Toast.makeText(requireContext(), result, Toast.LENGTH_LONG)
                                .show()
@ -72,6 +51,11 @@ class IndeterminateProgressDialogFragment : DialogFragment() {
                }
            }
        }
        if (!taskViewModel.isRunning.value) {
            taskViewModel.runTask()
        }
        return dialog
    }
    companion object {
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameIconUtils.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameIconUtils.kt
@ -6,11 +6,9 @@ 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
@ -76,13 +74,4 @@ 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)
    }
 }
--- a/src/android/app/src/main/jni/config.cpp
+++ b/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::strtoul(line.c_str(), nullptr, 16);
+        const auto title_id = std::stoul(line, nullptr, 16);
        const auto disabled_list = config->Get("AddOns", "disabled_" + line, "");
        std::stringstream inner_ss(disabled_list);
--- a/src/android/app/src/main/jni/native.cpp
+++ b/src/android/app/src/main/jni/native.cpp
@ -262,6 +262,9 @@ 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);
@ -327,13 +330,12 @@ 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() {
@ -670,6 +672,18 @@ 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();
 }
--- a/src/android/app/src/main/res/drawable/shortcut.xml
+++ b/src/android/app/src/main/res/drawable/shortcut.xml
@ -1,11 +0,0 @@
 <?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>
--- a/src/android/app/src/main/res/navigation/emulation_navigation.xml
+++ b/src/android/app/src/main/res/navigation/emulation_navigation.xml
@ -27,7 +27,7 @@
            app:nullable="true" />
        <argument
            android:name="menuTag"
-            app:argType="org.yuzu.yuzu_emu.features.settings.model.Settings$MenuTag" />
+            app:argType="string" />
    </activity>
    <action
--- a/src/android/app/src/main/res/values/dimens.xml
+++ b/src/android/app/src/main/res/values/dimens.xml
@ -12,7 +12,6 @@
    <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>
--- a/src/audio_core/CMakeLists.txt
+++ b/src/audio_core/CMakeLists.txt
@ -10,13 +10,6 @@ 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
@ -42,13 +35,6 @@ 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
@ -228,7 +214,7 @@ else()
    )
 endif()
-target_link_libraries(audio_core PUBLIC common core Opus::opus)
+target_link_libraries(audio_core PUBLIC common core)
 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
    target_link_libraries(audio_core PRIVATE dynarmic::dynarmic)
 endif()
--- a/src/audio_core/adsp/adsp.cpp
+++ b/src/audio_core/adsp/adsp.cpp
@ -7,21 +7,12 @@
 namespace AudioCore::ADSP {
 ADSP::ADSP(Core::System& system, Sink::Sink& sink) {
-    audio_renderer = std::make_unique<AudioRenderer::AudioRenderer>(system, sink);
+    audio_renderer =
-    opus_decoder = std::make_unique<OpusDecoder::OpusDecoder>(system);
+        std::make_unique<AudioRenderer::AudioRenderer>(system, system.ApplicationMemory(), sink);
    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
--- a/src/audio_core/adsp/adsp.h
+++ b/src/audio_core/adsp/adsp.h
@ -4,7 +4,6 @@
 #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 {
@ -41,12 +40,10 @@ 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
--- a/src/audio_core/adsp/apps/audio_renderer/audio_renderer.cpp
+++ b/src/audio_core/adsp/apps/audio_renderer/audio_renderer.cpp
@ -14,12 +14,13 @@
 #include "core/core.h"
 #include "core/core_timing.h"
-MICROPROFILE_DEFINE(Audio_Renderer, "Audio", "DSP_AudioRenderer", MP_RGB(60, 19, 97));
+MICROPROFILE_DEFINE(Audio_Renderer, "Audio", "DSP", MP_RGB(60, 19, 97));
 namespace AudioCore::ADSP::AudioRenderer {
-AudioRenderer::AudioRenderer(Core::System& system_, Sink::Sink& sink_)
+AudioRenderer::AudioRenderer(Core::System& system_, Core::Memory::Memory& memory_,
-    : system{system_}, sink{sink_} {}
+                             Sink::Sink& sink_)
    : system{system_}, memory{memory_}, sink{sink_} {}
 AudioRenderer::~AudioRenderer() {
    Stop();
@ -32,8 +33,8 @@ void AudioRenderer::Start() {
    main_thread = std::jthread([this](std::stop_token stop_token) { Main(stop_token); });
-    mailbox.Send(Direction::DSP, Message::InitializeOK);
+    mailbox.Send(Direction::DSP, {Message::InitializeOK, {}});
-    if (mailbox.Receive(Direction::Host) != Message::InitializeOK) {
+    if (mailbox.Receive(Direction::Host).msg != Message::InitializeOK) {
        LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown "
                                 "message response from ADSP!");
        return;
@ -46,8 +47,8 @@ void AudioRenderer::Stop() {
        return;
    }
-    mailbox.Send(Direction::DSP, Message::Shutdown);
+    mailbox.Send(Direction::DSP, {Message::Shutdown, {}});
-    if (mailbox.Receive(Direction::Host) != Message::Shutdown) {
+    if (mailbox.Receive(Direction::Host).msg != Message::Shutdown) {
        LOG_ERROR(Service_Audio, "Host Audio Renderer -- Failed to receive shutdown "
                                 "message response from ADSP!");
    }
@ -66,25 +67,25 @@ 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 msg = Receive(Direction::Host);
+    auto received = Receive(Direction::Host);
-    if (msg != Message::RenderResponse) {
+    if (received.msg != Message::RenderResponse) {
        LOG_ERROR(Service_Audio,
                  "Did not receive the expected render response from the AudioRenderer! Expected "
                  "{}, got {}",
-                  Message::RenderResponse, msg);
+                  Message::RenderResponse, received.msg);
    }
 }
-void AudioRenderer::Send(Direction dir, u32 message) {
+void AudioRenderer::Send(Direction dir, MailboxMessage message) {
    mailbox.Send(dir, std::move(message));
 }
-u32 AudioRenderer::Receive(Direction dir) {
+MailboxMessage AudioRenderer::Receive(Direction dir, bool block) {
-    return mailbox.Receive(dir);
+    return mailbox.Receive(dir, block);
 }
 void AudioRenderer::SetCommandBuffer(s32 session_id, CpuAddr buffer, u64 size, u64 time_limit,
@ -119,7 +120,7 @@ void AudioRenderer::CreateSinkStreams() {
 }
 void AudioRenderer::Main(std::stop_token stop_token) {
-    static constexpr char name[]{"DSP_AudioRenderer_Main"};
+    static constexpr char name[]{"AudioRenderer"};
    MicroProfileOnThreadCreate(name);
    Common::SetCurrentThreadName(name);
    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
@ -127,28 +128,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) != Message::InitializeOK) {
+    if (mailbox.Receive(Direction::DSP).msg != 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 msg{mailbox.Receive(Direction::DSP)};
+        auto received{mailbox.Receive(Direction::DSP)};
-        switch (msg) {
+        switch (received.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{};
@ -204,12 +205,13 @@ 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}!", msg);
+                        "ADSP AudioRenderer received an invalid message, msg={:02X}!",
                        received.msg);
            break;
        }
    }
--- a/src/audio_core/adsp/apps/audio_renderer/audio_renderer.h
+++ b/src/audio_core/adsp/apps/audio_renderer/audio_renderer.h
@ -17,6 +17,13 @@
 namespace Core {
 class System;
 namespace Timing {
 struct EventType;
 }
 namespace Memory {
 class Memory;
 }
 class System;
 } // namespace Core
 namespace AudioCore {
@ -27,19 +34,19 @@ class Sink;
 namespace ADSP::AudioRenderer {
 enum Message : u32 {
-    Invalid = 0,
+    Invalid = 0x00,
-    MapUnmap_Map = 1,
+    MapUnmap_Map = 0x01,
-    MapUnmap_MapResponse = 2,
+    MapUnmap_MapResponse = 0x02,
-    MapUnmap_Unmap = 3,
+    MapUnmap_Unmap = 0x03,
-    MapUnmap_UnmapResponse = 4,
+    MapUnmap_UnmapResponse = 0x04,
-    MapUnmap_InvalidateCache = 5,
+    MapUnmap_InvalidateCache = 0x05,
-    MapUnmap_InvalidateCacheResponse = 6,
+    MapUnmap_InvalidateCacheResponse = 0x06,
-    MapUnmap_Shutdown = 7,
+    MapUnmap_Shutdown = 0x07,
-    MapUnmap_ShutdownResponse = 8,
+    MapUnmap_ShutdownResponse = 0x08,
-    InitializeOK = 22,
+    InitializeOK = 0x16,
-    RenderResponse = 32,
+    RenderResponse = 0x20,
-    Render = 42,
+    Render = 0x2A,
-    Shutdown = 52,
+    Shutdown = 0x34,
 };
 /**
@ -47,7 +54,7 @@ enum Message : u32 {
 */
 class AudioRenderer {
 public:
-    explicit AudioRenderer(Core::System& system, Sink::Sink& sink);
+    explicit AudioRenderer(Core::System& system, Core::Memory::Memory& memory, Sink::Sink& sink);
    ~AudioRenderer();
    /**
@ -65,8 +72,8 @@ public:
    void Signal();
    void Wait();
-    void Send(Direction dir, u32 message);
+    void Send(Direction dir, MailboxMessage message);
-    u32 Receive(Direction dir);
+    MailboxMessage Receive(Direction dir, bool block = true);
    void SetCommandBuffer(s32 session_id, CpuAddr buffer, u64 size, u64 time_limit,
                          u64 applet_resource_user_id, bool reset) noexcept;
@ -87,7 +94,9 @@ private:
    /// Core system
    Core::System& system;
-    /// The output sink the AudioRenderer will send samples to
+    /// Memory
    Core::Memory::Memory& memory;
    /// The output sink the AudioRenderer will use
    Sink::Sink& sink;
    /// The active mailbox
    Mailbox mailbox;
@ -95,13 +104,11 @@ 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};
 };
--- a/src/audio_core/adsp/apps/opus/opus_decode_object.cpp
+++ b/src/audio_core/adsp/apps/opus/opus_decode_object.cpp
@ -1,107 +0,0 @@
 // 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
--- a/src/audio_core/adsp/apps/opus/opus_decode_object.h
+++ b/src/audio_core/adsp/apps/opus/opus_decode_object.h
@ -1,38 +0,0 @@
 // 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
--- a/src/audio_core/adsp/apps/opus/opus_decoder.cpp
+++ b/src/audio_core/adsp/apps/opus/opus_decoder.cpp
@ -1,269 +0,0 @@
 // 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
--- a/src/audio_core/adsp/apps/opus/opus_decoder.h
+++ b/src/audio_core/adsp/apps/opus/opus_decoder.h
@ -1,92 +0,0 @@
 // 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
--- a/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp
+++ b/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp
@ -1,111 +0,0 @@
 // 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
--- a/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.h
+++ b/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.h
@ -1,39 +0,0 @@
 // 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
--- a/src/audio_core/adsp/apps/opus/shared_memory.h
+++ b/src/audio_core/adsp/apps/opus/shared_memory.h
@ -1,17 +0,0 @@
 // 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
--- a/src/audio_core/adsp/mailbox.h
+++ b/src/audio_core/adsp/mailbox.h
@ -3,8 +3,6 @@
 #pragma once
 #include <span>
 #include "common/bounded_threadsafe_queue.h"
 #include "common/common_types.h"
@ -21,6 +19,11 @@ enum class Direction : u32 {
    DSP,
 };
 struct MailboxMessage {
    u32 msg;
    std::span<u8> data;
 };
 class Mailbox {
 public:
    void Initialize(AppMailboxId id_) {
@ -32,19 +35,25 @@ public:
        return id;
    }
-    void Send(Direction dir, u32 message) {
+    void Send(Direction dir, MailboxMessage&& message) {
        auto& queue = dir == Direction::Host ? host_queue : adsp_queue;
-        queue.EmplaceWait(message);
+        queue.EmplaceWait(std::move(message));
    }
-    u32 Receive(Direction dir, std::stop_token stop_token = {}) {
+    MailboxMessage Receive(Direction dir, bool block = true) {
        auto& queue = dir == Direction::Host ? host_queue : adsp_queue;
-        return queue.PopWait(stop_token);
+        MailboxMessage t;
        if (block) {
            queue.PopWait(t);
        } else {
            queue.TryPop(t);
        }
        return t;
    }
    void Reset() {
        id = AppMailboxId::Invalid;
-        u32 t{};
+        MailboxMessage t;
        while (host_queue.TryPop(t)) {
        }
        while (adsp_queue.TryPop(t)) {
@ -53,8 +62,8 @@ public:
 private:
    AppMailboxId id{0};
-    Common::SPSCQueue<u32> host_queue;
+    Common::SPSCQueue<MailboxMessage> host_queue;
-    Common::SPSCQueue<u32> adsp_queue;
+    Common::SPSCQueue<MailboxMessage> adsp_queue;
 };
 } // namespace AudioCore::ADSP
--- a/src/audio_core/opus/decoder.cpp
+++ b/src/audio_core/opus/decoder.cpp
@ -1,179 +0,0 @@
 // 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
--- a/src/audio_core/opus/decoder.h
+++ b/src/audio_core/opus/decoder.h
@ -1,53 +0,0 @@
 // 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
--- a/src/audio_core/opus/decoder_manager.cpp
+++ b/src/audio_core/opus/decoder_manager.cpp
@ -1,102 +0,0 @@
 // 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
--- a/src/audio_core/opus/decoder_manager.h
+++ b/src/audio_core/opus/decoder_manager.h
@ -1,38 +0,0 @@
 // 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
--- a/src/audio_core/opus/hardware_opus.cpp
+++ b/src/audio_core/opus/hardware_opus.cpp
@ -1,241 +0,0 @@
 // 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
--- a/src/audio_core/opus/hardware_opus.h
+++ b/src/audio_core/opus/hardware_opus.h
@ -1,45 +0,0 @@
 // 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
--- a/src/audio_core/opus/parameters.h
+++ b/src/audio_core/opus/parameters.h
@ -1,54 +0,0 @@
 // 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
--- a/src/audio_core/renderer/command/command_processing_time_estimator.cpp
+++ b/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.46f * 1.2f);
+    return static_cast<u32>(command.pitch * 0.25f * 1.2f);
 }
 u32 CommandProcessingTimeEstimatorVersion1::Estimate(
    const AdpcmDataSourceVersion2Command& command) const {
-    return static_cast<u32>(command.pitch * 0.46f * 1.2f);
+    return static_cast<u32>(command.pitch * 0.25f * 1.2f);
 }
 u32 CommandProcessingTimeEstimatorVersion1::Estimate(
--- a/src/audio_core/renderer/system.cpp
+++ b/src/audio_core/renderer/system.cpp
@ -684,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();
@ -708,13 +708,11 @@ 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>(std::max(dsp_time_limit + estimated_time, 0.0f))};
+        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)))};
        num_voices_dropped =
            DropVoices(command_buffer, static_cast<u32>(start_estimated_time), time_limit);
    }
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@ -26,11 +26,12 @@ 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
@ -40,8 +41,6 @@ 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
--- a/src/common/bounded_threadsafe_queue.h
+++ b/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;
    }
--- a/src/common/fs/fs.cpp
+++ b/src/common/fs/fs.cpp
@ -528,41 +528,38 @@ 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, ec);
+        return fs::exists(path);
    }
 #else
-    return fs::exists(path, ec);
+    return fs::exists(path);
 #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, ec);
+        return fs::is_regular_file(path);
    }
 #else
-    return fs::is_regular_file(path, ec);
+    return fs::is_regular_file(path);
 #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, ec);
+        return fs::is_directory(path);
    }
 #else
-    return fs::is_directory(path, ec);
+    return fs::is_directory(path);
 #endif
 }
--- a/src/common/settings.h
+++ b/src/common/settings.h
@ -348,8 +348,6 @@ 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,
--- a/src/common/settings_common.h
+++ b/src/common/settings_common.h
@ -225,16 +225,6 @@ 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
     */
--- a/src/common/settings_setting.h
+++ b/src/common/settings_setting.h
@ -10,7 +10,6 @@
 #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"
@ -116,12 +115,8 @@ 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(value_);
+            return std::to_string(static_cast<u64>(value_));
        }
    }
@ -185,15 +180,13 @@ 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, float>) {
+            } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-                this->SetValue(std::stof(input));
+                this->SetValue(ToEnum<Type>(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());
        }
    }
@ -222,27 +215,11 @@ 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 {
-        if constexpr (std::is_arithmetic_v<Type> && !ranged) {
+        return this->ToString(minimum);
            return this->ToString(std::numeric_limits<Type>::min());
        } else {
            return this->ToString(minimum);
        }
    }
    [[nodiscard]] std::string MaxVal() const override final {
-        if constexpr (std::is_arithmetic_v<Type> && !ranged) {
+        return this->ToString(maximum);
            return this->ToString(std::numeric_limits<Type>::max());
        } else {
            return this->ToString(maximum);
        }
    }
    [[nodiscard]] constexpr bool Ranged() const override {
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@ -864,8 +864,6 @@ add_library(core STATIC
    telemetry_session.h
    tools/freezer.cpp
    tools/freezer.h
    tools/renderdoc.cpp
    tools/renderdoc.h
 )
 if (MSVC)
@ -881,7 +879,6 @@ else()
        -Werror=conversion
        -Wno-sign-conversion
        -Wno-cast-function-type
        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
    )
@ -890,7 +887,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 renderdoc)
+target_link_libraries(core PUBLIC Boost::headers PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::opus)
 if (MINGW)
    target_link_libraries(core PRIVATE ${MSWSOCK_LIBRARY})
 endif()
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@ -51,7 +51,6 @@
 #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"
@ -282,10 +281,6 @@ 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;
@ -526,8 +521,6 @@ 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;
@ -1031,10 +1024,6 @@ 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));
 }
--- a/src/core/core.h
+++ b/src/core/core.h
@ -102,10 +102,6 @@ namespace Network {
 class RoomNetwork;
 }
 namespace Tools {
 class RenderdocAPI;
 }
 namespace Core {
 class ARM_Interface;
@ -417,8 +413,6 @@ 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;
--- a/src/core/crypto/key_manager.cpp
+++ b/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::strtoul(out[0].substr(8, 2).c_str(), nullptr, 16);
+                const auto index = std::stoul(out[0].substr(8, 2), 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::strtoul(out[0].substr(18, 2).c_str(), nullptr, 16);
+                const auto index = std::stoul(out[0].substr(18, 2), 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::strtoul(out[0].substr(kv.second.size(), 2).c_str(), nullptr, 16);
+                            std::stoul(out[0].substr(kv.second.size(), 2), 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::strtoul(out[0].substr(std::strlen(match), 2).c_str(), nullptr, 16);
+                            std::stoul(out[0].substr(std::strlen(match), 2), nullptr, 16);
                        s128_keys[{S128KeyType::KeyArea, index, j}] =
                            Common::HexStringToArray<16>(out[1]);
                    }
--- a/src/core/file_sys/ips_layer.cpp
+++ b/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::strtoll(line.substr(19).c_str(), nullptr, 0);
+        offset_shift = std::stoll(line.substr(19), 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::strtoul(patch_line.substr(0, 8).c_str(), nullptr, 16);
+                auto offset = std::stoul(patch_line.substr(0, 8), nullptr, 16);
                offset += static_cast<unsigned long>(offset_shift);
                std::vector<u8> replace;
--- a/src/core/file_sys/patch_manager.cpp
+++ b/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_, std::string_view name) const {
+bool PatchManager::HasNSOPatch(const BuildID& build_id_) 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={}, name={}", build_id, name);
+    LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
--- a/src/core/file_sys/patch_manager.h
+++ b/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, std::string_view name) const;
+    [[nodiscard]] bool HasNSOPatch(const BuildID& build_id) const;
    // Creates a CheatList object with all
    [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@ -752,9 +752,7 @@ 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);
-        if (meta_dir->GetFile(filename)) {
+        removed_data |= meta_dir->DeleteFile(filename);
            removed_data |= meta_dir->DeleteFile(filename);
        }
    }
    return removed_data;
--- a/src/core/hid/hid_core.cpp
+++ b/src/core/hid/hid_core.cpp
@ -154,14 +154,6 @@ NpadIdType HIDCore::GetFirstDisconnectedNpadId() const {
    return NpadIdType::Player1;
 }
 void HIDCore::SetLastActiveController(NpadIdType npad_id) {
    last_active_controller = npad_id;
 }
 NpadIdType HIDCore::GetLastActiveController() const {
    return last_active_controller;
 }
 void HIDCore::EnableAllControllerConfiguration() {
    player_1->EnableConfiguration();
    player_2->EnableConfiguration();
--- a/src/core/hid/hid_core.h
+++ b/src/core/hid/hid_core.h
@ -48,12 +48,6 @@ public:
    /// Returns the first disconnected npad id
    NpadIdType GetFirstDisconnectedNpadId() const;
    /// Sets the npad id of the last active controller
    void SetLastActiveController(NpadIdType npad_id);
    /// Returns the npad id of the last controller that pushed a button
    NpadIdType GetLastActiveController() const;
    /// Sets all emulated controllers into configuring mode.
    void EnableAllControllerConfiguration();
@ -83,7 +77,6 @@ private:
    std::unique_ptr<EmulatedConsole> console;
    std::unique_ptr<EmulatedDevices> devices;
    NpadStyleTag supported_style_tag{NpadStyleSet::All};
    NpadIdType last_active_controller{NpadIdType::Handheld};
 };
 } // namespace Core::HID
--- a/src/core/hle/kernel/k_process.cpp
+++ b/src/core/hle/kernel/k_process.cpp
@ -96,7 +96,6 @@ Result KProcess::Initialize(KProcess* process, Core::System& system, std::string
    process->m_is_suspended = false;
    process->m_schedule_count = 0;
    process->m_is_handle_table_initialized = false;
    process->m_is_hbl = false;
    // Open a reference to the resource limit.
    process->m_resource_limit->Open();
@ -352,14 +351,12 @@ Result KProcess::SetActivity(ProcessActivity activity) {
    R_SUCCEED();
 }
-Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
+Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size) {
                                  bool is_hbl) {
    m_program_id = metadata.GetTitleID();
    m_ideal_core = metadata.GetMainThreadCore();
    m_is_64bit_process = metadata.Is64BitProgram();
    m_system_resource_size = metadata.GetSystemResourceSize();
    m_image_size = code_size;
    m_is_hbl = is_hbl;
    if (metadata.GetAddressSpaceType() == FileSys::ProgramAddressSpaceType::Is39Bit) {
        // For 39-bit processes, the ASLR region starts at 0x800'0000 and is ~512GiB large.
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@ -338,8 +338,7 @@ public:
     * @returns ResultSuccess if all relevant metadata was able to be
     *          loaded and parsed. Otherwise, an error code is returned.
     */
-    Result LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size,
+    Result LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size);
                            bool is_hbl);
    /**
     * Starts the main application thread for this process.
@ -369,10 +368,6 @@ public:
        return GetProcessId();
    }
    bool IsHbl() const {
        return m_is_hbl;
    }
    bool IsSignaled() const override;
    void DoWorkerTaskImpl();
@ -530,7 +525,6 @@ private:
    bool m_is_immortal{};
    bool m_is_handle_table_initialized{};
    bool m_is_initialized{};
    bool m_is_hbl{};
    std::atomic<u16> m_num_running_threads{};
--- a/src/core/hle/kernel/svc/svc_debug_string.cpp
+++ b/src/core/hle/kernel/svc/svc_debug_string.cpp
@ -14,7 +14,7 @@ Result OutputDebugString(Core::System& system, u64 address, u64 len) {
    std::string str(len, '\0');
    GetCurrentMemory(system.Kernel()).ReadBlock(address, str.data(), str.size());
-    LOG_INFO(Debug_Emulated, "{}", str);
+    LOG_DEBUG(Debug_Emulated, "{}", str);
    R_SUCCEED();
 }
--- a/src/core/hle/kernel/svc/svc_exception.cpp
+++ b/src/core/hle/kernel/svc/svc_exception.cpp
@ -3,7 +3,6 @@
 #include "core/core.h"
 #include "core/debugger/debugger.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/svc_types.h"
@ -108,10 +107,7 @@ void Break(Core::System& system, BreakReason reason, u64 info1, u64 info2) {
        system.ArmInterface(static_cast<std::size_t>(thread_processor_id)).LogBacktrace();
    }
-    const bool is_hbl = GetCurrentProcess(system.Kernel()).IsHbl();
+    if (system.DebuggerEnabled()) {
    const bool should_break = is_hbl || !notification_only;
    if (system.DebuggerEnabled() && should_break) {
        auto* thread = system.Kernel().GetCurrentEmuThread();
        system.GetDebugger().NotifyThreadStopped(thread);
        thread->RequestSuspend(Kernel::SuspendType::Debug);
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@ -62,7 +62,7 @@ enum class ErrorModule : u32 {
    XCD = 108,
    TMP451 = 109,
    NIFM = 110,
-    HwOpus = 111,
+    Hwopus = 111,
    LSM6DS3 = 112,
    Bluetooth = 113,
    VI = 114,
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@ -1386,7 +1386,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
        {25, &IApplicationFunctions::ExtendSaveData, "ExtendSaveData"},
        {26, &IApplicationFunctions::GetSaveDataSize, "GetSaveDataSize"},
        {27, &IApplicationFunctions::CreateCacheStorage, "CreateCacheStorage"},
-        {28, &IApplicationFunctions::GetSaveDataSizeMax, "GetSaveDataSizeMax"},
+        {28, nullptr, "GetSaveDataSizeMax"},
        {29, nullptr, "GetCacheStorageMax"},
        {30, &IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed, "BeginBlockingHomeButtonShortAndLongPressed"},
        {31, &IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed, "EndBlockingHomeButtonShortAndLongPressed"},
@ -1821,18 +1821,6 @@ void IApplicationFunctions::CreateCacheStorage(HLERequestContext& ctx) {
    rb.PushRaw(resp);
 }
 void IApplicationFunctions::GetSaveDataSizeMax(HLERequestContext& ctx) {
    LOG_WARNING(Service_AM, "(STUBBED) called");
    constexpr u64 size_max_normal = 0xFFFFFFF;
    constexpr u64 size_max_journal = 0xFFFFFFF;
    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(ResultSuccess);
    rb.Push(size_max_normal);
    rb.Push(size_max_journal);
 }
 void IApplicationFunctions::QueryApplicationPlayStatistics(HLERequestContext& ctx) {
    LOG_WARNING(Service_AM, "(STUBBED) called");
--- a/src/core/hle/service/am/am.h
+++ b/src/core/hle/service/am/am.h
@ -316,7 +316,6 @@ private:
    void ExtendSaveData(HLERequestContext& ctx);
    void GetSaveDataSize(HLERequestContext& ctx);
    void CreateCacheStorage(HLERequestContext& ctx);
    void GetSaveDataSizeMax(HLERequestContext& ctx);
    void BeginBlockingHomeButtonShortAndLongPressed(HLERequestContext& ctx);
    void EndBlockingHomeButtonShortAndLongPressed(HLERequestContext& ctx);
    void BeginBlockingHomeButton(HLERequestContext& ctx);
--- a/src/core/hle/service/audio/errors.h
+++ b/src/core/hle/service/audio/errors.h
@ -20,16 +20,4 @@ constexpr Result ResultNotSupported{ErrorModule::Audio, 513};
 constexpr Result ResultInvalidHandle{ErrorModule::Audio, 1536};
 constexpr Result ResultInvalidRevision{ErrorModule::Audio, 1537};
 constexpr Result ResultLibOpusAllocFail{ErrorModule::HwOpus, 7};
 constexpr Result ResultInputDataTooSmall{ErrorModule::HwOpus, 8};
 constexpr Result ResultLibOpusInvalidState{ErrorModule::HwOpus, 6};
 constexpr Result ResultLibOpusUnimplemented{ErrorModule::HwOpus, 5};
 constexpr Result ResultLibOpusInvalidPacket{ErrorModule::HwOpus, 17};
 constexpr Result ResultLibOpusInternalError{ErrorModule::HwOpus, 4};
 constexpr Result ResultBufferTooSmall{ErrorModule::HwOpus, 3};
 constexpr Result ResultLibOpusBadArg{ErrorModule::HwOpus, 2};
 constexpr Result ResultInvalidOpusDSPReturnCode{ErrorModule::HwOpus, 259};
 constexpr Result ResultInvalidOpusSampleRate{ErrorModule::HwOpus, 1001};
 constexpr Result ResultInvalidOpusChannelCount{ErrorModule::HwOpus, 1002};
 } // namespace Service::Audio
--- a/src/core/hle/service/audio/hwopus.cpp
+++ b/src/core/hle/service/audio/hwopus.cpp
@ -1,506 +1,420 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include <chrono>
 #include <cstring>
 #include <memory>
 #include <vector>
-#include "audio_core/opus/decoder.h"
+#include <opus.h>
-#include "audio_core/opus/parameters.h"
+#include <opus_multistream.h>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/scratch_buffer.h"
 #include "core/core.h"
 #include "core/hle/service/audio/hwopus.h"
 #include "core/hle/service/ipc_helpers.h"
 namespace Service::Audio {
-using namespace AudioCore::OpusDecoder;
+namespace {
 struct OpusDeleter {
    void operator()(OpusMSDecoder* ptr) const {
        opus_multistream_decoder_destroy(ptr);
    }
 };
-class IHardwareOpusDecoder final : public ServiceFramework<IHardwareOpusDecoder> {
+using OpusDecoderPtr = std::unique_ptr<OpusMSDecoder, OpusDeleter>;
 struct OpusPacketHeader {
    // Packet size in bytes.
    u32_be size;
    // Indicates the final range of the codec's entropy coder.
    u32_be final_range;
 };
 static_assert(sizeof(OpusPacketHeader) == 0x8, "OpusHeader is an invalid size");
 class OpusDecoderState {
 public:
-    explicit IHardwareOpusDecoder(Core::System& system_, HardwareOpus& hardware_opus)
+    /// Describes extra behavior that may be asked of the decoding context.
-        : ServiceFramework{system_, "IHardwareOpusDecoder"},
+    enum class ExtraBehavior {
-          impl{std::make_unique<AudioCore::OpusDecoder::OpusDecoder>(system_, hardware_opus)} {
+        /// No extra behavior.
        None,
        /// Resets the decoder context back to a freshly initialized state.
        ResetContext,
    };
    enum class PerfTime {
        Disabled,
        Enabled,
    };
    explicit OpusDecoderState(OpusDecoderPtr decoder_, u32 sample_rate_, u32 channel_count_)
        : decoder{std::move(decoder_)}, sample_rate{sample_rate_}, channel_count{channel_count_} {}
    // Decodes interleaved Opus packets. Optionally allows reporting time taken to
    // perform the decoding, as well as any relevant extra behavior.
    void DecodeInterleaved(HLERequestContext& ctx, PerfTime perf_time,
                           ExtraBehavior extra_behavior) {
        if (perf_time == PerfTime::Disabled) {
            DecodeInterleavedHelper(ctx, nullptr, extra_behavior);
        } else {
            u64 performance = 0;
            DecodeInterleavedHelper(ctx, &performance, extra_behavior);
        }
    }
 private:
    void DecodeInterleavedHelper(HLERequestContext& ctx, u64* performance,
                                 ExtraBehavior extra_behavior) {
        u32 consumed = 0;
        u32 sample_count = 0;
        samples.resize_destructive(ctx.GetWriteBufferNumElements<opus_int16>());
        if (extra_behavior == ExtraBehavior::ResetContext) {
            ResetDecoderContext();
        }
        if (!DecodeOpusData(consumed, sample_count, ctx.ReadBuffer(), samples, performance)) {
            LOG_ERROR(Audio, "Failed to decode opus data");
            IPC::ResponseBuilder rb{ctx, 2};
            // TODO(ogniK): Use correct error code
            rb.Push(ResultUnknown);
            return;
        }
        const u32 param_size = performance != nullptr ? 6 : 4;
        IPC::ResponseBuilder rb{ctx, param_size};
        rb.Push(ResultSuccess);
        rb.Push<u32>(consumed);
        rb.Push<u32>(sample_count);
        if (performance) {
            rb.Push<u64>(*performance);
        }
        ctx.WriteBuffer(samples);
    }
    bool DecodeOpusData(u32& consumed, u32& sample_count, std::span<const u8> input,
                        std::span<opus_int16> output, u64* out_performance_time) const {
        const auto start_time = std::chrono::steady_clock::now();
        const std::size_t raw_output_sz = output.size() * sizeof(opus_int16);
        if (sizeof(OpusPacketHeader) > input.size()) {
            LOG_ERROR(Audio, "Input is smaller than the header size, header_sz={}, input_sz={}",
                      sizeof(OpusPacketHeader), input.size());
            return false;
        }
        OpusPacketHeader hdr{};
        std::memcpy(&hdr, input.data(), sizeof(OpusPacketHeader));
        if (sizeof(OpusPacketHeader) + static_cast<u32>(hdr.size) > input.size()) {
            LOG_ERROR(Audio, "Input does not fit in the opus header size. data_sz={}, input_sz={}",
                      sizeof(OpusPacketHeader) + static_cast<u32>(hdr.size), input.size());
            return false;
        }
        const auto frame = input.data() + sizeof(OpusPacketHeader);
        const auto decoded_sample_count = opus_packet_get_nb_samples(
            frame, static_cast<opus_int32>(input.size() - sizeof(OpusPacketHeader)),
            static_cast<opus_int32>(sample_rate));
        if (decoded_sample_count * channel_count * sizeof(u16) > raw_output_sz) {
            LOG_ERROR(
                Audio,
                "Decoded data does not fit into the output data, decoded_sz={}, raw_output_sz={}",
                decoded_sample_count * channel_count * sizeof(u16), raw_output_sz);
            return false;
        }
        const int frame_size = (static_cast<int>(raw_output_sz / sizeof(s16) / channel_count));
        const auto out_sample_count =
            opus_multistream_decode(decoder.get(), frame, hdr.size, output.data(), frame_size, 0);
        if (out_sample_count < 0) {
            LOG_ERROR(Audio,
                      "Incorrect sample count received from opus_decode, "
                      "output_sample_count={}, frame_size={}, data_sz_from_hdr={}",
                      out_sample_count, frame_size, static_cast<u32>(hdr.size));
            return false;
        }
        const auto end_time = std::chrono::steady_clock::now() - start_time;
        sample_count = out_sample_count;
        consumed = static_cast<u32>(sizeof(OpusPacketHeader) + hdr.size);
        if (out_performance_time != nullptr) {
            *out_performance_time =
                std::chrono::duration_cast<std::chrono::milliseconds>(end_time).count();
        }
        return true;
    }
    void ResetDecoderContext() {
        ASSERT(decoder != nullptr);
        opus_multistream_decoder_ctl(decoder.get(), OPUS_RESET_STATE);
    }
    OpusDecoderPtr decoder;
    u32 sample_rate;
    u32 channel_count;
    Common::ScratchBuffer<opus_int16> samples;
 };
 class IHardwareOpusDecoderManager final : public ServiceFramework<IHardwareOpusDecoderManager> {
 public:
    explicit IHardwareOpusDecoderManager(Core::System& system_, OpusDecoderState decoder_state_)
        : ServiceFramework{system_, "IHardwareOpusDecoderManager"}, decoder_state{
                                                                        std::move(decoder_state_)} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {0, &IHardwareOpusDecoder::DecodeInterleavedOld, "DecodeInterleavedOld"},
+            {0, &IHardwareOpusDecoderManager::DecodeInterleavedOld, "DecodeInterleavedOld"},
-            {1, &IHardwareOpusDecoder::SetContext, "SetContext"},
+            {1, nullptr, "SetContext"},
-            {2, &IHardwareOpusDecoder::DecodeInterleavedForMultiStreamOld, "DecodeInterleavedForMultiStreamOld"},
+            {2, nullptr, "DecodeInterleavedForMultiStreamOld"},
-            {3, &IHardwareOpusDecoder::SetContextForMultiStream, "SetContextForMultiStream"},
+            {3, nullptr, "SetContextForMultiStream"},
-            {4, &IHardwareOpusDecoder::DecodeInterleavedWithPerfOld, "DecodeInterleavedWithPerfOld"},
+            {4, &IHardwareOpusDecoderManager::DecodeInterleavedWithPerfOld, "DecodeInterleavedWithPerfOld"},
-            {5, &IHardwareOpusDecoder::DecodeInterleavedForMultiStreamWithPerfOld, "DecodeInterleavedForMultiStreamWithPerfOld"},
+            {5, nullptr, "DecodeInterleavedForMultiStreamWithPerfOld"},
-            {6, &IHardwareOpusDecoder::DecodeInterleavedWithPerfAndResetOld, "DecodeInterleavedWithPerfAndResetOld"},
+            {6, &IHardwareOpusDecoderManager::DecodeInterleaved, "DecodeInterleavedWithPerfAndResetOld"},
-            {7, &IHardwareOpusDecoder::DecodeInterleavedForMultiStreamWithPerfAndResetOld, "DecodeInterleavedForMultiStreamWithPerfAndResetOld"},
+            {7, nullptr, "DecodeInterleavedForMultiStreamWithPerfAndResetOld"},
-            {8, &IHardwareOpusDecoder::DecodeInterleaved, "DecodeInterleaved"},
+            {8, &IHardwareOpusDecoderManager::DecodeInterleaved, "DecodeInterleaved"},
-            {9, &IHardwareOpusDecoder::DecodeInterleavedForMultiStream, "DecodeInterleavedForMultiStream"},
+            {9, &IHardwareOpusDecoderManager::DecodeInterleavedForMultiStream, "DecodeInterleavedForMultiStream"},
        };
        // clang-format on
        RegisterHandlers(functions);
    }
    Result Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
                      u64 transfer_memory_size) {
        return impl->Initialize(params, transfer_memory, transfer_memory_size);
    }
    Result Initialize(OpusMultiStreamParametersEx& params, Kernel::KTransferMemory* transfer_memory,
                      u64 transfer_memory_size) {
        return impl->Initialize(params, transfer_memory, transfer_memory_size);
    }
 private:
    void DecodeInterleavedOld(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
+        LOG_DEBUG(Audio, "called");
-        auto input_data{ctx.ReadBuffer(0)};
+        decoder_state.DecodeInterleaved(ctx, OpusDecoderState::PerfTime::Disabled,
-        output_data.resize_destructive(ctx.GetWriteBufferSize());
+                                        OpusDecoderState::ExtraBehavior::None);
        u32 size{};
        u32 sample_count{};
        auto result =
            impl->DecodeInterleaved(&size, nullptr, &sample_count, input_data, output_data, false);
        LOG_DEBUG(Service_Audio, "bytes read 0x{:X} samples generated {}", size, sample_count);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
    }
    void SetContext(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        LOG_DEBUG(Service_Audio, "called");
        auto input_data{ctx.ReadBuffer(0)};
        auto result = impl->SetContext(input_data);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(result);
    }
    void DecodeInterleavedForMultiStreamOld(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto input_data{ctx.ReadBuffer(0)};
        output_data.resize_destructive(ctx.GetWriteBufferSize());
        u32 size{};
        u32 sample_count{};
        auto result = impl->DecodeInterleavedForMultiStream(&size, nullptr, &sample_count,
                                                            input_data, output_data, false);
        LOG_DEBUG(Service_Audio, "bytes read 0x{:X} samples generated {}", size, sample_count);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 4};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
    }
    void SetContextForMultiStream(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        LOG_DEBUG(Service_Audio, "called");
        auto input_data{ctx.ReadBuffer(0)};
        auto result = impl->SetContext(input_data);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(result);
    }
    void DecodeInterleavedWithPerfOld(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
+        LOG_DEBUG(Audio, "called");
-        auto input_data{ctx.ReadBuffer(0)};
+        decoder_state.DecodeInterleaved(ctx, OpusDecoderState::PerfTime::Enabled,
-        output_data.resize_destructive(ctx.GetWriteBufferSize());
+                                        OpusDecoderState::ExtraBehavior::None);
        u32 size{};
        u32 sample_count{};
        u64 time_taken{};
        auto result = impl->DecodeInterleaved(&size, &time_taken, &sample_count, input_data,
                                              output_data, false);
        LOG_DEBUG(Service_Audio, "bytes read 0x{:X} samples generated {} time taken {}", size,
                  sample_count, time_taken);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
        rb.Push(time_taken);
    }
    void DecodeInterleavedForMultiStreamWithPerfOld(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto input_data{ctx.ReadBuffer(0)};
        output_data.resize_destructive(ctx.GetWriteBufferSize());
        u32 size{};
        u32 sample_count{};
        u64 time_taken{};
        auto result = impl->DecodeInterleavedForMultiStream(&size, &time_taken, &sample_count,
                                                            input_data, output_data, false);
        LOG_DEBUG(Service_Audio, "bytes read 0x{:X} samples generated {} time taken {}", size,
                  sample_count, time_taken);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
        rb.Push(time_taken);
    }
    void DecodeInterleavedWithPerfAndResetOld(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto reset{rp.Pop<bool>()};
        auto input_data{ctx.ReadBuffer(0)};
        output_data.resize_destructive(ctx.GetWriteBufferSize());
        u32 size{};
        u32 sample_count{};
        u64 time_taken{};
        auto result = impl->DecodeInterleaved(&size, &time_taken, &sample_count, input_data,
                                              output_data, reset);
        LOG_DEBUG(Service_Audio, "reset {} bytes read 0x{:X} samples generated {} time taken {}",
                  reset, size, sample_count, time_taken);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
        rb.Push(time_taken);
    }
    void DecodeInterleavedForMultiStreamWithPerfAndResetOld(HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        auto reset{rp.Pop<bool>()};
        auto input_data{ctx.ReadBuffer(0)};
        output_data.resize_destructive(ctx.GetWriteBufferSize());
        u32 size{};
        u32 sample_count{};
        u64 time_taken{};
        auto result = impl->DecodeInterleavedForMultiStream(&size, &time_taken, &sample_count,
                                                            input_data, output_data, reset);
        LOG_DEBUG(Service_Audio, "reset {} bytes read 0x{:X} samples generated {} time taken {}",
                  reset, size, sample_count, time_taken);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
        rb.Push(time_taken);
    }
    void DecodeInterleaved(HLERequestContext& ctx) {
        LOG_DEBUG(Audio, "called");
        IPC::RequestParser rp{ctx};
        const auto extra_behavior = rp.Pop<bool>() ? OpusDecoderState::ExtraBehavior::ResetContext
                                                   : OpusDecoderState::ExtraBehavior::None;
-        auto reset{rp.Pop<bool>()};
+        decoder_state.DecodeInterleaved(ctx, OpusDecoderState::PerfTime::Enabled, extra_behavior);
        auto input_data{ctx.ReadBuffer(0)};
        output_data.resize_destructive(ctx.GetWriteBufferSize());
        u32 size{};
        u32 sample_count{};
        u64 time_taken{};
        auto result = impl->DecodeInterleaved(&size, &time_taken, &sample_count, input_data,
                                              output_data, reset);
        LOG_DEBUG(Service_Audio, "reset {} bytes read 0x{:X} samples generated {} time taken {}",
                  reset, size, sample_count, time_taken);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
        rb.Push(time_taken);
    }
    void DecodeInterleavedForMultiStream(HLERequestContext& ctx) {
        LOG_DEBUG(Audio, "called");
        IPC::RequestParser rp{ctx};
        const auto extra_behavior = rp.Pop<bool>() ? OpusDecoderState::ExtraBehavior::ResetContext
                                                   : OpusDecoderState::ExtraBehavior::None;
-        auto reset{rp.Pop<bool>()};
+        decoder_state.DecodeInterleaved(ctx, OpusDecoderState::PerfTime::Enabled, extra_behavior);
        auto input_data{ctx.ReadBuffer(0)};
        output_data.resize_destructive(ctx.GetWriteBufferSize());
        u32 size{};
        u32 sample_count{};
        u64 time_taken{};
        auto result = impl->DecodeInterleavedForMultiStream(&size, &time_taken, &sample_count,
                                                            input_data, output_data, reset);
        LOG_DEBUG(Service_Audio, "reset {} bytes read 0x{:X} samples generated {} time taken {}",
                  reset, size, sample_count, time_taken);
        ctx.WriteBuffer(output_data);
        IPC::ResponseBuilder rb{ctx, 6};
        rb.Push(result);
        rb.Push(size);
        rb.Push(sample_count);
        rb.Push(time_taken);
    }
-    std::unique_ptr<AudioCore::OpusDecoder::OpusDecoder> impl;
+    OpusDecoderState decoder_state;
    Common::ScratchBuffer<u8> output_data;
 };
-void HwOpus::OpenHardwareOpusDecoder(HLERequestContext& ctx) {
+std::size_t WorkerBufferSize(u32 channel_count) {
-    IPC::RequestParser rp{ctx};
+    ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
-
+    constexpr int num_streams = 1;
-    auto params = rp.PopRaw<OpusParameters>();
+    const int num_stereo_streams = channel_count == 2 ? 1 : 0;
-    auto transfer_memory_size{rp.Pop<u32>()};
+    return opus_multistream_decoder_get_size(num_streams, num_stereo_streams);
    auto transfer_memory_handle{ctx.GetCopyHandle(0)};
    auto transfer_memory{
        system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
            transfer_memory_handle)};
    LOG_DEBUG(Service_Audio, "sample_rate {} channel_count {} transfer_memory_size 0x{:X}",
              params.sample_rate, params.channel_count, transfer_memory_size);
    auto decoder{std::make_shared<IHardwareOpusDecoder>(system, impl.GetHardwareOpus())};
    OpusParametersEx ex{
        .sample_rate = params.sample_rate,
        .channel_count = params.channel_count,
        .use_large_frame_size = false,
    };
    auto result = decoder->Initialize(ex, transfer_memory.GetPointerUnsafe(), transfer_memory_size);
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(result);
    rb.PushIpcInterface(decoder);
 }
 // Creates the mapping table that maps the input channels to the particular
 // output channels. In the stereo case, we map the left and right input channels
 // to the left and right output channels respectively.
 //
 // However, in the monophonic case, we only map the one available channel
 // to the sole output channel. We specify 255 for the would-be right channel
 // as this is a special value defined by Opus to indicate to the decoder to
 // ignore that channel.
 std::array<u8, 2> CreateMappingTable(u32 channel_count) {
    if (channel_count == 2) {
        return {{0, 1}};
    }
    return {{0, 255}};
 }
 } // Anonymous namespace
 void HwOpus::GetWorkBufferSize(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    auto params = rp.PopRaw<OpusParameters>();
+    const auto sample_rate = rp.Pop<u32>();
    const auto channel_count = rp.Pop<u32>();
-    u64 size{};
+    LOG_DEBUG(Audio, "called with sample_rate={}, channel_count={}", sample_rate, channel_count);
    auto result = impl.GetWorkBufferSize(params, size);
-    LOG_DEBUG(Service_Audio, "sample_rate {} channel_count {} -- returned size 0x{:X}",
+    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
-              params.sample_rate, params.channel_count, size);
+                   sample_rate == 12000 || sample_rate == 8000,
               "Invalid sample rate");
    ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
-    IPC::ResponseBuilder rb{ctx, 4};
+    const u32 worker_buffer_sz = static_cast<u32>(WorkerBufferSize(channel_count));
-    rb.Push(result);
+    LOG_DEBUG(Audio, "worker_buffer_sz={}", worker_buffer_sz);
-    rb.Push(size);
+
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(ResultSuccess);
    rb.Push<u32>(worker_buffer_sz);
 }
-void HwOpus::OpenHardwareOpusDecoderForMultiStream(HLERequestContext& ctx) {
+void HwOpus::GetWorkBufferSizeEx(HLERequestContext& ctx) {
    GetWorkBufferSize(ctx);
 }
 void HwOpus::GetWorkBufferSizeExEx(HLERequestContext& ctx) {
    GetWorkBufferSizeEx(ctx);
 }
 void HwOpus::GetWorkBufferSizeForMultiStreamEx(HLERequestContext& ctx) {
    OpusMultiStreamParametersEx param;
    std::memcpy(&param, ctx.ReadBuffer().data(), ctx.GetReadBufferSize());
    const auto sample_rate = param.sample_rate;
    const auto channel_count = param.channel_count;
    const auto number_streams = param.number_streams;
    const auto number_stereo_streams = param.number_stereo_streams;
    LOG_DEBUG(
        Audio,
        "called with sample_rate={}, channel_count={}, number_streams={}, number_stereo_streams={}",
        sample_rate, channel_count, number_streams, number_stereo_streams);
    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
                   sample_rate == 12000 || sample_rate == 8000,
               "Invalid sample rate");
    const u32 worker_buffer_sz =
        static_cast<u32>(opus_multistream_decoder_get_size(number_streams, number_stereo_streams));
    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(ResultSuccess);
    rb.Push<u32>(worker_buffer_sz);
 }
 void HwOpus::OpenHardwareOpusDecoder(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto sample_rate = rp.Pop<u32>();
    const auto channel_count = rp.Pop<u32>();
    const auto buffer_sz = rp.Pop<u32>();
-    auto input{ctx.ReadBuffer()};
+    LOG_DEBUG(Audio, "called sample_rate={}, channel_count={}, buffer_size={}", sample_rate,
-    OpusMultiStreamParameters params;
+              channel_count, buffer_sz);
    std::memcpy(&params, input.data(), sizeof(OpusMultiStreamParameters));
-    auto transfer_memory_size{rp.Pop<u32>()};
+    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
-    auto transfer_memory_handle{ctx.GetCopyHandle(0)};
+                   sample_rate == 12000 || sample_rate == 8000,
-    auto transfer_memory{
+               "Invalid sample rate");
-        system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
+    ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
            transfer_memory_handle)};
-    LOG_DEBUG(Service_Audio,
+    const std::size_t worker_sz = WorkerBufferSize(channel_count);
-              "sample_rate {} channel_count {} total_stream_count {} stereo_stream_count {} "
+    ASSERT_MSG(buffer_sz >= worker_sz, "Worker buffer too large");
              "transfer_memory_size 0x{:X}",
              params.sample_rate, params.channel_count, params.total_stream_count,
              params.stereo_stream_count, transfer_memory_size);
-    auto decoder{std::make_shared<IHardwareOpusDecoder>(system, impl.GetHardwareOpus())};
+    const int num_stereo_streams = channel_count == 2 ? 1 : 0;
    const auto mapping_table = CreateMappingTable(channel_count);
-    OpusMultiStreamParametersEx ex{
+    int error = 0;
-        .sample_rate = params.sample_rate,
+    OpusDecoderPtr decoder{
-        .channel_count = params.channel_count,
+        opus_multistream_decoder_create(sample_rate, static_cast<int>(channel_count), 1,
-        .total_stream_count = params.total_stream_count,
+                                        num_stereo_streams, mapping_table.data(), &error)};
-        .stereo_stream_count = params.stereo_stream_count,
+    if (error != OPUS_OK || decoder == nullptr) {
-        .use_large_frame_size = false,
+        LOG_ERROR(Audio, "Failed to create Opus decoder (error={}).", error);
-        .mappings{},
+        IPC::ResponseBuilder rb{ctx, 2};
-    };
+        // TODO(ogniK): Use correct error code
-    std::memcpy(ex.mappings.data(), params.mappings.data(), sizeof(params.mappings));
+        rb.Push(ResultUnknown);
-    auto result = decoder->Initialize(ex, transfer_memory.GetPointerUnsafe(), transfer_memory_size);
+        return;
    }
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(result);
+    rb.Push(ResultSuccess);
-    rb.PushIpcInterface(decoder);
+    rb.PushIpcInterface<IHardwareOpusDecoderManager>(
-}
+        system, OpusDecoderState{std::move(decoder), sample_rate, channel_count});
 void HwOpus::GetWorkBufferSizeForMultiStream(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    auto input{ctx.ReadBuffer()};
    OpusMultiStreamParameters params;
    std::memcpy(&params, input.data(), sizeof(OpusMultiStreamParameters));
    u64 size{};
    auto result = impl.GetWorkBufferSizeForMultiStream(params, size);
    LOG_DEBUG(Service_Audio, "size 0x{:X}", size);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(result);
    rb.Push(size);
 }
 void HwOpus::OpenHardwareOpusDecoderEx(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto sample_rate = rp.Pop<u32>();
    const auto channel_count = rp.Pop<u32>();
-    auto params = rp.PopRaw<OpusParametersEx>();
+    LOG_DEBUG(Audio, "called sample_rate={}, channel_count={}", sample_rate, channel_count);
    auto transfer_memory_size{rp.Pop<u32>()};
    auto transfer_memory_handle{ctx.GetCopyHandle(0)};
    auto transfer_memory{
        system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
            transfer_memory_handle)};
-    LOG_DEBUG(Service_Audio, "sample_rate {} channel_count {} transfer_memory_size 0x{:X}",
+    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
-              params.sample_rate, params.channel_count, transfer_memory_size);
+                   sample_rate == 12000 || sample_rate == 8000,
               "Invalid sample rate");
    ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
-    auto decoder{std::make_shared<IHardwareOpusDecoder>(system, impl.GetHardwareOpus())};
+    const int num_stereo_streams = channel_count == 2 ? 1 : 0;
    const auto mapping_table = CreateMappingTable(channel_count);
-    auto result =
+    int error = 0;
-        decoder->Initialize(params, transfer_memory.GetPointerUnsafe(), transfer_memory_size);
+    OpusDecoderPtr decoder{
        opus_multistream_decoder_create(sample_rate, static_cast<int>(channel_count), 1,
                                        num_stereo_streams, mapping_table.data(), &error)};
    if (error != OPUS_OK || decoder == nullptr) {
        LOG_ERROR(Audio, "Failed to create Opus decoder (error={}).", error);
        IPC::ResponseBuilder rb{ctx, 2};
        // TODO(ogniK): Use correct error code
        rb.Push(ResultUnknown);
        return;
    }
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(result);
+    rb.Push(ResultSuccess);
-    rb.PushIpcInterface(decoder);
+    rb.PushIpcInterface<IHardwareOpusDecoderManager>(
-}
+        system, OpusDecoderState{std::move(decoder), sample_rate, channel_count});
 void HwOpus::GetWorkBufferSizeEx(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    auto params = rp.PopRaw<OpusParametersEx>();
    u64 size{};
    auto result = impl.GetWorkBufferSizeEx(params, size);
    LOG_DEBUG(Service_Audio, "size 0x{:X}", size);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(result);
    rb.Push(size);
 }
 void HwOpus::OpenHardwareOpusDecoderForMultiStreamEx(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    auto input{ctx.ReadBuffer()};
    OpusMultiStreamParametersEx params;
-    std::memcpy(&params, input.data(), sizeof(OpusMultiStreamParametersEx));
+    std::memcpy(&params, ctx.ReadBuffer().data(), ctx.GetReadBufferSize());
-    auto transfer_memory_size{rp.Pop<u32>()};
+    const auto& sample_rate = params.sample_rate;
-    auto transfer_memory_handle{ctx.GetCopyHandle(0)};
+    const auto& channel_count = params.channel_count;
    auto transfer_memory{
        system.ApplicationProcess()->GetHandleTable().GetObject<Kernel::KTransferMemory>(
            transfer_memory_handle)};
-    LOG_DEBUG(Service_Audio,
+    LOG_INFO(
-              "sample_rate {} channel_count {} total_stream_count {} stereo_stream_count {} "
+        Audio,
-              "use_large_frame_size {}"
+        "called with sample_rate={}, channel_count={}, number_streams={}, number_stereo_streams={}",
-              "transfer_memory_size 0x{:X}",
+        sample_rate, channel_count, params.number_streams, params.number_stereo_streams);
              params.sample_rate, params.channel_count, params.total_stream_count,
              params.stereo_stream_count, params.use_large_frame_size, transfer_memory_size);
-    auto decoder{std::make_shared<IHardwareOpusDecoder>(system, impl.GetHardwareOpus())};
+    ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
                   sample_rate == 12000 || sample_rate == 8000,
               "Invalid sample rate");
-    auto result =
+    int error = 0;
-        decoder->Initialize(params, transfer_memory.GetPointerUnsafe(), transfer_memory_size);
+    OpusDecoderPtr decoder{opus_multistream_decoder_create(
        sample_rate, static_cast<int>(channel_count), params.number_streams,
        params.number_stereo_streams, params.channel_mappings.data(), &error)};
    if (error != OPUS_OK || decoder == nullptr) {
        LOG_ERROR(Audio, "Failed to create Opus decoder (error={}).", error);
        IPC::ResponseBuilder rb{ctx, 2};
        // TODO(ogniK): Use correct error code
        rb.Push(ResultUnknown);
        return;
    }
    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(result);
+    rb.Push(ResultSuccess);
-    rb.PushIpcInterface(decoder);
+    rb.PushIpcInterface<IHardwareOpusDecoderManager>(
        system, OpusDecoderState{std::move(decoder), sample_rate, channel_count});
 }
-void HwOpus::GetWorkBufferSizeForMultiStreamEx(HLERequestContext& ctx) {
+HwOpus::HwOpus(Core::System& system_) : ServiceFramework{system_, "hwopus"} {
    IPC::RequestParser rp{ctx};
    auto input{ctx.ReadBuffer()};
    OpusMultiStreamParametersEx params;
    std::memcpy(&params, input.data(), sizeof(OpusMultiStreamParametersEx));
    u64 size{};
    auto result = impl.GetWorkBufferSizeForMultiStreamEx(params, size);
    LOG_DEBUG(Service_Audio,
              "sample_rate {} channel_count {} total_stream_count {} stereo_stream_count {} "
              "use_large_frame_size {} -- returned size 0x{:X}",
              params.sample_rate, params.channel_count, params.total_stream_count,
              params.stereo_stream_count, params.use_large_frame_size, size);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(result);
    rb.Push(size);
 }
 void HwOpus::GetWorkBufferSizeExEx(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    auto params = rp.PopRaw<OpusParametersEx>();
    u64 size{};
    auto result = impl.GetWorkBufferSizeExEx(params, size);
    LOG_DEBUG(Service_Audio, "size 0x{:X}", size);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(result);
    rb.Push(size);
 }
 void HwOpus::GetWorkBufferSizeForMultiStreamExEx(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    auto input{ctx.ReadBuffer()};
    OpusMultiStreamParametersEx params;
    std::memcpy(&params, input.data(), sizeof(OpusMultiStreamParametersEx));
    u64 size{};
    auto result = impl.GetWorkBufferSizeForMultiStreamExEx(params, size);
    LOG_DEBUG(Service_Audio, "size 0x{:X}", size);
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(result);
    rb.Push(size);
 }
 HwOpus::HwOpus(Core::System& system_)
    : ServiceFramework{system_, "hwopus"}, system{system_}, impl{system} {
    static const FunctionInfo functions[] = {
        {0, &HwOpus::OpenHardwareOpusDecoder, "OpenHardwareOpusDecoder"},
        {1, &HwOpus::GetWorkBufferSize, "GetWorkBufferSize"},
-        {2, &HwOpus::OpenHardwareOpusDecoderForMultiStream, "OpenOpusDecoderForMultiStream"},
+        {2, nullptr, "OpenOpusDecoderForMultiStream"},
-        {3, &HwOpus::GetWorkBufferSizeForMultiStream, "GetWorkBufferSizeForMultiStream"},
+        {3, nullptr, "GetWorkBufferSizeForMultiStream"},
        {4, &HwOpus::OpenHardwareOpusDecoderEx, "OpenHardwareOpusDecoderEx"},
        {5, &HwOpus::GetWorkBufferSizeEx, "GetWorkBufferSizeEx"},
        {6, &HwOpus::OpenHardwareOpusDecoderForMultiStreamEx,
         "OpenHardwareOpusDecoderForMultiStreamEx"},
        {7, &HwOpus::GetWorkBufferSizeForMultiStreamEx, "GetWorkBufferSizeForMultiStreamEx"},
        {8, &HwOpus::GetWorkBufferSizeExEx, "GetWorkBufferSizeExEx"},
-        {9, &HwOpus::GetWorkBufferSizeForMultiStreamExEx, "GetWorkBufferSizeForMultiStreamExEx"},
+        {9, nullptr, "GetWorkBufferSizeForMultiStreamExEx"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/audio/hwopus.h
+++ b/src/core/hle/service/audio/hwopus.h
@ -3,7 +3,6 @@
 #pragma once
 #include "audio_core/opus/decoder_manager.h"
 #include "core/hle/service/service.h"
 namespace Core {
@ -12,6 +11,18 @@ class System;
 namespace Service::Audio {
 struct OpusMultiStreamParametersEx {
    u32 sample_rate;
    u32 channel_count;
    u32 number_streams;
    u32 number_stereo_streams;
    u32 use_large_frame_size;
    u32 padding;
    std::array<u8, 0x100> channel_mappings;
 };
 static_assert(sizeof(OpusMultiStreamParametersEx) == 0x118,
              "OpusMultiStreamParametersEx has incorrect size");
 class HwOpus final : public ServiceFramework<HwOpus> {
 public:
    explicit HwOpus(Core::System& system_);
@ -19,18 +30,12 @@ public:
 private:
    void OpenHardwareOpusDecoder(HLERequestContext& ctx);
    void GetWorkBufferSize(HLERequestContext& ctx);
    void OpenHardwareOpusDecoderForMultiStream(HLERequestContext& ctx);
    void GetWorkBufferSizeForMultiStream(HLERequestContext& ctx);
    void OpenHardwareOpusDecoderEx(HLERequestContext& ctx);
    void GetWorkBufferSizeEx(HLERequestContext& ctx);
    void OpenHardwareOpusDecoderForMultiStreamEx(HLERequestContext& ctx);
-    void GetWorkBufferSizeForMultiStreamEx(HLERequestContext& ctx);
+    void GetWorkBufferSize(HLERequestContext& ctx);
    void GetWorkBufferSizeEx(HLERequestContext& ctx);
    void GetWorkBufferSizeExEx(HLERequestContext& ctx);
-    void GetWorkBufferSizeForMultiStreamExEx(HLERequestContext& ctx);
+    void GetWorkBufferSizeForMultiStreamEx(HLERequestContext& ctx);
    Core::System& system;
    AudioCore::OpusDecoder::OpusDecoderManager impl;
 };
 } // namespace Service::Audio
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@ -193,7 +193,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        shared_memory->system_properties.use_minus.Assign(1);
        shared_memory->system_properties.is_charging_joy_dual.Assign(
            battery_level.dual.is_charging);
-        shared_memory->applet_footer_type = AppletFooterUiType::SwitchProController;
+        shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::SwitchProController;
        shared_memory->sixaxis_fullkey_properties.is_newly_assigned.Assign(1);
        break;
    case Core::HID::NpadStyleIndex::Handheld:
@ -216,7 +216,8 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        shared_memory->system_properties.is_charging_joy_right.Assign(
            battery_level.right.is_charging);
        shared_memory->assignment_mode = NpadJoyAssignmentMode::Dual;
-        shared_memory->applet_footer_type = AppletFooterUiType::HandheldJoyConLeftJoyConRight;
+        shared_memory->applet_nfc_xcd.applet_footer.type =
            AppletFooterUiType::HandheldJoyConLeftJoyConRight;
        shared_memory->sixaxis_handheld_properties.is_newly_assigned.Assign(1);
        break;
    case Core::HID::NpadStyleIndex::JoyconDual:
@ -246,19 +247,19 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        shared_memory->assignment_mode = NpadJoyAssignmentMode::Dual;
        if (controller.is_dual_left_connected && controller.is_dual_right_connected) {
-            shared_memory->applet_footer_type = AppletFooterUiType::JoyDual;
+            shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyDual;
            shared_memory->fullkey_color.fullkey = body_colors.left;
            shared_memory->battery_level_dual = battery_level.left.battery_level;
            shared_memory->system_properties.is_charging_joy_dual.Assign(
                battery_level.left.is_charging);
        } else if (controller.is_dual_left_connected) {
-            shared_memory->applet_footer_type = AppletFooterUiType::JoyDualLeftOnly;
+            shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyDualLeftOnly;
            shared_memory->fullkey_color.fullkey = body_colors.left;
            shared_memory->battery_level_dual = battery_level.left.battery_level;
            shared_memory->system_properties.is_charging_joy_dual.Assign(
                battery_level.left.is_charging);
        } else {
-            shared_memory->applet_footer_type = AppletFooterUiType::JoyDualRightOnly;
+            shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyDualRightOnly;
            shared_memory->fullkey_color.fullkey = body_colors.right;
            shared_memory->battery_level_dual = battery_level.right.battery_level;
            shared_memory->system_properties.is_charging_joy_dual.Assign(
@ -277,7 +278,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        shared_memory->system_properties.use_minus.Assign(1);
        shared_memory->system_properties.is_charging_joy_left.Assign(
            battery_level.left.is_charging);
-        shared_memory->applet_footer_type = AppletFooterUiType::JoyLeftHorizontal;
+        shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyLeftHorizontal;
        shared_memory->sixaxis_left_properties.is_newly_assigned.Assign(1);
        break;
    case Core::HID::NpadStyleIndex::JoyconRight:
@ -292,7 +293,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
        shared_memory->system_properties.use_plus.Assign(1);
        shared_memory->system_properties.is_charging_joy_right.Assign(
            battery_level.right.is_charging);
-        shared_memory->applet_footer_type = AppletFooterUiType::JoyRightHorizontal;
+        shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::JoyRightHorizontal;
        shared_memory->sixaxis_right_properties.is_newly_assigned.Assign(1);
        break;
    case Core::HID::NpadStyleIndex::GameCube:
@ -313,12 +314,12 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
    case Core::HID::NpadStyleIndex::SNES:
        shared_memory->style_tag.lucia.Assign(1);
        shared_memory->device_type.fullkey.Assign(1);
-        shared_memory->applet_footer_type = AppletFooterUiType::Lucia;
+        shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::Lucia;
        break;
    case Core::HID::NpadStyleIndex::N64:
        shared_memory->style_tag.lagoon.Assign(1);
        shared_memory->device_type.fullkey.Assign(1);
-        shared_memory->applet_footer_type = AppletFooterUiType::Lagon;
+        shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::Lagon;
        break;
    case Core::HID::NpadStyleIndex::SegaGenesis:
        shared_memory->style_tag.lager.Assign(1);
@ -418,17 +419,9 @@ void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
    std::scoped_lock lock{mutex};
    auto& controller = GetControllerFromNpadIdType(npad_id);
    const auto controller_type = controller.device->GetNpadStyleIndex();
    if (!controller.device->IsConnected() && controller.is_connected) {
        DisconnectNpad(npad_id);
        return;
    }
    if (!controller.device->IsConnected()) {
        return;
    }
    if (controller.device->IsConnected() && !controller.is_connected) {
        InitNewlyAddedController(npad_id);
    }
    // This function is unique to yuzu for the turbo buttons and motion to work properly
    controller.device->StatusUpdate();
@ -475,10 +468,6 @@ void Controller_NPad::RequestPadStateUpdate(Core::HID::NpadIdType npad_id) {
        pad_entry.npad_buttons.l.Assign(button_state.zl);
        pad_entry.npad_buttons.r.Assign(button_state.zr);
    }
    if (pad_entry.npad_buttons.raw != Core::HID::NpadButton::None) {
        hid_core.SetLastActiveController(npad_id);
    }
 }
 void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
@ -747,6 +736,14 @@ void Controller_NPad::SetSupportedStyleSet(Core::HID::NpadStyleTag style_set) {
    // Once SetSupportedStyleSet is called controllers are fully initialized
    is_controller_initialized = true;
    // Connect all active controllers
    for (auto& controller : controller_data) {
        const auto& device = controller.device;
        if (device->IsConnected()) {
            AddNewControllerAt(device->GetNpadStyleIndex(), device->GetNpadIdType());
        }
    }
 }
 Core::HID::NpadStyleTag Controller_NPad::GetSupportedStyleSet() const {
@ -1119,7 +1116,7 @@ Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
        .left = {},
        .right = {},
    };
-    shared_memory->applet_footer_type = AppletFooterUiType::None;
+    shared_memory->applet_nfc_xcd.applet_footer.type = AppletFooterUiType::None;
    controller.is_dual_left_connected = true;
    controller.is_dual_right_connected = true;
@ -1511,31 +1508,6 @@ Core::HID::NpadButton Controller_NPad::GetAndResetPressState() {
    return static_cast<Core::HID::NpadButton>(press_state.exchange(0));
 }
 void Controller_NPad::ApplyNpadSystemCommonPolicy() {
    Core::HID::NpadStyleTag styletag{};
    styletag.fullkey.Assign(1);
    styletag.handheld.Assign(1);
    styletag.joycon_dual.Assign(1);
    styletag.system_ext.Assign(1);
    styletag.system.Assign(1);
    SetSupportedStyleSet(styletag);
    SetNpadHandheldActivationMode(NpadHandheldActivationMode::Dual);
    supported_npad_id_types.clear();
    supported_npad_id_types.resize(10);
    supported_npad_id_types[0] = Core::HID::NpadIdType::Player1;
    supported_npad_id_types[1] = Core::HID::NpadIdType::Player2;
    supported_npad_id_types[2] = Core::HID::NpadIdType::Player3;
    supported_npad_id_types[3] = Core::HID::NpadIdType::Player4;
    supported_npad_id_types[4] = Core::HID::NpadIdType::Player5;
    supported_npad_id_types[5] = Core::HID::NpadIdType::Player6;
    supported_npad_id_types[6] = Core::HID::NpadIdType::Player7;
    supported_npad_id_types[7] = Core::HID::NpadIdType::Player8;
    supported_npad_id_types[8] = Core::HID::NpadIdType::Other;
    supported_npad_id_types[9] = Core::HID::NpadIdType::Handheld;
 }
 bool Controller_NPad::IsControllerSupported(Core::HID::NpadStyleIndex controller) const {
    if (controller == Core::HID::NpadStyleIndex::Handheld) {
        const bool support_handheld =
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@ -190,8 +190,6 @@ public:
    // Specifically for cheat engine and other features.
    Core::HID::NpadButton GetAndResetPressState();
    void ApplyNpadSystemCommonPolicy();
    static bool IsNpadIdValid(Core::HID::NpadIdType npad_id);
    static Result IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle& device_handle);
    static Result VerifyValidSixAxisSensorHandle(
@ -362,7 +360,7 @@ private:
    enum class AppletFooterUiType : u8 {
        None = 0,
        HandheldNone = 1,
-        HandheldJoyConLeftOnly = 2,
+        HandheldJoyConLeftOnly = 1,
        HandheldJoyConRightOnly = 3,
        HandheldJoyConLeftJoyConRight = 4,
        JoyDual = 5,
@ -384,6 +382,13 @@ private:
        Lagon = 21,
    };
    struct AppletFooterUi {
        AppletFooterUiAttributes attributes{};
        AppletFooterUiType type{AppletFooterUiType::None};
        INSERT_PADDING_BYTES(0x5B); // Reserved
    };
    static_assert(sizeof(AppletFooterUi) == 0x60, "AppletFooterUi is an invalid size");
    // This is nn::hid::NpadLarkType
    enum class NpadLarkType : u32 {
        Invalid,
@ -414,6 +419,13 @@ private:
        U,
    };
    struct AppletNfcXcd {
        union {
            AppletFooterUi applet_footer{};
            Lifo<NfcXcdDeviceHandleStateImpl, 0x2> nfc_xcd_device_lifo;
        };
    };
    // This is nn::hid::detail::NpadInternalState
    struct NpadInternalState {
        Core::HID::NpadStyleTag style_tag{Core::HID::NpadStyleSet::None};
@ -440,9 +452,7 @@ private:
        Core::HID::NpadBatteryLevel battery_level_dual{};
        Core::HID::NpadBatteryLevel battery_level_left{};
        Core::HID::NpadBatteryLevel battery_level_right{};
-        AppletFooterUiAttributes applet_footer_attributes{};
+        AppletNfcXcd applet_nfc_xcd{};
        AppletFooterUiType applet_footer_type{AppletFooterUiType::None};
        INSERT_PADDING_BYTES(0x5B); // Reserved
        INSERT_PADDING_BYTES(0x20); // Unknown
        Lifo<NpadGcTriggerState, hid_entry_count> gc_trigger_lifo{};
        NpadLarkType lark_type_l_and_main{};
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@ -231,10 +231,8 @@ std::shared_ptr<IAppletResource> Hid::GetAppletResource() {
    return applet_resource;
 }
-Hid::Hid(Core::System& system_, std::shared_ptr<IAppletResource> applet_resource_)
+Hid::Hid(Core::System& system_)
-    : ServiceFramework{system_, "hid"}, applet_resource{applet_resource_}, service_context{
+    : ServiceFramework{system_, "hid"}, service_context{system_, service_name} {
                                                                               system_,
                                                                               service_name} {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, &Hid::CreateAppletResource, "CreateAppletResource"},
@ -2545,9 +2543,8 @@ public:
 class HidSys final : public ServiceFramework<HidSys> {
 public:
-    explicit HidSys(Core::System& system_, std::shared_ptr<IAppletResource> applet_resource_)
+    explicit HidSys(Core::System& system_)
-        : ServiceFramework{system_, "hid:sys"}, service_context{system_, "hid:sys"},
+        : ServiceFramework{system_, "hid:sys"}, service_context{system_, "hid:sys"} {
          applet_resource{applet_resource_} {
        // clang-format off
        static const FunctionInfo functions[] = {
            {31, nullptr, "SendKeyboardLockKeyEvent"},
@ -2759,12 +2756,9 @@ public:
 private:
    void ApplyNpadSystemCommonPolicy(HLERequestContext& ctx) {
        // We already do this for homebrew so we can just stub it out
        LOG_WARNING(Service_HID, "called");
        GetAppletResource()
            ->GetController<Controller_NPad>(HidController::NPad)
            .ApplyNpadSystemCommonPolicy();
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultSuccess);
    }
@ -2774,7 +2768,7 @@ private:
        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(ResultSuccess);
-        rb.PushEnum(system.HIDCore().GetLastActiveController());
+        rb.PushEnum(Core::HID::NpadIdType::Handheld);
    }
    void GetUniquePadsFromNpad(HLERequestContext& ctx) {
@ -2827,28 +2821,17 @@ private:
        rb.PushRaw(touchscreen_config);
    }
    std::shared_ptr<IAppletResource> GetAppletResource() {
        if (applet_resource == nullptr) {
            applet_resource = std::make_shared<IAppletResource>(system, service_context);
        }
        return applet_resource;
    }
    Kernel::KEvent* joy_detach_event;
    KernelHelpers::ServiceContext service_context;
    std::shared_ptr<IAppletResource> applet_resource;
 };
 void LoopProcess(Core::System& system) {
    auto server_manager = std::make_unique<ServerManager>(system);
    std::shared_ptr<IAppletResource> applet_resource;
-    server_manager->RegisterNamedService("hid", std::make_shared<Hid>(system, applet_resource));
+    server_manager->RegisterNamedService("hid", std::make_shared<Hid>(system));
    server_manager->RegisterNamedService("hidbus", std::make_shared<HidBus>(system));
    server_manager->RegisterNamedService("hid:dbg", std::make_shared<HidDbg>(system));
-    server_manager->RegisterNamedService("hid:sys",
+    server_manager->RegisterNamedService("hid:sys", std::make_shared<HidSys>(system));
                                         std::make_shared<HidSys>(system, applet_resource));
    server_manager->RegisterNamedService("irs", std::make_shared<Service::IRS::IRS>(system));
    server_manager->RegisterNamedService("irs:sys",
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@ -95,7 +95,7 @@ private:
 class Hid final : public ServiceFramework<Hid> {
 public:
-    explicit Hid(Core::System& system_, std::shared_ptr<IAppletResource> applet_resource_);
+    explicit Hid(Core::System& system_);
    ~Hid() override;
    std::shared_ptr<IAppletResource> GetAppletResource();
--- a/src/core/hle/service/mii/mii_types.h
+++ b/src/core/hle/service/mii/mii_types.h
@ -606,12 +606,15 @@ struct Nickname {
    static constexpr std::size_t MaxNameSize = 10;
    std::array<char16_t, MaxNameSize> data;
-    // Checks for null or dirty strings
+    // Checks for null, non-zero terminated or dirty strings
    bool IsValid() const {
        if (data[0] == 0) {
            return false;
        }
        if (data[MaxNameSize] != 0) {
            return false;
        }
        std::size_t index = 1;
        while (data[index] != 0) {
            index++;
--- a/src/core/hle/service/nfc/common/device.cpp
+++ b/src/core/hle/service/nfc/common/device.cpp
@ -874,19 +874,17 @@ Result NfcDevice::RestoreAmiibo() {
 }
 Result NfcDevice::Format() {
-    Result result = ResultSuccess;
+    auto result1 = DeleteApplicationArea();
    auto result2 = DeleteRegisterInfo();
-    if (device_state == DeviceState::TagFound) {
+    if (result1.IsError()) {
-        result = Mount(NFP::ModelType::Amiibo, NFP::MountTarget::All);
+        return result1;
    }
-    if (result.IsError()) {
+    if (result2.IsError()) {
-        return result;
+        return result2;
    }
    DeleteApplicationArea();
    DeleteRegisterInfo();
    return Flush();
 }
--- a/src/core/hle/service/sockets/bsd.cpp
+++ b/src/core/hle/service/sockets/bsd.cpp
@ -170,7 +170,7 @@ void BSD::Socket(HLERequestContext& ctx) {
 }
 void BSD::Select(HLERequestContext& ctx) {
-    LOG_DEBUG(Service, "(STUBBED) called");
+    LOG_WARNING(Service, "(STUBBED) called");
    IPC::ResponseBuilder rb{ctx, 4};
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@ -18,7 +18,7 @@ namespace Loader {
 AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys::VirtualFile file_,
                                                                         bool override_update_)
-    : AppLoader(std::move(file_)), override_update(override_update_), is_hbl(false) {
+    : AppLoader(std::move(file_)), override_update(override_update_) {
    const auto file_dir = file->GetContainingDirectory();
    // Title ID
@ -69,9 +69,9 @@ AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys
 }
 AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(
-    FileSys::VirtualDir directory, bool override_update_, bool is_hbl_)
+    FileSys::VirtualDir directory, bool override_update_)
    : AppLoader(directory->GetFile("main")), dir(std::move(directory)),
-      override_update(override_update_), is_hbl(is_hbl_) {}
+      override_update(override_update_) {}
 FileType AppLoader_DeconstructedRomDirectory::IdentifyType(const FileSys::VirtualFile& dir_file) {
    if (FileSys::IsDirectoryExeFS(dir_file->GetContainingDirectory())) {
@ -147,7 +147,7 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
    }
    // Setup the process code layout
-    if (process.LoadFromMetadata(metadata, code_size, is_hbl).IsError()) {
+    if (process.LoadFromMetadata(metadata, code_size).IsError()) {
        return {ResultStatus::ErrorUnableToParseKernelMetadata, {}};
    }
--- a/src/core/loader/deconstructed_rom_directory.h
+++ b/src/core/loader/deconstructed_rom_directory.h
@ -27,8 +27,7 @@ public:
    // Overload to accept exefs directory. Must contain 'main' and 'main.npdm'
    explicit AppLoader_DeconstructedRomDirectory(FileSys::VirtualDir directory,
-                                                 bool override_update_ = false,
+                                                 bool override_update_ = false);
                                                 bool is_hbl_ = false);
    /**
     * Identifies whether or not the given file is a deconstructed ROM directory.
@ -63,7 +62,6 @@ private:
    std::string name;
    u64 title_id{};
    bool override_update;
    bool is_hbl;
    Modules modules;
 };
--- a/src/core/loader/kip.cpp
+++ b/src/core/loader/kip.cpp
@ -90,8 +90,7 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
    codeset.DataSegment().size += kip->GetBSSSize();
    // Setup the process code layout
-    if (process
+    if (process.LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), program_image.size())
            .LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), program_image.size(), false)
            .IsError()) {
        return {ResultStatus::ErrorNotInitialized, {}};
    }
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@ -196,8 +196,7 @@ static bool LoadNroImpl(Kernel::KProcess& process, const std::vector<u8>& data)
    program_image.resize(static_cast<u32>(program_image.size()) + bss_size);
    // Setup the process code layout
-    if (process
+    if (process.LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), program_image.size())
            .LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), program_image.size(), false)
            .IsError()) {
        return false;
    }
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@ -127,14 +127,13 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
    }
    // Apply patches if necessary
-    const auto name = nso_file.GetName();
+    if (pm && (pm->HasNSOPatch(nso_header.build_id) || Settings::values.dump_nso)) {
    if (pm && (pm->HasNSOPatch(nso_header.build_id, name) || Settings::values.dump_nso)) {
        std::vector<u8> pi_header(sizeof(NSOHeader) + program_image.size());
        std::memcpy(pi_header.data(), &nso_header, sizeof(NSOHeader));
        std::memcpy(pi_header.data() + sizeof(NSOHeader), program_image.data(),
                    program_image.size());
-        pi_header = pm->PatchNSO(pi_header, name);
+        pi_header = pm->PatchNSO(pi_header, nso_file.GetName());
        std::copy(pi_header.begin() + sizeof(NSOHeader), pi_header.end(), program_image.data());
    }
--- a/src/core/loader/nsp.cpp
+++ b/src/core/loader/nsp.cpp
@ -30,8 +30,7 @@ AppLoader_NSP::AppLoader_NSP(FileSys::VirtualFile file_,
    }
    if (nsp->IsExtractedType()) {
-        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(
+        secondary_loader = std::make_unique<AppLoader_DeconstructedRomDirectory>(nsp->GetExeFS());
            nsp->GetExeFS(), false, file->GetName() == "hbl.nsp");
    } else {
        const auto control_nca =
            nsp->GetNCA(nsp->GetProgramTitleID(), FileSys::ContentRecordType::Control);
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@ -154,7 +154,7 @@ std::vector<CheatEntry> TextCheatParser::Parse(std::string_view data) const {
                return {};
            }
-            const auto value = static_cast<u32>(std::strtoul(hex.c_str(), nullptr, 0x10));
+            const auto value = static_cast<u32>(std::stoul(hex, nullptr, 0x10));
            out[*current_entry].definition.opcodes[out[*current_entry].definition.num_opcodes++] =
                value;
--- a/src/core/tools/renderdoc.cpp
+++ b/src/core/tools/renderdoc.cpp
@ -1,55 +0,0 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 #include <renderdoc_app.h>
 #include "common/assert.h"
 #include "common/dynamic_library.h"
 #include "core/tools/renderdoc.h"
 #ifdef WIN32
 #include <windows.h>
 #else
 #include <dlfcn.h>
 #endif
 namespace Tools {
 RenderdocAPI::RenderdocAPI() {
 #ifdef WIN32
    if (HMODULE mod = GetModuleHandleA("renderdoc.dll")) {
        const auto RENDERDOC_GetAPI =
            reinterpret_cast<pRENDERDOC_GetAPI>(GetProcAddress(mod, "RENDERDOC_GetAPI"));
        const s32 ret = RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_6_0, (void**)&rdoc_api);
        ASSERT(ret == 1);
    }
 #else
 #ifdef ANDROID
    static constexpr const char RENDERDOC_LIB[] = "libVkLayer_GLES_RenderDoc.so";
 #else
    static constexpr const char RENDERDOC_LIB[] = "librenderdoc.so";
 #endif
    if (void* mod = dlopen(RENDERDOC_LIB, RTLD_NOW | RTLD_NOLOAD)) {
        const auto RENDERDOC_GetAPI =
            reinterpret_cast<pRENDERDOC_GetAPI>(dlsym(mod, "RENDERDOC_GetAPI"));
        const s32 ret = RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_6_0, (void**)&rdoc_api);
        ASSERT(ret == 1);
    }
 #endif
 }
 RenderdocAPI::~RenderdocAPI() = default;
 void RenderdocAPI::ToggleCapture() {
    if (!rdoc_api) [[unlikely]] {
        return;
    }
    if (!is_capturing) {
        rdoc_api->StartFrameCapture(NULL, NULL);
    } else {
        rdoc_api->EndFrameCapture(NULL, NULL);
    }
    is_capturing = !is_capturing;
 }
 } // namespace Tools
--- a/src/core/tools/renderdoc.h
+++ b/src/core/tools/renderdoc.h
@ -1,22 +0,0 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 #pragma once
 struct RENDERDOC_API_1_6_0;
 namespace Tools {
 class RenderdocAPI {
 public:
    explicit RenderdocAPI();
    ~RenderdocAPI();
    void ToggleCapture();
 private:
    RENDERDOC_API_1_6_0* rdoc_api{};
    bool is_capturing{false};
 };
 } // namespace Tools
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@ -294,11 +294,10 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
      texture_cache{texture_cache_}, shader_notify{shader_notify_},
      use_asynchronous_shaders{Settings::values.use_asynchronous_shaders.GetValue()},
      use_vulkan_pipeline_cache{Settings::values.use_vulkan_driver_pipeline_cache.GetValue()},
-#ifdef ANDROID
+      workers(device.GetDriverID() == VK_DRIVER_ID_QUALCOMM_PROPRIETARY
-      workers(1, "VkPipelineBuilder"),
+                  ? 1
-#else
+                  : (std::max(std::thread::hardware_concurrency(), 2U) - 1),
-      workers(std::max(std::thread::hardware_concurrency(), 2U) - 1, "VkPipelineBuilder"),
+              "VkPipelineBuilder"),
 #endif
      serialization_thread(1, "VkPipelineSerialization") {
    const auto& float_control{device.FloatControlProperties()};
    const VkDriverId driver_id{device.GetDriverID()};
--- a/src/video_core/texture_cache/format_lookup_table.cpp
+++ b/src/video_core/texture_cache/format_lookup_table.cpp
@ -140,8 +140,6 @@ PixelFormat PixelFormatFromTextureInfo(TextureFormat format, ComponentType red,
        return PixelFormat::D32_FLOAT;
    case Hash(TextureFormat::Z16, UNORM):
        return PixelFormat::D16_UNORM;
    case Hash(TextureFormat::Z16, UNORM, UINT, UINT, UINT, LINEAR):
        return PixelFormat::D16_UNORM;
    case Hash(TextureFormat::Z24S8, UINT, UNORM, UNORM, UNORM, LINEAR):
        return PixelFormat::S8_UINT_D24_UNORM;
    case Hash(TextureFormat::Z24S8, UINT, UNORM, UINT, UINT, LINEAR):
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@ -59,8 +59,6 @@ void ConfigureDebug::SetConfiguration() {
    ui->use_debug_asserts->setChecked(Settings::values.use_debug_asserts.GetValue());
    ui->use_auto_stub->setChecked(Settings::values.use_auto_stub.GetValue());
    ui->enable_all_controllers->setChecked(Settings::values.enable_all_controllers.GetValue());
    ui->enable_renderdoc_hotkey->setEnabled(runtime_lock);
    ui->enable_renderdoc_hotkey->setChecked(Settings::values.enable_renderdoc_hotkey.GetValue());
    ui->enable_graphics_debugging->setEnabled(runtime_lock);
    ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug.GetValue());
    ui->enable_shader_feedback->setEnabled(runtime_lock);
@ -113,7 +111,6 @@ void ConfigureDebug::ApplyConfiguration() {
    Settings::values.use_auto_stub = ui->use_auto_stub->isChecked();
    Settings::values.enable_all_controllers = ui->enable_all_controllers->isChecked();
    Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
    Settings::values.enable_renderdoc_hotkey = ui->enable_renderdoc_hotkey->isChecked();
    Settings::values.renderer_shader_feedback = ui->enable_shader_feedback->isChecked();
    Settings::values.cpu_debug_mode = ui->enable_cpu_debugging->isChecked();
    Settings::values.enable_nsight_aftermath = ui->enable_nsight_aftermath->isChecked();
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@ -18,8 +18,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-     <width>842</width>
+     <width>829</width>
-     <height>741</height>
+     <height>758</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_1">
@ -260,7 +260,7 @@
         <string>Graphics</string>
        </property>
        <layout class="QGridLayout" name="gridLayout_2">
-         <item row="4" column="0">
+         <item row="3" column="0">
          <widget class="QCheckBox" name="disable_loop_safety_checks">
           <property name="toolTip">
            <string>When checked, it executes shaders without loop logic changes</string>
@ -270,7 +270,20 @@
           </property>
          </widget>
         </item>
-         <item row="8" column="0">
+         <item row="4" column="0">
          <widget class="QCheckBox" name="dump_shaders">
           <property name="enabled">
            <bool>true</bool>
           </property>
           <property name="toolTip">
            <string>When checked, it will dump all the original assembler shaders from the disk shader cache or game as found</string>
           </property>
           <property name="text">
            <string>Dump Game Shaders</string>
           </property>
          </widget>
         </item>
         <item row="7" column="0">
          <widget class="QCheckBox" name="disable_macro_hle">
           <property name="enabled">
            <bool>true</bool>
@ -283,40 +296,7 @@
           </property>
          </widget>
         </item>
-         <item row="7" column="0">
+         <item row="5" column="0">
          <widget class="QCheckBox" name="dump_macros">
           <property name="enabled">
            <bool>true</bool>
           </property>
           <property name="toolTip">
            <string>When checked, it will dump all the macro programs of the GPU</string>
           </property>
           <property name="text">
            <string>Dump Maxwell Macros</string>
           </property>
          </widget>
         </item>
         <item row="3" column="0">
          <widget class="QCheckBox" name="enable_nsight_aftermath">
           <property name="toolTip">
            <string>When checked, it enables Nsight Aftermath crash dumps</string>
           </property>
           <property name="text">
            <string>Enable Nsight Aftermath</string>
           </property>
          </widget>
         </item>
         <item row="2" column="0">
          <widget class="QCheckBox" name="enable_shader_feedback">
           <property name="toolTip">
            <string>When checked, yuzu will log statistics about the compiled pipeline cache</string>
           </property>
           <property name="text">
            <string>Enable Shader Feedback</string>
           </property>
          </widget>
         </item>
         <item row="6" column="0">
          <widget class="QCheckBox" name="disable_macro_jit">
           <property name="enabled">
            <bool>true</bool>
@ -329,22 +309,6 @@
           </property>
          </widget>
         </item>
         <item row="9" column="0">
          <spacer name="verticalSpacer_5">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeType">
            <enum>QSizePolicy::Preferred</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>0</height>
            </size>
           </property>
          </spacer>
         </item>
         <item row="0" column="0">
          <widget class="QCheckBox" name="enable_graphics_debugging">
           <property name="enabled">
@ -358,26 +322,55 @@
           </property>
          </widget>
         </item>
-         <item row="5" column="0">
+         <item row="6" column="0">
-          <widget class="QCheckBox" name="dump_shaders">
+          <widget class="QCheckBox" name="dump_macros">
           <property name="enabled">
            <bool>true</bool>
           </property>
           <property name="toolTip">
-            <string>When checked, it will dump all the original assembler shaders from the disk shader cache or game as found</string>
+            <string>When checked, it will dump all the macro programs of the GPU</string>
           </property>
           <property name="text">
-            <string>Dump Game Shaders</string>
+            <string>Dump Maxwell Macros</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
-          <widget class="QCheckBox" name="enable_renderdoc_hotkey">
+          <widget class="QCheckBox" name="enable_shader_feedback">
           <property name="toolTip">
            <string>When checked, yuzu will log statistics about the compiled pipeline cache</string>
           </property>
           <property name="text">
-            <string>Enable Renderdoc Hotkey</string>
+            <string>Enable Shader Feedback</string>
           </property>
          </widget>
         </item>
         <item row="2" column="0">
          <widget class="QCheckBox" name="enable_nsight_aftermath">
           <property name="toolTip">
            <string>When checked, it enables Nsight Aftermath crash dumps</string>
           </property>
           <property name="text">
            <string>Enable Nsight Aftermath</string>
           </property>
          </widget>
         </item>
         <item row="8" column="0">
          <spacer name="verticalSpacer_5">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeType">
            <enum>QSizePolicy::Preferred</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>0</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </widget>
      </item>
--- a/src/yuzu/configuration/configure_ui.cpp
+++ b/src/yuzu/configuration/configure_ui.cpp
@ -4,7 +4,6 @@
 #include "yuzu/configuration/configure_ui.h"
 #include <array>
 #include <cstdlib>
 #include <set>
 #include <stdexcept>
 #include <string>
@ -95,7 +94,11 @@ static void PopulateResolutionComboBox(QComboBox* screenshot_height, QWidget* pa
 }
 static u32 ScreenshotDimensionToInt(const QString& height) {
-    return std::strtoul(height.toUtf8(), nullptr, 0);
+    try {
        return std::stoi(height.toStdString());
    } catch (std::invalid_argument&) {
        return 0;
    }
 }
 ConfigureUi::ConfigureUi(Core::System& system_, QWidget* parent)
--- a/src/yuzu/configuration/shared_widget.cpp
+++ b/src/yuzu/configuration/shared_widget.cpp
@ -63,7 +63,7 @@ static QString DefaultSuffix(QWidget* parent, Settings::BasicSetting& setting) {
        return tr("%", context.c_str());
    }
-    return default_suffix;
+    return QStringLiteral("");
 }
 QPushButton* Widget::CreateRestoreGlobalButton(bool using_global, QWidget* parent) {
@ -71,7 +71,7 @@ QPushButton* Widget::CreateRestoreGlobalButton(bool using_global, QWidget* paren
    QStyle* style = parent->style();
    QIcon* icon = new QIcon(style->standardIcon(QStyle::SP_LineEditClearButton));
-    QPushButton* restore_button = new QPushButton(*icon, QStringLiteral(), parent);
+    QPushButton* restore_button = new QPushButton(*icon, QStringLiteral(""), parent);
    restore_button->setObjectName(QStringLiteral("RestoreButton%1").arg(restore_button_count));
    restore_button->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
@ -151,7 +151,7 @@ QWidget* Widget::CreateCombobox(std::function<std::string()>& serializer,
        return -1;
    };
-    const u32 setting_value = std::strtoul(setting.ToString().c_str(), nullptr, 0);
+    const u32 setting_value = std::stoi(setting.ToString());
    combobox->setCurrentIndex(find_index(setting_value));
    serializer = [this, enumeration]() {
@ -160,7 +160,7 @@ QWidget* Widget::CreateCombobox(std::function<std::string()>& serializer,
    };
    restore_func = [this, find_index]() {
-        const u32 global_value = std::strtoul(RelevantDefault(setting).c_str(), nullptr, 0);
+        const u32 global_value = std::stoi(RelevantDefault(setting));
        combobox->setCurrentIndex(find_index(global_value));
    };
@ -209,7 +209,7 @@ QWidget* Widget::CreateRadioGroup(std::function<std::string()>& serializer,
        }
    };
-    const u32 setting_value = std::strtoul(setting.ToString().c_str(), nullptr, 0);
+    const u32 setting_value = std::stoi(setting.ToString());
    set_index(setting_value);
    serializer = [get_selected]() {
@ -218,7 +218,7 @@ QWidget* Widget::CreateRadioGroup(std::function<std::string()>& serializer,
    };
    restore_func = [this, set_index]() {
-        const u32 global_value = std::strtoul(RelevantDefault(setting).c_str(), nullptr, 0);
+        const u32 global_value = std::stoi(RelevantDefault(setting));
        set_index(global_value);
    };
@ -255,59 +255,6 @@ QWidget* Widget::CreateLineEdit(std::function<std::string()>& serializer,
    return line_edit;
 }
 static void CreateIntSlider(Settings::BasicSetting& setting, bool reversed, float multiplier,
                            QLabel* feedback, const QString& use_format, QSlider* slider,
                            std::function<std::string()>& serializer,
                            std::function<void()>& restore_func) {
    const int max_val = std::strtol(setting.MaxVal().c_str(), nullptr, 0);
    const auto update_feedback = [=](int value) {
        int present = (reversed ? max_val - value : value) * multiplier + 0.5f;
        feedback->setText(use_format.arg(QVariant::fromValue(present).value<QString>()));
    };
    QObject::connect(slider, &QAbstractSlider::valueChanged, update_feedback);
    update_feedback(std::strtol(setting.ToString().c_str(), nullptr, 0));
    slider->setMinimum(std::strtol(setting.MinVal().c_str(), nullptr, 0));
    slider->setMaximum(max_val);
    slider->setValue(std::strtol(setting.ToString().c_str(), nullptr, 0));
    serializer = [slider]() { return std::to_string(slider->value()); };
    restore_func = [slider, &setting]() {
        slider->setValue(std::strtol(RelevantDefault(setting).c_str(), nullptr, 0));
    };
 }
 static void CreateFloatSlider(Settings::BasicSetting& setting, bool reversed, float multiplier,
                              QLabel* feedback, const QString& use_format, QSlider* slider,
                              std::function<std::string()>& serializer,
                              std::function<void()>& restore_func) {
    const float max_val = std::strtof(setting.MaxVal().c_str(), nullptr);
    const float min_val = std::strtof(setting.MinVal().c_str(), nullptr);
    const float use_multiplier =
        multiplier == default_multiplier ? default_float_multiplier : multiplier;
    const auto update_feedback = [=](float value) {
        int present = (reversed ? max_val - value : value) + 0.5f;
        feedback->setText(use_format.arg(QVariant::fromValue(present).value<QString>()));
    };
    QObject::connect(slider, &QAbstractSlider::valueChanged, update_feedback);
    update_feedback(std::strtof(setting.ToString().c_str(), nullptr));
    slider->setMinimum(min_val * use_multiplier);
    slider->setMaximum(max_val * use_multiplier);
    slider->setValue(std::strtof(setting.ToString().c_str(), nullptr) * use_multiplier);
    serializer = [slider, use_multiplier]() {
        return std::to_string(slider->value() / use_multiplier);
    };
    restore_func = [slider, &setting, use_multiplier]() {
        slider->setValue(std::strtof(RelevantDefault(setting).c_str(), nullptr) * use_multiplier);
    };
 }
 QWidget* Widget::CreateSlider(bool reversed, float multiplier, const QString& given_suffix,
                              std::function<std::string()>& serializer,
                              std::function<void()>& restore_func,
@ -331,19 +278,27 @@ QWidget* Widget::CreateSlider(bool reversed, float multiplier, const QString& gi
    layout->setContentsMargins(0, 0, 0, 0);
-    QString suffix = given_suffix == default_suffix ? DefaultSuffix(this, setting) : given_suffix;
+    int max_val = std::stoi(setting.MaxVal());
    QString suffix =
        given_suffix == QStringLiteral("") ? DefaultSuffix(this, setting) : given_suffix;
    const QString use_format = QStringLiteral("%1").append(suffix);
-    if (setting.IsIntegral()) {
+    QObject::connect(slider, &QAbstractSlider::valueChanged, [=](int value) {
-        CreateIntSlider(setting, reversed, multiplier, feedback, use_format, slider, serializer,
+        int present = (reversed ? max_val - value : value) * multiplier + 0.5f;
-                        restore_func);
+        feedback->setText(use_format.arg(QVariant::fromValue(present).value<QString>()));
-    } else {
+    });
-        CreateFloatSlider(setting, reversed, multiplier, feedback, use_format, slider, serializer,
+
-                          restore_func);
+    slider->setMinimum(std::stoi(setting.MinVal()));
-    }
+    slider->setMaximum(max_val);
    slider->setValue(std::stoi(setting.ToString()));
    slider->setInvertedAppearance(reversed);
    slider->setInvertedControls(reversed);
    serializer = [this]() { return std::to_string(slider->value()); };
    restore_func = [this]() { slider->setValue(std::stoi(RelevantDefault(setting))); };
    if (!Settings::IsConfiguringGlobal()) {
        QObject::connect(slider, &QAbstractSlider::actionTriggered, [touch]() { touch(); });
@ -356,11 +311,14 @@ QWidget* Widget::CreateSpinBox(const QString& given_suffix,
                               std::function<std::string()>& serializer,
                               std::function<void()>& restore_func,
                               const std::function<void()>& touch) {
-    const auto min_val = std::strtol(setting.MinVal().c_str(), nullptr, 0);
+    const int min_val =
-    const auto max_val = std::strtol(setting.MaxVal().c_str(), nullptr, 0);
+        setting.Ranged() ? std::stoi(setting.MinVal()) : std::numeric_limits<int>::min();
-    const auto default_val = std::strtol(setting.ToString().c_str(), nullptr, 0);
+    const int max_val =
        setting.Ranged() ? std::stoi(setting.MaxVal()) : std::numeric_limits<int>::max();
    const int default_val = std::stoi(setting.ToString());
-    QString suffix = given_suffix == default_suffix ? DefaultSuffix(this, setting) : given_suffix;
+    QString suffix =
        given_suffix == QStringLiteral("") ? DefaultSuffix(this, setting) : given_suffix;
    spinbox = new QSpinBox(this);
    spinbox->setRange(min_val, max_val);
@ -371,13 +329,13 @@ QWidget* Widget::CreateSpinBox(const QString& given_suffix,
    serializer = [this]() { return std::to_string(spinbox->value()); };
    restore_func = [this]() {
-        auto value{std::strtol(RelevantDefault(setting).c_str(), nullptr, 0)};
+        auto value{std::stol(RelevantDefault(setting))};
        spinbox->setValue(value);
    };
    if (!Settings::IsConfiguringGlobal()) {
        QObject::connect(spinbox, QOverload<int>::of(&QSpinBox::valueChanged), [this, touch]() {
-            if (spinbox->value() != std::strtol(setting.ToStringGlobal().c_str(), nullptr, 0)) {
+            if (spinbox->value() != std::stoi(setting.ToStringGlobal())) {
                touch();
            }
        });
@ -386,42 +344,6 @@ QWidget* Widget::CreateSpinBox(const QString& given_suffix,
    return spinbox;
 }
 QWidget* Widget::CreateDoubleSpinBox(const QString& given_suffix,
                                     std::function<std::string()>& serializer,
                                     std::function<void()>& restore_func,
                                     const std::function<void()>& touch) {
    const auto min_val = std::strtod(setting.MinVal().c_str(), nullptr);
    const auto max_val = std::strtod(setting.MaxVal().c_str(), nullptr);
    const auto default_val = std::strtod(setting.ToString().c_str(), nullptr);
    QString suffix = given_suffix == default_suffix ? DefaultSuffix(this, setting) : given_suffix;
    double_spinbox = new QDoubleSpinBox(this);
    double_spinbox->setRange(min_val, max_val);
    double_spinbox->setValue(default_val);
    double_spinbox->setSuffix(suffix);
    double_spinbox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    serializer = [this]() { return fmt::format("{:f}", double_spinbox->value()); };
    restore_func = [this]() {
        auto value{std::strtod(RelevantDefault(setting).c_str(), nullptr)};
        double_spinbox->setValue(value);
    };
    if (!Settings::IsConfiguringGlobal()) {
        QObject::connect(double_spinbox, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
                         [this, touch]() {
                             if (double_spinbox->value() !=
                                 std::strtod(setting.ToStringGlobal().c_str(), nullptr)) {
                                 touch();
                             }
                         });
    }
    return double_spinbox;
 }
 QWidget* Widget::CreateHexEdit(std::function<std::string()>& serializer,
                               std::function<void()>& restore_func,
                               const std::function<void()>& touch) {
@ -431,8 +353,7 @@ QWidget* Widget::CreateHexEdit(std::function<std::string()>& serializer,
    }
    auto to_hex = [=](const std::string& input) {
-        return QString::fromStdString(
+        return QString::fromStdString(fmt::format("{:08x}", std::stoul(input)));
            fmt::format("{:08x}", std::strtoul(input.c_str(), nullptr, 0)));
    };
    QRegularExpressionValidator* regex = new QRegularExpressionValidator(
@ -445,7 +366,7 @@ QWidget* Widget::CreateHexEdit(std::function<std::string()>& serializer,
    line_edit->setValidator(regex);
    auto hex_to_dec = [this]() -> std::string {
-        return std::to_string(std::strtoul(line_edit->text().toStdString().c_str(), nullptr, 16));
+        return std::to_string(std::stoul(line_edit->text().toStdString(), nullptr, 16));
    };
    serializer = [hex_to_dec]() { return hex_to_dec(); };
@ -465,8 +386,7 @@ QWidget* Widget::CreateDateTimeEdit(bool disabled, bool restrict,
                                    std::function<void()>& restore_func,
                                    const std::function<void()>& touch) {
    const long long current_time = QDateTime::currentSecsSinceEpoch();
-    const s64 the_time =
+    const s64 the_time = disabled ? current_time : std::stoll(setting.ToString());
        disabled ? current_time : std::strtoll(setting.ToString().c_str(), nullptr, 0);
    const auto default_val = QDateTime::fromSecsSinceEpoch(the_time);
    date_time_edit = new QDateTimeEdit(this);
@ -479,7 +399,7 @@ QWidget* Widget::CreateDateTimeEdit(bool disabled, bool restrict,
    auto get_clear_val = [this, restrict, current_time]() {
        return QDateTime::fromSecsSinceEpoch([this, restrict, current_time]() {
            if (restrict && checkbox->checkState() == Qt::Checked) {
-                return std::strtoll(RelevantDefault(setting).c_str(), nullptr, 0);
+                return std::stoll(RelevantDefault(setting));
            }
            return current_time;
        }());
@ -586,7 +506,8 @@ void Widget::SetupComponent(const QString& label, std::function<void()>& load_fu
        } else {
            data_component = CreateCombobox(serializer, restore_func, touch);
        }
-    } else if (setting.IsIntegral()) {
+    } else if (type == typeid(u32) || type == typeid(int) || type == typeid(u16) ||
               type == typeid(s64) || type == typeid(u8)) {
        switch (request) {
        case RequestType::Slider:
        case RequestType::ReverseSlider:
@ -613,20 +534,6 @@ void Widget::SetupComponent(const QString& label, std::function<void()>& load_fu
        default:
            UNIMPLEMENTED();
        }
    } else if (setting.IsFloatingPoint()) {
        switch (request) {
        case RequestType::Default:
        case RequestType::SpinBox:
            data_component = CreateDoubleSpinBox(suffix, serializer, restore_func, touch);
            break;
        case RequestType::Slider:
        case RequestType::ReverseSlider:
            data_component = CreateSlider(request == RequestType::ReverseSlider, multiplier, suffix,
                                          serializer, restore_func, touch);
            break;
        default:
            UNIMPLEMENTED();
        }
    } else if (type == typeid(std::string)) {
        switch (request) {
        case RequestType::Default:
@ -731,10 +638,10 @@ Widget::Widget(Settings::BasicSetting* setting_, const TranslationMap& translati
            return std::pair{translations.at(id).first, translations.at(id).second};
        }
        LOG_WARNING(Frontend, "Translation table lacks entry for \"{}\"", setting_label);
-        return std::pair{QString::fromStdString(setting_label), QStringLiteral()};
+        return std::pair{QString::fromStdString(setting_label), QStringLiteral("")};
    }();
-    if (label == QStringLiteral()) {
+    if (label == QStringLiteral("")) {
        LOG_DEBUG(Frontend, "Translation table has empty entry for \"{}\", skipping...",
                  setting.GetLabel());
        return;
--- a/src/yuzu/configuration/shared_widget.h
+++ b/src/yuzu/configuration/shared_widget.h
@ -22,7 +22,6 @@ class QObject;
 class QPushButton;
 class QSlider;
 class QSpinBox;
 class QDoubleSpinBox;
 class QRadioButton;
 namespace Settings {
@ -44,10 +43,6 @@ enum class RequestType {
    MaxEnum,
 };
 constexpr float default_multiplier{1.f};
 constexpr float default_float_multiplier{100.f};
 static const QString default_suffix = QStringLiteral();
 class Widget : public QWidget {
    Q_OBJECT
@ -71,9 +66,8 @@ public:
                    const ComboboxTranslationMap& combobox_translations, QWidget* parent,
                    bool runtime_lock, std::vector<std::function<void(bool)>>& apply_funcs_,
                    RequestType request = RequestType::Default, bool managed = true,
-                    float multiplier = default_multiplier,
+                    float multiplier = 1.0f, Settings::BasicSetting* other_setting = nullptr,
-                    Settings::BasicSetting* other_setting = nullptr,
+                    const QString& suffix = QStringLiteral(""));
                    const QString& suffix = default_suffix);
    virtual ~Widget();
    /**
@ -95,7 +89,6 @@ public:
    QPushButton* restore_button{}; ///< Restore button for custom configurations
    QLineEdit* line_edit{};        ///< QLineEdit, used for LineEdit and HexEdit
    QSpinBox* spinbox{};
    QDoubleSpinBox* double_spinbox{};
    QCheckBox* checkbox{};
    QSlider* slider{};
    QComboBox* combobox{};
@ -133,9 +126,6 @@ private:
                                const std::function<void()>& touch);
    QWidget* CreateSpinBox(const QString& suffix, std::function<std::string()>& serializer,
                           std::function<void()>& restore_func, const std::function<void()>& touch);
    QWidget* CreateDoubleSpinBox(const QString& suffix, std::function<std::string()>& serializer,
                                 std::function<void()>& restore_func,
                                 const std::function<void()>& touch);
    QWidget* parent;
    const TranslationMap& translations;
@ -155,15 +145,14 @@ public:
    Widget* BuildWidget(Settings::BasicSetting* setting,
                        std::vector<std::function<void(bool)>>& apply_funcs,
                        RequestType request = RequestType::Default, bool managed = true,
-                        float multiplier = default_multiplier,
+                        float multiplier = 1.0f, Settings::BasicSetting* other_setting = nullptr,
-                        Settings::BasicSetting* other_setting = nullptr,
+                        const QString& suffix = QStringLiteral("")) const;
                        const QString& suffix = default_suffix) const;
    Widget* BuildWidget(Settings::BasicSetting* setting,
                        std::vector<std::function<void(bool)>>& apply_funcs,
                        Settings::BasicSetting* other_setting,
                        RequestType request = RequestType::Default,
-                        const QString& suffix = default_suffix) const;
+                        const QString& suffix = QStringLiteral("")) const;
    const ComboboxTranslationMap& ComboboxTranslations() const;
--- a/src/yuzu/hotkeys.h
+++ b/src/yuzu/hotkeys.h
@ -4,12 +4,10 @@
 #pragma once
 #include <map>
 #include <QKeySequence>
 #include <QString>
 #include <QWidget>
 #include "core/hid/hid_types.h"
 class QDialog;
 class QKeySequence;
 class QSettings;
 class QShortcut;
 class ControllerShortcut;
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@ -9,7 +9,6 @@
 #include <memory>
 #include <thread>
 #include "core/loader/nca.h"
 #include "core/tools/renderdoc.h"
 #ifdef __APPLE__
 #include <unistd.h> // for chdir
 #endif
@ -1349,11 +1348,6 @@ void GMainWindow::InitializeHotkeys() {
    connect_shortcut(QStringLiteral("Toggle Framerate Limit"), [] {
        Settings::values.use_speed_limit.SetValue(!Settings::values.use_speed_limit.GetValue());
    });
    connect_shortcut(QStringLiteral("Toggle Renderdoc Capture"), [this] {
        if (Settings::values.enable_renderdoc_hotkey) {
            system->GetRenderdocAPI().ToggleCapture();
        }
    });
    connect_shortcut(QStringLiteral("Toggle Mouse Panning"), [&] {
        if (Settings::values.mouse_enabled) {
            Settings::values.mouse_panning = false;
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@ -259,7 +259,7 @@ void Config::ReadValues() {
    std::stringstream ss(title_list);
    std::string line;
    while (std::getline(ss, line, '|')) {
-        const auto title_id = std::strtoul(line.c_str(), nullptr, 16);
+        const auto title_id = std::stoul(line, nullptr, 16);
        const auto disabled_list = sdl2_config->Get("AddOns", "disabled_" + line, "");
        std::stringstream inner_ss(disabled_list);
--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@ -264,9 +264,8 @@ int main(int argc, char** argv) {
                nickname = match[1];
                password = match[2];
                address = match[3];
-                if (!match[4].str().empty()) {
+                if (!match[4].str().empty())
-                    port = static_cast<u16>(std::strtoul(match[4].str().c_str(), nullptr, 0));
+                    port = static_cast<u16>(std::stoi(match[4]));
                }
                std::regex nickname_re("^[a-zA-Z0-9._\\- ]+$");
                if (!std::regex_match(nickname, nickname_re)) {
                    std::cout