Android #120

.git-blame-ignore-revs

@@ -1,5 +0,0 @@
-# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-# CRLF -> LF
-90aa937593e53a5d5e070fb623b228578b0b225f

.github/workflows/android-build.yml

@@ -40,11 +40,11 @@ jobs:
           sudo apt-get install -y ccache apksigner glslang-dev glslang-tools
       - name: Build
         run: ./.ci/scripts/android/build.sh
+      - name: Copy and sign artifacts
         env:
           ANDROID_KEYSTORE_B64: ${{ secrets.ANDROID_KEYSTORE_B64 }}
           ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
           ANDROID_KEYSTORE_PASS: ${{ secrets.ANDROID_KEYSTORE_PASS }}
-      - name: Copy artifacts
         run: ./.ci/scripts/android/upload.sh
       - name: Upload
         uses: actions/upload-artifact@v3

src/CMakeLists.txt

@@ -21,7 +21,7 @@ if (MSVC)
     # Avoid windows.h from including some usually unused libs like winsocks.h, since this might cause some redefinition errors.
     add_definitions(-DWIN32_LEAN_AND_MEAN)
 
-    # Ensure that projects are built with Unicode support.
+    # Ensure that projects build with Unicode support.
     add_definitions(-DUNICODE -D_UNICODE)
 
     # /W4                 - Level 4 warnings
@@ -54,11 +54,11 @@ if (MSVC)
         /GT
 
         # Modules
-        /experimental:module- # Explicitly disable module support due to conflicts with precompiled headers.
+        /experimental:module- # Disable module support explicitly due to conflicts with precompiled headers
 
         # External headers diagnostics
         /external:anglebrackets # Treats all headers included by #include <header>, where the header file is enclosed in angle brackets (< >), as external headers
-        /external:W0            # Sets the default warning level to 0 for external headers, effectively disabling warnings for them.
+        /external:W0            # Sets the default warning level to 0 for external headers, effectively turning off warnings for external headers
 
         # Warnings
         /W4

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

@@ -252,7 +252,7 @@ object NativeLibrary {
 
     external fun reloadKeys(): Boolean
 
-    external fun initializeSystem(reload: Boolean)
+    external fun initializeSystem()
 
     external fun defaultCPUCore(): Int
 

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

@@ -11,7 +11,6 @@ import java.io.File
 import org.yuzu.yuzu_emu.utils.DirectoryInitialization
 import org.yuzu.yuzu_emu.utils.DocumentsTree
 import org.yuzu.yuzu_emu.utils.GpuDriverHelper
-import org.yuzu.yuzu_emu.utils.Log
 
 fun Context.getPublicFilesDir(): File = getExternalFilesDir(null) ?: filesDir
 
@@ -50,7 +49,6 @@ class YuzuApplication : Application() {
         DirectoryInitialization.start()
         GpuDriverHelper.initializeDriverParameters()
         NativeLibrary.logDeviceInfo()
-        Log.logDeviceInfo()
 
         createNotificationChannels()
     }

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

@@ -107,7 +107,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener {
 
         val preferences = PreferenceManager.getDefaultSharedPreferences(YuzuApplication.appContext)
         if (!preferences.getBoolean(Settings.PREF_MEMORY_WARNING_SHOWN, false)) {
-            if (MemoryUtil.isLessThan(MemoryUtil.REQUIRED_MEMORY, MemoryUtil.totalMemory)) {
+            if (MemoryUtil.isLessThan(MemoryUtil.REQUIRED_MEMORY, MemoryUtil.Gb)) {
                 Toast.makeText(
                     this,
                     getString(

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

@@ -10,6 +10,7 @@ import android.content.DialogInterface
 import android.content.SharedPreferences
 import android.content.pm.ActivityInfo
 import android.content.res.Configuration
+import android.graphics.Color
 import android.net.Uri
 import android.os.Bundle
 import android.os.Handler
@@ -154,6 +155,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
 
         binding.surfaceEmulation.holder.addCallback(this)
+        binding.showFpsText.setTextColor(Color.YELLOW)
         binding.doneControlConfig.setOnClickListener { stopConfiguringControls() }
 
         binding.drawerLayout.addDrawerListener(object : DrawerListener {
@@ -310,8 +312,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                             ViewUtils.showView(binding.surfaceInputOverlay)
                             ViewUtils.hideView(binding.loadingIndicator)
 
-                            emulationState.updateSurface()
-
                             // Setup overlay
                             updateShowFpsOverlay()
                         }
@@ -412,12 +412,12 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             val FRAMETIME = 2
             val SPEED = 3
             perfStatsUpdater = {
-                if (emulationViewModel.emulationStarted.value) {
+                if (emulationViewModel.emulationStarted.value == true) {
                     val perfStats = NativeLibrary.getPerfStats()
-                    if (_binding != null) {
+                    if (perfStats[FPS] > 0 && _binding != null) {
                         binding.showFpsText.text = String.format("FPS: %.1f", perfStats[FPS])
                     }
-                    perfStatsUpdateHandler.postDelayed(perfStatsUpdater!!, 800)
+                    perfStatsUpdateHandler.postDelayed(perfStatsUpdater!!, 100)
                 }
             }
             perfStatsUpdateHandler.post(perfStatsUpdater!!)
@@ -462,6 +462,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                     if (it.orientation == FoldingFeature.Orientation.HORIZONTAL) {
                         // Restrict emulation and overlays to the top of the screen
                         binding.emulationContainer.layoutParams.height = it.bounds.top
+                        binding.overlayContainer.layoutParams.height = it.bounds.top
                         // Restrict input and menu drawer to the bottom of the screen
                         binding.inputContainer.layoutParams.height = it.bounds.bottom
                         binding.inGameMenu.layoutParams.height = it.bounds.bottom
@@ -475,6 +476,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         if (!isFolding) {
             binding.emulationContainer.layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT
             binding.inputContainer.layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT
+            binding.overlayContainer.layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT
             binding.inGameMenu.layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT
             isInFoldableLayout = false
             updateOrientation()
@@ -482,6 +484,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
         binding.emulationContainer.requestLayout()
         binding.inputContainer.requestLayout()
+        binding.overlayContainer.requestLayout()
         binding.inGameMenu.requestLayout()
     }
 
@@ -707,6 +710,24 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             }
 
             v.setPadding(left, cutInsets.top, right, 0)
+
+            // Ensure FPS text doesn't get cut off by rounded display corners
+            val sidePadding = resources.getDimensionPixelSize(R.dimen.spacing_xtralarge)
+            if (cutInsets.left == 0) {
+                binding.showFpsText.setPadding(
+                    sidePadding,
+                    cutInsets.top,
+                    cutInsets.right,
+                    cutInsets.bottom
+                )
+            } else {
+                binding.showFpsText.setPadding(
+                    cutInsets.left,
+                    cutInsets.top,
+                    cutInsets.right,
+                    cutInsets.bottom
+                )
+            }
             windowInsets
         }
     }
@@ -783,13 +804,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             }
         }
 
-        @Synchronized
-        fun updateSurface() {
-            if (surface != null) {
-                NativeLibrary.surfaceChanged(surface)
-            }
-        }
-
         @Synchronized
         fun clearSurface() {
             if (surface == null) {

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

@@ -403,7 +403,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     } else {
                         firmwarePath.deleteRecursively()
                         cacheFirmwareDir.copyRecursively(firmwarePath, true)
-                        NativeLibrary.initializeSystem(true)
+                        NativeLibrary.initializeSystem()
                         getString(R.string.save_file_imported_success)
                     }
                 } catch (e: Exception) {
@@ -649,7 +649,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                 }
 
                 // Reinitialize relevant data
-                NativeLibrary.initializeSystem(true)
+                NativeLibrary.initializeSystem()
                 gamesViewModel.reloadGames(false)
 
                 return@newInstance getString(R.string.user_data_import_success)

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

@@ -15,7 +15,7 @@ object DirectoryInitialization {
     fun start() {
         if (!areDirectoriesReady) {
             initializeInternalStorage()
-            NativeLibrary.initializeSystem(false)
+            NativeLibrary.initializeSystem()
             areDirectoriesReady = true
         }
     }

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

@@ -3,8 +3,6 @@
 
 package org.yuzu.yuzu_emu.utils
 
-import android.os.Build
-
 object Log {
     // Tracks whether we should share the old log or the current log
     var gameLaunched = false
@@ -18,14 +16,4 @@ object Log {
     external fun error(message: String)
 
     external fun critical(message: String)
-
-    fun logDeviceInfo() {
-        info("Device Manufacturer - ${Build.MANUFACTURER}")
-        info("Device Model - ${Build.MODEL}")
-        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
-            info("SoC Manufacturer - ${Build.SOC_MANUFACTURER}")
-            info("SoC Model - ${Build.SOC_MODEL}")
-        }
-        info("Total System Memory - ${MemoryUtil.getDeviceRAM()}")
-    }
 }

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

@@ -27,7 +27,7 @@ object MemoryUtil {
     const val Pb = Tb * 1024
     const val Eb = Pb * 1024
 
-    private fun bytesToSizeUnit(size: Float, roundUp: Boolean = false): String =
+    private fun bytesToSizeUnit(size: Float): String =
         when {
             size < Kb -> {
                 context.getString(
@@ -39,59 +39,63 @@ object MemoryUtil {
             size < Mb -> {
                 context.getString(
                     R.string.memory_formatted,
-                    if (roundUp) ceil(size / Kb) else (size / Kb).hundredths,
+                    (size / Kb).hundredths,
                     context.getString(R.string.memory_kilobyte)
                 )
             }
             size < Gb -> {
                 context.getString(
                     R.string.memory_formatted,
-                    if (roundUp) ceil(size / Mb) else (size / Mb).hundredths,
+                    (size / Mb).hundredths,
                     context.getString(R.string.memory_megabyte)
                 )
             }
             size < Tb -> {
                 context.getString(
                     R.string.memory_formatted,
-                    if (roundUp) ceil(size / Gb) else (size / Gb).hundredths,
+                    (size / Gb).hundredths,
                     context.getString(R.string.memory_gigabyte)
                 )
             }
             size < Pb -> {
                 context.getString(
                     R.string.memory_formatted,
-                    if (roundUp) ceil(size / Tb) else (size / Tb).hundredths,
+                    (size / Tb).hundredths,
                     context.getString(R.string.memory_terabyte)
                 )
             }
             size < Eb -> {
                 context.getString(
                     R.string.memory_formatted,
-                    if (roundUp) ceil(size / Pb) else (size / Pb).hundredths,
+                    (size / Pb).hundredths,
                     context.getString(R.string.memory_petabyte)
                 )
             }
             else -> {
                 context.getString(
                     R.string.memory_formatted,
-                    if (roundUp) ceil(size / Eb) else (size / Eb).hundredths,
+                    (size / Eb).hundredths,
                     context.getString(R.string.memory_exabyte)
                 )
             }
         }
 
-    val totalMemory: Float
+    // Devices are unlikely to have 0.5GB increments of memory so we'll just round up to account for
+    // the potential error created by memInfo.totalMem
+    private val totalMemory: Float
         get() {
             val memInfo = ActivityManager.MemoryInfo()
             with(context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager) {
                 getMemoryInfo(memInfo)
             }
 
-            return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                memInfo.advertisedMem.toFloat()
-            } else {
-                memInfo.totalMem.toFloat()
-            }
+            return ceil(
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                    memInfo.advertisedMem.toFloat()
+                } else {
+                    memInfo.totalMem.toFloat()
+                }
+            )
         }
 
     fun isLessThan(minimum: Int, size: Float): Boolean =
@@ -105,7 +109,5 @@ object MemoryUtil {
             else -> totalMemory < Kb && totalMemory < minimum
         }
 
-    // Devices are unlikely to have 0.5GB increments of memory so we'll just round up to account for
-    // the potential error created by memInfo.totalMem
-    fun getDeviceRAM(): String = bytesToSizeUnit(totalMemory, true)
+    fun getDeviceRAM(): String = bytesToSizeUnit(totalMemory)
 }

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

@@ -199,8 +199,8 @@ bool EmulationSession::IsPaused() const {
     return m_is_running && m_is_paused;
 }
 
-const Core::PerfStatsResults& EmulationSession::PerfStats() {
-    m_perf_stats = m_system.GetAndResetPerfStats();
+const Core::PerfStatsResults& EmulationSession::PerfStats() const {
+    std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
     return m_perf_stats;
 }
 
@@ -247,13 +247,11 @@ void EmulationSession::ConfigureFilesystemProvider(const std::string& filepath)
     }
 }
 
-void EmulationSession::InitializeSystem(bool reload) {
-    if (!reload) {
-        // Initialize logging system
-        Common::Log::Initialize();
-        Common::Log::SetColorConsoleBackendEnabled(true);
-        Common::Log::Start();
-    }
+void EmulationSession::InitializeSystem() {
+    // Initialize logging system
+    Common::Log::Initialize();
+    Common::Log::SetColorConsoleBackendEnabled(true);
+    Common::Log::Start();
 
     // Initialize filesystem.
     m_system.SetFilesystem(m_vfs);
@@ -383,6 +381,11 @@ void EmulationSession::RunEmulation() {
                 break;
             }
         }
+        {
+            // Refresh performance stats.
+            std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
+            m_perf_stats = m_system.GetAndResetPerfStats();
+        }
     }
 }
 
@@ -664,15 +667,12 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_onTouchReleased(JNIEnv* env, jclass c
     }
 }
 
-void Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeSystem(JNIEnv* env, jclass clazz,
-                                                            jboolean reload) {
+void Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeSystem(JNIEnv* env, jclass clazz) {
     // Create the default config.ini.
     Config{};
     // Initialize the emulated system.
-    if (!reload) {
-        EmulationSession::GetInstance().System().Initialize();
-    }
-    EmulationSession::GetInstance().InitializeSystem(reload);
+    EmulationSession::GetInstance().System().Initialize();
+    EmulationSession::GetInstance().InitializeSystem();
 }
 
 jint Java_org_yuzu_yuzu_1emu_NativeLibrary_defaultCPUCore(JNIEnv* env, jclass clazz) {

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

@@ -41,9 +41,9 @@ public:
     void RunEmulation();
     void ShutdownEmulation();
 
-    const Core::PerfStatsResults& PerfStats();
+    const Core::PerfStatsResults& PerfStats() const;
     void ConfigureFilesystemProvider(const std::string& filepath);
-    void InitializeSystem(bool reload);
+    void InitializeSystem();
     Core::SystemResultStatus InitializeEmulation(const std::string& filepath);
 
     bool IsHandheldOnly();
@@ -80,5 +80,6 @@ private:
 
     // Synchronization
     std::condition_variable_any m_cv;
+    mutable std::mutex m_perf_stats_mutex;
     mutable std::mutex m_mutex;
 };

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

@@ -134,18 +134,16 @@
         <FrameLayout
             android:id="@+id/overlay_container"
             android:layout_width="match_parent"
-            android:layout_height="match_parent"
-            android:fitsSystemWindows="true">
+            android:layout_height="match_parent">
 
-            <com.google.android.material.textview.MaterialTextView
+            <TextView
                 android:id="@+id/show_fps_text"
-                style="@style/TextAppearance.Material3.BodyMedium"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_gravity="left"
                 android:clickable="false"
                 android:focusable="false"
-                android:paddingHorizontal="20dp"
+                android:shadowColor="@android:color/black"
                 android:textColor="@android:color/white"
                 android:textSize="12sp"
                 tools:ignore="RtlHardcoded" />

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

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

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

@@ -30,9 +30,9 @@ bool IsValidMultiStreamChannelCount(u32 channel_count) {
     return channel_count <= OpusStreamCountMax;
 }
 
-bool IsValidMultiStreamStreamCounts(s32 total_stream_count, s32 stereo_stream_count) {
+bool IsValidMultiStreamStreamCounts(s32 total_stream_count, s32 sterero_stream_count) {
     return IsValidMultiStreamChannelCount(total_stream_count) && total_stream_count > 0 &&
-           stereo_stream_count >= 0 && stereo_stream_count <= total_stream_count;
+           sterero_stream_count > 0 && sterero_stream_count <= total_stream_count;
 }
 } // namespace
 

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

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

src/audio_core/opus/decoder.cpp

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

src/audio_core/opus/decoder.h

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

src/audio_core/opus/decoder_manager.cpp

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

src/audio_core/opus/decoder_manager.h

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

src/audio_core/opus/hardware_opus.cpp

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

src/audio_core/opus/hardware_opus.h

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

src/common/arm64/native_clock.cpp

@@ -1,9 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#ifdef ANDROID
-#include <sys/system_properties.h>
-#endif
 #include "common/arm64/native_clock.h"
 
 namespace Common::Arm64 {
@@ -68,23 +65,7 @@ bool NativeClock::IsNative() const {
 
 u64 NativeClock::GetHostCNTFRQ() {
     u64 cntfrq_el0 = 0;
-    std::string_view board{""};
-#ifdef ANDROID
-    char buffer[PROP_VALUE_MAX];
-    int len{__system_property_get("ro.product.board", buffer)};
-    board = std::string_view(buffer, static_cast<size_t>(len));
-#endif
-    if (board == "s5e9925") { // Exynos 2200
-        cntfrq_el0 = 25600000;
-    } else if (board == "exynos2100") { // Exynos 2100
-        cntfrq_el0 = 26000000;
-    } else if (board == "exynos9810") { // Exynos 9810
-        cntfrq_el0 = 26000000;
-    } else if (board == "s5e8825") { // Exynos 1280
-        cntfrq_el0 = 26000000;
-    } else {
-        asm("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));
-    }
+    asm("mrs %[cntfrq_el0], cntfrq_el0" : [cntfrq_el0] "=r"(cntfrq_el0));
     return cntfrq_el0;
 }
 

src/core/file_sys/romfs.cpp

@@ -35,14 +35,13 @@ struct RomFSHeader {
 static_assert(sizeof(RomFSHeader) == 0x50, "RomFSHeader has incorrect size.");
 
 struct DirectoryEntry {
-    u32_le parent;
     u32_le sibling;
     u32_le child_dir;
     u32_le child_file;
     u32_le hash;
     u32_le name_length;
 };
-static_assert(sizeof(DirectoryEntry) == 0x18, "DirectoryEntry has incorrect size.");
+static_assert(sizeof(DirectoryEntry) == 0x14, "DirectoryEntry has incorrect size.");
 
 struct FileEntry {
     u32_le parent;
@@ -65,22 +64,25 @@ std::pair<Entry, std::string> GetEntry(const VirtualFile& file, std::size_t offs
     return {entry, string};
 }
 
-void ProcessFile(const VirtualFile& file, std::size_t file_offset, std::size_t data_offset,
-                 u32 this_file_offset, std::shared_ptr<VectorVfsDirectory>& parent) {
-    while (this_file_offset != ROMFS_ENTRY_EMPTY) {
+void ProcessFile(VirtualFile file, std::size_t file_offset, std::size_t data_offset,
+                 u32 this_file_offset, std::shared_ptr<VectorVfsDirectory> parent) {
+    while (true) {
         auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset);
 
         parent->AddFile(std::make_shared<OffsetVfsFile>(
             file, entry.first.size, entry.first.offset + data_offset, entry.second));
 
+        if (entry.first.sibling == ROMFS_ENTRY_EMPTY)
+            break;
+
         this_file_offset = entry.first.sibling;
     }
 }
 
-void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size_t file_offset,
+void ProcessDirectory(VirtualFile file, std::size_t dir_offset, std::size_t file_offset,
                       std::size_t data_offset, u32 this_dir_offset,
-                      std::shared_ptr<VectorVfsDirectory>& parent) {
-    while (this_dir_offset != ROMFS_ENTRY_EMPTY) {
+                      std::shared_ptr<VectorVfsDirectory> parent) {
+    while (true) {
         auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset);
         auto current = std::make_shared<VectorVfsDirectory>(
             std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, entry.second);
@@ -95,12 +97,14 @@ void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size
         }
 
         parent->AddDirectory(current);
+        if (entry.first.sibling == ROMFS_ENTRY_EMPTY)
+            break;
         this_dir_offset = entry.first.sibling;
     }
 }
 } // Anonymous namespace
 
-VirtualDir ExtractRomFS(VirtualFile file) {
+VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
     RomFSHeader header{};
     if (file->ReadObject(&header) != sizeof(RomFSHeader))
         return nullptr;
@@ -109,17 +113,27 @@ VirtualDir ExtractRomFS(VirtualFile file) {
         return nullptr;
 
     const u64 file_offset = header.file_meta.offset;
-    const u64 dir_offset = header.directory_meta.offset;
+    const u64 dir_offset = header.directory_meta.offset + 4;
 
-    auto root_container = std::make_shared<VectorVfsDirectory>();
+    auto root =
+        std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{}, std::vector<VirtualDir>{},
+                                             file->GetName(), file->GetContainingDirectory());
 
-    ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root_container);
+    ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root);
 
-    if (auto root = root_container->GetSubdirectory(""); root) {
-        return std::make_shared<CachedVfsDirectory>(std::move(root));
+    VirtualDir out = std::move(root);
+
+    if (type == RomFSExtractionType::SingleDiscard)
+        return out->GetSubdirectories().front();
+
+    while (out->GetSubdirectories().size() == 1 && out->GetFiles().empty()) {
+        if (Common::ToLower(out->GetSubdirectories().front()->GetName()) == "data" &&
+            type == RomFSExtractionType::Truncated)
+            break;
+        out = out->GetSubdirectories().front();
     }
 
-    return nullptr;
+    return std::make_shared<CachedVfsDirectory>(std::move(out));
 }
 
 VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {

src/core/file_sys/romfs.h

@@ -7,9 +7,16 @@
 
 namespace FileSys {
 
+enum class RomFSExtractionType {
+    Full,          // Includes data directory
+    Truncated,     // Traverses into data directory
+    SingleDiscard, // Traverses into the first subdirectory of root
+};
+
 // Converts a RomFS binary blob to VFS Filesystem
 // Returns nullptr on failure
-VirtualDir ExtractRomFS(VirtualFile file);
+VirtualDir ExtractRomFS(VirtualFile file,
+                        RomFSExtractionType type = RomFSExtractionType::Truncated);
 
 // Converts a VFS filesystem into a RomFS binary
 // Returns nullptr on failure

src/core/hid/emulated_controller.cpp

@@ -96,7 +96,18 @@ void EmulatedController::ReloadFromSettings() {
     }
 
     controller.color_values = {};
-    ReloadColorsFromSettings();
+    controller.colors_state.fullkey = {
+        .body = GetNpadColor(player.body_color_left),
+        .button = GetNpadColor(player.button_color_left),
+    };
+    controller.colors_state.left = {
+        .body = GetNpadColor(player.body_color_left),
+        .button = GetNpadColor(player.button_color_left),
+    };
+    controller.colors_state.right = {
+        .body = GetNpadColor(player.body_color_right),
+        .button = GetNpadColor(player.button_color_right),
+    };
 
     ring_params[0] = Common::ParamPackage(Settings::values.ringcon_analogs);
 
@@ -117,30 +128,6 @@ void EmulatedController::ReloadFromSettings() {
     ReloadInput();
 }
 
-void EmulatedController::ReloadColorsFromSettings() {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
-    const auto& player = Settings::values.players.GetValue()[player_index];
-
-    // Avoid updating colors if overridden by physical controller
-    if (controller.color_values[LeftIndex].body != 0 &&
-        controller.color_values[RightIndex].body != 0) {
-        return;
-    }
-
-    controller.colors_state.fullkey = {
-        .body = GetNpadColor(player.body_color_left),
-        .button = GetNpadColor(player.button_color_left),
-    };
-    controller.colors_state.left = {
-        .body = GetNpadColor(player.body_color_left),
-        .button = GetNpadColor(player.button_color_left),
-    };
-    controller.colors_state.right = {
-        .body = GetNpadColor(player.body_color_right),
-        .button = GetNpadColor(player.button_color_right),
-    };
-}
-
 void EmulatedController::LoadDevices() {
     // TODO(german77): Use more buttons to detect the correct device
     const auto left_joycon = button_params[Settings::NativeButton::DRight];
@@ -1104,30 +1091,30 @@ void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callbac
 
     bool is_charging = false;
     bool is_powered = false;
-    NpadBatteryLevel battery_level = NpadBatteryLevel::Empty;
+    NpadBatteryLevel battery_level = 0;
     switch (controller.battery_values[index]) {
     case Common::Input::BatteryLevel::Charging:
         is_charging = true;
         is_powered = true;
-        battery_level = NpadBatteryLevel::Full;
+        battery_level = 6;
         break;
     case Common::Input::BatteryLevel::Medium:
-        battery_level = NpadBatteryLevel::High;
+        battery_level = 6;
         break;
     case Common::Input::BatteryLevel::Low:
-        battery_level = NpadBatteryLevel::Low;
+        battery_level = 4;
         break;
     case Common::Input::BatteryLevel::Critical:
-        battery_level = NpadBatteryLevel::Critical;
+        battery_level = 2;
         break;
     case Common::Input::BatteryLevel::Empty:
-        battery_level = NpadBatteryLevel::Empty;
+        battery_level = 0;
         break;
     case Common::Input::BatteryLevel::None:
     case Common::Input::BatteryLevel::Full:
     default:
         is_powered = true;
-        battery_level = NpadBatteryLevel::Full;
+        battery_level = 8;
         break;
     }
 

src/core/hid/emulated_controller.h

@@ -253,9 +253,6 @@ public:
     /// Overrides current mapped devices with the stored configuration and reloads all input devices
     void ReloadFromSettings();
 
-    /// Updates current colors with the ones stored in the configuration
-    void ReloadColorsFromSettings();
-
     /// Saves the current mapped configuration
     void SaveCurrentConfig();
 

src/core/hid/hid_types.h

@@ -302,15 +302,6 @@ enum class TouchScreenModeForNx : u8 {
     Heat2,
 };
 
-// This is nn::hid::system::NpadBatteryLevel
-enum class NpadBatteryLevel : u32 {
-    Empty,
-    Critical,
-    Low,
-    High,
-    Full,
-};
-
 // This is nn::hid::NpadStyleTag
 struct NpadStyleTag {
     union {
@@ -394,12 +385,16 @@ struct NpadGcTriggerState {
 };
 static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size");
 
+// This is nn::hid::system::NpadBatteryLevel
+using NpadBatteryLevel = u32;
+static_assert(sizeof(NpadBatteryLevel) == 0x4, "NpadBatteryLevel is an invalid size");
+
 // This is nn::hid::system::NpadPowerInfo
 struct NpadPowerInfo {
     bool is_powered{};
     bool is_charging{};
     INSERT_PADDING_BYTES(0x6);
-    NpadBatteryLevel battery_level{NpadBatteryLevel::Full};
+    NpadBatteryLevel battery_level{8};
 };
 static_assert(sizeof(NpadPowerInfo) == 0xC, "NpadPowerInfo is an invalid size");
 

src/core/hle/service/acc/acc.cpp

@@ -3,13 +3,11 @@
 
 #include <algorithm>
 #include <array>
-
 #include "common/common_types.h"
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "common/polyfill_ranges.h"
-#include "common/stb.h"
 #include "common/string_util.h"
 #include "common/swap.h"
 #include "core/constants.h"
@@ -40,36 +38,9 @@ static std::filesystem::path GetImagePath(const Common::UUID& uuid) {
            fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
 }
 
-static void JPGToMemory(void* context, void* data, int len) {
-    std::vector<u8>* jpg_image = static_cast<std::vector<u8>*>(context);
-    unsigned char* jpg = static_cast<unsigned char*>(data);
-    jpg_image->insert(jpg_image->end(), jpg, jpg + len);
-}
-
-static void SanitizeJPEGImageSize(std::vector<u8>& image) {
+static constexpr u32 SanitizeJPEGSize(std::size_t size) {
     constexpr std::size_t max_jpeg_image_size = 0x20000;
-    constexpr int profile_dimensions = 256;
-    int original_width, original_height, color_channels;
-
-    const auto plain_image =
-        stbi_load_from_memory(image.data(), static_cast<int>(image.size()), &original_width,
-                              &original_height, &color_channels, STBI_rgb);
-
-    // Resize image to match 256*256
-    if (original_width != profile_dimensions || original_height != profile_dimensions) {
-        // Use vector instead of array to avoid overflowing the stack
-        std::vector<u8> out_image(profile_dimensions * profile_dimensions * STBI_rgb);
-        stbir_resize_uint8_srgb(plain_image, original_width, original_height, 0, out_image.data(),
-                                profile_dimensions, profile_dimensions, 0, STBI_rgb, 0,
-                                STBIR_FILTER_BOX);
-        image.clear();
-        if (!stbi_write_jpg_to_func(JPGToMemory, &image, profile_dimensions, profile_dimensions,
-                                    STBI_rgb, out_image.data(), 0)) {
-            LOG_ERROR(Service_ACC, "Failed to resize the user provided image.");
-        }
-    }
-
-    image.resize(std::min(image.size(), max_jpeg_image_size));
+    return static_cast<u32>(std::min(size, max_jpeg_image_size));
 }
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
@@ -368,20 +339,19 @@ protected:
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
             ctx.WriteBuffer(Core::Constants::ACCOUNT_BACKUP_JPEG);
-            rb.Push(static_cast<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            rb.Push(SanitizeJPEGSize(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
             return;
         }
 
-        std::vector<u8> buffer(image.GetSize());
+        const u32 size = SanitizeJPEGSize(image.GetSize());
+        std::vector<u8> buffer(size);
 
         if (image.Read(buffer) != buffer.size()) {
             LOG_ERROR(Service_ACC, "Failed to read all the bytes in the user provided image.");
         }
 
-        SanitizeJPEGImageSize(buffer);
-
         ctx.WriteBuffer(buffer);
-        rb.Push(static_cast<u32>(buffer.size()));
+        rb.Push<u32>(size);
     }
 
     void GetImageSize(HLERequestContext& ctx) {
@@ -395,18 +365,10 @@ protected:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push(static_cast<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
-            return;
+            rb.Push(SanitizeJPEGSize(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+        } else {
+            rb.Push(SanitizeJPEGSize(image.GetSize()));
         }
-
-        std::vector<u8> buffer(image.GetSize());
-
-        if (image.Read(buffer) != buffer.size()) {
-            LOG_ERROR(Service_ACC, "Failed to read all the bytes in the user provided image.");
-        }
-
-        SanitizeJPEGImageSize(buffer);
-        rb.Push(static_cast<u32>(buffer.size()));
     }
 
     void Store(HLERequestContext& ctx) {

src/core/hle/service/am/applets/applet_web_browser.cpp

@@ -330,7 +330,8 @@ void WebBrowser::ExtractOfflineRomFS() {
     LOG_DEBUG(Service_AM, "Extracting RomFS to {}",
               Common::FS::PathToUTF8String(offline_cache_dir));
 
-    const auto extracted_romfs_dir = FileSys::ExtractRomFS(offline_romfs);
+    const auto extracted_romfs_dir =
+        FileSys::ExtractRomFS(offline_romfs, FileSys::RomFSExtractionType::SingleDiscard);
 
     const auto temp_dir = system.GetFilesystem()->CreateDirectory(
         Common::FS::PathToUTF8String(offline_cache_dir), FileSys::Mode::ReadWrite);

src/core/hle/service/am/applets/applets.h

@@ -69,30 +69,6 @@ enum class AppletId : u32 {
     MyPage = 0x1A,
 };
 
-enum class AppletProgramId : u64 {
-    QLaunch = 0x0100000000001000ull,
-    Auth = 0x0100000000001001ull,
-    Cabinet = 0x0100000000001002ull,
-    Controller = 0x0100000000001003ull,
-    DataErase = 0x0100000000001004ull,
-    Error = 0x0100000000001005ull,
-    NetConnect = 0x0100000000001006ull,
-    ProfileSelect = 0x0100000000001007ull,
-    SoftwareKeyboard = 0x0100000000001008ull,
-    MiiEdit = 0x0100000000001009ull,
-    Web = 0x010000000000100Aull,
-    Shop = 0x010000000000100Bull,
-    OverlayDisplay = 0x010000000000100Cull,
-    PhotoViewer = 0x010000000000100Dull,
-    Settings = 0x010000000000100Eull,
-    OfflineWeb = 0x010000000000100Full,
-    LoginShare = 0x0100000000001010ull,
-    WebAuth = 0x0100000000001011ull,
-    Starter = 0x0100000000001012ull,
-    MyPage = 0x0100000000001013ull,
-    MaxProgramId = 0x0100000000001FFFull,
-};
-
 enum class LibraryAppletMode : u32 {
     AllForeground = 0,
     Background = 1,

src/core/hle/service/hid/controllers/npad.cpp

@@ -1108,9 +1108,9 @@ Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     shared_memory->sixaxis_dual_right_properties.raw = 0;
     shared_memory->sixaxis_left_properties.raw = 0;
     shared_memory->sixaxis_right_properties.raw = 0;
-    shared_memory->battery_level_dual = Core::HID::NpadBatteryLevel::Empty;
-    shared_memory->battery_level_left = Core::HID::NpadBatteryLevel::Empty;
-    shared_memory->battery_level_right = Core::HID::NpadBatteryLevel::Empty;
+    shared_memory->battery_level_dual = 0;
+    shared_memory->battery_level_left = 0;
+    shared_memory->battery_level_right = 0;
     shared_memory->fullkey_color = {
         .attribute = ColorAttribute::NoController,
         .fullkey = {},

src/core/hle/service/hid/hid.cpp

@@ -1353,7 +1353,7 @@ void Hid::IsUnintendedHomeButtonInputProtectionEnabled(HLERequestContext& ctx) {
 void Hid::EnableUnintendedHomeButtonInputProtection(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     struct Parameters {
-        bool is_enabled;
+        bool unintended_home_button_input_protection;
         INSERT_PADDING_BYTES_NOINIT(3);
         Core::HID::NpadIdType npad_id;
         u64 applet_resource_user_id;
@@ -1364,11 +1364,13 @@ void Hid::EnableUnintendedHomeButtonInputProtection(HLERequestContext& ctx) {
 
     auto& controller = GetAppletResource()->GetController<Controller_NPad>(HidController::NPad);
     const auto result = controller.SetUnintendedHomeButtonInputProtectionEnabled(
-        parameters.is_enabled, parameters.npad_id);
+        parameters.unintended_home_button_input_protection, parameters.npad_id);
 
-    LOG_DEBUG(Service_HID,
-              "(STUBBED) called, is_enabled={}, npad_id={}, applet_resource_user_id={}",
-              parameters.is_enabled, parameters.npad_id, parameters.applet_resource_user_id);
+    LOG_WARNING(Service_HID,
+                "(STUBBED) called, unintended_home_button_input_protection={}, npad_id={},"
+                "applet_resource_user_id={}",
+                parameters.unintended_home_button_input_protection, parameters.npad_id,
+                parameters.applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(result);

src/core/hle/service/hid/ring_lifo.h

@@ -32,15 +32,15 @@ struct Lifo {
     }
 
     std::size_t GetPreviousEntryIndex() const {
-        return static_cast<size_t>((buffer_tail + max_buffer_size - 1) % max_buffer_size);
+        return static_cast<size_t>((buffer_tail + total_buffer_count - 1) % total_buffer_count);
     }
 
     std::size_t GetNextEntryIndex() const {
-        return static_cast<size_t>((buffer_tail + 1) % max_buffer_size);
+        return static_cast<size_t>((buffer_tail + 1) % total_buffer_count);
     }
 
     void WriteNextEntry(const State& new_state) {
-        if (buffer_count < static_cast<s64>(max_buffer_size) - 1) {
+        if (buffer_count < total_buffer_count - 1) {
             buffer_count++;
         }
         buffer_tail = GetNextEntryIndex();

src/core/hle/service/nvdrv/devices/ioctl_serialization.h

@@ -1,159 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <span>
-#include <vector>
-
-#include "common/concepts.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service::Nvidia::Devices {
-
-struct IoctlOneArgTraits {
-    template <typename T, typename R, typename A, typename... B>
-    static A GetFirstArgImpl(R (T::*)(A, B...));
-};
-
-struct IoctlTwoArgTraits {
-    template <typename T, typename R, typename A, typename B, typename... C>
-    static A GetFirstArgImpl(R (T::*)(A, B, C...));
-
-    template <typename T, typename R, typename A, typename B, typename... C>
-    static B GetSecondArgImpl(R (T::*)(A, B, C...));
-};
-
-struct Null {};
-
-// clang-format off
-
-template <typename FixedArg, typename VarArg, typename InlInVarArg, typename InlOutVarArg, typename F>
-NvResult WrapGeneric(F&& callable, std::span<const u8> input, std::span<const u8> inline_input, std::span<u8> output, std::span<u8> inline_output) {
-    constexpr bool HasFixedArg     = !std::is_same_v<FixedArg, Null>;
-    constexpr bool HasVarArg       = !std::is_same_v<VarArg, Null>;
-    constexpr bool HasInlInVarArg  = !std::is_same_v<InlInVarArg, Null>;
-    constexpr bool HasInlOutVarArg = !std::is_same_v<InlOutVarArg, Null>;
-
-    // Declare the fixed-size input value.
-    FixedArg fixed{};
-    size_t var_offset = 0;
-
-    if constexpr (HasFixedArg) {
-        // Read the fixed-size input value.
-        var_offset = std::min(sizeof(FixedArg), input.size());
-        if (var_offset > 0) {
-            std::memcpy(&fixed, input.data(), var_offset);
-        }
-    }
-
-    // Read the variable-sized inputs.
-    const size_t num_var_args = HasVarArg ? ((input.size() - var_offset) / sizeof(VarArg)) : 0;
-    std::vector<VarArg> var_args(num_var_args);
-    if constexpr (HasVarArg) {
-        if (num_var_args > 0) {
-            std::memcpy(var_args.data(), input.data() + var_offset, num_var_args * sizeof(VarArg));
-        }
-    }
-
-    const size_t num_inl_in_var_args = HasInlInVarArg ? (inline_input.size() / sizeof(InlInVarArg)) : 0;
-    std::vector<InlInVarArg> inl_in_var_args(num_inl_in_var_args);
-    if constexpr (HasInlInVarArg) {
-        if (num_inl_in_var_args > 0) {
-            std::memcpy(inl_in_var_args.data(), inline_input.data(), num_inl_in_var_args * sizeof(InlInVarArg));
-        }
-    }
-
-    // Construct inline output data.
-    const size_t num_inl_out_var_args = HasInlOutVarArg ? (inline_output.size() / sizeof(InlOutVarArg)) : 0;
-    std::vector<InlOutVarArg> inl_out_var_args(num_inl_out_var_args);
-
-    // Perform the call.
-    NvResult result = callable(fixed, var_args, inl_in_var_args, inl_out_var_args);
-
-    // Copy outputs.
-    if constexpr (HasFixedArg) {
-        if (output.size() > 0) {
-            std::memcpy(output.data(), &fixed, std::min(output.size(), sizeof(FixedArg)));
-        }
-    }
-
-    if constexpr (HasVarArg) {
-        if (num_var_args > 0 && output.size() > var_offset) {
-            const size_t max_var_size = output.size() - var_offset;
-            std::memcpy(output.data() + var_offset, var_args.data(), std::min(max_var_size, num_var_args * sizeof(VarArg)));
-        }
-    }
-
-    // Copy inline outputs.
-    if constexpr (HasInlOutVarArg) {
-        if (num_inl_out_var_args > 0) {
-            std::memcpy(inline_output.data(), inl_out_var_args.data(), num_inl_out_var_args * sizeof(InlOutVarArg));
-        }
-    }
-
-    // We're done.
-    return result;
-}
-
-template <typename Self, typename F, typename... Rest>
-NvResult WrapFixed(Self* self, F&& callable, std::span<const u8> input, std::span<u8> output, Rest&&... rest) {
-    using FixedArg = typename std::remove_reference_t<decltype(IoctlOneArgTraits::GetFirstArgImpl(callable))>;
-
-    const auto Callable = [&](auto& fixed, auto& var, auto& inl_in, auto& inl_out) -> NvResult {
-        return (self->*callable)(fixed, std::forward<Rest>(rest)...);
-    };
-
-    return WrapGeneric<FixedArg, Null, Null, Null>(std::move(Callable), input, {}, output, {});
-}
-
-template <typename Self, typename F, typename... Rest>
-NvResult WrapFixedInlOut(Self* self, F&& callable, std::span<const u8> input, std::span<u8> output, std::span<u8> inline_output, Rest&&... rest) {
-    using FixedArg     = typename std::remove_reference_t<decltype(IoctlTwoArgTraits::GetFirstArgImpl(callable))>;
-    using InlOutVarArg = typename std::remove_reference_t<decltype(IoctlTwoArgTraits::GetSecondArgImpl(callable))>::value_type;
-
-    const auto Callable = [&](auto& fixed, auto& var, auto& inl_in, auto& inl_out) -> NvResult {
-        return (self->*callable)(fixed, inl_out, std::forward<Rest>(rest)...);
-    };
-
-    return WrapGeneric<FixedArg, Null, Null, InlOutVarArg>(std::move(Callable), input, {}, output, inline_output);
-}
-
-template <typename Self, typename F, typename... Rest>
-NvResult WrapVariable(Self* self, F&& callable, std::span<const u8> input, std::span<u8> output, Rest&&... rest) {
-    using VarArg = typename std::remove_reference_t<decltype(IoctlOneArgTraits::GetFirstArgImpl(callable))>::value_type;
-
-    const auto Callable = [&](auto& fixed, auto& var, auto& inl_in, auto& inl_out) -> NvResult {
-        return (self->*callable)(var, std::forward<Rest>(rest)...);
-    };
-
-    return WrapGeneric<Null, VarArg, Null, Null>(std::move(Callable), input, {}, output, {});
-}
-
-template <typename Self, typename F, typename... Rest>
-NvResult WrapFixedVariable(Self* self, F&& callable, std::span<const u8> input, std::span<u8> output, Rest&&... rest) {
-    using FixedArg = typename std::remove_reference_t<decltype(IoctlTwoArgTraits::GetFirstArgImpl(callable))>;
-    using VarArg   = typename std::remove_reference_t<decltype(IoctlTwoArgTraits::GetSecondArgImpl(callable))>::value_type;
-
-    const auto Callable = [&](auto& fixed, auto& var, auto& inl_in, auto& inl_out) -> NvResult {
-        return (self->*callable)(fixed, var, std::forward<Rest>(rest)...);
-    };
-
-    return WrapGeneric<FixedArg, VarArg, Null, Null>(std::move(Callable), input, {}, output, {});
-}
-
-template <typename Self, typename F, typename... Rest>
-NvResult WrapFixedInlIn(Self* self, F&& callable, std::span<const u8> input, std::span<const u8> inline_input, std::span<u8> output, Rest&&... rest) {
-    using FixedArg    = typename std::remove_reference_t<decltype(IoctlTwoArgTraits::GetFirstArgImpl(callable))>;
-    using InlInVarArg = typename std::remove_reference_t<decltype(IoctlTwoArgTraits::GetSecondArgImpl(callable))>::value_type;
-
-    const auto Callable = [&](auto& fixed, auto& var, auto& inl_in, auto& inl_out) -> NvResult {
-        return (self->*callable)(fixed, inl_in, std::forward<Rest>(rest)...);
-    };
-
-    return WrapGeneric<FixedArg, Null, InlInVarArg, Null>(std::move(Callable), input, inline_input, output, {});
-}
-
-// clang-format on
-
-} // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -11,7 +11,6 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_as_gpu.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
@@ -34,21 +33,21 @@ NvResult nvhost_as_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> i
     case 'A':
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvhost_as_gpu::BindChannel, input, output);
+            return BindChannel(input, output);
         case 0x2:
-            return WrapFixed(this, &nvhost_as_gpu::AllocateSpace, input, output);
+            return AllocateSpace(input, output);
         case 0x3:
-            return WrapFixed(this, &nvhost_as_gpu::FreeSpace, input, output);
+            return FreeSpace(input, output);
         case 0x5:
-            return WrapFixed(this, &nvhost_as_gpu::UnmapBuffer, input, output);
+            return UnmapBuffer(input, output);
         case 0x6:
-            return WrapFixed(this, &nvhost_as_gpu::MapBufferEx, input, output);
+            return MapBufferEx(input, output);
         case 0x8:
-            return WrapFixed(this, &nvhost_as_gpu::GetVARegions1, input, output);
+            return GetVARegions(input, output);
         case 0x9:
-            return WrapFixed(this, &nvhost_as_gpu::AllocAsEx, input, output);
+            return AllocAsEx(input, output);
         case 0x14:
-            return WrapVariable(this, &nvhost_as_gpu::Remap, input, output);
+            return Remap(input, output);
         default:
             break;
         }
@@ -73,8 +72,7 @@ NvResult nvhost_as_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> i
     case 'A':
         switch (command.cmd) {
         case 0x8:
-            return WrapFixedInlOut(this, &nvhost_as_gpu::GetVARegions3, input, output,
-                                   inline_output);
+            return GetVARegions(input, output, inline_output);
         default:
             break;
         }
@@ -89,7 +87,10 @@ NvResult nvhost_as_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> i
 void nvhost_as_gpu::OnOpen(DeviceFD fd) {}
 void nvhost_as_gpu::OnClose(DeviceFD fd) {}
 
-NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
+NvResult nvhost_as_gpu::AllocAsEx(std::span<const u8> input, std::span<u8> output) {
+    IoctlAllocAsEx params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV, "called, big_page_size=0x{:X}", params.big_page_size);
 
     std::scoped_lock lock(mutex);
@@ -140,7 +141,10 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
     return NvResult::Success;
 }
 
-NvResult nvhost_as_gpu::AllocateSpace(IoctlAllocSpace& params) {
+NvResult nvhost_as_gpu::AllocateSpace(std::span<const u8> input, std::span<u8> output) {
+    IoctlAllocSpace params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV, "called, pages={:X}, page_size={:X}, flags={:X}", params.pages,
               params.page_size, params.flags);
 
@@ -190,6 +194,7 @@ NvResult nvhost_as_gpu::AllocateSpace(IoctlAllocSpace& params) {
         .big_pages = params.page_size != VM::YUZU_PAGESIZE,
     };
 
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
@@ -217,7 +222,10 @@ void nvhost_as_gpu::FreeMappingLocked(u64 offset) {
     mapping_map.erase(offset);
 }
 
-NvResult nvhost_as_gpu::FreeSpace(IoctlFreeSpace& params) {
+NvResult nvhost_as_gpu::FreeSpace(std::span<const u8> input, std::span<u8> output) {
+    IoctlFreeSpace params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV, "called, offset={:X}, pages={:X}, page_size={:X}", params.offset,
               params.pages, params.page_size);
 
@@ -256,11 +264,18 @@ NvResult nvhost_as_gpu::FreeSpace(IoctlFreeSpace& params) {
         return NvResult::BadValue;
     }
 
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_as_gpu::Remap(std::span<IoctlRemapEntry> entries) {
-    LOG_DEBUG(Service_NVDRV, "called, num_entries=0x{:X}", entries.size());
+NvResult nvhost_as_gpu::Remap(std::span<const u8> input, std::span<u8> output) {
+    const auto num_entries = input.size() / sizeof(IoctlRemapEntry);
+
+    LOG_DEBUG(Service_NVDRV, "called, num_entries=0x{:X}", num_entries);
+
+    std::scoped_lock lock(mutex);
+    entries.resize_destructive(num_entries);
+    std::memcpy(entries.data(), input.data(), input.size());
 
     if (!vm.initialised) {
         return NvResult::BadValue;
@@ -302,10 +317,14 @@ NvResult nvhost_as_gpu::Remap(std::span<IoctlRemapEntry> entries) {
         }
     }
 
+    std::memcpy(output.data(), entries.data(), output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
+NvResult nvhost_as_gpu::MapBufferEx(std::span<const u8> input, std::span<u8> output) {
+    IoctlMapBufferEx params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV,
               "called, flags={:X}, nvmap_handle={:X}, buffer_offset={}, mapping_size={}"
               ", offset={}",
@@ -402,10 +421,14 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         mapping_map[params.offset] = mapping;
     }
 
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_as_gpu::UnmapBuffer(IoctlUnmapBuffer& params) {
+NvResult nvhost_as_gpu::UnmapBuffer(std::span<const u8> input, std::span<u8> output) {
+    IoctlUnmapBuffer params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
 
     std::scoped_lock lock(mutex);
@@ -441,7 +464,9 @@ NvResult nvhost_as_gpu::UnmapBuffer(IoctlUnmapBuffer& params) {
     return NvResult::Success;
 }
 
-NvResult nvhost_as_gpu::BindChannel(IoctlBindChannel& params) {
+NvResult nvhost_as_gpu::BindChannel(std::span<const u8> input, std::span<u8> output) {
+    IoctlBindChannel params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
 
     auto gpu_channel_device = module.GetDevice<nvhost_gpu>(params.fd);
@@ -468,7 +493,10 @@ void nvhost_as_gpu::GetVARegionsImpl(IoctlGetVaRegions& params) {
     };
 }
 
-NvResult nvhost_as_gpu::GetVARegions1(IoctlGetVaRegions& params) {
+NvResult nvhost_as_gpu::GetVARegions(std::span<const u8> input, std::span<u8> output) {
+    IoctlGetVaRegions params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV, "called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
               params.buf_size);
 
@@ -480,10 +508,15 @@ NvResult nvhost_as_gpu::GetVARegions1(IoctlGetVaRegions& params) {
 
     GetVARegionsImpl(params);
 
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_as_gpu::GetVARegions3(IoctlGetVaRegions& params, std::span<VaRegion> regions) {
+NvResult nvhost_as_gpu::GetVARegions(std::span<const u8> input, std::span<u8> output,
+                                     std::span<u8> inline_output) {
+    IoctlGetVaRegions params{};
+    std::memcpy(&params, input.data(), input.size());
+
     LOG_DEBUG(Service_NVDRV, "called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
               params.buf_size);
 
@@ -495,10 +528,9 @@ NvResult nvhost_as_gpu::GetVARegions3(IoctlGetVaRegions& params, std::span<VaReg
 
     GetVARegionsImpl(params);
 
-    const size_t num_regions = std::min(params.regions.size(), regions.size());
-    for (size_t i = 0; i < num_regions; i++) {
-        regions[i] = params.regions[i];
-    }
+    std::memcpy(output.data(), &params, output.size());
+    std::memcpy(inline_output.data(), &params.regions[0], sizeof(VaRegion));
+    std::memcpy(inline_output.data() + sizeof(VaRegion), &params.regions[1], sizeof(VaRegion));
 
     return NvResult::Success;
 }

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -139,17 +139,18 @@ private:
     static_assert(sizeof(IoctlGetVaRegions) == 16 + sizeof(VaRegion) * 2,
                   "IoctlGetVaRegions is incorrect size");
 
-    NvResult AllocAsEx(IoctlAllocAsEx& params);
-    NvResult AllocateSpace(IoctlAllocSpace& params);
-    NvResult Remap(std::span<IoctlRemapEntry> params);
-    NvResult MapBufferEx(IoctlMapBufferEx& params);
-    NvResult UnmapBuffer(IoctlUnmapBuffer& params);
-    NvResult FreeSpace(IoctlFreeSpace& params);
-    NvResult BindChannel(IoctlBindChannel& params);
+    NvResult AllocAsEx(std::span<const u8> input, std::span<u8> output);
+    NvResult AllocateSpace(std::span<const u8> input, std::span<u8> output);
+    NvResult Remap(std::span<const u8> input, std::span<u8> output);
+    NvResult MapBufferEx(std::span<const u8> input, std::span<u8> output);
+    NvResult UnmapBuffer(std::span<const u8> input, std::span<u8> output);
+    NvResult FreeSpace(std::span<const u8> input, std::span<u8> output);
+    NvResult BindChannel(std::span<const u8> input, std::span<u8> output);
 
     void GetVARegionsImpl(IoctlGetVaRegions& params);
-    NvResult GetVARegions1(IoctlGetVaRegions& params);
-    NvResult GetVARegions3(IoctlGetVaRegions& params, std::span<VaRegion> regions);
+    NvResult GetVARegions(std::span<const u8> input, std::span<u8> output);
+    NvResult GetVARegions(std::span<const u8> input, std::span<u8> output,
+                          std::span<u8> inline_output);
 
     void FreeMappingLocked(u64 offset);
 
@@ -212,6 +213,7 @@ private:
         bool initialised{};
     } vm;
     std::shared_ptr<Tegra::MemoryManager> gmmu;
+    Common::ScratchBuffer<IoctlRemapEntry> entries;
 
     // s32 channel{};
     // u32 big_page_size{VM::DEFAULT_BIG_PAGE_SIZE};

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -14,7 +14,6 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/syncpoint_manager.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl.h"
 #include "video_core/gpu.h"
 #include "video_core/host1x/host1x.h"
@@ -41,19 +40,19 @@ NvResult nvhost_ctrl::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inp
     case 0x0:
         switch (command.cmd) {
         case 0x1b:
-            return WrapFixed(this, &nvhost_ctrl::NvOsGetConfigU32, input, output);
+            return NvOsGetConfigU32(input, output);
         case 0x1c:
-            return WrapFixed(this, &nvhost_ctrl::IocCtrlClearEventWait, input, output);
+            return IocCtrlClearEventWait(input, output);
         case 0x1d:
-            return WrapFixed(this, &nvhost_ctrl::IocCtrlEventWait, input, output, true);
+            return IocCtrlEventWait(input, output, true);
         case 0x1e:
-            return WrapFixed(this, &nvhost_ctrl::IocCtrlEventWait, input, output, false);
+            return IocCtrlEventWait(input, output, false);
         case 0x1f:
-            return WrapFixed(this, &nvhost_ctrl::IocCtrlEventRegister, input, output);
+            return IocCtrlEventRegister(input, output);
         case 0x20:
-            return WrapFixed(this, &nvhost_ctrl::IocCtrlEventUnregister, input, output);
+            return IocCtrlEventUnregister(input, output);
         case 0x21:
-            return WrapFixed(this, &nvhost_ctrl::IocCtrlEventUnregisterBatch, input, output);
+            return IocCtrlEventUnregisterBatch(input, output);
         }
         break;
     default:
@@ -80,19 +79,25 @@ void nvhost_ctrl::OnOpen(DeviceFD fd) {}
 
 void nvhost_ctrl::OnClose(DeviceFD fd) {}
 
-NvResult nvhost_ctrl::NvOsGetConfigU32(IocGetConfigParams& params) {
+NvResult nvhost_ctrl::NvOsGetConfigU32(std::span<const u8> input, std::span<u8> output) {
+    IocGetConfigParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
     LOG_TRACE(Service_NVDRV, "called, setting={}!{}", params.domain_str.data(),
               params.param_str.data());
     return NvResult::ConfigVarNotFound; // Returns error on production mode
 }
 
-NvResult nvhost_ctrl::IocCtrlEventWait(IocCtrlEventWaitParams& params, bool is_allocation) {
+NvResult nvhost_ctrl::IocCtrlEventWait(std::span<const u8> input, std::span<u8> output,
+                                       bool is_allocation) {
+    IocCtrlEventWaitParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "syncpt_id={}, threshold={}, timeout={}, is_allocation={}",
               params.fence.id, params.fence.value, params.timeout, is_allocation);
 
     bool must_unmark_fail = !is_allocation;
     const u32 event_id = params.value.raw;
     SCOPE_EXIT({
+        std::memcpy(output.data(), &params, sizeof(params));
         if (must_unmark_fail) {
             events[event_id].fails = 0;
         }
@@ -226,7 +231,9 @@ NvResult nvhost_ctrl::FreeEvent(u32 slot) {
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl::IocCtrlEventRegister(IocCtrlEventRegisterParams& params) {
+NvResult nvhost_ctrl::IocCtrlEventRegister(std::span<const u8> input, std::span<u8> output) {
+    IocCtrlEventRegisterParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
     const u32 event_id = params.user_event_id;
     LOG_DEBUG(Service_NVDRV, " called, user_event_id: {:X}", event_id);
     if (event_id >= MaxNvEvents) {
@@ -245,7 +252,9 @@ NvResult nvhost_ctrl::IocCtrlEventRegister(IocCtrlEventRegisterParams& params) {
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl::IocCtrlEventUnregister(IocCtrlEventUnregisterParams& params) {
+NvResult nvhost_ctrl::IocCtrlEventUnregister(std::span<const u8> input, std::span<u8> output) {
+    IocCtrlEventUnregisterParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
     const u32 event_id = params.user_event_id & 0x00FF;
     LOG_DEBUG(Service_NVDRV, " called, user_event_id: {:X}", event_id);
 
@@ -253,7 +262,9 @@ NvResult nvhost_ctrl::IocCtrlEventUnregister(IocCtrlEventUnregisterParams& param
     return FreeEvent(event_id);
 }
 
-NvResult nvhost_ctrl::IocCtrlEventUnregisterBatch(IocCtrlEventUnregisterBatchParams& params) {
+NvResult nvhost_ctrl::IocCtrlEventUnregisterBatch(std::span<const u8> input, std::span<u8> output) {
+    IocCtrlEventUnregisterBatchParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
     u64 event_mask = params.user_events;
     LOG_DEBUG(Service_NVDRV, " called, event_mask: {:X}", event_mask);
 
@@ -269,7 +280,10 @@ NvResult nvhost_ctrl::IocCtrlEventUnregisterBatch(IocCtrlEventUnregisterBatchPar
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl::IocCtrlClearEventWait(IocCtrlEventClearParams& params) {
+NvResult nvhost_ctrl::IocCtrlClearEventWait(std::span<const u8> input, std::span<u8> output) {
+    IocCtrlEventClearParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
+
     u32 event_id = params.event_id.slot;
     LOG_DEBUG(Service_NVDRV, "called, event_id: {:X}", event_id);
 

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -186,12 +186,12 @@ private:
     static_assert(sizeof(IocCtrlEventUnregisterBatchParams) == 8,
                   "IocCtrlEventKill is incorrect size");
 
-    NvResult NvOsGetConfigU32(IocGetConfigParams& params);
-    NvResult IocCtrlEventRegister(IocCtrlEventRegisterParams& params);
-    NvResult IocCtrlEventUnregister(IocCtrlEventUnregisterParams& params);
-    NvResult IocCtrlEventUnregisterBatch(IocCtrlEventUnregisterBatchParams& params);
-    NvResult IocCtrlEventWait(IocCtrlEventWaitParams& params, bool is_allocation);
-    NvResult IocCtrlClearEventWait(IocCtrlEventClearParams& params);
+    NvResult NvOsGetConfigU32(std::span<const u8> input, std::span<u8> output);
+    NvResult IocCtrlEventWait(std::span<const u8> input, std::span<u8> output, bool is_allocation);
+    NvResult IocCtrlEventRegister(std::span<const u8> input, std::span<u8> output);
+    NvResult IocCtrlEventUnregister(std::span<const u8> input, std::span<u8> output);
+    NvResult IocCtrlEventUnregisterBatch(std::span<const u8> input, std::span<u8> output);
+    NvResult IocCtrlClearEventWait(std::span<const u8> input, std::span<u8> output);
 
     NvResult FreeEvent(u32 slot);
 

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp

@@ -6,7 +6,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 
@@ -28,23 +27,23 @@ NvResult nvhost_ctrl_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8>
     case 'G':
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvhost_ctrl_gpu::ZCullGetCtxSize, input, output);
+            return ZCullGetCtxSize(input, output);
         case 0x2:
-            return WrapFixed(this, &nvhost_ctrl_gpu::ZCullGetInfo, input, output);
+            return ZCullGetInfo(input, output);
         case 0x3:
-            return WrapFixed(this, &nvhost_ctrl_gpu::ZBCSetTable, input, output);
+            return ZBCSetTable(input, output);
         case 0x4:
-            return WrapFixed(this, &nvhost_ctrl_gpu::ZBCQueryTable, input, output);
+            return ZBCQueryTable(input, output);
         case 0x5:
-            return WrapFixed(this, &nvhost_ctrl_gpu::GetCharacteristics1, input, output);
+            return GetCharacteristics(input, output);
         case 0x6:
-            return WrapFixed(this, &nvhost_ctrl_gpu::GetTPCMasks1, input, output);
+            return GetTPCMasks(input, output);
         case 0x7:
-            return WrapFixed(this, &nvhost_ctrl_gpu::FlushL2, input, output);
+            return FlushL2(input, output);
         case 0x14:
-            return WrapFixed(this, &nvhost_ctrl_gpu::GetActiveSlotMask, input, output);
+            return GetActiveSlotMask(input, output);
         case 0x1c:
-            return WrapFixed(this, &nvhost_ctrl_gpu::GetGpuTime, input, output);
+            return GetGpuTime(input, output);
         default:
             break;
         }
@@ -66,11 +65,9 @@ NvResult nvhost_ctrl_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8>
     case 'G':
         switch (command.cmd) {
         case 0x5:
-            return WrapFixedInlOut(this, &nvhost_ctrl_gpu::GetCharacteristics3, input, output,
-                                   inline_output);
+            return GetCharacteristics(input, output, inline_output);
         case 0x6:
-            return WrapFixedInlOut(this, &nvhost_ctrl_gpu::GetTPCMasks3, input, output,
-                                   inline_output);
+            return GetTPCMasks(input, output, inline_output);
         default:
             break;
         }
@@ -85,8 +82,10 @@ NvResult nvhost_ctrl_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8>
 void nvhost_ctrl_gpu::OnOpen(DeviceFD fd) {}
 void nvhost_ctrl_gpu::OnClose(DeviceFD fd) {}
 
-NvResult nvhost_ctrl_gpu::GetCharacteristics1(IoctlCharacteristics& params) {
+NvResult nvhost_ctrl_gpu::GetCharacteristics(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
+    IoctlCharacteristics params{};
+    std::memcpy(&params, input.data(), input.size());
     params.gc.arch = 0x120;
     params.gc.impl = 0xb;
     params.gc.rev = 0xa1;
@@ -124,13 +123,15 @@ NvResult nvhost_ctrl_gpu::GetCharacteristics1(IoctlCharacteristics& params) {
     params.gc.gr_compbit_store_base_hw = 0x0;
     params.gpu_characteristics_buf_size = 0xA0;
     params.gpu_characteristics_buf_addr = 0xdeadbeef; // Cannot be 0 (UNUSED)
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::GetCharacteristics3(
-    IoctlCharacteristics& params, std::span<IoctlGpuCharacteristics> gpu_characteristics) {
+NvResult nvhost_ctrl_gpu::GetCharacteristics(std::span<const u8> input, std::span<u8> output,
+                                             std::span<u8> inline_output) {
     LOG_DEBUG(Service_NVDRV, "called");
-
+    IoctlCharacteristics params{};
+    std::memcpy(&params, input.data(), input.size());
     params.gc.arch = 0x120;
     params.gc.impl = 0xb;
     params.gc.rev = 0xa1;
@@ -168,47 +169,70 @@ NvResult nvhost_ctrl_gpu::GetCharacteristics3(
     params.gc.gr_compbit_store_base_hw = 0x0;
     params.gpu_characteristics_buf_size = 0xA0;
     params.gpu_characteristics_buf_addr = 0xdeadbeef; // Cannot be 0 (UNUSED)
-    if (!gpu_characteristics.empty()) {
-        gpu_characteristics.front() = params.gc;
-    }
+
+    std::memcpy(output.data(), &params, output.size());
+    std::memcpy(inline_output.data(), &params.gc, inline_output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::GetTPCMasks1(IoctlGpuGetTpcMasksArgs& params) {
+NvResult nvhost_ctrl_gpu::GetTPCMasks(std::span<const u8> input, std::span<u8> output) {
+    IoctlGpuGetTpcMasksArgs params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, mask_buffer_size=0x{:X}", params.mask_buffer_size);
     if (params.mask_buffer_size != 0) {
         params.tcp_mask = 3;
     }
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::GetTPCMasks3(IoctlGpuGetTpcMasksArgs& params, std::span<u32> tpc_mask) {
+NvResult nvhost_ctrl_gpu::GetTPCMasks(std::span<const u8> input, std::span<u8> output,
+                                      std::span<u8> inline_output) {
+    IoctlGpuGetTpcMasksArgs params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, mask_buffer_size=0x{:X}", params.mask_buffer_size);
     if (params.mask_buffer_size != 0) {
         params.tcp_mask = 3;
     }
-    if (!tpc_mask.empty()) {
-        tpc_mask.front() = params.tcp_mask;
-    }
+    std::memcpy(output.data(), &params, output.size());
+    std::memcpy(inline_output.data(), &params.tcp_mask, inline_output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::GetActiveSlotMask(IoctlActiveSlotMask& params) {
+NvResult nvhost_ctrl_gpu::GetActiveSlotMask(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
 
+    IoctlActiveSlotMask params{};
+    if (input.size() > 0) {
+        std::memcpy(&params, input.data(), input.size());
+    }
     params.slot = 0x07;
     params.mask = 0x01;
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::ZCullGetCtxSize(IoctlZcullGetCtxSize& params) {
+NvResult nvhost_ctrl_gpu::ZCullGetCtxSize(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
+
+    IoctlZcullGetCtxSize params{};
+    if (input.size() > 0) {
+        std::memcpy(&params, input.data(), input.size());
+    }
     params.size = 0x1;
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::ZCullGetInfo(IoctlNvgpuGpuZcullGetInfoArgs& params) {
+NvResult nvhost_ctrl_gpu::ZCullGetInfo(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
+
+    IoctlNvgpuGpuZcullGetInfoArgs params{};
+
+    if (input.size() > 0) {
+        std::memcpy(&params, input.data(), input.size());
+    }
+
     params.width_align_pixels = 0x20;
     params.height_align_pixels = 0x20;
     params.pixel_squares_by_aliquots = 0x400;
@@ -219,28 +243,53 @@ NvResult nvhost_ctrl_gpu::ZCullGetInfo(IoctlNvgpuGpuZcullGetInfoArgs& params) {
     params.subregion_width_align_pixels = 0x20;
     params.subregion_height_align_pixels = 0x40;
     params.subregion_count = 0x10;
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::ZBCSetTable(IoctlZbcSetTable& params) {
+NvResult nvhost_ctrl_gpu::ZBCSetTable(std::span<const u8> input, std::span<u8> output) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+
+    IoctlZbcSetTable params{};
+    std::memcpy(&params, input.data(), input.size());
     // TODO(ogniK): What does this even actually do?
+
+    // Prevent null pointer being passed as arg 1
+    if (output.empty()) {
+        LOG_WARNING(Service_NVDRV, "Avoiding passing null pointer to memcpy");
+    } else {
+        std::memcpy(output.data(), &params, output.size());
+    }
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::ZBCQueryTable(IoctlZbcQueryTable& params) {
+NvResult nvhost_ctrl_gpu::ZBCQueryTable(std::span<const u8> input, std::span<u8> output) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+
+    IoctlZbcQueryTable params{};
+    std::memcpy(&params, input.data(), input.size());
+    // TODO : To implement properly
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::FlushL2(IoctlFlushL2& params) {
+NvResult nvhost_ctrl_gpu::FlushL2(std::span<const u8> input, std::span<u8> output) {
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+
+    IoctlFlushL2 params{};
+    std::memcpy(&params, input.data(), input.size());
+    // TODO : To implement properly
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_ctrl_gpu::GetGpuTime(IoctlGetGpuTime& params) {
+NvResult nvhost_ctrl_gpu::GetGpuTime(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
+
+    IoctlGetGpuTime params{};
+    std::memcpy(&params, input.data(), input.size());
     params.gpu_time = static_cast<u64_le>(system.CoreTiming().GetGlobalTimeNs().count());
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 

src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h

@@ -151,20 +151,21 @@ private:
     };
     static_assert(sizeof(IoctlGetGpuTime) == 0x10, "IoctlGetGpuTime is incorrect size");
 
-    NvResult GetCharacteristics1(IoctlCharacteristics& params);
-    NvResult GetCharacteristics3(IoctlCharacteristics& params,
-                                 std::span<IoctlGpuCharacteristics> gpu_characteristics);
+    NvResult GetCharacteristics(std::span<const u8> input, std::span<u8> output);
+    NvResult GetCharacteristics(std::span<const u8> input, std::span<u8> output,
+                                std::span<u8> inline_output);
 
-    NvResult GetTPCMasks1(IoctlGpuGetTpcMasksArgs& params);
-    NvResult GetTPCMasks3(IoctlGpuGetTpcMasksArgs& params, std::span<u32> tpc_mask);
+    NvResult GetTPCMasks(std::span<const u8> input, std::span<u8> output);
+    NvResult GetTPCMasks(std::span<const u8> input, std::span<u8> output,
+                         std::span<u8> inline_output);
 
-    NvResult GetActiveSlotMask(IoctlActiveSlotMask& params);
-    NvResult ZCullGetCtxSize(IoctlZcullGetCtxSize& params);
-    NvResult ZCullGetInfo(IoctlNvgpuGpuZcullGetInfoArgs& params);
-    NvResult ZBCSetTable(IoctlZbcSetTable& params);
-    NvResult ZBCQueryTable(IoctlZbcQueryTable& params);
-    NvResult FlushL2(IoctlFlushL2& params);
-    NvResult GetGpuTime(IoctlGetGpuTime& params);
+    NvResult GetActiveSlotMask(std::span<const u8> input, std::span<u8> output);
+    NvResult ZCullGetCtxSize(std::span<const u8> input, std::span<u8> output);
+    NvResult ZCullGetInfo(std::span<const u8> input, std::span<u8> output);
+    NvResult ZBCSetTable(std::span<const u8> input, std::span<u8> output);
+    NvResult ZBCQueryTable(std::span<const u8> input, std::span<u8> output);
+    NvResult FlushL2(std::span<const u8> input, std::span<u8> output);
+    NvResult GetGpuTime(std::span<const u8> input, std::span<u8> output);
 
     EventInterface& events_interface;
 

src/core/hle/service/nvdrv/devices/nvhost_gpu.cpp

@@ -8,7 +8,6 @@
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
 #include "core/hle/service/nvdrv/core/syncpoint_manager.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_gpu.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/memory.h"
@@ -53,7 +52,7 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     case 0x0:
         switch (command.cmd) {
         case 0x3:
-            return WrapFixed(this, &nvhost_gpu::GetWaitbase, input, output);
+            return GetWaitbase(input, output);
         default:
             break;
         }
@@ -61,25 +60,25 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     case 'H':
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvhost_gpu::SetNVMAPfd, input, output);
+            return SetNVMAPfd(input, output);
         case 0x3:
-            return WrapFixed(this, &nvhost_gpu::ChannelSetTimeout, input, output);
+            return ChannelSetTimeout(input, output);
         case 0x8:
-            return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, false);
+            return SubmitGPFIFOBase(input, output, false);
         case 0x9:
-            return WrapFixed(this, &nvhost_gpu::AllocateObjectContext, input, output);
+            return AllocateObjectContext(input, output);
         case 0xb:
-            return WrapFixed(this, &nvhost_gpu::ZCullBind, input, output);
+            return ZCullBind(input, output);
         case 0xc:
-            return WrapFixed(this, &nvhost_gpu::SetErrorNotifier, input, output);
+            return SetErrorNotifier(input, output);
         case 0xd:
-            return WrapFixed(this, &nvhost_gpu::SetChannelPriority, input, output);
+            return SetChannelPriority(input, output);
         case 0x1a:
-            return WrapFixed(this, &nvhost_gpu::AllocGPFIFOEx2, input, output);
+            return AllocGPFIFOEx2(input, output);
         case 0x1b:
-            return WrapFixedVariable(this, &nvhost_gpu::SubmitGPFIFOBase1, input, output, true);
+            return SubmitGPFIFOBase(input, output, true);
         case 0x1d:
-            return WrapFixed(this, &nvhost_gpu::ChannelSetTimeslice, input, output);
+            return ChannelSetTimeslice(input, output);
         default:
             break;
         }
@@ -87,9 +86,9 @@ NvResult nvhost_gpu::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     case 'G':
         switch (command.cmd) {
         case 0x14:
-            return WrapFixed(this, &nvhost_gpu::SetClientData, input, output);
+            return SetClientData(input, output);
         case 0x15:
-            return WrapFixed(this, &nvhost_gpu::GetClientData, input, output);
+            return GetClientData(input, output);
         default:
             break;
         }
@@ -105,8 +104,7 @@ NvResult nvhost_gpu::Ioctl2(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     case 'H':
         switch (command.cmd) {
         case 0x1b:
-            return WrapFixedInlIn(this, &nvhost_gpu::SubmitGPFIFOBase2, input, inline_input,
-                                  output);
+            return SubmitGPFIFOBase(input, inline_input, output);
         }
         break;
     }
@@ -123,45 +121,63 @@ NvResult nvhost_gpu::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
 void nvhost_gpu::OnOpen(DeviceFD fd) {}
 void nvhost_gpu::OnClose(DeviceFD fd) {}
 
-NvResult nvhost_gpu::SetNVMAPfd(IoctlSetNvmapFD& params) {
+NvResult nvhost_gpu::SetNVMAPfd(std::span<const u8> input, std::span<u8> output) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
 
     nvmap_fd = params.nvmap_fd;
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::SetClientData(IoctlClientData& params) {
+NvResult nvhost_gpu::SetClientData(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
+
+    IoctlClientData params{};
+    std::memcpy(&params, input.data(), input.size());
     user_data = params.data;
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::GetClientData(IoctlClientData& params) {
+NvResult nvhost_gpu::GetClientData(std::span<const u8> input, std::span<u8> output) {
     LOG_DEBUG(Service_NVDRV, "called");
+
+    IoctlClientData params{};
+    std::memcpy(&params, input.data(), input.size());
     params.data = user_data;
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::ZCullBind(IoctlZCullBind& params) {
-    zcull_params = params;
+NvResult nvhost_gpu::ZCullBind(std::span<const u8> input, std::span<u8> output) {
+    std::memcpy(&zcull_params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, gpu_va={:X}, mode={:X}", zcull_params.gpu_va,
               zcull_params.mode);
+
+    std::memcpy(output.data(), &zcull_params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::SetErrorNotifier(IoctlSetErrorNotifier& params) {
+NvResult nvhost_gpu::SetErrorNotifier(std::span<const u8> input, std::span<u8> output) {
+    IoctlSetErrorNotifier params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, offset={:X}, size={:X}, mem={:X}", params.offset,
                 params.size, params.mem);
+
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::SetChannelPriority(IoctlChannelSetPriority& params) {
-    channel_priority = params.priority;
+NvResult nvhost_gpu::SetChannelPriority(std::span<const u8> input, std::span<u8> output) {
+    std::memcpy(&channel_priority, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "(STUBBED) called, priority={:X}", channel_priority);
+
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params) {
+NvResult nvhost_gpu::AllocGPFIFOEx2(std::span<const u8> input, std::span<u8> output) {
+    IoctlAllocGpfifoEx2 params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_WARNING(Service_NVDRV,
                 "(STUBBED) called, num_entries={:X}, flags={:X}, unk0={:X}, "
                 "unk1={:X}, unk2={:X}, unk3={:X}",
@@ -177,14 +193,18 @@ NvResult nvhost_gpu::AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params) {
 
     params.fence_out = syncpoint_manager.GetSyncpointFence(channel_syncpoint);
 
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::AllocateObjectContext(IoctlAllocObjCtx& params) {
+NvResult nvhost_gpu::AllocateObjectContext(std::span<const u8> input, std::span<u8> output) {
+    IoctlAllocObjCtx params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_WARNING(Service_NVDRV, "(STUBBED) called, class_num={:X}, flags={:X}", params.class_num,
                 params.flags);
 
     params.obj_id = 0x0;
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
@@ -228,7 +248,8 @@ static boost::container::small_vector<Tegra::CommandHeader, 512> BuildIncrementW
     return result;
 }
 
-NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandList&& entries) {
+NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::span<u8> output,
+                                      Tegra::CommandList&& entries) {
     LOG_TRACE(Service_NVDRV, "called, gpfifo={:X}, num_entries={:X}, flags={:X}", params.address,
               params.num_entries, params.flags.raw);
 
@@ -269,55 +290,65 @@ NvResult nvhost_gpu::SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandL
 
     flags.raw = 0;
 
+    std::memcpy(output.data(), &params, sizeof(IoctlSubmitGpfifo));
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::SubmitGPFIFOBase1(IoctlSubmitGpfifo& params,
-                                       std::span<Tegra::CommandListHeader> commands, bool kickoff) {
-    if (params.num_entries > commands.size()) {
+NvResult nvhost_gpu::SubmitGPFIFOBase(std::span<const u8> input, std::span<u8> output,
+                                      bool kickoff) {
+    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
         UNIMPLEMENTED();
         return NvResult::InvalidSize;
     }
-
+    IoctlSubmitGpfifo params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
     Tegra::CommandList entries(params.num_entries);
+
     if (kickoff) {
         system.ApplicationMemory().ReadBlock(params.address, entries.command_lists.data(),
                                              params.num_entries * sizeof(Tegra::CommandListHeader));
     } else {
-        std::memcpy(entries.command_lists.data(), commands.data(),
+        std::memcpy(entries.command_lists.data(), &input[sizeof(IoctlSubmitGpfifo)],
                     params.num_entries * sizeof(Tegra::CommandListHeader));
     }
 
-    return SubmitGPFIFOImpl(params, std::move(entries));
+    return SubmitGPFIFOImpl(params, output, std::move(entries));
 }
 
-NvResult nvhost_gpu::SubmitGPFIFOBase2(IoctlSubmitGpfifo& params,
-                                       std::span<const Tegra::CommandListHeader> commands) {
-    if (params.num_entries > commands.size()) {
+NvResult nvhost_gpu::SubmitGPFIFOBase(std::span<const u8> input, std::span<const u8> input_inline,
+                                      std::span<u8> output) {
+    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
         UNIMPLEMENTED();
         return NvResult::InvalidSize;
     }
-
+    IoctlSubmitGpfifo params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSubmitGpfifo));
     Tegra::CommandList entries(params.num_entries);
-    std::memcpy(entries.command_lists.data(), commands.data(),
-                params.num_entries * sizeof(Tegra::CommandListHeader));
-    return SubmitGPFIFOImpl(params, std::move(entries));
+    std::memcpy(entries.command_lists.data(), input_inline.data(), input_inline.size());
+    return SubmitGPFIFOImpl(params, output, std::move(entries));
 }
 
-NvResult nvhost_gpu::GetWaitbase(IoctlGetWaitbase& params) {
+NvResult nvhost_gpu::GetWaitbase(std::span<const u8> input, std::span<u8> output) {
+    IoctlGetWaitbase params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
     LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
 
     params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::ChannelSetTimeout(IoctlChannelSetTimeout& params) {
+NvResult nvhost_gpu::ChannelSetTimeout(std::span<const u8> input, std::span<u8> output) {
+    IoctlChannelSetTimeout params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlChannelSetTimeout));
     LOG_INFO(Service_NVDRV, "called, timeout=0x{:X}", params.timeout);
 
     return NvResult::Success;
 }
 
-NvResult nvhost_gpu::ChannelSetTimeslice(IoctlSetTimeslice& params) {
+NvResult nvhost_gpu::ChannelSetTimeslice(std::span<const u8> input, std::span<u8> output) {
+    IoctlSetTimeslice params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSetTimeslice));
     LOG_INFO(Service_NVDRV, "called, timeslice=0x{:X}", params.timeslice);
 
     channel_timeslice = params.timeslice;

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -186,24 +186,23 @@ private:
     u32_le channel_priority{};
     u32_le channel_timeslice{};
 
-    NvResult SetNVMAPfd(IoctlSetNvmapFD& params);
-    NvResult SetClientData(IoctlClientData& params);
-    NvResult GetClientData(IoctlClientData& params);
-    NvResult ZCullBind(IoctlZCullBind& params);
-    NvResult SetErrorNotifier(IoctlSetErrorNotifier& params);
-    NvResult SetChannelPriority(IoctlChannelSetPriority& params);
-    NvResult AllocGPFIFOEx2(IoctlAllocGpfifoEx2& params);
-    NvResult AllocateObjectContext(IoctlAllocObjCtx& params);
-
-    NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, Tegra::CommandList&& entries);
-    NvResult SubmitGPFIFOBase1(IoctlSubmitGpfifo& params,
-                               std::span<Tegra::CommandListHeader> commands, bool kickoff = false);
-    NvResult SubmitGPFIFOBase2(IoctlSubmitGpfifo& params,
-                               std::span<const Tegra::CommandListHeader> commands);
-
-    NvResult GetWaitbase(IoctlGetWaitbase& params);
-    NvResult ChannelSetTimeout(IoctlChannelSetTimeout& params);
-    NvResult ChannelSetTimeslice(IoctlSetTimeslice& params);
+    NvResult SetNVMAPfd(std::span<const u8> input, std::span<u8> output);
+    NvResult SetClientData(std::span<const u8> input, std::span<u8> output);
+    NvResult GetClientData(std::span<const u8> input, std::span<u8> output);
+    NvResult ZCullBind(std::span<const u8> input, std::span<u8> output);
+    NvResult SetErrorNotifier(std::span<const u8> input, std::span<u8> output);
+    NvResult SetChannelPriority(std::span<const u8> input, std::span<u8> output);
+    NvResult AllocGPFIFOEx2(std::span<const u8> input, std::span<u8> output);
+    NvResult AllocateObjectContext(std::span<const u8> input, std::span<u8> output);
+    NvResult SubmitGPFIFOImpl(IoctlSubmitGpfifo& params, std::span<u8> output,
+                              Tegra::CommandList&& entries);
+    NvResult SubmitGPFIFOBase(std::span<const u8> input, std::span<u8> output,
+                              bool kickoff = false);
+    NvResult SubmitGPFIFOBase(std::span<const u8> input, std::span<const u8> input_inline,
+                              std::span<u8> output);
+    NvResult GetWaitbase(std::span<const u8> input, std::span<u8> output);
+    NvResult ChannelSetTimeout(std::span<const u8> input, std::span<u8> output);
+    NvResult ChannelSetTimeslice(std::span<const u8> input, std::span<u8> output);
 
     EventInterface& events_interface;
     NvCore::Container& core;

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -6,7 +6,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/core/container.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
 #include "video_core/renderer_base.h"
 
@@ -26,18 +25,18 @@ NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> in
             if (!host1x_file.fd_to_id.contains(fd)) {
                 host1x_file.fd_to_id[fd] = host1x_file.nvdec_next_id++;
             }
-            return WrapFixedVariable(this, &nvhost_nvdec::Submit, input, output, fd);
+            return Submit(fd, input, output);
         }
         case 0x2:
-            return WrapFixed(this, &nvhost_nvdec::GetSyncpoint, input, output);
+            return GetSyncpoint(input, output);
         case 0x3:
-            return WrapFixed(this, &nvhost_nvdec::GetWaitbase, input, output);
+            return GetWaitbase(input, output);
         case 0x7:
-            return WrapFixed(this, &nvhost_nvdec::SetSubmitTimeout, input, output);
+            return SetSubmitTimeout(input, output);
         case 0x9:
-            return WrapFixedVariable(this, &nvhost_nvdec::MapBuffer, input, output);
+            return MapBuffer(input, output);
         case 0xa:
-            return WrapFixedVariable(this, &nvhost_nvdec::UnmapBuffer, input, output);
+            return UnmapBuffer(input, output);
         default:
             break;
         }
@@ -45,7 +44,7 @@ NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> in
     case 'H':
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvhost_nvdec::SetNVMAPfd, input, output);
+            return SetNVMAPfd(input);
         default:
             break;
         }

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -29,9 +29,6 @@ std::size_t SliceVectors(std::span<const u8> input, std::vector<T>& dst, std::si
         return 0;
     }
     const size_t bytes_copied = count * sizeof(T);
-    if (input.size() < offset + bytes_copied) {
-        return 0;
-    }
     std::memcpy(dst.data(), input.data() + offset, bytes_copied);
     return bytes_copied;
 }
@@ -44,9 +41,6 @@ std::size_t WriteVectors(std::span<u8> dst, const std::vector<T>& src, std::size
         return 0;
     }
     const size_t bytes_copied = src.size() * sizeof(T);
-    if (dst.size() < offset + bytes_copied) {
-        return 0;
-    }
     std::memcpy(dst.data() + offset, src.data(), bytes_copied);
     return bytes_copied;
 }
@@ -69,14 +63,18 @@ nvhost_nvdec_common::~nvhost_nvdec_common() {
     core.Host1xDeviceFile().syncpts_accumulated.push_back(channel_syncpoint);
 }
 
-NvResult nvhost_nvdec_common::SetNVMAPfd(IoctlSetNvmapFD& params) {
+NvResult nvhost_nvdec_common::SetNVMAPfd(std::span<const u8> input) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSetNvmapFD));
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
 
     nvmap_fd = params.nvmap_fd;
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, DeviceFD fd) {
+NvResult nvhost_nvdec_common::Submit(DeviceFD fd, std::span<const u8> input, std::span<u8> output) {
+    IoctlSubmit params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSubmit));
     LOG_DEBUG(Service_NVDRV, "called NVDEC Submit, cmd_buffer_count={}", params.cmd_buffer_count);
 
     // Instantiate param buffers
@@ -87,12 +85,12 @@ NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, De
     std::vector<u32> fence_thresholds(params.fence_count);
 
     // Slice input into their respective buffers
-    std::size_t offset = 0;
-    offset += SliceVectors(data, command_buffers, params.cmd_buffer_count, offset);
-    offset += SliceVectors(data, relocs, params.relocation_count, offset);
-    offset += SliceVectors(data, reloc_shifts, params.relocation_count, offset);
-    offset += SliceVectors(data, syncpt_increments, params.syncpoint_count, offset);
-    offset += SliceVectors(data, fence_thresholds, params.fence_count, offset);
+    std::size_t offset = sizeof(IoctlSubmit);
+    offset += SliceVectors(input, command_buffers, params.cmd_buffer_count, offset);
+    offset += SliceVectors(input, relocs, params.relocation_count, offset);
+    offset += SliceVectors(input, reloc_shifts, params.relocation_count, offset);
+    offset += SliceVectors(input, syncpt_increments, params.syncpoint_count, offset);
+    offset += SliceVectors(input, fence_thresholds, params.fence_count, offset);
 
     auto& gpu = system.GPU();
     if (gpu.UseNvdec()) {
@@ -110,51 +108,72 @@ NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, De
                                              cmdlist.size() * sizeof(u32));
         gpu.PushCommandBuffer(core.Host1xDeviceFile().fd_to_id[fd], cmdlist);
     }
+    std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
     // Some games expect command_buffers to be written back
-    offset = 0;
-    offset += WriteVectors(data, command_buffers, offset);
-    offset += WriteVectors(data, relocs, offset);
-    offset += WriteVectors(data, reloc_shifts, offset);
-    offset += WriteVectors(data, syncpt_increments, offset);
-    offset += WriteVectors(data, fence_thresholds, offset);
+    offset = sizeof(IoctlSubmit);
+    offset += WriteVectors(output, command_buffers, offset);
+    offset += WriteVectors(output, relocs, offset);
+    offset += WriteVectors(output, reloc_shifts, offset);
+    offset += WriteVectors(output, syncpt_increments, offset);
+    offset += WriteVectors(output, fence_thresholds, offset);
 
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::GetSyncpoint(IoctlGetSyncpoint& params) {
+NvResult nvhost_nvdec_common::GetSyncpoint(std::span<const u8> input, std::span<u8> output) {
+    IoctlGetSyncpoint params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
     LOG_DEBUG(Service_NVDRV, "called GetSyncpoint, id={}", params.param);
+
+    // const u32 id{NvCore::SyncpointManager::channel_syncpoints[static_cast<u32>(channel_type)]};
     params.value = channel_syncpoint;
+    std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));
+
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::GetWaitbase(IoctlGetWaitbase& params) {
+NvResult nvhost_nvdec_common::GetWaitbase(std::span<const u8> input, std::span<u8> output) {
+    IoctlGetWaitbase params{};
     LOG_CRITICAL(Service_NVDRV, "called WAITBASE");
+    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
     params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, sizeof(IoctlGetWaitbase));
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::MapBuffer(IoctlMapBuffer& params, std::span<MapBufferEntry> entries) {
-    const size_t num_entries = std::min(params.num_entries, static_cast<u32>(entries.size()));
-    for (size_t i = 0; i < num_entries; i++) {
-        entries[i].map_address = nvmap.PinHandle(entries[i].map_handle);
+NvResult nvhost_nvdec_common::MapBuffer(std::span<const u8> input, std::span<u8> output) {
+    IoctlMapBuffer params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
+    std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
+
+    SliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));
+
+    for (auto& cmd_buffer : cmd_buffer_handles) {
+        cmd_buffer.map_address = nvmap.PinHandle(cmd_buffer.map_handle);
+    }
+    std::memcpy(output.data(), &params, sizeof(IoctlMapBuffer));
+    std::memcpy(output.data() + sizeof(IoctlMapBuffer), cmd_buffer_handles.data(),
+                cmd_buffer_handles.size() * sizeof(MapBufferEntry));
+
+    return NvResult::Success;
+}
+
+NvResult nvhost_nvdec_common::UnmapBuffer(std::span<const u8> input, std::span<u8> output) {
+    IoctlMapBuffer params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
+    std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
+
+    SliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));
+    for (auto& cmd_buffer : cmd_buffer_handles) {
+        nvmap.UnpinHandle(cmd_buffer.map_handle);
     }
 
+    std::memset(output.data(), 0, output.size());
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::UnmapBuffer(IoctlMapBuffer& params,
-                                          std::span<MapBufferEntry> entries) {
-    const size_t num_entries = std::min(params.num_entries, static_cast<u32>(entries.size()));
-    for (size_t i = 0; i < num_entries; i++) {
-        nvmap.UnpinHandle(entries[i].map_handle);
-        entries[i] = {};
-    }
-
-    params = {};
-    return NvResult::Success;
-}
-
-NvResult nvhost_nvdec_common::SetSubmitTimeout(u32 timeout) {
+NvResult nvhost_nvdec_common::SetSubmitTimeout(std::span<const u8> input, std::span<u8> output) {
+    std::memcpy(&submit_timeout, input.data(), input.size());
     LOG_WARNING(Service_NVDRV, "(STUBBED) called");
     return NvResult::Success;
 }

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -107,13 +107,13 @@ protected:
     static_assert(sizeof(IoctlMapBuffer) == 0x0C, "IoctlMapBuffer is incorrect size");
 
     /// Ioctl command implementations
-    NvResult SetNVMAPfd(IoctlSetNvmapFD&);
-    NvResult Submit(IoctlSubmit& params, std::span<u8> input, DeviceFD fd);
-    NvResult GetSyncpoint(IoctlGetSyncpoint& params);
-    NvResult GetWaitbase(IoctlGetWaitbase& params);
-    NvResult MapBuffer(IoctlMapBuffer& params, std::span<MapBufferEntry> entries);
-    NvResult UnmapBuffer(IoctlMapBuffer& params, std::span<MapBufferEntry> entries);
-    NvResult SetSubmitTimeout(u32 timeout);
+    NvResult SetNVMAPfd(std::span<const u8> input);
+    NvResult Submit(DeviceFD fd, std::span<const u8> input, std::span<u8> output);
+    NvResult GetSyncpoint(std::span<const u8> input, std::span<u8> output);
+    NvResult GetWaitbase(std::span<const u8> input, std::span<u8> output);
+    NvResult MapBuffer(std::span<const u8> input, std::span<u8> output);
+    NvResult UnmapBuffer(std::span<const u8> input, std::span<u8> output);
+    NvResult SetSubmitTimeout(std::span<const u8> input, std::span<u8> output);
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;
 

src/core/hle/service/nvdrv/devices/nvhost_nvjpg.cpp

@@ -5,7 +5,6 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvjpg.h"
 
 namespace Service::Nvidia::Devices {
@@ -19,7 +18,7 @@ NvResult nvhost_nvjpg::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> in
     case 'H':
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvhost_nvjpg::SetNVMAPfd, input, output);
+            return SetNVMAPfd(input, output);
         default:
             break;
         }
@@ -47,7 +46,9 @@ NvResult nvhost_nvjpg::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
 void nvhost_nvjpg::OnOpen(DeviceFD fd) {}
 void nvhost_nvjpg::OnClose(DeviceFD fd) {}
 
-NvResult nvhost_nvjpg::SetNVMAPfd(IoctlSetNvmapFD& params) {
+NvResult nvhost_nvjpg::SetNVMAPfd(std::span<const u8> input, std::span<u8> output) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), input.size());
     LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
 
     nvmap_fd = params.nvmap_fd;

src/core/hle/service/nvdrv/devices/nvhost_nvjpg.h

@@ -33,7 +33,7 @@ private:
 
     s32_le nvmap_fd{};
 
-    NvResult SetNVMAPfd(IoctlSetNvmapFD& params);
+    NvResult SetNVMAPfd(std::span<const u8> input, std::span<u8> output);
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_vic.cpp

@@ -5,7 +5,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/core/container.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_vic.h"
 #include "video_core/renderer_base.h"
 
@@ -26,16 +25,16 @@ NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
             if (!host1x_file.fd_to_id.contains(fd)) {
                 host1x_file.fd_to_id[fd] = host1x_file.vic_next_id++;
             }
-            return WrapFixedVariable(this, &nvhost_vic::Submit, input, output, fd);
+            return Submit(fd, input, output);
         }
         case 0x2:
-            return WrapFixed(this, &nvhost_vic::GetSyncpoint, input, output);
+            return GetSyncpoint(input, output);
         case 0x3:
-            return WrapFixed(this, &nvhost_vic::GetWaitbase, input, output);
+            return GetWaitbase(input, output);
         case 0x9:
-            return WrapFixedVariable(this, &nvhost_vic::MapBuffer, input, output);
+            return MapBuffer(input, output);
         case 0xa:
-            return WrapFixedVariable(this, &nvhost_vic::UnmapBuffer, input, output);
+            return UnmapBuffer(input, output);
         default:
             break;
         }
@@ -43,7 +42,7 @@ NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     case 'H':
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvhost_vic::SetNVMAPfd, input, output);
+            return SetNVMAPfd(input);
         default:
             break;
         }

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
-#include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
 #include "core/memory.h"
 
@@ -32,17 +31,17 @@ NvResult nvmap::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> input,
     case 0x1:
         switch (command.cmd) {
         case 0x1:
-            return WrapFixed(this, &nvmap::IocCreate, input, output);
+            return IocCreate(input, output);
         case 0x3:
-            return WrapFixed(this, &nvmap::IocFromId, input, output);
+            return IocFromId(input, output);
         case 0x4:
-            return WrapFixed(this, &nvmap::IocAlloc, input, output);
+            return IocAlloc(input, output);
         case 0x5:
-            return WrapFixed(this, &nvmap::IocFree, input, output);
+            return IocFree(input, output);
         case 0x9:
-            return WrapFixed(this, &nvmap::IocParam, input, output);
+            return IocParam(input, output);
         case 0xe:
-            return WrapFixed(this, &nvmap::IocGetId, input, output);
+            return IocGetId(input, output);
         default:
             break;
         }
@@ -70,7 +69,9 @@ NvResult nvmap::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> input, st
 void nvmap::OnOpen(DeviceFD fd) {}
 void nvmap::OnClose(DeviceFD fd) {}
 
-NvResult nvmap::IocCreate(IocCreateParams& params) {
+NvResult nvmap::IocCreate(std::span<const u8> input, std::span<u8> output) {
+    IocCreateParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "called, size=0x{:08X}", params.size);
 
     std::shared_ptr<NvCore::NvMap::Handle> handle_description{};
@@ -84,10 +85,13 @@ NvResult nvmap::IocCreate(IocCreateParams& params) {
     params.handle = handle_description->id;
     LOG_DEBUG(Service_NVDRV, "handle: {}, size: 0x{:X}", handle_description->id, params.size);
 
+    std::memcpy(output.data(), &params, sizeof(params));
     return NvResult::Success;
 }
 
-NvResult nvmap::IocAlloc(IocAllocParams& params) {
+NvResult nvmap::IocAlloc(std::span<const u8> input, std::span<u8> output) {
+    IocAllocParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
     LOG_DEBUG(Service_NVDRV, "called, addr={:X}", params.address);
 
     if (!params.handle) {
@@ -129,10 +133,14 @@ NvResult nvmap::IocAlloc(IocAllocParams& params) {
                                              handle_description->size,
                                              Kernel::KMemoryPermission::None, true, false)
                .IsSuccess());
+    std::memcpy(output.data(), &params, sizeof(params));
     return result;
 }
 
-NvResult nvmap::IocGetId(IocGetIdParams& params) {
+NvResult nvmap::IocGetId(std::span<const u8> input, std::span<u8> output) {
+    IocGetIdParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
+
     LOG_DEBUG(Service_NVDRV, "called");
 
     // See the comment in FromId for extra info on this function
@@ -149,10 +157,14 @@ NvResult nvmap::IocGetId(IocGetIdParams& params) {
     }
 
     params.id = handle_description->id;
+    std::memcpy(output.data(), &params, sizeof(params));
     return NvResult::Success;
 }
 
-NvResult nvmap::IocFromId(IocFromIdParams& params) {
+NvResult nvmap::IocFromId(std::span<const u8> input, std::span<u8> output) {
+    IocFromIdParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
+
     LOG_DEBUG(Service_NVDRV, "called, id:{}", params.id);
 
     // Handles and IDs are always the same value in nvmap however IDs can be used globally given the
@@ -176,12 +188,16 @@ NvResult nvmap::IocFromId(IocFromIdParams& params) {
         return result;
     }
     params.handle = handle_description->id;
+    std::memcpy(output.data(), &params, sizeof(params));
     return NvResult::Success;
 }
 
-NvResult nvmap::IocParam(IocParamParams& params) {
+NvResult nvmap::IocParam(std::span<const u8> input, std::span<u8> output) {
     enum class ParamTypes { Size = 1, Alignment = 2, Base = 3, Heap = 4, Kind = 5, Compr = 6 };
 
+    IocParamParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
+
     LOG_DEBUG(Service_NVDRV, "called type={}", params.param);
 
     if (!params.handle) {
@@ -221,10 +237,14 @@ NvResult nvmap::IocParam(IocParamParams& params) {
         return NvResult::BadValue;
     }
 
+    std::memcpy(output.data(), &params, sizeof(params));
     return NvResult::Success;
 }
 
-NvResult nvmap::IocFree(IocFreeParams& params) {
+NvResult nvmap::IocFree(std::span<const u8> input, std::span<u8> output) {
+    IocFreeParams params;
+    std::memcpy(&params, input.data(), sizeof(params));
+
     LOG_DEBUG(Service_NVDRV, "called");
 
     if (!params.handle) {
@@ -247,6 +267,7 @@ NvResult nvmap::IocFree(IocFreeParams& params) {
         // This is possible when there's internal dups or other duplicates.
     }
 
+    std::memcpy(output.data(), &params, sizeof(params));
     return NvResult::Success;
 }
 

src/core/hle/service/nvdrv/devices/nvmap.h

@@ -99,12 +99,12 @@ public:
     };
     static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
 
-    NvResult IocCreate(IocCreateParams& params);
-    NvResult IocAlloc(IocAllocParams& params);
-    NvResult IocGetId(IocGetIdParams& params);
-    NvResult IocFromId(IocFromIdParams& params);
-    NvResult IocParam(IocParamParams& params);
-    NvResult IocFree(IocFreeParams& params);
+    NvResult IocCreate(std::span<const u8> input, std::span<u8> output);
+    NvResult IocAlloc(std::span<const u8> input, std::span<u8> output);
+    NvResult IocGetId(std::span<const u8> input, std::span<u8> output);
+    NvResult IocFromId(std::span<const u8> input, std::span<u8> output);
+    NvResult IocParam(std::span<const u8> input, std::span<u8> output);
+    NvResult IocFree(std::span<const u8> input, std::span<u8> output);
 
 private:
     /// Id to use for the next handle that is created.

src/core/hle/service/nvnflinger/buffer_transform_flags.h

@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Service::android {
@@ -22,6 +21,5 @@ enum class BufferTransformFlags : u32 {
     /// Rotate source image 270 degrees clockwise
     Rotate270 = 0x07,
 };
-DECLARE_ENUM_FLAG_OPERATORS(BufferTransformFlags);
 
 } // namespace Service::android

src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp

@@ -71,17 +71,24 @@ Result AllocateIoForProcessAddressSpace(Common::ProcessAddress* out_map_address,
     R_SUCCEED();
 }
 
+template <typename T>
+std::span<u8> SerializeIoc(T& params) {
+    return std::span(reinterpret_cast<u8*>(std::addressof(params)), sizeof(T));
+}
+
 Result CreateNvMapHandle(u32* out_nv_map_handle, Nvidia::Devices::nvmap& nvmap, u32 size) {
     // Create a handle.
-    Nvidia::Devices::nvmap::IocCreateParams create_params{
+    Nvidia::Devices::nvmap::IocCreateParams create_in_params{
         .size = size,
         .handle = 0,
     };
-    R_UNLESS(nvmap.IocCreate(create_params) == Nvidia::NvResult::Success,
+    Nvidia::Devices::nvmap::IocCreateParams create_out_params{};
+    R_UNLESS(nvmap.IocCreate(SerializeIoc(create_in_params), SerializeIoc(create_out_params)) ==
+                 Nvidia::NvResult::Success,
              VI::ResultOperationFailed);
 
     // Assign the output handle.
-    *out_nv_map_handle = create_params.handle;
+    *out_nv_map_handle = create_out_params.handle;
 
     // We succeeded.
     R_SUCCEED();
@@ -89,10 +96,13 @@ Result CreateNvMapHandle(u32* out_nv_map_handle, Nvidia::Devices::nvmap& nvmap,
 
 Result FreeNvMapHandle(Nvidia::Devices::nvmap& nvmap, u32 handle) {
     // Free the handle.
-    Nvidia::Devices::nvmap::IocFreeParams free_params{
+    Nvidia::Devices::nvmap::IocFreeParams free_in_params{
         .handle = handle,
     };
-    R_UNLESS(nvmap.IocFree(free_params) == Nvidia::NvResult::Success, VI::ResultOperationFailed);
+    Nvidia::Devices::nvmap::IocFreeParams free_out_params{};
+    R_UNLESS(nvmap.IocFree(SerializeIoc(free_in_params), SerializeIoc(free_out_params)) ==
+                 Nvidia::NvResult::Success,
+             VI::ResultOperationFailed);
 
     // We succeeded.
     R_SUCCEED();
@@ -101,7 +111,7 @@ Result FreeNvMapHandle(Nvidia::Devices::nvmap& nvmap, u32 handle) {
 Result AllocNvMapHandle(Nvidia::Devices::nvmap& nvmap, u32 handle, Common::ProcessAddress buffer,
                         u32 size) {
     // Assign the allocated memory to the handle.
-    Nvidia::Devices::nvmap::IocAllocParams alloc_params{
+    Nvidia::Devices::nvmap::IocAllocParams alloc_in_params{
         .handle = handle,
         .heap_mask = 0,
         .flags = {},
@@ -109,7 +119,10 @@ Result AllocNvMapHandle(Nvidia::Devices::nvmap& nvmap, u32 handle, Common::Proce
         .kind = 0,
         .address = GetInteger(buffer),
     };
-    R_UNLESS(nvmap.IocAlloc(alloc_params) == Nvidia::NvResult::Success, VI::ResultOperationFailed);
+    Nvidia::Devices::nvmap::IocAllocParams alloc_out_params{};
+    R_UNLESS(nvmap.IocAlloc(SerializeIoc(alloc_in_params), SerializeIoc(alloc_out_params)) ==
+                 Nvidia::NvResult::Success,
+             VI::ResultOperationFailed);
 
     // We succeeded.
     R_SUCCEED();

src/core/hle/service/sockets/bsd.cpp

@@ -39,18 +39,6 @@ bool IsConnectionBased(Type type) {
     }
 }
 
-template <typename T>
-T GetValue(std::span<const u8> buffer) {
-    T t{};
-    std::memcpy(&t, buffer.data(), std::min(sizeof(T), buffer.size()));
-    return t;
-}
-
-template <typename T>
-void PutValue(std::span<u8> buffer, const T& t) {
-    std::memcpy(buffer.data(), &t, std::min(sizeof(T), buffer.size()));
-}
-
 } // Anonymous namespace
 
 void BSD::PollWork::Execute(BSD* bsd) {
@@ -328,12 +316,22 @@ void BSD::SetSockOpt(HLERequestContext& ctx) {
     const s32 fd = rp.Pop<s32>();
     const u32 level = rp.Pop<u32>();
     const OptName optname = static_cast<OptName>(rp.Pop<u32>());
-    const auto optval = ctx.ReadBuffer();
+
+    const auto buffer = ctx.ReadBuffer();
+    const u8* optval = buffer.empty() ? nullptr : buffer.data();
+    size_t optlen = buffer.size();
+
+    std::array<u64, 2> values;
+    if ((optname == OptName::SNDTIMEO || optname == OptName::RCVTIMEO) && buffer.size() == 8) {
+        std::memcpy(values.data(), buffer.data(), sizeof(values));
+        optlen = sizeof(values);
+        optval = reinterpret_cast<const u8*>(values.data());
+    }
 
     LOG_DEBUG(Service, "called. fd={} level={} optname=0x{:x} optlen={}", fd, level,
-              static_cast<u32>(optname), optval.size());
+              static_cast<u32>(optname), optlen);
 
-    BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
+    BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optlen, optval));
 }
 
 void BSD::Shutdown(HLERequestContext& ctx) {
@@ -523,19 +521,18 @@ std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protoco
 
 std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
                                     s32 nfds, s32 timeout) {
-    if (nfds <= 0) {
-        // When no entries are provided, -1 is returned with errno zero
-        return {-1, Errno::SUCCESS};
-    }
-    if (read_buffer.size() < nfds * sizeof(PollFD)) {
-        return {-1, Errno::INVAL};
-    }
     if (write_buffer.size() < nfds * sizeof(PollFD)) {
         return {-1, Errno::INVAL};
     }
 
+    if (nfds == 0) {
+        // When no entries are provided, -1 is returned with errno zero
+        return {-1, Errno::SUCCESS};
+    }
+
+    const size_t length = std::min(read_buffer.size(), write_buffer.size());
     std::vector<PollFD> fds(nfds);
-    std::memcpy(fds.data(), read_buffer.data(), nfds * sizeof(PollFD));
+    std::memcpy(fds.data(), read_buffer.data(), length);
 
     if (timeout >= 0) {
         const s64 seconds = timeout / 1000;
@@ -583,7 +580,7 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<con
     for (size_t i = 0; i < num; ++i) {
         fds[i].revents = Translate(host_pollfds[i].revents);
     }
-    std::memcpy(write_buffer.data(), fds.data(), nfds * sizeof(PollFD));
+    std::memcpy(write_buffer.data(), fds.data(), length);
 
     return Translate(result);
 }
@@ -611,7 +608,8 @@ std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
     new_descriptor.is_connection_based = descriptor.is_connection_based;
 
     const SockAddrIn guest_addr_in = Translate(result.sockaddr_in);
-    PutValue(write_buffer, guest_addr_in);
+    const size_t length = std::min(sizeof(guest_addr_in), write_buffer.size());
+    std::memcpy(write_buffer.data(), &guest_addr_in, length);
 
     return {new_fd, Errno::SUCCESS};
 }
@@ -621,7 +619,8 @@ Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
         return Errno::BADF;
     }
     ASSERT(addr.size() == sizeof(SockAddrIn));
-    auto addr_in = GetValue<SockAddrIn>(addr);
+    SockAddrIn addr_in;
+    std::memcpy(&addr_in, addr.data(), sizeof(addr_in));
 
     return Translate(file_descriptors[fd]->socket->Bind(Translate(addr_in)));
 }
@@ -632,7 +631,8 @@ Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
     }
 
     UNIMPLEMENTED_IF(addr.size() != sizeof(SockAddrIn));
-    auto addr_in = GetValue<SockAddrIn>(addr);
+    SockAddrIn addr_in;
+    std::memcpy(&addr_in, addr.data(), sizeof(addr_in));
 
     return Translate(file_descriptors[fd]->socket->Connect(Translate(addr_in)));
 }
@@ -650,7 +650,7 @@ Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
 
     ASSERT(write_buffer.size() >= sizeof(guest_addrin));
     write_buffer.resize(sizeof(guest_addrin));
-    PutValue(write_buffer, guest_addrin);
+    std::memcpy(write_buffer.data(), &guest_addrin, sizeof(guest_addrin));
     return Translate(bsd_errno);
 }
 
@@ -667,7 +667,7 @@ Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
 
     ASSERT(write_buffer.size() >= sizeof(guest_addrin));
     write_buffer.resize(sizeof(guest_addrin));
-    PutValue(write_buffer, guest_addrin);
+    std::memcpy(write_buffer.data(), &guest_addrin, sizeof(guest_addrin));
     return Translate(bsd_errno);
 }
 
@@ -725,7 +725,7 @@ Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& o
                 optval.size() == sizeof(Errno), { return Errno::INVAL; },
                 "Incorrect getsockopt option size");
             optval.resize(sizeof(Errno));
-            PutValue(optval, translated_pending_err);
+            memcpy(optval.data(), &translated_pending_err, sizeof(Errno));
         }
         return Translate(getsockopt_err);
     }
@@ -735,7 +735,7 @@ Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& o
     }
 }
 
-Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
+Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, size_t optlen, const void* optval) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -748,15 +748,17 @@ Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8
     Network::SocketBase* const socket = file_descriptors[fd]->socket.get();
 
     if (optname == OptName::LINGER) {
-        ASSERT(optval.size() == sizeof(Linger));
-        auto linger = GetValue<Linger>(optval);
+        ASSERT(optlen == sizeof(Linger));
+        Linger linger;
+        std::memcpy(&linger, optval, sizeof(linger));
         ASSERT(linger.onoff == 0 || linger.onoff == 1);
 
         return Translate(socket->SetLinger(linger.onoff != 0, linger.linger));
     }
 
-    ASSERT(optval.size() == sizeof(u32));
-    auto value = GetValue<u32>(optval);
+    ASSERT(optlen == sizeof(u32));
+    u32 value;
+    std::memcpy(&value, optval, sizeof(value));
 
     switch (optname) {
     case OptName::REUSEADDR:
@@ -860,7 +862,7 @@ std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& mess
         } else {
             ASSERT(addr.size() == sizeof(SockAddrIn));
             const SockAddrIn result = Translate(addr_in);
-            PutValue(addr, result);
+            std::memcpy(addr.data(), &result, sizeof(result));
         }
     }
 
@@ -884,7 +886,8 @@ std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> mes
     Network::SockAddrIn* p_addr_in = nullptr;
     if (!addr.empty()) {
         ASSERT(addr.size() == sizeof(SockAddrIn));
-        auto guest_addr_in = GetValue<SockAddrIn>(addr);
+        SockAddrIn guest_addr_in;
+        std::memcpy(&guest_addr_in, addr.data(), sizeof(guest_addr_in));
         addr_in = Translate(guest_addr_in);
         p_addr_in = &addr_in;
     }

src/core/hle/service/sockets/bsd.h

@@ -163,7 +163,7 @@ private:
     Errno ListenImpl(s32 fd, s32 backlog);
     std::pair<s32, Errno> FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg);
     Errno GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval);
-    Errno SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval);
+    Errno SetSockOptImpl(s32 fd, u32 level, OptName optname, size_t optlen, const void* optval);
     Errno ShutdownImpl(s32 fd, s32 how);
     std::pair<s32, Errno> RecvImpl(s32 fd, u32 flags, std::vector<u8>& message);
     std::pair<s32, Errno> RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,

src/video_core/renderer_null/null_rasterizer.cpp

@@ -3,7 +3,6 @@
 
 #include "common/alignment.h"
 #include "core/memory.h"
-#include "video_core/control/channel_state.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/memory_manager.h"
 #include "video_core/renderer_null/null_rasterizer.h"
@@ -100,14 +99,8 @@ bool RasterizerNull::AccelerateDisplay(const Tegra::FramebufferConfig& config,
 }
 void RasterizerNull::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                                        const VideoCore::DiskResourceLoadCallback& callback) {}
-void RasterizerNull::InitializeChannel(Tegra::Control::ChannelState& channel) {
-    CreateChannel(channel);
-}
-void RasterizerNull::BindChannel(Tegra::Control::ChannelState& channel) {
-    BindToChannel(channel.bind_id);
-}
-void RasterizerNull::ReleaseChannel(s32 channel_id) {
-    EraseChannel(channel_id);
-}
+void RasterizerNull::InitializeChannel(Tegra::Control::ChannelState& channel) {}
+void RasterizerNull::BindChannel(Tegra::Control::ChannelState& channel) {}
+void RasterizerNull::ReleaseChannel(s32 channel_id) {}
 
 } // namespace Null

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -137,56 +137,6 @@ BlitScreen::BlitScreen(Core::Memory::Memory& cpu_memory_, Core::Frontend::EmuWin
 
 BlitScreen::~BlitScreen() = default;
 
-static Common::Rectangle<f32> NormalizeCrop(const Tegra::FramebufferConfig& framebuffer,
-                                            const ScreenInfo& screen_info) {
-    f32 left, top, right, bottom;
-
-    if (!framebuffer.crop_rect.IsEmpty()) {
-        // If crop rectangle is not empty, apply properties from rectangle.
-        left = static_cast<f32>(framebuffer.crop_rect.left);
-        top = static_cast<f32>(framebuffer.crop_rect.top);
-        right = static_cast<f32>(framebuffer.crop_rect.right);
-        bottom = static_cast<f32>(framebuffer.crop_rect.bottom);
-    } else {
-        // Otherwise, fall back to framebuffer dimensions.
-        left = 0;
-        top = 0;
-        right = static_cast<f32>(framebuffer.width);
-        bottom = static_cast<f32>(framebuffer.height);
-    }
-
-    // Apply transformation flags.
-    auto framebuffer_transform_flags = framebuffer.transform_flags;
-
-    if (True(framebuffer_transform_flags & Service::android::BufferTransformFlags::FlipH)) {
-        // Switch left and right.
-        std::swap(left, right);
-    }
-    if (True(framebuffer_transform_flags & Service::android::BufferTransformFlags::FlipV)) {
-        // Switch top and bottom.
-        std::swap(top, bottom);
-    }
-
-    framebuffer_transform_flags &= ~Service::android::BufferTransformFlags::FlipH;
-    framebuffer_transform_flags &= ~Service::android::BufferTransformFlags::FlipV;
-    if (True(framebuffer_transform_flags)) {
-        UNIMPLEMENTED_MSG("Unsupported framebuffer_transform_flags={}",
-                          static_cast<u32>(framebuffer_transform_flags));
-    }
-
-    // Get the screen properties.
-    const f32 screen_width = static_cast<f32>(screen_info.width);
-    const f32 screen_height = static_cast<f32>(screen_info.height);
-
-    // Normalize coordinate space.
-    left /= screen_width;
-    top /= screen_height;
-    right /= screen_width;
-    bottom /= screen_height;
-
-    return Common::Rectangle<f32>(left, top, right, bottom);
-}
-
 void BlitScreen::Recreate() {
     present_manager.WaitPresent();
     scheduler.Finish();
@@ -404,10 +354,17 @@ void BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer,
         source_image_view = smaa->Draw(scheduler, image_index, source_image, source_image_view);
     }
     if (fsr) {
-        const auto crop_rect = NormalizeCrop(framebuffer, screen_info);
-        const VkExtent2D fsr_input_size{
-            .width = Settings::values.resolution_info.ScaleUp(screen_info.width),
-            .height = Settings::values.resolution_info.ScaleUp(screen_info.height),
+        auto crop_rect = framebuffer.crop_rect;
+        if (crop_rect.GetWidth() == 0) {
+            crop_rect.right = framebuffer.width;
+        }
+        if (crop_rect.GetHeight() == 0) {
+            crop_rect.bottom = framebuffer.height;
+        }
+        crop_rect = crop_rect.Scale(Settings::values.resolution_info.up_factor);
+        VkExtent2D fsr_input_size{
+            .width = Settings::values.resolution_info.ScaleUp(framebuffer.width),
+            .height = Settings::values.resolution_info.ScaleUp(framebuffer.height),
         };
         VkImageView fsr_image_view =
             fsr->Draw(scheduler, image_index, source_image_view, fsr_input_size, crop_rect);
@@ -1440,37 +1397,61 @@ void BlitScreen::SetUniformData(BufferData& data, const Layout::FramebufferLayou
 
 void BlitScreen::SetVertexData(BufferData& data, const Tegra::FramebufferConfig& framebuffer,
                                const Layout::FramebufferLayout layout) const {
-    f32 left, top, right, bottom;
+    const auto& framebuffer_transform_flags = framebuffer.transform_flags;
+    const auto& framebuffer_crop_rect = framebuffer.crop_rect;
 
-    if (fsr) {
-        // FSR has already applied the crop, so we just want to render the image
-        // it has produced.
-        left = 0;
-        top = 0;
-        right = 1;
-        bottom = 1;
-    } else {
-        // Get the normalized crop rectangle.
-        const auto crop = NormalizeCrop(framebuffer, screen_info);
+    static constexpr Common::Rectangle<f32> texcoords{0.f, 0.f, 1.f, 1.f};
+    auto left = texcoords.left;
+    auto right = texcoords.right;
 
-        // Apply the crop.
-        left = crop.left;
-        top = crop.top;
-        right = crop.right;
-        bottom = crop.bottom;
+    switch (framebuffer_transform_flags) {
+    case Service::android::BufferTransformFlags::Unset:
+        break;
+    case Service::android::BufferTransformFlags::FlipV:
+        // Flip the framebuffer vertically
+        left = texcoords.right;
+        right = texcoords.left;
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unsupported framebuffer_transform_flags={}",
+                          static_cast<u32>(framebuffer_transform_flags));
+        break;
+    }
+
+    UNIMPLEMENTED_IF(framebuffer_crop_rect.left != 0);
+
+    f32 left_start{};
+    if (framebuffer_crop_rect.Top() > 0) {
+        left_start = static_cast<f32>(framebuffer_crop_rect.Top()) /
+                     static_cast<f32>(framebuffer_crop_rect.Bottom());
+    }
+    f32 scale_u = static_cast<f32>(framebuffer.width) / static_cast<f32>(screen_info.width);
+    f32 scale_v = static_cast<f32>(framebuffer.height) / static_cast<f32>(screen_info.height);
+    // Scale the output by the crop width/height. This is commonly used with 1280x720 rendering
+    // (e.g. handheld mode) on a 1920x1080 framebuffer.
+    if (!fsr) {
+        if (framebuffer_crop_rect.GetWidth() > 0) {
+            scale_u = static_cast<f32>(framebuffer_crop_rect.GetWidth()) /
+                      static_cast<f32>(screen_info.width);
+        }
+        if (framebuffer_crop_rect.GetHeight() > 0) {
+            scale_v = static_cast<f32>(framebuffer_crop_rect.GetHeight()) /
+                      static_cast<f32>(screen_info.height);
+        }
     }
 
-    // Map the coordinates to the screen.
     const auto& screen = layout.screen;
     const auto x = static_cast<f32>(screen.left);
     const auto y = static_cast<f32>(screen.top);
     const auto w = static_cast<f32>(screen.GetWidth());
     const auto h = static_cast<f32>(screen.GetHeight());
-
-    data.vertices[0] = ScreenRectVertex(x, y, left, top);
-    data.vertices[1] = ScreenRectVertex(x + w, y, right, top);
-    data.vertices[2] = ScreenRectVertex(x, y + h, left, bottom);
-    data.vertices[3] = ScreenRectVertex(x + w, y + h, right, bottom);
+    data.vertices[0] = ScreenRectVertex(x, y, texcoords.top * scale_u, left_start + left * scale_v);
+    data.vertices[1] =
+        ScreenRectVertex(x + w, y, texcoords.bottom * scale_u, left_start + left * scale_v);
+    data.vertices[2] =
+        ScreenRectVertex(x, y + h, texcoords.top * scale_u, left_start + right * scale_v);
+    data.vertices[3] =
+        ScreenRectVertex(x + w, y + h, texcoords.bottom * scale_u, left_start + right * scale_v);
 }
 
 void BlitScreen::CreateSMAA(VkExtent2D smaa_size) {

src/video_core/renderer_vulkan/vk_fsr.cpp

@@ -34,7 +34,7 @@ FSR::FSR(const Device& device_, MemoryAllocator& memory_allocator_, size_t image
 }
 
 VkImageView FSR::Draw(Scheduler& scheduler, size_t image_index, VkImageView image_view,
-                      VkExtent2D input_image_extent, const Common::Rectangle<f32>& crop_rect) {
+                      VkExtent2D input_image_extent, const Common::Rectangle<int>& crop_rect) {
 
     UpdateDescriptorSet(image_index, image_view);
 
@@ -61,21 +61,15 @@ VkImageView FSR::Draw(Scheduler& scheduler, size_t image_index, VkImageView imag
 
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *easu_pipeline);
 
-        const f32 input_image_width = static_cast<f32>(input_image_extent.width);
-        const f32 input_image_height = static_cast<f32>(input_image_extent.height);
-        const f32 output_image_width = static_cast<f32>(output_size.width);
-        const f32 output_image_height = static_cast<f32>(output_size.height);
-        const f32 viewport_width = (crop_rect.right - crop_rect.left) * input_image_width;
-        const f32 viewport_x = crop_rect.left * input_image_width;
-        const f32 viewport_height = (crop_rect.bottom - crop_rect.top) * input_image_height;
-        const f32 viewport_y = crop_rect.top * input_image_height;
-
         std::array<u32, 4 * 4> push_constants;
-        FsrEasuConOffset(push_constants.data() + 0, push_constants.data() + 4,
-                         push_constants.data() + 8, push_constants.data() + 12,
+        FsrEasuConOffset(
+            push_constants.data() + 0, push_constants.data() + 4, push_constants.data() + 8,
+            push_constants.data() + 12,
 
-                         viewport_width, viewport_height, input_image_width, input_image_height,
-                         output_image_width, output_image_height, viewport_x, viewport_y);
+            static_cast<f32>(crop_rect.GetWidth()), static_cast<f32>(crop_rect.GetHeight()),
+            static_cast<f32>(input_image_extent.width), static_cast<f32>(input_image_extent.height),
+            static_cast<f32>(output_size.width), static_cast<f32>(output_size.height),
+            static_cast<f32>(crop_rect.left), static_cast<f32>(crop_rect.top));
         cmdbuf.PushConstants(*pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, push_constants);
 
         {

src/video_core/renderer_vulkan/vk_fsr.h

@@ -17,7 +17,7 @@ public:
     explicit FSR(const Device& device, MemoryAllocator& memory_allocator, size_t image_count,
                  VkExtent2D output_size);
     VkImageView Draw(Scheduler& scheduler, size_t image_index, VkImageView image_view,
-                     VkExtent2D input_image_extent, const Common::Rectangle<f32>& crop_rect);
+                     VkExtent2D input_image_extent, const Common::Rectangle<int>& crop_rect);
 
 private:
     void CreateDescriptorPool();

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -82,7 +82,7 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
     }
 
     if (y_negate) {
-        y += conv(static_cast<f32>(regs.surface_clip.height));
+        y += height;
         height = -height;
     }
 
@@ -923,13 +923,9 @@ void RasterizerVulkan::UpdateDynamicStates() {
 }
 
 void RasterizerVulkan::HandleTransformFeedback() {
-    static std::once_flag warn_unsupported;
-
     const auto& regs = maxwell3d->regs;
     if (!device.IsExtTransformFeedbackSupported()) {
-        std::call_once(warn_unsupported, [&] {
-            LOG_ERROR(Render_Vulkan, "Transform feedbacks used but not supported");
-        });
+        LOG_ERROR(Render_Vulkan, "Transform feedbacks used but not supported");
         return;
     }
     query_cache.CounterEnable(VideoCommon::QueryType::StreamingByteCount,

src/yuzu/configuration/config.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_camera.h

@@ -1,4 +1,4 @@
-// Text : Copyright 2022 yuzu Emulator Project
+// Text : Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_input.cpp

@@ -152,7 +152,7 @@ void ConfigureInput::Initialize(InputCommon::InputSubsystem* input_subsystem,
     connect(player_controllers[0], &ConfigureInputPlayer::HandheldStateChanged,
             [this](bool is_handheld) { UpdateDockedState(is_handheld); });
 
-    advanced = new ConfigureInputAdvanced(hid_core, this);
+    advanced = new ConfigureInputAdvanced(this);
     ui->tabAdvanced->setLayout(new QHBoxLayout(ui->tabAdvanced));
     ui->tabAdvanced->layout()->addWidget(advanced);
 

src/yuzu/configuration/configure_input.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_input_advanced.cpp

@@ -4,13 +4,11 @@
 #include <QColorDialog>
 #include "common/settings.h"
 #include "core/core.h"
-#include "core/hid/emulated_controller.h"
-#include "core/hid/hid_core.h"
 #include "ui_configure_input_advanced.h"
 #include "yuzu/configuration/configure_input_advanced.h"
 
-ConfigureInputAdvanced::ConfigureInputAdvanced(Core::HID::HIDCore& hid_core_, QWidget* parent)
-    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputAdvanced>()), hid_core{hid_core_} {
+ConfigureInputAdvanced::ConfigureInputAdvanced(QWidget* parent)
+    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputAdvanced>()) {
     ui->setupUi(this);
 
     controllers_color_buttons = {{
@@ -125,8 +123,6 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
         player.button_color_left = colors[1];
         player.body_color_right = colors[2];
         player.button_color_right = colors[3];
-
-        hid_core.GetEmulatedControllerByIndex(player_idx)->ReloadColorsFromSettings();
     }
 
     Settings::values.debug_pad_enabled = ui->debug_enabled->isChecked();

src/yuzu/configuration/configure_input_advanced.h

@@ -14,15 +14,11 @@ namespace Ui {
 class ConfigureInputAdvanced;
 }
 
-namespace Core::HID {
-class HIDCore;
-} // namespace Core::HID
-
 class ConfigureInputAdvanced : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureInputAdvanced(Core::HID::HIDCore& hid_core_, QWidget* parent = nullptr);
+    explicit ConfigureInputAdvanced(QWidget* parent = nullptr);
     ~ConfigureInputAdvanced() override;
 
     void ApplyConfiguration();
@@ -48,6 +44,4 @@ private:
 
     std::array<std::array<QColor, 4>, 8> controllers_colors;
     std::array<std::array<QPushButton*, 4>, 8> controllers_color_buttons;
-
-    Core::HID::HIDCore& hid_core;
 };

src/yuzu/configuration/configure_input_player.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_per_game.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_profile_manager.cpp

@@ -306,10 +306,10 @@ void ConfigureProfileManager::SetUserImage() {
         return;
     }
 
-    // Profile image must be 256x256
+    // Some games crash when the profile image is too big. Resize any image bigger than 256x256
     QImage image(image_path);
-    if (image.width() != 256 || image.height() != 256) {
-        image = image.scaled(256, 256, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
+    if (image.width() > 256 || image.height() > 256) {
+        image = image.scaled(256, 256, Qt::KeepAspectRatio);
         if (!image.save(image_path)) {
             QMessageBox::warning(this, tr("Error resizing user image"),
                                  tr("Unable to resize image"));

src/yuzu/configuration/configure_ringcon.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_tas.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/configure_touchscreen_advanced.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once

src/yuzu/configuration/shared_translation.cpp

@@ -156,6 +156,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
     // Ui General
     INSERT(UISettings, select_user_on_boot, "Prompt for user on game boot", "");
     INSERT(UISettings, pause_when_in_background, "Pause emulation when in background", "");
+    INSERT(UISettings, confirm_before_closing, "Confirm exit while emulation is running", "");
     INSERT(UISettings, confirm_before_stopping, "Confirm before stopping emulation", "");
     INSERT(UISettings, hide_mouse, "Hide mouse on inactivity", "");
     INSERT(UISettings, controller_applet_disabled, "Disable controller applet", "");

src/yuzu/main.cpp

@@ -1908,10 +1908,7 @@ void GMainWindow::ConfigureFilesystemProvider(const std::string& filepath) {
 void GMainWindow::BootGame(const QString& filename, u64 program_id, std::size_t program_index,
                            StartGameType type, AmLaunchType launch_type) {
     LOG_INFO(Frontend, "yuzu starting...");
-
-    if (program_id > static_cast<u64>(Service::AM::Applets::AppletProgramId::MaxProgramId)) {
-        StoreRecentFile(filename); // Put the filename on top of the list
-    }
+    StoreRecentFile(filename); // Put the filename on top of the list
 
     // Save configurations
     UpdateUISettings();
@@ -2177,7 +2174,6 @@ void GMainWindow::ShutdownGame() {
         return;
     }
 
-    play_time_manager->Stop();
     OnShutdownBegin();
     OnEmulationStopTimeExpired();
     OnEmulationStopped();
@@ -2741,7 +2737,7 @@ void GMainWindow::OnGameListDumpRomFS(u64 program_id, const std::string& game_pa
         return;
     }
 
-    const auto extracted = FileSys::ExtractRomFS(romfs);
+    const auto extracted = FileSys::ExtractRomFS(romfs, FileSys::RomFSExtractionType::Full);
     if (extracted == nullptr) {
         failed();
         return;
@@ -3488,7 +3484,7 @@ void GMainWindow::OnExecuteProgram(std::size_t program_index) {
 }
 
 void GMainWindow::OnExit() {
-    ShutdownGame();
+    OnStopGame();
 }
 
 void GMainWindow::OnSaveConfig() {
@@ -4276,7 +4272,7 @@ void GMainWindow::OnToggleStatusBar() {
 }
 
 void GMainWindow::OnAlbum() {
-    constexpr u64 AlbumId = static_cast<u64>(Service::AM::Applets::AppletProgramId::PhotoViewer);
+    constexpr u64 AlbumId = 0x010000000000100Dull;
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
     if (!bis_system) {
         QMessageBox::warning(this, tr("No firmware available"),
@@ -4299,7 +4295,7 @@ void GMainWindow::OnAlbum() {
 }
 
 void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
-    constexpr u64 CabinetId = static_cast<u64>(Service::AM::Applets::AppletProgramId::Cabinet);
+    constexpr u64 CabinetId = 0x0100000000001002ull;
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
     if (!bis_system) {
         QMessageBox::warning(this, tr("No firmware available"),
@@ -4323,7 +4319,7 @@ void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
 }
 
 void GMainWindow::OnMiiEdit() {
-    constexpr u64 MiiEditId = static_cast<u64>(Service::AM::Applets::AppletProgramId::MiiEdit);
+    constexpr u64 MiiEditId = 0x0100000000001009ull;
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
     if (!bis_system) {
         QMessageBox::warning(this, tr("No firmware available"),
@@ -4851,12 +4847,7 @@ bool GMainWindow::SelectRomFSDumpTarget(const FileSys::ContentProvider& installe
 }
 
 bool GMainWindow::ConfirmClose() {
-    if (emu_thread == nullptr ||
-        UISettings::values.confirm_before_stopping.GetValue() == ConfirmStop::Ask_Never) {
-        return true;
-    }
-    if (!system->GetExitLocked() &&
-        UISettings::values.confirm_before_stopping.GetValue() == ConfirmStop::Ask_Based_On_Game) {
+    if (emu_thread == nullptr || !UISettings::values.confirm_before_closing) {
         return true;
     }
     const auto text = tr("Are you sure you want to close yuzu?");
@@ -4961,7 +4952,7 @@ bool GMainWindow::ConfirmChangeGame() {
 }
 
 bool GMainWindow::ConfirmForceLockedExit() {
-    if (emu_thread == nullptr) {
+    if (emu_thread == nullptr || !UISettings::values.confirm_before_closing) {
         return true;
     }
     const auto text = tr("The currently running application has requested yuzu to not exit.\n\n"

src/yuzu/uisettings.h

@@ -93,6 +93,10 @@ struct Values {
     Setting<bool> show_filter_bar{linkage, true, "showFilterBar", Category::Ui};
     Setting<bool> show_status_bar{linkage, true, "showStatusBar", Category::Ui};
 
+    Setting<bool> confirm_before_closing{
+        linkage, true, "confirmClose", Category::UiGeneral, Settings::Specialization::Default,
+        true,    true};
+
     SwitchableSetting<ConfirmStop> confirm_before_stopping{linkage,
                                                            ConfirmStop::Ask_Always,
                                                            "confirmStop",

src/yuzu/vk_device_info.cpp

@@ -31,7 +31,6 @@ void PopulateRecords(std::vector<Record>& records, QWindow* window) try {
     // Create a test window with a Vulkan surface type for checking present modes.
     QWindow test_window(window);
     test_window.setSurfaceType(QWindow::VulkanSurface);
-    test_window.create();
     auto wsi = QtCommon::GetWindowSystemInfo(&test_window);
 
     vk::InstanceDispatch dld;