Remove Ignore Global Monitor from CPU Accuracy Auto

CMakeModules/GenerateSCMRev.cmake

@@ -35,17 +35,17 @@ set(GIT_DESC ${BUILD_VERSION})
 # Generate cpp with Git revision from template
 # Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
 
-# Auto-updater metadata! Must somewhat mirror GitHub/Forgejo API endpoint
-
-set(BUILD_AUTO_UPDATE_API_PATH "/latest/release.json")
+# Auto-updater metadata! Must somewhat mirror GitHub API endpoint
 if (NIGHTLY_BUILD)
     set(BUILD_AUTO_UPDATE_WEBSITE "https://git.eden-emu.dev")
-    set(BUILD_AUTO_UPDATE_API "nightly.eden-emu.dev")
+    set(BUILD_AUTO_UPDATE_API "git.eden-emu.dev")
+    set(BUILD_AUTO_UPDATE_API_PATH "/api/v1/repos/")
     set(BUILD_AUTO_UPDATE_REPO "eden-ci/nightly")
     set(REPO_NAME "Eden Nightly")
 else()
     set(BUILD_AUTO_UPDATE_WEBSITE "https://git.eden-emu.dev")
-    set(BUILD_AUTO_UPDATE_API "stable.eden-emu.dev")
+    set(BUILD_AUTO_UPDATE_API "git.eden-emu.dev")
+    set(BUILD_AUTO_UPDATE_API_PATH "/api/v1/repos/")
     set(BUILD_AUTO_UPDATE_REPO "eden-emu/eden")
     set(REPO_NAME "Eden")
 endif()

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

@@ -15,7 +15,6 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.graphics.Rect
 import android.graphics.drawable.Icon
@@ -101,7 +100,6 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
     private var romSwapGeneration = 0
     private var hasEmulationSession = processHasEmulationSession
     private val romSwapStopTimeoutRunnable = Runnable { onRomSwapStopTimeout() }
-    private val pictureInPictureFailureActions: MutableSet<String> = mutableSetOf()
 
     private fun onRomSwapStopTimeout() {
         if (!isWaitingForRomSwapStop) {
@@ -268,18 +266,12 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
     }
 
     override fun onUserLeaveHint() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S ||
-            !isPictureInPictureSupported() ||
-            !BooleanSetting.PICTURE_IN_PICTURE.getBoolean() ||
-            isInPictureInPictureMode
-        ) {
-            return
-        }
-
-        val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
-            .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
-        runPictureInPictureAction("enter picture-in-picture mode") {
-            enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            if (BooleanSetting.PICTURE_IN_PICTURE.getBoolean() && !isInPictureInPictureMode) {
+                val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
+                    .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
+                enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+            }
         }
     }
 
@@ -659,29 +651,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
         return this.apply { setActions(pictureInPictureActions) }
     }
 
-    private fun isPictureInPictureSupported() =
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
-            packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
-
-    private fun runPictureInPictureAction(actionName: String, action: () -> Unit) {
-        try {
-            action()
-        } catch (e: IllegalStateException) {
-            if (pictureInPictureFailureActions.add(actionName)) {
-                Log.warning("[PiP] Failed to $actionName: ${e.message}")
-            }
-        } catch (e: UnsupportedOperationException) {
-            if (pictureInPictureFailureActions.add(actionName)) {
-                Log.warning("[PiP] Failed to $actionName: ${e.message}")
-            }
-        }
-    }
-
     fun buildPictureInPictureParams() {
-        if (!isPictureInPictureSupported()) {
-            return
-        }
-
         val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
             .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
@@ -691,9 +661,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
                 BooleanSetting.PICTURE_IN_PICTURE.getBoolean() && isEmulationActive
             )
         }
-        runPictureInPictureAction("set picture-in-picture params") {
-            setPictureInPictureParams(pictureInPictureParamsBuilder.build())
-        }
+        setPictureInPictureParams(pictureInPictureParamsBuilder.build())
     }
 
     fun displayMultiplayerDialog() {

src/android/app/src/main/java/org/yuzu/yuzu_emu/applets/keyboard/SoftwareKeyboard.kt

@@ -1,7 +1,3 @@
-
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -37,10 +33,8 @@ object SoftwareKeyboard {
         val emulationActivity = NativeLibrary.sEmulationActivity.get()
 
         val overlayView = emulationActivity!!.findViewById<View>(R.id.surface_input_overlay)
-        overlayView.requestFocus()
         val im =
             overlayView.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-        im.restartInput(overlayView)
         im.showSoftInput(overlayView, InputMethodManager.SHOW_FORCED)
 
         // There isn't a good way to know that the IMM is dismissed, so poll every 500ms to submit inline keyboard result.

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

@@ -17,7 +17,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     USE_CUSTOM_CPU_TICKS("use_custom_cpu_ticks"),
     SKIP_CPU_INNER_INVALIDATION("skip_cpu_inner_invalidation"),
     FIX_BLOOM_EFFECTS("fix_bloom_effects"),
-    EMULATE_BGR565("emulate_bgr565"),
     CPUOPT_UNSAFE_HOST_MMU("cpuopt_unsafe_host_mmu"),
     USE_DOCKED_MODE("use_docked_mode"),
     USE_AUTO_STUB("use_auto_stub"),

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

@@ -756,13 +756,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.fix_bloom_effects_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.EMULATE_BGR565,
-                    titleId = R.string.emulate_bgr565,
-                    descriptionId = R.string.emulate_bgr565_description
-                )
-            )
             put(
                 SwitchSetting(
                     BooleanSetting.CPUOPT_UNSAFE_HOST_MMU,

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

@@ -293,7 +293,6 @@ class SettingsFragmentPresenter(
             add(IntSetting.FAST_GPU_TIME.key)
             add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)
             add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
-            add(BooleanSetting.EMULATE_BGR565.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
             add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/overlay/InputOverlay.kt

@@ -17,23 +17,16 @@ import android.graphics.drawable.VectorDrawable
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
-import android.text.Editable
-import android.text.InputType
 import android.util.AttributeSet
 import android.view.HapticFeedbackConstants
-import android.view.KeyEvent
 import android.view.MotionEvent
 import android.view.View
 import android.view.View.OnTouchListener
 import android.view.WindowInsets
-import android.view.inputmethod.BaseInputConnection
-import android.view.inputmethod.EditorInfo
-import android.view.inputmethod.InputConnection
 import androidx.core.content.ContextCompat
 import androidx.window.layout.WindowMetricsCalculator
 import kotlin.math.max
 import kotlin.math.min
-import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.features.input.NativeInput
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.features.input.model.NativeAnalog
@@ -56,7 +49,6 @@ class InputOverlay(context: Context, attrs: AttributeSet?) :
     private val overlayButtons: MutableSet<InputOverlayDrawableButton> = HashSet()
     private val overlayDpads: MutableSet<InputOverlayDrawableDpad> = HashSet()
     private val overlayJoysticks: MutableSet<InputOverlayDrawableJoystick> = HashSet()
-    private val imeEditable = Editable.Factory.getInstance().newEditable("")
 
     private var inEditMode = false
     private var gamelessMode = false
@@ -83,63 +75,6 @@ class InputOverlay(context: Context, attrs: AttributeSet?) :
     // External listener for EmulationFragment joypad overlay auto-hide
     var touchEventListener: ((MotionEvent) -> Unit)? = null
 
-    override fun onCheckIsTextEditor(): Boolean = true
-
-    override fun onCreateInputConnection(outAttrs: EditorInfo): InputConnection {
-        imeEditable.clear()
-        outAttrs.inputType =
-            InputType.TYPE_CLASS_TEXT or
-                InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS or
-                InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
-        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI or EditorInfo.IME_ACTION_DONE
-        outAttrs.initialSelStart = 0
-        outAttrs.initialSelEnd = 0
-
-        return object : BaseInputConnection(this, true) {
-            override fun getEditable(): Editable = imeEditable
-
-            override fun commitText(text: CharSequence?, newCursorPosition: Int): Boolean {
-                if (!text.isNullOrEmpty()) {
-                    forwardCommittedText(text)
-                }
-                return super.commitText(text, newCursorPosition)
-            }
-
-            override fun deleteSurroundingText(beforeLength: Int, afterLength: Int): Boolean {
-                repeat(beforeLength.coerceAtLeast(0)) {
-                    NativeLibrary.submitInlineKeyboardInput(KeyEvent.KEYCODE_DEL)
-                }
-                return super.deleteSurroundingText(beforeLength, afterLength)
-            }
-
-            override fun sendKeyEvent(event: KeyEvent): Boolean {
-                if (event.action != KeyEvent.ACTION_DOWN) {
-                    return true
-                }
-
-                when (event.keyCode) {
-                    KeyEvent.KEYCODE_BACK,
-                    KeyEvent.KEYCODE_DEL,
-                    KeyEvent.KEYCODE_ENTER -> {
-                        NativeLibrary.submitInlineKeyboardInput(event.keyCode)
-                    }
-                    else -> {
-                        val textChar = event.unicodeChar
-                        if (textChar != 0) {
-                            NativeLibrary.submitInlineKeyboardText(textChar.toChar().toString())
-                        }
-                    }
-                }
-                return true
-            }
-
-            override fun performEditorAction(actionCode: Int): Boolean {
-                NativeLibrary.submitInlineKeyboardInput(KeyEvent.KEYCODE_ENTER)
-                return true
-            }
-        }
-    }
-
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
         super.onLayout(changed, left, top, right, bottom)
 
@@ -184,25 +119,6 @@ class InputOverlay(context: Context, attrs: AttributeSet?) :
         }
     }
 
-    private fun forwardCommittedText(text: CharSequence) {
-        val builder = StringBuilder()
-        text.forEach { character ->
-            when (character) {
-                '\n' -> {
-                    if (builder.isNotEmpty()) {
-                        NativeLibrary.submitInlineKeyboardText(builder.toString())
-                        builder.clear()
-                    }
-                    NativeLibrary.submitInlineKeyboardInput(KeyEvent.KEYCODE_ENTER)
-                }
-                else -> builder.append(character)
-            }
-        }
-        if (builder.isNotEmpty()) {
-            NativeLibrary.submitInlineKeyboardText(builder.toString())
-        }
-    }
-
     private fun drawGrid(canvas: Canvas) {
         val gridSize = IntSetting.OVERLAY_GRID_SIZE.getInt()
         val width = canvas.width

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

@@ -1726,8 +1726,9 @@ JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateUrl(
         jobject obj,
         jstring version) {
     const char* version_str = env->GetStringUTFChars(version, nullptr);
-    const std::string url = fmt::format("{}/{}",
-        std::string{Common::g_build_auto_update_api},
+    const std::string url = fmt::format("{}/{}/releases/tag/{}",
+        std::string{Common::g_build_auto_update_website},
+        std::string{Common::g_build_auto_update_repo},
         version_str);
     env->ReleaseStringUTFChars(version, version_str);
     return env->NewStringUTF(url.c_str());
@@ -1759,10 +1760,11 @@ JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateApkUrl(
     }
 
     const std::string apk_filename = fmt::format("Eden-Android-{}-{}.apk", artifact_str, variant);
-
-    const std::string url = fmt::format("{}/{}/{}",
-        std::string{Common::g_build_auto_update_api},
-        version_str, apk_filename);
+    const std::string url = fmt::format("{}/{}/releases/download/{}/{}",
+        std::string{Common::g_build_auto_update_website},
+        std::string{Common::g_build_auto_update_repo},
+        version_str,
+        apk_filename);
 
     env->ReleaseStringUTFChars(tag, version_str);
     env->ReleaseStringUTFChars(artifact, artifact_str);

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -476,25 +476,21 @@
     <string name="use_disk_shader_cache_description">将生成的着色器缓存于磁盘中并进行读取，以减少卡顿。</string>
     <string name="renderer_force_max_clock">强制最大时钟 (仅限 Adreno)</string>
     <string name="renderer_force_max_clock_description">强制 GPU 以最大时钟运行 (仍被温控限制)。</string>
-    <string name="renderer_asynchronous_gpu_emulation">GPU 异步模拟</string>
-    <string name="renderer_asynchronous_gpu_emulation_description">异步运行 GPU 模拟，以减少 CPU 停顿并提高吞吐量。仅当遇到与时序相关的问题时才应禁用此功能。</string>
-    <string name="renderer_async_presentation">异步呈现</string>
-    <string name="renderer_async_presentation_description">通过将呈现操作移至单独的 CPU 线程来略微提升性能。</string>
     <string name="renderer_reactive_flushing">启用反应性刷新</string>
-    <string name="renderer_reactive_flushing_description">通过牺牲性能来提高某些游戏的渲染精度。</string>
+    <string name="renderer_reactive_flushing_description">牺牲性能，提高某些游戏的渲染精度。</string>
     <string name="enable_buffer_history">启用缓冲区历史</string>
-    <string name="enable_buffer_history_description">启用对先前缓冲区状态的访问。此选项可在某些游戏中提升渲染质量并保持性能的一致性。</string>
+    <string name="enable_buffer_history_description">允许访问之前的缓冲状态。\n这个选项可能会提升某些游戏的渲染质量和性能一致性。</string>
     <string name="use_optimized_vertex_buffers">优化顶点缓冲区</string>
-    <string name="use_optimized_vertex_buffers_description">启用经过优化的顶点缓冲区绑定以提升性能。需要 Mesa 26.0 及以上版本的 Turnip 驱动程序。在旧版驱动程序上会导致程序崩溃。</string>
+    <string name="use_optimized_vertex_buffers_description">实现优化顶点缓冲区绑定以提升性能。需要 Mesa 26.0+ Turnip 驱动。老驱动会崩溃。</string>
 
     <string name="hacks">Hacks</string>
 
     <string name="fast_gpu_time">GPU 超频频率</string>
-    <string name="fast_gpu_time_description">强制大多数游戏以其最高原生分辨率运行。设置为 256 可获得最佳性能，设置为 512 可获得最佳画面保真度。</string>
+    <string name="fast_gpu_time_description">强制大多数游戏以其最高原生分辨率运行。使用 256 以获得最大性能，使用 512 以获得最大图形保真度。</string>
     <string name="skip_cpu_inner_invalidation">跳过CPU内部无效化</string>
     <string name="skip_cpu_inner_invalidation_description">在内存更新期间跳过某些CPU端缓存无效化，减少CPU使用率并提高其性能。可能会导致某些游戏出现故障或崩溃。</string>
-    <string name="fix_bloom_effects">修复 Bloom 效果</string>
-    <string name="fix_bloom_effects_description">减少《塞尔达传说：智慧的再现》（Adreno 700）中的 bloom 模糊，并移除《Burnout》中的 bloom 效果。警告：可能会导致在其他游戏中出现画面显示问题。</string>
+    <string name="fix_bloom_effects">修复泛光效果</string>
+    <string name="fix_bloom_effects_description">减少《塞尔达传说：智慧的再现》(LA/EOW) 在 Adreno 700 系列 GPU 上的模糊感，并移除《横冲直撞》(Burnout) 中的模糊特效。警告：可能会导致其他游戏出现画面花屏或异常。</string>
     <string name="renderer_asynchronous_shaders">使用异步着色器</string>
     <string name="renderer_asynchronous_shaders_description">异步编译着色器。这可能会减少卡顿，但也可能会导致图形错误。</string>
     <string name="gpu_unswizzle_settings">GPU 还原设置</string>

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

@@ -501,7 +501,7 @@
     <string name="enable_buffer_history">Enable buffer history</string>
     <string name="enable_buffer_history_description">Enables access to previous buffer states. This option may improve rendering quality and performance consistency in some games.</string>
     <string name="use_optimized_vertex_buffers">Optimized Vertex Buffers</string>
-    <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers/ QCOM drivers. Will crash on older Turnip drivers.</string>
+    <string name="use_optimized_vertex_buffers_description">Enables optimized vertex buffer binding for improved performance. Requires Mesa 26.0+ Turnip drivers. Will crash on older drivers.</string>
 
     <string name="hacks">Hacks</string>
 
@@ -510,9 +510,7 @@
     <string name="skip_cpu_inner_invalidation">Skip CPU Inner Invalidation</string>
     <string name="skip_cpu_inner_invalidation_description">Skips certain CPU-side cache invalidations during memory updates, reducing CPU usage and improving it\'s performance. This may cause glitches or crashes on some games.</string>
     <string name="fix_bloom_effects">Fix Bloom Effects</string>
-    <string name="fix_bloom_effects_description">Reduces bloom blur in LA/EOW (Adreno A6XX - A7XX/ Turnip), removes bloom in Burnout. Warning: may cause graphical artifacts in other games.</string>
-    <string name="emulate_bgr565">Emulate BGR565</string>
-    <string name="emulate_bgr565_description">Fixes problems with inverted colors in games or strange artifacts or strange shadows.</string>
+    <string name="fix_bloom_effects_description">Reduces bloom blur in LA/EOW (Adreno 700), removes bloom in Burnout. Warning: may cause graphical artifacts in other games.</string>
     <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
     <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>

src/common/android/applets/software_keyboard.cpp

@@ -243,9 +243,6 @@ void AndroidKeyboard::SubmitInlineKeyboardInput(int key_code) {
                                static_cast<s32>(m_current_text.size()));
         break;
     case KEYCODE_DEL:
-        if (m_current_text.empty()) {
-            return;
-        }
         m_current_text.pop_back();
         submit_inline_callback(Service::AM::Frontend::SwkbdReplyType::ChangedString, m_current_text,
                                static_cast<int>(m_current_text.size()));

src/common/settings.h

@@ -555,9 +555,6 @@ struct Values {
     SwitchableSetting<bool> fix_bloom_effects{linkage, false, "fix_bloom_effects",
                                                      Category::RendererHacks};
 
-    SwitchableSetting<bool> emulate_bgr565{linkage, false, "emulate_bgr565",
-                                            Category::RendererHacks};
-
     SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
                                                      Category::RendererHacks};
 
@@ -587,7 +584,7 @@ struct Values {
 
     SwitchableSetting<ExtendedDynamicState> dyna_state{linkage,
 #if defined(ANDROID)
-                                           ExtendedDynamicState::Disabled,
+                                           ExtendedDynamicState::EDS1,
 #elif defined(__APPLE__)
                                            ExtendedDynamicState::Disabled,
 #else

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

@@ -89,7 +89,7 @@ void NvMap::UnmapHandle(Handle& handle_description) {
 
     // Free and unmap the handle from Host1x GMMU
     if (handle_description.pin_virt_address) {
-        host1x.gmmu_manager.Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
+        host1x.GMMU().Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
                             handle_description.aligned_size);
         host1x.Allocator().Free(handle_description.pin_virt_address,
                                 static_cast<u32>(handle_description.aligned_size));
@@ -169,8 +169,12 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
     std::scoped_lock lock(handle_description->mutex);
     const auto map_low_area = [&] {
         if (handle_description->pin_virt_address == 0) {
-            u32 address = host1x.Allocator().Allocate(u32(handle_description->aligned_size));
-            host1x.gmmu_manager.Map(GPUVAddr(address), handle_description->d_address, handle_description->aligned_size);
+            auto& gmmu_allocator = host1x.Allocator();
+            auto& gmmu = host1x.GMMU();
+            u32 address =
+                gmmu_allocator.Allocate(static_cast<u32>(handle_description->aligned_size));
+            gmmu.Map(static_cast<GPUVAddr>(address), handle_description->d_address,
+                     handle_description->aligned_size);
             handle_description->pin_virt_address = address;
         }
     };

src/dynarmic/src/dynarmic/common/spin_lock_x64.cpp

@@ -23,14 +23,16 @@ static const auto default_cg_mode = nullptr; //Allow RWE
 namespace Dynarmic {
 
 void EmitSpinLockLock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg32 tmp, bool waitpkg) {
+    // TODO: this is because we lack regalloc - so better to be safe :(
+    if (waitpkg) {
+        code.push(Xbyak::util::eax);
+        code.push(Xbyak::util::ebx);
+        code.push(Xbyak::util::edx);
+    }
     Xbyak::Label start, loop;
     code.jmp(start, code.T_NEAR);
     code.L(loop);
     if (waitpkg) {
-        // TODO: this is because we lack regalloc - so better to be safe :(
-        code.push(Xbyak::util::rax);
-        code.push(Xbyak::util::rbx);
-        code.push(Xbyak::util::rdx);
         // TODO: This clobbers EAX and EDX did we tell the regalloc?
         // ARM ptr for address-monitoring
         code.umonitor(ptr);
@@ -47,9 +49,6 @@ void EmitSpinLockLock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg32
         code.umwait(Xbyak::util::ebx);
         // CF == 1 if we hit the OS-timeout in IA32_UMWAIT_CONTROL without a write
         // CF == 0 if we exited the wait for any other reason
-        code.pop(Xbyak::util::rdx);
-        code.pop(Xbyak::util::rbx);
-        code.pop(Xbyak::util::rax);
     } else {
         code.pause();
     }
@@ -58,6 +57,11 @@ void EmitSpinLockLock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg32
     /*code.lock();*/ code.xchg(code.dword[ptr], tmp);
     code.test(tmp, tmp);
     code.jnz(loop, code.T_NEAR);
+    if (waitpkg) {
+        code.pop(Xbyak::util::edx);
+        code.pop(Xbyak::util::ebx);
+        code.pop(Xbyak::util::eax);
+    }
 }
 
 void EmitSpinLockUnlock(Xbyak::CodeGenerator& code, Xbyak::Reg64 ptr, Xbyak::Reg32 tmp) {

src/frontend_common/update_checker.cpp

@@ -80,24 +80,55 @@ std::optional<std::string> UpdateChecker::GetResponse(std::string url, std::stri
     }
 }
 
-std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease() {
+std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease(bool include_prereleases) {
 #ifdef YUZU_BUNDLED_OPENSSL
     const auto update_check_url = fmt::format("https://{}", Common::g_build_auto_update_api);
 #else
     const auto update_check_url = std::string{Common::g_build_auto_update_api};
 #endif
 
-    auto update_check_path = std::string{Common::g_build_auto_update_api_path};
+    auto update_check_path = fmt::format("{}{}", std::string{Common::g_build_auto_update_api_path},
+                                         std::string{Common::g_build_auto_update_repo});
     try {
-        const auto response = UpdateChecker::GetResponse(update_check_url, update_check_path);
+        if (include_prereleases) { // This can return either a prerelease or a stable release,
+            // whichever is more recent.
+            const auto update_check_tags_path = update_check_path + "/tags";
+            const auto update_check_releases_path = update_check_path + "/releases";
 
-        if (!response)
-            return {};
+            const auto tags_response = UpdateChecker::GetResponse(update_check_url, update_check_tags_path);
+            const auto releases_response = UpdateChecker::GetResponse(update_check_url, update_check_releases_path);
 
-        const std::string latest_tag = nlohmann::json::parse(response.value()).at("tag_name");
-        const std::string latest_name = nlohmann::json::parse(response.value()).at("name");
+            if (!tags_response || !releases_response)
+                return {};
+
+            const std::string latest_tag
+                = nlohmann::json::parse(tags_response.value()).at(0).at("name");
+            const std::string latest_name =
+                nlohmann::json::parse(releases_response.value()).at(0).at("name");
+
+            const bool latest_tag_has_release = releases_response.value().find(
+                                                    fmt::format("\"{}\"", latest_tag))
+                                                != std::string::npos;
+
+            // If there is a newer tag, but that tag has no associated release, don't prompt the
+            // user to update.
+            if (!latest_tag_has_release)
+                return {};
+
+            return Update{latest_tag, latest_name};
+        } else { // This is a stable release, only check for other stable releases.
+            update_check_path += "/releases/latest";
+            const auto response = UpdateChecker::GetResponse(update_check_url, update_check_path);
+
+            if (!response)
+                return {};
+
+            const std::string latest_tag = nlohmann::json::parse(response.value()).at("tag_name");
+            const std::string latest_name = nlohmann::json::parse(response.value()).at("name");
+
+            return Update{latest_tag, latest_name};
+        }
 
-        return Update{latest_tag, latest_name};
     } catch (nlohmann::detail::out_of_range&) {
         LOG_ERROR(Frontend,
                   "Parsing JSON response from {}{} failed during update check: "
@@ -116,8 +147,12 @@ std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease() {
 }
 
 std::optional<UpdateChecker::Update> UpdateChecker::GetUpdate() {
+    const bool is_prerelease = ((strstr(Common::g_build_version, "pre-alpha") != NULL) ||
+                                (strstr(Common::g_build_version, "alpha") != NULL) ||
+                                (strstr(Common::g_build_version, "beta") != NULL) ||
+                                (strstr(Common::g_build_version, "rc") != NULL));
     const std::optional<UpdateChecker::Update> latest_release_tag =
-        UpdateChecker::GetLatestRelease();
+        UpdateChecker::GetLatestRelease(is_prerelease);
 
     if (!latest_release_tag)
         goto empty;

src/frontend_common/update_checker.h

@@ -18,6 +18,6 @@ typedef struct {
 } Update;
 
 std::optional<std::string> GetResponse(std::string url, std::string path);
-std::optional<Update> GetLatestRelease();
+std::optional<Update> GetLatestRelease(bool include_prereleases);
 std::optional<Update> GetUpdate();
 } // namespace UpdateChecker

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -178,9 +178,6 @@ void DefineGenericOutput(EmitContext& ctx, size_t index, std::optional<u32> invo
             ctx.Decorate(id, spv::Decoration::XfbBuffer, xfb_varying->buffer);
             ctx.Decorate(id, spv::Decoration::XfbStride, xfb_varying->stride);
             ctx.Decorate(id, spv::Decoration::Offset, xfb_varying->offset);
-            if (ctx.stage == Stage::Geometry && xfb_varying->stream != 0) {
-                ctx.Decorate(id, spv::Decoration::Stream, xfb_varying->stream);
-            }
         }
         if (num_components < 4 || element > 0) {
             const std::string_view subswizzle{swizzle.substr(element, num_components)};

src/shader_recompiler/runtime_info.h

@@ -76,7 +76,6 @@ enum class TessSpacing {
 
 struct TransformFeedbackVarying {
     u32 buffer{};
-    u32 stream{};
     u32 stride{};
     u32 offset{};
     u32 components{};

src/video_core/CMakeLists.txt

@@ -8,7 +8,7 @@ add_subdirectory(host_shaders)
 add_subdirectory(gpu_logging)
 
 if(LIBVA_FOUND)
-    set_source_files_properties(host1x/ffmpeg.cpp
+    set_source_files_properties(host1x/ffmpeg/ffmpeg.cpp
         PROPERTIES COMPILE_DEFINITIONS LIBVA_FOUND=1)
     list(APPEND FFmpeg_LIBRARIES ${LIBVA_LIBRARIES})
 endif()
@@ -72,9 +72,9 @@ add_library(video_core STATIC
     host1x/codecs/vp8.h
     host1x/codecs/vp9.cpp
     host1x/codecs/vp9.h
-    host1x/codec_types.h
-    host1x/ffmpeg.cpp
-    host1x/ffmpeg.h
+    host1x/codecs/vp9_types.h
+    host1x/ffmpeg/ffmpeg.cpp
+    host1x/ffmpeg/ffmpeg.h
     host1x/control.cpp
     host1x/control.h
     host1x/gpu_device_memory_manager.cpp

src/video_core/buffer_cache/buffer_cache.h

@@ -1067,29 +1067,26 @@ void BufferCache<P>::BindHostTransformFeedbackBuffers() {
     HostBindings<typename P::Buffer> host_bindings;
     for (u32 index = 0; index < NUM_TRANSFORM_FEEDBACK_BUFFERS; ++index) {
         const Binding& binding = channel_state->transform_feedback_buffers[index];
-        const auto& control = maxwell3d->regs.transform_feedback.controls[index];
-        const bool has_layout = control.varying_count != 0 || control.stride != 0;
-
-        Buffer* host_buffer = &slot_buffers[NULL_BUFFER_ID];
-        u32 offset = 0;
-        u32 size = 0;
-
-        if (has_layout && binding.buffer_id != NULL_BUFFER_ID && binding.size != 0) {
-            Buffer& buffer = slot_buffers[binding.buffer_id];
-            TouchBuffer(buffer, binding.buffer_id);
-            size = binding.size;
-            SynchronizeBuffer(buffer, binding.device_addr, size);
-            MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
-            offset = buffer.Offset(binding.device_addr);
-            buffer.MarkUsage(offset, size);
-            host_buffer = &buffer;
+        if (maxwell3d->regs.transform_feedback.controls[index].varying_count == 0 &&
+            maxwell3d->regs.transform_feedback.controls[index].stride == 0) {
+            break;
         }
+        Buffer& buffer = slot_buffers[binding.buffer_id];
+        TouchBuffer(buffer, binding.buffer_id);
+        const u32 size = binding.size;
+        SynchronizeBuffer(buffer, binding.device_addr, size);
 
-        host_bindings.buffers.push_back(host_buffer);
+        MarkWrittenBuffer(binding.buffer_id, binding.device_addr, size);
+
+        const u32 offset = buffer.Offset(binding.device_addr);
+        buffer.MarkUsage(offset, size);
+        host_bindings.buffers.push_back(&buffer);
         host_bindings.offsets.push_back(offset);
         host_bindings.sizes.push_back(size);
     }
-    runtime.BindTransformFeedbackBuffers(host_bindings);
+    if (host_bindings.buffers.size() > 0) {
+        runtime.BindTransformFeedbackBuffers(host_bindings);
+    }
 }
 
 template <class P>

src/video_core/cdma_pusher.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Ryujinx Team and Contributors
@@ -20,10 +20,9 @@
 namespace Tegra {
 
 CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
-    : host_processor{std::make_unique<Host1x::Control>(host1x_)}
-    , host1x{host1x_}
-    , current_class{ChClassId(id)}
-{
+    : host1x{host1x_}, memory_manager{host1x.GMMU()},
+      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
+                                                                      static_cast<ChClassId>(id)} {
     thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
 }
 

src/video_core/cdma_pusher.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -120,6 +117,9 @@ protected:
 
     virtual void ProcessMethod(u32 method, u32 arg) = 0;
 
+    Host1x::Host1x& host1x;
+    Tegra::MemoryManager& memory_manager;
+
 private:
     /// Process the command entry
     void ProcessEntries(std::stop_token stop_token);
@@ -127,14 +127,14 @@ private:
     /// Invoke command class devices to execute the command based on the current state
     void ExecuteCommand(u32 state_offset, u32 data);
 
-protected:
-    ThiRegisters thi_regs{};
-    std::deque<ChCommandHeaderList> command_lists;
-    std::condition_variable_any command_cv;
-    std::jthread thread;
     std::unique_ptr<Host1x::Control> host_processor;
+
     std::mutex command_mutex;
-    Host1x::Host1x& host1x;
+    std::condition_variable_any command_cv;
+    std::deque<ChCommandHeaderList> command_lists;
+    std::jthread thread;
+
+    ThiRegisters thi_regs{};
     ChClassId current_class;
 };
 

src/video_core/gpu.cpp

@@ -89,7 +89,7 @@ struct GPU::Impl {
         renderer = std::move(renderer_);
         rasterizer = renderer->ReadRasterizer();
         host1x.MemoryManager().BindInterface(rasterizer);
-        host1x.gmmu_manager.BindRasterizer(rasterizer);
+        host1x.GMMU().BindRasterizer(rasterizer);
     }
 
     /// Flush all current written commands into the host GPU for execution.

src/video_core/gpu_thread.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -92,16 +92,7 @@ void ThreadManager::InvalidateRegion(DAddr addr, u64 size) {
 }
 
 void ThreadManager::FlushAndInvalidateRegion(DAddr addr, u64 size) {
-    if (Settings::IsGPULevelHigh()) {
-        if (!is_async) {
-            PushCommand(FlushRegionCommand(addr, size));
-        } else {
-            auto& gpu = system.GPU();
-            const u64 fence = gpu.RequestFlush(addr, size);
-            TickGPU();
-            gpu.WaitForSyncOperation(fence);
-        }
-    }
+    // Skip flush on asynch mode, as FlushAndInvalidateRegion is not used for anything too important
     rasterizer->OnCacheInvalidation(addr, size);
 }
 

src/video_core/host1x/codecs/codec.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -16,12 +13,9 @@
 namespace Tegra {
 
 Codec::Codec(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs)
-    : host1x(host1x_)
-    , state{regs}
-    , h264_decoder(host1x_)
-    , vp8_decoder(host1x_)
-    , vp9_decoder(host1x_)
-{}
+    : host1x(host1x_), state{regs}, h264_decoder(std::make_unique<Decoder::H264>(host1x)),
+      vp8_decoder(std::make_unique<Decoder::VP8>(host1x)),
+      vp9_decoder(std::make_unique<Decoder::VP9>(host1x)) {}
 
 Codec::~Codec() = default;
 
@@ -38,11 +32,13 @@ void Codec::SetTargetCodec(Host1x::NvdecCommon::VideoCodec codec) {
 
 void Codec::Decode() {
     const bool is_first_frame = !initialized;
-    if (is_first_frame)
+    if (is_first_frame) {
         Initialize();
+    }
 
-    if (!initialized)
+    if (!initialized) {
         return;
+    }
 
     // Assemble bitstream.
     bool vp9_hidden_frame = false;
@@ -50,13 +46,13 @@ void Codec::Decode() {
     const auto packet_data = [&]() {
         switch (current_codec) {
         case Tegra::Host1x::NvdecCommon::VideoCodec::H264:
-            return h264_decoder.ComposeFrame(state, &configuration_size, is_first_frame);
+            return h264_decoder->ComposeFrame(state, &configuration_size, is_first_frame);
         case Tegra::Host1x::NvdecCommon::VideoCodec::VP8:
-            return vp8_decoder.ComposeFrame(state);
+            return vp8_decoder->ComposeFrame(state);
         case Tegra::Host1x::NvdecCommon::VideoCodec::VP9:
-            vp9_decoder.ComposeFrame(state);
-            vp9_hidden_frame = vp9_decoder.WasFrameHidden();
-            return vp9_decoder.GetFrameBytes();
+            vp9_decoder->ComposeFrame(state);
+            vp9_hidden_frame = vp9_decoder->WasFrameHidden();
+            return vp9_decoder->GetFrameBytes();
         default:
             ASSERT(false);
             return std::span<const u8>{};
@@ -85,13 +81,19 @@ void Codec::Decode() {
 std::unique_ptr<FFmpeg::Frame> Codec::GetCurrentFrame() {
     // Sometimes VIC will request more frames than have been decoded.
     // in this case, return a blank frame and don't overwrite previous data.
-    if (frames.empty())
+    if (frames.empty()) {
         return {};
+    }
+
     auto frame = std::move(frames.front());
     frames.pop();
     return frame;
 }
 
+Host1x::NvdecCommon::VideoCodec Codec::GetCurrentCodec() const {
+    return current_codec;
+}
+
 std::string_view Codec::GetCurrentCodecName() const {
     switch (current_codec) {
     case Host1x::NvdecCommon::VideoCodec::None:

src/video_core/host1x/codecs/codec.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,14 +8,17 @@
 #include <string_view>
 #include <queue>
 #include "common/common_types.h"
-#include "video_core/host1x/codecs/h264.h"
-#include "video_core/host1x/codecs/vp8.h"
-#include "video_core/host1x/codecs/vp9.h"
-#include "video_core/host1x/ffmpeg.h"
+#include "video_core/host1x/ffmpeg/ffmpeg.h"
 #include "video_core/host1x/nvdec_common.h"
 
 namespace Tegra {
 
+namespace Decoder {
+class H264;
+class VP8;
+class VP9;
+} // namespace Decoder
+
 namespace Host1x {
 class Host1x;
 } // namespace Host1x
@@ -40,6 +40,9 @@ public:
     /// Returns next decoded frame
     [[nodiscard]] std::unique_ptr<FFmpeg::Frame> GetCurrentFrame();
 
+    /// Returns the value of current_codec
+    [[nodiscard]] Host1x::NvdecCommon::VideoCodec GetCurrentCodec() const;
+
     /// Return name of the current codec
     [[nodiscard]] std::string_view GetCurrentCodecName() const;
 
@@ -50,9 +53,10 @@ private:
 
     Host1x::Host1x& host1x;
     const Host1x::NvdecCommon::NvdecRegisters& state;
-    Decoders::H264 h264_decoder;
-    Decoders::VP8 vp8_decoder;
-    Decoders::VP9 vp9_decoder;
+    std::unique_ptr<Decoder::H264> h264_decoder;
+    std::unique_ptr<Decoder::VP8> vp8_decoder;
+    std::unique_ptr<Decoder::VP9> vp9_decoder;
+
     std::queue<std::unique_ptr<FFmpeg::Frame>> frames{};
 };
 

src/video_core/host1x/codecs/decoder.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -12,11 +12,10 @@
 
 namespace Tegra {
 
-Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_)
-    : host1x(host1x_)
-    , regs{regs_}
-    , id{id_}
-{}
+Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_,
+                 Host1x::FrameQueue& frame_queue_)
+    : host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_}, frame_queue{
+                                                                                frame_queue_} {}
 
 Decoder::~Decoder() = default;
 
@@ -54,11 +53,11 @@ void Decoder::Decode() {
         }
 
         if (UsingDecodeOrder()) {
-            host1x.frame_queue.PushDecodeOrder(id, luma_top, std::move(frame));
-            host1x.frame_queue.PushDecodeOrder(id, luma_bottom, std::move(frame_copy));
+            frame_queue.PushDecodeOrder(id, luma_top, std::move(frame));
+            frame_queue.PushDecodeOrder(id, luma_bottom, std::move(frame_copy));
         } else {
-            host1x.frame_queue.PushPresentOrder(id, luma_top, std::move(frame));
-            host1x.frame_queue.PushPresentOrder(id, luma_bottom, std::move(frame_copy));
+            frame_queue.PushPresentOrder(id, luma_top, std::move(frame));
+            frame_queue.PushPresentOrder(id, luma_bottom, std::move(frame_copy));
         }
     } else {
         auto [luma_offset, chroma_offset] = GetProgressiveOffsets();
@@ -69,9 +68,9 @@ void Decoder::Decode() {
         }
 
         if (UsingDecodeOrder()) {
-            host1x.frame_queue.PushDecodeOrder(id, luma_offset, std::move(frame));
+            frame_queue.PushDecodeOrder(id, luma_offset, std::move(frame));
         } else {
-            host1x.frame_queue.PushPresentOrder(id, luma_offset, std::move(frame));
+            frame_queue.PushPresentOrder(id, luma_offset, std::move(frame));
         }
     }
 }

src/video_core/host1x/codecs/decoder.h

@@ -14,7 +14,7 @@
 #include <queue>
 
 #include "common/common_types.h"
-#include "video_core/host1x/ffmpeg.h"
+#include "video_core/host1x/ffmpeg/ffmpeg.h"
 #include "video_core/host1x/nvdec_common.h"
 
 namespace Tegra {
@@ -35,23 +35,33 @@ public:
         return decode_api.UsingDecodeOrder();
     }
 
+    /// Returns the value of current_codec
+    [[nodiscard]] Host1x::NvdecCommon::VideoCodec GetCurrentCodec() const {
+        return codec;
+    }
+
     /// Return name of the current codec
     [[nodiscard]] virtual std::string_view GetCurrentCodecName() const = 0;
 
 protected:
-    explicit Decoder(Host1x::Host1x& host1x, s32 id, const Host1x::NvdecCommon::NvdecRegisters& regs);
+    explicit Decoder(Host1x::Host1x& host1x, s32 id,
+                     const Host1x::NvdecCommon::NvdecRegisters& regs,
+                     Host1x::FrameQueue& frame_queue);
 
     virtual std::span<const u8> ComposeFrame() = 0;
     virtual std::tuple<u64, u64> GetProgressiveOffsets() = 0;
     virtual std::tuple<u64, u64, u64, u64> GetInterlacedOffsets() = 0;
     virtual bool IsInterlaced() = 0;
 
-    FFmpeg::DecodeApi decode_api;
     Host1x::Host1x& host1x;
+    Tegra::MemoryManager& memory_manager;
     const Host1x::NvdecCommon::NvdecRegisters& regs;
     s32 id;
-    bool initialized : 1 = false;
-    bool vp9_hidden_frame : 1 = false;
+    Host1x::FrameQueue& frame_queue;
+    Host1x::NvdecCommon::VideoCodec codec;
+    FFmpeg::DecodeApi decode_api;
+    bool initialized{};
+    bool vp9_hidden_frame{};
 };
 
 } // namespace Tegra

src/video_core/host1x/codecs/h264.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -14,11 +14,25 @@
 #include "video_core/memory_manager.h"
 
 namespace Tegra::Decoders {
+namespace {
+// ZigZag LUTs from libavcodec.
+constexpr std::array<u8, 64> zig_zag_direct{
+    0,  1,  8,  16, 9,  2,  3,  10, 17, 24, 32, 25, 18, 11, 4,  5,  12, 19, 26, 33, 40, 48,
+    41, 34, 27, 20, 13, 6,  7,  14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23,
+    30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
+};
 
-H264::H264(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_)
-    : Decoder{host1x_, id_, regs_}
-{
-    initialized = decode_api.Initialize(Host1x::NvdecCommon::VideoCodec::H264);
+constexpr std::array<u8, 16> zig_zag_scan{
+    0 + 0 * 4, 1 + 0 * 4, 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 2 + 0 * 4, 3 + 0 * 4, 2 + 1 * 4,
+    1 + 2 * 4, 0 + 3 * 4, 1 + 3 * 4, 2 + 2 * 4, 3 + 1 * 4, 3 + 2 * 4, 2 + 3 * 4, 3 + 3 * 4,
+};
+} // Anonymous namespace
+
+H264::H264(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_,
+           Host1x::FrameQueue& frame_queue_)
+    : Decoder{host1x_, id_, regs_, frame_queue_} {
+    codec = Host1x::NvdecCommon::VideoCodec::H264;
+    initialized = decode_api.Initialize(codec);
 }
 
 H264::~H264() = default;
@@ -51,11 +65,14 @@ bool H264::IsInterlaced() {
 }
 
 std::span<const u8> H264::ComposeFrame() {
-    host1x.memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context, sizeof(H264DecoderContext));
+    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context,
+                             sizeof(H264DecoderContext));
+
     const s64 frame_number = current_context.h264_parameter_set.frame_number.Value();
     if (!is_first_frame && frame_number != 0) {
         frame_scratch.resize_destructive(current_context.stream_len);
-        host1x.memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data(), frame_scratch.size());
+        memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data(),
+                                 frame_scratch.size());
         return frame_scratch;
     }
 
@@ -157,13 +174,15 @@ std::span<const u8> H264::ComposeFrame() {
 
     for (s32 index = 0; index < 6; index++) {
         writer.WriteBit(true);
-        writer.WriteScalingList(current_context.weight_scale_4x4, index * 16, 16);
+        std::span<const u8> matrix{current_context.weight_scale_4x4};
+        writer.WriteScalingList(scan_scratch, matrix, index * 16, 16);
     }
 
     if (current_context.h264_parameter_set.transform_8x8_mode_flag) {
         for (s32 index = 0; index < 2; index++) {
             writer.WriteBit(true);
-            writer.WriteScalingList(current_context.weight_scale_8x8, index * 64, 64);
+            std::span<const u8> matrix{current_context.weight_scale_8x8};
+            writer.WriteScalingList(scan_scratch, matrix, index * 64, 64);
         }
     }
 
@@ -177,7 +196,11 @@ std::span<const u8> H264::ComposeFrame() {
     const auto& encoded_header = writer.GetByteArray();
     frame_scratch.resize(encoded_header.size() + current_context.stream_len);
     std::memcpy(frame_scratch.data(), encoded_header.data(), encoded_header.size());
-    host1x.memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data() + encoded_header.size(), current_context.stream_len);
+
+    memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(),
+                             frame_scratch.data() + encoded_header.size(),
+                             current_context.stream_len);
+
     return frame_scratch;
 }
 
@@ -206,37 +229,23 @@ void H264BitWriter::WriteBit(bool state) {
     WriteBits(state ? 1 : 0, 1);
 }
 
-void H264BitWriter::WriteScalingList(std::span<const u8> list, s32 start, s32 count) {
+void H264BitWriter::WriteScalingList(Common::ScratchBuffer<u8>& scan, std::span<const u8> list,
+                                     s32 start, s32 count) {
+    scan.resize_destructive(count);
     if (count == 16) {
-        u8 last_scale = 8;
-        for (s32 index = 0; index < count; index++) {
-            // libavcodec has a zig zag LUT, but we dont need it, just use a magic
-            // constant which is a packing of 4 bits for each component of the table
-            const u8 value = list[start + ((0xfeb7adc963258410 >> (index * 4)) & 0xf)];
-            const s32 delta_scale = s32(value - last_scale);
-            WriteSe(delta_scale);
-            last_scale = value;
-        }
+        std::memcpy(scan.data(), zig_zag_scan.data(), scan.size());
     } else {
-        // ZigZag LUTs from libavcodec: this is the famous zigzag pattern found in the ffmpeg logo itself!
-        static constexpr std::array<u8, 64> scan{
-            0,  1,  8,  16, 9,  2,  3,  10,
-            17, 24, 32, 25, 18, 11, 4,
-            5,  12, 19, 26, 33, 40, 48,
-            41, 34, 27, 20, 13, 6,  7,
-            14, 21, 28, 35, 42, 49, 56,
-            57, 50, 43, 36, 29, 22, 15,
-            23, 30, 37, 44, 51, 58, 59,
-            52, 45, 38, 31, 39, 46, 53,
-            60, 61, 54, 47, 55, 62, 63,
-        };
-        u8 last_scale = 8;
-        for (s32 index = 0; index < count; index++) {
-            const u8 value = list[start + scan[index]];
-            const s32 delta_scale = s32(value - last_scale);
-            WriteSe(delta_scale);
-            last_scale = value;
-        }
+        std::memcpy(scan.data(), zig_zag_direct.data(), scan.size());
+    }
+    u8 last_scale = 8;
+
+    for (s32 index = 0; index < count; index++) {
+        const u8 value = list[start + scan[index]];
+        const s32 delta_scale = static_cast<s32>(value - last_scale);
+
+        WriteSe(delta_scale);
+
+        last_scale = value;
     }
 }
 
@@ -277,15 +286,19 @@ void H264BitWriter::WriteBits(s32 value, s32 bit_count) {
 
 void H264BitWriter::WriteExpGolombCodedInt(s32 value) {
     const s32 sign = value <= 0 ? 0 : 1;
-    if (!sign) value = -value;
-    WriteExpGolombCodedUInt((value << 1) - sign);
+    if (value < 0) {
+        value = -value;
+    }
+    value = (value << 1) - sign;
+    WriteExpGolombCodedUInt(value);
 }
 
 void H264BitWriter::WriteExpGolombCodedUInt(u32 value) {
     const s32 size = 32 - std::countl_zero(value + 1);
     WriteBits(1, size);
+
     value -= (1U << (size - 1)) - 1;
-    WriteBits(s32(value), size - 1);
+    WriteBits(static_cast<s32>(value), size - 1);
 }
 
 s32 H264BitWriter::GetFreeBufferBits() {

src/video_core/host1x/codecs/h264.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,10 +6,11 @@
 #include <span>
 #include <vector>
 
+#include "common/bit_field.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
 #include "video_core/host1x/codecs/decoder.h"
-#include "video_core/host1x/codec_types.h"
 #include "video_core/host1x/nvdec_common.h"
 
 namespace Tegra {
@@ -42,7 +40,8 @@ public:
 
     /// Based on section 7.3.2.1.1.1 and Table 7-4 in the H.264 specification
     /// Writes the scaling matrices of the sream
-    void WriteScalingList(std::span<const u8> list, s32 start, s32 count);
+    void WriteScalingList(Common::ScratchBuffer<u8>& scan, std::span<const u8> list, s32 start,
+                          s32 count);
 
     /// Return the bitstream as a vector.
     [[nodiscard]] std::vector<u8>& GetByteArray();
@@ -62,9 +61,188 @@ private:
     std::vector<u8> byte_array;
 };
 
+struct Offset {
+    constexpr u32 Address() const noexcept {
+        return offset << 8;
+    }
+
+private:
+    u32 offset;
+};
+static_assert(std::is_trivial_v<Offset>, "Offset must be trivial");
+static_assert(sizeof(Offset) == 0x4, "Offset has the wrong size!");
+
+struct H264ParameterSet {
+    s32 log2_max_pic_order_cnt_lsb_minus4; ///< 0x00
+    s32 delta_pic_order_always_zero_flag;  ///< 0x04
+    s32 frame_mbs_only_flag;               ///< 0x08
+    u32 pic_width_in_mbs;                  ///< 0x0C
+    u32 frame_height_in_mbs;               ///< 0x10
+    union {                                ///< 0x14
+        BitField<0, 2, u32> tile_format;
+        BitField<2, 3, u32> gob_height;
+        BitField<5, 27, u32> reserved_surface_format;
+    };
+    u32 entropy_coding_mode_flag;               ///< 0x18
+    s32 pic_order_present_flag;                 ///< 0x1C
+    s32 num_refidx_l0_default_active;           ///< 0x20
+    s32 num_refidx_l1_default_active;           ///< 0x24
+    s32 deblocking_filter_control_present_flag; ///< 0x28
+    s32 redundant_pic_cnt_present_flag;         ///< 0x2C
+    u32 transform_8x8_mode_flag;                ///< 0x30
+    u32 pitch_luma;                             ///< 0x34
+    u32 pitch_chroma;                           ///< 0x38
+    Offset luma_top_offset;                     ///< 0x3C
+    Offset luma_bot_offset;                     ///< 0x40
+    Offset luma_frame_offset;                   ///< 0x44
+    Offset chroma_top_offset;                   ///< 0x48
+    Offset chroma_bot_offset;                   ///< 0x4C
+    Offset chroma_frame_offset;                 ///< 0x50
+    u32 hist_buffer_size;                       ///< 0x54
+    union {                                     ///< 0x58
+        union {
+            BitField<0, 1, u64> mbaff_frame;
+            BitField<1, 1, u64> direct_8x8_inference;
+            BitField<2, 1, u64> weighted_pred;
+            BitField<3, 1, u64> constrained_intra_pred;
+            BitField<4, 1, u64> ref_pic;
+            BitField<5, 1, u64> field_pic;
+            BitField<6, 1, u64> bottom_field;
+            BitField<7, 1, u64> second_field;
+        } flags;
+        BitField<8, 4, u64> log2_max_frame_num_minus4;
+        BitField<12, 2, u64> chroma_format_idc;
+        BitField<14, 2, u64> pic_order_cnt_type;
+        BitField<16, 6, s64> pic_init_qp_minus26;
+        BitField<22, 5, s64> chroma_qp_index_offset;
+        BitField<27, 5, s64> second_chroma_qp_index_offset;
+        BitField<32, 2, u64> weighted_bipred_idc;
+        BitField<34, 7, u64> curr_pic_idx;
+        BitField<41, 5, u64> curr_col_idx;
+        BitField<46, 16, u64> frame_number;
+        BitField<62, 1, u64> frame_surfaces;
+        BitField<63, 1, u64> output_memory_layout;
+    };
+};
+static_assert(sizeof(H264ParameterSet) == 0x60, "H264ParameterSet is an invalid size");
+
+#define ASSERT_POSITION(field_name, position)                                                      \
+    static_assert(offsetof(H264ParameterSet, field_name) == position,                              \
+                  "Field " #field_name " has invalid position")
+
+ASSERT_POSITION(log2_max_pic_order_cnt_lsb_minus4, 0x00);
+ASSERT_POSITION(delta_pic_order_always_zero_flag, 0x04);
+ASSERT_POSITION(frame_mbs_only_flag, 0x08);
+ASSERT_POSITION(pic_width_in_mbs, 0x0C);
+ASSERT_POSITION(frame_height_in_mbs, 0x10);
+ASSERT_POSITION(tile_format, 0x14);
+ASSERT_POSITION(entropy_coding_mode_flag, 0x18);
+ASSERT_POSITION(pic_order_present_flag, 0x1C);
+ASSERT_POSITION(num_refidx_l0_default_active, 0x20);
+ASSERT_POSITION(num_refidx_l1_default_active, 0x24);
+ASSERT_POSITION(deblocking_filter_control_present_flag, 0x28);
+ASSERT_POSITION(redundant_pic_cnt_present_flag, 0x2C);
+ASSERT_POSITION(transform_8x8_mode_flag, 0x30);
+ASSERT_POSITION(pitch_luma, 0x34);
+ASSERT_POSITION(pitch_chroma, 0x38);
+ASSERT_POSITION(luma_top_offset, 0x3C);
+ASSERT_POSITION(luma_bot_offset, 0x40);
+ASSERT_POSITION(luma_frame_offset, 0x44);
+ASSERT_POSITION(chroma_top_offset, 0x48);
+ASSERT_POSITION(chroma_bot_offset, 0x4C);
+ASSERT_POSITION(chroma_frame_offset, 0x50);
+ASSERT_POSITION(hist_buffer_size, 0x54);
+ASSERT_POSITION(flags, 0x58);
+#undef ASSERT_POSITION
+
+struct DpbEntry {
+    union {
+        BitField<0, 7, u32> index;
+        BitField<7, 5, u32> col_idx;
+        BitField<12, 2, u32> state;
+        BitField<14, 1, u32> is_long_term;
+        BitField<15, 1, u32> non_existing;
+        BitField<16, 1, u32> is_field;
+        BitField<17, 4, u32> top_field_marking;
+        BitField<21, 4, u32> bottom_field_marking;
+        BitField<25, 1, u32> output_memory_layout;
+        BitField<26, 6, u32> reserved;
+    } flags;
+    std::array<u32, 2> field_order_cnt;
+    u32 frame_idx;
+};
+static_assert(sizeof(DpbEntry) == 0x10, "DpbEntry has the wrong size!");
+
+struct DisplayParam {
+    union {
+        BitField<0, 1, u32> enable_tf_output;
+        BitField<1, 1, u32> vc1_map_y_flag;
+        BitField<2, 3, u32> map_y_value;
+        BitField<5, 1, u32> vc1_map_uv_flag;
+        BitField<6, 3, u32> map_uv_value;
+        BitField<9, 8, u32> out_stride;
+        BitField<17, 3, u32> tiling_format;
+        BitField<20, 1, u32> output_structure; // 0=frame, 1=field
+        BitField<21, 11, u32> reserved0;
+    };
+    std::array<s32, 2> output_top;
+    std::array<s32, 2> output_bottom;
+    union {
+        BitField<0, 1, u32> enable_histogram;
+        BitField<1, 12, u32> histogram_start_x;
+        BitField<13, 12, u32> histogram_start_y;
+        BitField<25, 7, u32> reserved1;
+    };
+    union {
+        BitField<0, 12, u32> histogram_end_x;
+        BitField<12, 12, u32> histogram_end_y;
+        BitField<24, 8, u32> reserved2;
+    };
+};
+static_assert(sizeof(DisplayParam) == 0x1C, "DisplayParam has the wrong size!");
+
+struct H264DecoderContext {
+    INSERT_PADDING_WORDS_NOINIT(13);                        ///< 0x0000
+    std::array<u8, 16> eos;                                 ///< 0x0034
+    u8 explicit_eos_present_flag;                           ///< 0x0044
+    u8 hint_dump_en;                                        ///< 0x0045
+    INSERT_PADDING_BYTES_NOINIT(2);                         ///< 0x0046
+    u32 stream_len;                                         ///< 0x0048
+    u32 slice_count;                                        ///< 0x004C
+    u32 mbhist_buffer_size;                                 ///< 0x0050
+    u32 gptimer_timeout_value;                              ///< 0x0054
+    H264ParameterSet h264_parameter_set;                    ///< 0x0058
+    std::array<s32, 2> curr_field_order_cnt;                ///< 0x00B8
+    std::array<DpbEntry, 16> dpb;                           ///< 0x00C0
+    std::array<u8, 0x60> weight_scale_4x4;                  ///< 0x01C0
+    std::array<u8, 0x80> weight_scale_8x8;                  ///< 0x0220
+    std::array<u8, 2> num_inter_view_refs_lX;               ///< 0x02A0
+    std::array<u8, 14> reserved2;                           ///< 0x02A2
+    std::array<std::array<s8, 16>, 2> inter_view_refidx_lX; ///< 0x02B0
+    union {                                                 ///< 0x02D0
+        BitField<0, 1, u32> lossless_ipred8x8_filter_enable;
+        BitField<1, 1, u32> qpprime_y_zero_transform_bypass_flag;
+        BitField<2, 30, u32> reserved3;
+    };
+    DisplayParam display_param;   ///< 0x02D4
+    std::array<u32, 3> reserved4; ///< 0x02F0
+};
+static_assert(sizeof(H264DecoderContext) == 0x2FC, "H264DecoderContext is an invalid size");
+
+#define ASSERT_POSITION(field_name, position)                                                      \
+    static_assert(offsetof(H264DecoderContext, field_name) == position,                            \
+                  "Field " #field_name " has invalid position")
+
+ASSERT_POSITION(stream_len, 0x48);
+ASSERT_POSITION(h264_parameter_set, 0x58);
+ASSERT_POSITION(dpb, 0xC0);
+ASSERT_POSITION(weight_scale_4x4, 0x1C0);
+#undef ASSERT_POSITION
+
 class H264 final : public Decoder {
 public:
-    explicit H264(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id);
+    explicit H264(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
+                  Host1x::FrameQueue& frame_queue);
     ~H264() override;
 
     H264(const H264&) = delete;
@@ -85,10 +263,10 @@ public:
     }
 
 private:
-    H264DecoderContext current_context{};
-    std::array<u8, 64> scan_scratch;
-    Common::ScratchBuffer<u8> frame_scratch;
     bool is_first_frame{true};
+    Common::ScratchBuffer<u8> frame_scratch;
+    Common::ScratchBuffer<u8> scan_scratch;
+    H264DecoderContext current_context{};
 };
 
 } // namespace Decoders

src/video_core/host1x/codecs/vp8.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,10 +8,11 @@
 #include "video_core/memory_manager.h"
 
 namespace Tegra::Decoders {
-VP8::VP8(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_)
-    : Decoder{host1x_, id_, regs_}
-{
-    initialized = decode_api.Initialize(Host1x::NvdecCommon::VideoCodec::VP8);
+VP8::VP8(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_,
+         Host1x::FrameQueue& frame_queue_)
+    : Decoder{host1x_, id_, regs_, frame_queue_} {
+    codec = Host1x::NvdecCommon::VideoCodec::VP8;
+    initialized = decode_api.Initialize(codec);
 }
 
 VP8::~VP8() = default;
@@ -27,30 +25,35 @@ std::tuple<u64, u64> VP8::GetProgressiveOffsets() {
 
 std::tuple<u64, u64, u64, u64> VP8::GetInterlacedOffsets() {
     auto luma_top{regs.surface_luma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
-    auto luma_bottom = regs.surface_luma_offsets[u32(Vp8SurfaceIndex::Current)].Address();
-    auto chroma_top = regs.surface_chroma_offsets[u32(Vp8SurfaceIndex::Current)].Address();
-    auto chroma_bottom = regs.surface_chroma_offsets[u32(Vp8SurfaceIndex::Current)].Address();
+    auto luma_bottom{
+        regs.surface_luma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    auto chroma_top{
+        regs.surface_chroma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    auto chroma_bottom{
+        regs.surface_chroma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
     return {luma_top, luma_bottom, chroma_top, chroma_bottom};
 }
 
 std::span<const u8> VP8::ComposeFrame() {
-    host1x.gmmu_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context, sizeof(VP8PictureInfo));
+    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context,
+                             sizeof(VP8PictureInfo));
 
     const bool is_key_frame = current_context.key_frame == 1u;
-    const auto bitstream_size = size_t(current_context.vld_buffer_size);
+    const auto bitstream_size = static_cast<size_t>(current_context.vld_buffer_size);
     const size_t header_size = is_key_frame ? 10u : 3u;
     frame_scratch.resize(header_size + bitstream_size);
 
     // Based on page 30 of the VP8 specification.
     // https://datatracker.ietf.org/doc/rfc6386/
     frame_scratch[0] = is_key_frame ? 0u : 1u; // 1-bit frame type (0: keyframe, 1: interframes).
-    frame_scratch[0] |= u8((current_context.version & 7u) << 1u); // 3-bit version number
-    frame_scratch[0] |= u8(1u << 4u);             // 1-bit show_frame flag
+    frame_scratch[0] |=
+        static_cast<u8>((current_context.version & 7u) << 1u); // 3-bit version number
+    frame_scratch[0] |= static_cast<u8>(1u << 4u);             // 1-bit show_frame flag
 
     // The next 19-bits are the first partition size
-    frame_scratch[0] |= u8((current_context.first_part_size & 7u) << 5u);
-    frame_scratch[1] = u8((current_context.first_part_size & 0x7f8u) >> 3u);
-    frame_scratch[2] = u8((current_context.first_part_size & 0x7f800u) >> 11u);
+    frame_scratch[0] |= static_cast<u8>((current_context.first_part_size & 7u) << 5u);
+    frame_scratch[1] = static_cast<u8>((current_context.first_part_size & 0x7f8u) >> 3u);
+    frame_scratch[2] = static_cast<u8>((current_context.first_part_size & 0x7f800u) >> 11u);
 
     if (is_key_frame) {
         frame_scratch[3] = 0x9du;
@@ -58,15 +61,15 @@ std::span<const u8> VP8::ComposeFrame() {
         frame_scratch[5] = 0x2au;
         // TODO(ameerj): Horizontal/Vertical Scale
         // 16 bits: (2 bits Horizontal Scale << 14) | Width (14 bits)
-        frame_scratch[6] = u8(current_context.frame_width & 0xff);
-        frame_scratch[7] = u8(((current_context.frame_width >> 8) & 0x3f));
+        frame_scratch[6] = static_cast<u8>(current_context.frame_width & 0xff);
+        frame_scratch[7] = static_cast<u8>(((current_context.frame_width >> 8) & 0x3f));
         // 16 bits:(2 bits Vertical Scale << 14) | Height (14 bits)
-        frame_scratch[8] = u8(current_context.frame_height & 0xff);
-        frame_scratch[9] = u8(((current_context.frame_height >> 8) & 0x3f));
+        frame_scratch[8] = static_cast<u8>(current_context.frame_height & 0xff);
+        frame_scratch[9] = static_cast<u8>(((current_context.frame_height >> 8) & 0x3f));
     }
-
     const u64 bitstream_offset = regs.frame_bitstream_offset.Address();
-    host1x.gmmu_manager.ReadBlock(bitstream_offset, frame_scratch.data() + header_size, bitstream_size);
+    memory_manager.ReadBlock(bitstream_offset, frame_scratch.data() + header_size, bitstream_size);
+
     return frame_scratch;
 }
 

src/video_core/host1x/codecs/vp8.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -14,7 +11,6 @@
 #include "common/scratch_buffer.h"
 #include "video_core/host1x/codecs/decoder.h"
 #include "video_core/host1x/nvdec_common.h"
-#include "video_core/host1x/codec_types.h"
 
 namespace Tegra {
 
@@ -32,7 +28,8 @@ enum class Vp8SurfaceIndex : u32 {
 
 class VP8 final : public Decoder {
 public:
-    explicit VP8(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id);
+    explicit VP8(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
+                 Host1x::FrameQueue& frame_queue);
     ~VP8() override;
 
     VP8(const VP8&) = delete;
@@ -55,8 +52,51 @@ public:
     }
 
 private:
-    VP8PictureInfo current_context{};
     Common::ScratchBuffer<u8> frame_scratch;
+
+    struct VP8PictureInfo {
+        INSERT_PADDING_WORDS_NOINIT(14);
+        u16 frame_width;  // actual frame width
+        u16 frame_height; // actual frame height
+        u8 key_frame;
+        u8 version;
+        union {
+            u8 raw;
+            BitField<0, 2, u8> tile_format;
+            BitField<2, 3, u8> gob_height;
+            BitField<5, 3, u8> reserved_surface_format;
+        };
+        u8 error_conceal_on;  // 1: error conceal on; 0: off
+        u32 first_part_size;  // the size of first partition(frame header and mb header partition)
+        u32 hist_buffer_size; // in units of 256
+        u32 vld_buffer_size;  // in units of 1
+        // Current frame buffers
+        std::array<u32, 2> frame_stride; // [y_c]
+        u32 luma_top_offset;             // offset of luma top field in units of 256
+        u32 luma_bot_offset;             // offset of luma bottom field in units of 256
+        u32 luma_frame_offset;           // offset of luma frame in units of 256
+        u32 chroma_top_offset;           // offset of chroma top field in units of 256
+        u32 chroma_bot_offset;           // offset of chroma bottom field in units of 256
+        u32 chroma_frame_offset;         // offset of chroma frame in units of 256
+
+        INSERT_PADDING_BYTES_NOINIT(0x1c); // NvdecDisplayParams
+
+        // Decode picture buffer related
+        s8 current_output_memory_layout;
+        // output NV12/NV24 setting. index 0: golden; 1: altref; 2: last
+        std::array<s8, 3> output_memory_layout;
+
+        u8 segmentation_feature_data_update;
+        INSERT_PADDING_BYTES_NOINIT(3);
+
+        // ucode return result
+        u32 result_value;
+        std::array<u32, 8> partition_offset;
+        INSERT_PADDING_WORDS_NOINIT(3);
+    };
+    static_assert(sizeof(VP8PictureInfo) == 0xc0, "PictureInfo is an invalid size");
+
+    VP8PictureInfo current_context{};
 };
 
 } // namespace Decoders

src/video_core/host1x/codecs/vp9.cpp

@@ -1,11 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm> // for std::copy
-#include <bit>
 #include <numeric>
 
 #include "common/alignment.h"
@@ -16,11 +15,11 @@
 
 namespace Tegra::Decoders {
 namespace {
-static constexpr u32 diff_update_probability = 252;
-static constexpr u32 frame_sync_code = 0x498342;
+constexpr u32 diff_update_probability = 252;
+constexpr u32 frame_sync_code = 0x498342;
 
 // Default compressed header probabilities once frame context resets
-static constexpr Vp9EntropyProbs default_probs{
+constexpr Vp9EntropyProbs default_probs{
     .y_mode_prob{
         65,  32, 18, 144, 162, 194, 41, 51, 98, 132, 68,  18, 165, 217, 196, 45, 40, 78,
         173, 80, 19, 176, 240, 193, 64, 35, 46, 221, 135, 38, 194, 248, 121, 96, 85, 29,
@@ -159,6 +158,34 @@ static constexpr Vp9EntropyProbs default_probs{
     .high_precision{128, 128},
 };
 
+constexpr std::array<u8, 256> norm_lut{
+    0, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+constexpr std::array<u8, 254> map_lut{
+    20,  21,  22,  23,  24,  25,  0,   26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,
+    1,   38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  2,   50,  51,  52,  53,  54,
+    55,  56,  57,  58,  59,  60,  61,  3,   62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,
+    73,  4,   74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  5,   86,  87,  88,  89,
+    90,  91,  92,  93,  94,  95,  96,  97,  6,   98,  99,  100, 101, 102, 103, 104, 105, 106, 107,
+    108, 109, 7,   110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 8,   122, 123, 124,
+    125, 126, 127, 128, 129, 130, 131, 132, 133, 9,   134, 135, 136, 137, 138, 139, 140, 141, 142,
+    143, 144, 145, 10,  146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 11,  158, 159,
+    160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 12,  170, 171, 172, 173, 174, 175, 176, 177,
+    178, 179, 180, 181, 13,  182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 14,  194,
+    195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 15,  206, 207, 208, 209, 210, 211, 212,
+    213, 214, 215, 216, 217, 16,  218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 17,
+    230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 18,  242, 243, 244, 245, 246, 247,
+    248, 249, 250, 251, 252, 253, 19,
+};
+
 // 6.2.14 Tile size calculation
 
 [[nodiscard]] s32 CalcMinLog2TileCols(s32 frame_width) {
@@ -200,17 +227,25 @@ static constexpr Vp9EntropyProbs default_probs{
 [[nodiscard]] s32 RemapProbability(s32 new_prob, s32 old_prob) {
     new_prob--;
     old_prob--;
-    u8 i = old_prob * 2 <= 0xff
-        ? u8((std::max)(0, RecenterNonNeg(new_prob, old_prob) - 1))
-        : u8((std::max)(0, RecenterNonNeg(0xff - 1 - new_prob, 0xff - 1 - old_prob) - 1));
-    return s32((i + 7) % 13 == 0 ? (i + 7) / 13 - 1 : i + 20 - (i + 7) / 13);
+
+    std::size_t index{};
+
+    if (old_prob * 2 <= 0xff) {
+        index = static_cast<std::size_t>((std::max)(0, RecenterNonNeg(new_prob, old_prob) - 1));
+    } else {
+        index = static_cast<std::size_t>(
+            (std::max)(0, RecenterNonNeg(0xff - 1 - new_prob, 0xff - 1 - old_prob) - 1));
+    }
+
+    return static_cast<s32>(map_lut[index]);
 }
 } // Anonymous namespace
 
-VP9::VP9(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_)
-    : Decoder{host1x_, id_, regs_}
-{
-    initialized = decode_api.Initialize(Host1x::NvdecCommon::VideoCodec::VP9);
+VP9::VP9(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_,
+         Host1x::FrameQueue& frame_queue_)
+    : Decoder{host1x_, id_, regs_, frame_queue_} {
+    codec = Host1x::NvdecCommon::VideoCodec::VP9;
+    initialized = decode_api.Initialize(codec);
 }
 
 VP9::~VP9() = default;
@@ -342,7 +377,8 @@ void VP9::WriteSegmentation(VpxBitStreamWriter& writer) {
 
     if (update_map) {
         EntropyProbs entropy_probs{};
-        host1x.gmmu_manager.ReadBlock(regs.vp9_prob_tab_buffer_offset.Address(), &entropy_probs, sizeof(entropy_probs));
+        memory_manager.ReadBlock(regs.vp9_prob_tab_buffer_offset.Address(), &entropy_probs,
+                                 sizeof(entropy_probs));
 
         auto WriteProb = [&](u8 prob) {
             bool coded = prob != 255;
@@ -406,7 +442,8 @@ void VP9::WriteSegmentation(VpxBitStreamWriter& writer) {
 }
 
 Vp9PictureInfo VP9::GetVp9PictureInfo() {
-    host1x.gmmu_manager.ReadBlock(regs.picture_info_offset.Address(), &current_picture_info, sizeof(PictureInfo));
+    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_picture_info,
+                             sizeof(PictureInfo));
     Vp9PictureInfo vp9_info = current_picture_info.Convert();
 
     InsertEntropy(regs.vp9_prob_tab_buffer_offset.Address(), vp9_info.entropy);
@@ -422,7 +459,7 @@ Vp9PictureInfo VP9::GetVp9PictureInfo() {
 
 void VP9::InsertEntropy(u64 offset, Vp9EntropyProbs& dst) {
     EntropyProbs entropy;
-    host1x.gmmu_manager.ReadBlock(offset, &entropy, sizeof(EntropyProbs));
+    memory_manager.ReadBlock(offset, &entropy, sizeof(EntropyProbs));
     entropy.Convert(dst);
 }
 
@@ -432,7 +469,9 @@ Vp9FrameContainer VP9::GetCurrentFrame() {
         // gpu.SyncGuestHost(); epic, why?
         current_frame.info = GetVp9PictureInfo();
         current_frame.bit_stream.resize(current_frame.info.bitstream_size);
-        host1x.gmmu_manager.ReadBlock(regs.frame_bitstream_offset.Address(), current_frame.bit_stream.data(), current_frame.info.bitstream_size);
+        memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(),
+                                 current_frame.bit_stream.data(),
+                                 current_frame.info.bitstream_size);
     }
     if (!next_frame.bit_stream.empty()) {
         Vp9FrameContainer temp{
@@ -854,9 +893,13 @@ std::span<const u8> VP9::ComposeFrame() {
     // Write headers and frame to buffer
     frame_scratch.resize(uncompressed_header.size() + compressed_header.size() + bitstream.size());
     std::copy(uncompressed_header.begin(), uncompressed_header.end(), frame_scratch.begin());
-    std::copy(compressed_header.begin(), compressed_header.end(), frame_scratch.begin() + uncompressed_header.size());
-    std::copy(bitstream.begin(), bitstream.end(), frame_scratch.begin() + uncompressed_header.size() + compressed_header.size());
+    std::copy(compressed_header.begin(), compressed_header.end(),
+              frame_scratch.begin() + uncompressed_header.size());
+    std::copy(bitstream.begin(), bitstream.end(),
+              frame_scratch.begin() + uncompressed_header.size() + compressed_header.size());
+
     vp9_hidden_frame = WasFrameHidden();
+
     return GetFrameBytes();
 }
 
@@ -886,7 +929,7 @@ void VpxRangeEncoder::Write(bool bit, s32 probability) {
         local_range = range - split;
     }
 
-    s32 shift = s32(local_range == 0 ? 0 : (std::countl_zero<uint32_t>(local_range) - 24));
+    s32 shift = static_cast<s32>(norm_lut[local_range]);
     local_range <<= shift;
     count += shift;
 

src/video_core/host1x/codecs/vp9.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -14,7 +11,7 @@
 #include "common/scratch_buffer.h"
 #include "common/stream.h"
 #include "video_core/host1x/codecs/decoder.h"
-#include "video_core/host1x/codec_types.h"
+#include "video_core/host1x/codecs/vp9_types.h"
 #include "video_core/host1x/nvdec_common.h"
 
 namespace Tegra {
@@ -116,7 +113,8 @@ private:
 
 class VP9 final : public Decoder {
 public:
-    explicit VP9(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id);
+    explicit VP9(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
+                 Host1x::FrameQueue& frame_queue);
     ~VP9() override;
 
     VP9(const VP9&) = delete;
@@ -195,10 +193,11 @@ private:
     [[nodiscard]] std::vector<u8> ComposeCompressedHeader();
     [[nodiscard]] VpxBitStreamWriter ComposeUncompressedHeader();
 
+    Common::ScratchBuffer<u8> frame_scratch;
+
     std::array<s8, 4> loop_filter_ref_deltas{};
     std::array<s8, 2> loop_filter_mode_deltas{};
 
-    Common::ScratchBuffer<u8> frame_scratch;
     Vp9FrameContainer next_frame{};
     std::array<Vp9EntropyProbs, 4> frame_ctxs{};
     bool swap_ref_indices{};

src/video_core/host1x/codecs/vp9_types.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,192 +6,12 @@
 #include <array>
 #include <vector>
 
-#include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Tegra {
 
 namespace Decoders {
-
-struct Offset {
-    constexpr u32 Address() const noexcept {
-        return offset << 8;
-    }
-
-private:
-    u32 offset;
-};
-static_assert(std::is_trivial_v<Offset>, "Offset must be trivial");
-static_assert(sizeof(Offset) == 0x4, "Offset has the wrong size!");
-
-struct H264ParameterSet {
-    s32 log2_max_pic_order_cnt_lsb_minus4; ///< 0x00
-    s32 delta_pic_order_always_zero_flag;  ///< 0x04
-    s32 frame_mbs_only_flag;               ///< 0x08
-    u32 pic_width_in_mbs;                  ///< 0x0C
-    u32 frame_height_in_mbs;               ///< 0x10
-    union {                                ///< 0x14
-        BitField<0, 2, u32> tile_format;
-        BitField<2, 3, u32> gob_height;
-        BitField<5, 27, u32> reserved_surface_format;
-    };
-    u32 entropy_coding_mode_flag;               ///< 0x18
-    s32 pic_order_present_flag;                 ///< 0x1C
-    s32 num_refidx_l0_default_active;           ///< 0x20
-    s32 num_refidx_l1_default_active;           ///< 0x24
-    s32 deblocking_filter_control_present_flag; ///< 0x28
-    s32 redundant_pic_cnt_present_flag;         ///< 0x2C
-    u32 transform_8x8_mode_flag;                ///< 0x30
-    u32 pitch_luma;                             ///< 0x34
-    u32 pitch_chroma;                           ///< 0x38
-    Offset luma_top_offset;                     ///< 0x3C
-    Offset luma_bot_offset;                     ///< 0x40
-    Offset luma_frame_offset;                   ///< 0x44
-    Offset chroma_top_offset;                   ///< 0x48
-    Offset chroma_bot_offset;                   ///< 0x4C
-    Offset chroma_frame_offset;                 ///< 0x50
-    u32 hist_buffer_size;                       ///< 0x54
-    union {                                     ///< 0x58
-        union {
-            BitField<0, 1, u64> mbaff_frame;
-            BitField<1, 1, u64> direct_8x8_inference;
-            BitField<2, 1, u64> weighted_pred;
-            BitField<3, 1, u64> constrained_intra_pred;
-            BitField<4, 1, u64> ref_pic;
-            BitField<5, 1, u64> field_pic;
-            BitField<6, 1, u64> bottom_field;
-            BitField<7, 1, u64> second_field;
-        } flags;
-        BitField<8, 4, u64> log2_max_frame_num_minus4;
-        BitField<12, 2, u64> chroma_format_idc;
-        BitField<14, 2, u64> pic_order_cnt_type;
-        BitField<16, 6, s64> pic_init_qp_minus26;
-        BitField<22, 5, s64> chroma_qp_index_offset;
-        BitField<27, 5, s64> second_chroma_qp_index_offset;
-        BitField<32, 2, u64> weighted_bipred_idc;
-        BitField<34, 7, u64> curr_pic_idx;
-        BitField<41, 5, u64> curr_col_idx;
-        BitField<46, 16, u64> frame_number;
-        BitField<62, 1, u64> frame_surfaces;
-        BitField<63, 1, u64> output_memory_layout;
-    };
-};
-static_assert(sizeof(H264ParameterSet) == 0x60, "H264ParameterSet is an invalid size");
-
-#define ASSERT_POSITION(field_name, position)                                                      \
-    static_assert(offsetof(H264ParameterSet, field_name) == position,                              \
-                  "Field " #field_name " has invalid position")
-
-ASSERT_POSITION(log2_max_pic_order_cnt_lsb_minus4, 0x00);
-ASSERT_POSITION(delta_pic_order_always_zero_flag, 0x04);
-ASSERT_POSITION(frame_mbs_only_flag, 0x08);
-ASSERT_POSITION(pic_width_in_mbs, 0x0C);
-ASSERT_POSITION(frame_height_in_mbs, 0x10);
-ASSERT_POSITION(tile_format, 0x14);
-ASSERT_POSITION(entropy_coding_mode_flag, 0x18);
-ASSERT_POSITION(pic_order_present_flag, 0x1C);
-ASSERT_POSITION(num_refidx_l0_default_active, 0x20);
-ASSERT_POSITION(num_refidx_l1_default_active, 0x24);
-ASSERT_POSITION(deblocking_filter_control_present_flag, 0x28);
-ASSERT_POSITION(redundant_pic_cnt_present_flag, 0x2C);
-ASSERT_POSITION(transform_8x8_mode_flag, 0x30);
-ASSERT_POSITION(pitch_luma, 0x34);
-ASSERT_POSITION(pitch_chroma, 0x38);
-ASSERT_POSITION(luma_top_offset, 0x3C);
-ASSERT_POSITION(luma_bot_offset, 0x40);
-ASSERT_POSITION(luma_frame_offset, 0x44);
-ASSERT_POSITION(chroma_top_offset, 0x48);
-ASSERT_POSITION(chroma_bot_offset, 0x4C);
-ASSERT_POSITION(chroma_frame_offset, 0x50);
-ASSERT_POSITION(hist_buffer_size, 0x54);
-ASSERT_POSITION(flags, 0x58);
-#undef ASSERT_POSITION
-
-struct DpbEntry {
-    union {
-        BitField<0, 7, u32> index;
-        BitField<7, 5, u32> col_idx;
-        BitField<12, 2, u32> state;
-        BitField<14, 1, u32> is_long_term;
-        BitField<15, 1, u32> non_existing;
-        BitField<16, 1, u32> is_field;
-        BitField<17, 4, u32> top_field_marking;
-        BitField<21, 4, u32> bottom_field_marking;
-        BitField<25, 1, u32> output_memory_layout;
-        BitField<26, 6, u32> reserved;
-    } flags;
-    std::array<u32, 2> field_order_cnt;
-    u32 frame_idx;
-};
-static_assert(sizeof(DpbEntry) == 0x10, "DpbEntry has the wrong size!");
-
-struct DisplayParam {
-    union {
-        BitField<0, 1, u32> enable_tf_output;
-        BitField<1, 1, u32> vc1_map_y_flag;
-        BitField<2, 3, u32> map_y_value;
-        BitField<5, 1, u32> vc1_map_uv_flag;
-        BitField<6, 3, u32> map_uv_value;
-        BitField<9, 8, u32> out_stride;
-        BitField<17, 3, u32> tiling_format;
-        BitField<20, 1, u32> output_structure; // 0=frame, 1=field
-        BitField<21, 11, u32> reserved0;
-    };
-    std::array<s32, 2> output_top;
-    std::array<s32, 2> output_bottom;
-    union {
-        BitField<0, 1, u32> enable_histogram;
-        BitField<1, 12, u32> histogram_start_x;
-        BitField<13, 12, u32> histogram_start_y;
-        BitField<25, 7, u32> reserved1;
-    };
-    union {
-        BitField<0, 12, u32> histogram_end_x;
-        BitField<12, 12, u32> histogram_end_y;
-        BitField<24, 8, u32> reserved2;
-    };
-};
-static_assert(sizeof(DisplayParam) == 0x1C, "DisplayParam has the wrong size!");
-
-struct H264DecoderContext {
-    INSERT_PADDING_WORDS_NOINIT(13);                        ///< 0x0000
-    std::array<u8, 16> eos;                                 ///< 0x0034
-    u8 explicit_eos_present_flag;                           ///< 0x0044
-    u8 hint_dump_en;                                        ///< 0x0045
-    INSERT_PADDING_BYTES_NOINIT(2);                         ///< 0x0046
-    u32 stream_len;                                         ///< 0x0048
-    u32 slice_count;                                        ///< 0x004C
-    u32 mbhist_buffer_size;                                 ///< 0x0050
-    u32 gptimer_timeout_value;                              ///< 0x0054
-    H264ParameterSet h264_parameter_set;                    ///< 0x0058
-    std::array<s32, 2> curr_field_order_cnt;                ///< 0x00B8
-    std::array<DpbEntry, 16> dpb;                           ///< 0x00C0
-    std::array<u8, 0x60> weight_scale_4x4;                  ///< 0x01C0
-    std::array<u8, 0x80> weight_scale_8x8;                  ///< 0x0220
-    std::array<u8, 2> num_inter_view_refs_lX;               ///< 0x02A0
-    std::array<u8, 14> reserved2;                           ///< 0x02A2
-    std::array<std::array<s8, 16>, 2> inter_view_refidx_lX; ///< 0x02B0
-    union {                                                 ///< 0x02D0
-        BitField<0, 1, u32> lossless_ipred8x8_filter_enable;
-        BitField<1, 1, u32> qpprime_y_zero_transform_bypass_flag;
-        BitField<2, 30, u32> reserved3;
-    };
-    DisplayParam display_param;   ///< 0x02D4
-    std::array<u32, 3> reserved4; ///< 0x02F0
-};
-static_assert(sizeof(H264DecoderContext) == 0x2FC, "H264DecoderContext is an invalid size");
-
-#define ASSERT_POSITION(field_name, position)                                                      \
-    static_assert(offsetof(H264DecoderContext, field_name) == position,                            \
-                  "Field " #field_name " has invalid position")
-
-ASSERT_POSITION(stream_len, 0x48);
-ASSERT_POSITION(h264_parameter_set, 0x58);
-ASSERT_POSITION(dpb, 0xC0);
-ASSERT_POSITION(weight_scale_4x4, 0x1C0);
-#undef ASSERT_POSITION
-
 enum class Vp9SurfaceIndex : u32 {
     Last = 0,
     Golden = 1,
@@ -470,7 +287,10 @@ struct RefPoolElement {
     bool refresh{};
 };
 
-#define ASSERT_POSITION(field_name, position) static_assert(offsetof(Vp9EntropyProbs, field_name) == position)
+#define ASSERT_POSITION(field_name, position)                                                      \
+    static_assert(offsetof(Vp9EntropyProbs, field_name) == position,                               \
+                  "Field " #field_name " has invalid position")
+
 ASSERT_POSITION(partition_prob, 0x0024);
 ASSERT_POSITION(switchable_interp_prob, 0x0724);
 ASSERT_POSITION(sign, 0x0772);
@@ -478,7 +298,10 @@ ASSERT_POSITION(class_0_fr, 0x079E);
 ASSERT_POSITION(high_precision, 0x07B2);
 #undef ASSERT_POSITION
 
-#define ASSERT_POSITION(field_name, position) static_assert(offsetof(PictureInfo, field_name) == position)
+#define ASSERT_POSITION(field_name, position)                                                      \
+    static_assert(offsetof(PictureInfo, field_name) == position,                                   \
+                  "Field " #field_name " has invalid position")
+
 ASSERT_POSITION(bitstream_size, 0x30);
 ASSERT_POSITION(last_frame_size, 0x48);
 ASSERT_POSITION(first_level, 0x70);
@@ -486,7 +309,9 @@ ASSERT_POSITION(segmentation, 0x80);
 ASSERT_POSITION(loop_filter, 0xE4);
 #undef ASSERT_POSITION
 
-#define ASSERT_POSITION(field_name, position) static_assert(offsetof(EntropyProbs, field_name) == position)
+#define ASSERT_POSITION(field_name, position)                                                      \
+    static_assert(offsetof(EntropyProbs, field_name) == position,                                  \
+                  "Field " #field_name " has invalid position")
 
 ASSERT_POSITION(inter_mode_prob, 0x400);
 ASSERT_POSITION(tx_8x8_prob, 0x470);
@@ -496,47 +321,5 @@ ASSERT_POSITION(class_0_fr, 0x560);
 ASSERT_POSITION(coef_probs, 0x5A0);
 #undef ASSERT_POSITION
 
-struct VP8PictureInfo {
-    INSERT_PADDING_WORDS_NOINIT(14);
-    u16 frame_width;  // actual frame width
-    u16 frame_height; // actual frame height
-    u8 key_frame;
-    u8 version;
-    union {
-        u8 raw;
-        BitField<0, 2, u8> tile_format;
-        BitField<2, 3, u8> gob_height;
-        BitField<5, 3, u8> reserved_surface_format;
-    };
-    u8 error_conceal_on;  // 1: error conceal on; 0: off
-    u32 first_part_size;  // the size of first partition(frame header and mb header partition)
-    u32 hist_buffer_size; // in units of 256
-    u32 vld_buffer_size;  // in units of 1
-    // Current frame buffers
-    std::array<u32, 2> frame_stride; // [y_c]
-    u32 luma_top_offset;             // offset of luma top field in units of 256
-    u32 luma_bot_offset;             // offset of luma bottom field in units of 256
-    u32 luma_frame_offset;           // offset of luma frame in units of 256
-    u32 chroma_top_offset;           // offset of chroma top field in units of 256
-    u32 chroma_bot_offset;           // offset of chroma bottom field in units of 256
-    u32 chroma_frame_offset;         // offset of chroma frame in units of 256
-
-    INSERT_PADDING_BYTES_NOINIT(0x1c); // NvdecDisplayParams
-
-    // Decode picture buffer related
-    s8 current_output_memory_layout;
-    // output NV12/NV24 setting. index 0: golden; 1: altref; 2: last
-    std::array<s8, 3> output_memory_layout;
-
-    u8 segmentation_feature_data_update;
-    INSERT_PADDING_BYTES_NOINIT(3);
-
-    // ucode return result
-    u32 result_value;
-    std::array<u32, 8> partition_offset;
-    INSERT_PADDING_WORDS_NOINIT(3);
-};
-static_assert(sizeof(VP8PictureInfo) == 0xc0, "PictureInfo is an invalid size");
-
 }; // namespace Decoders
 }; // namespace Tegra

src/video_core/host1x/ffmpeg/ffmpeg.cpp

@@ -9,7 +9,7 @@
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "core/memory.h"
-#include "video_core/host1x/ffmpeg.h"
+#include "video_core/host1x/ffmpeg/ffmpeg.h"
 #include "video_core/memory_manager.h"
 
 extern "C" {
@@ -34,9 +34,7 @@ constexpr std::array PreferredGpuDecoders = {
     AV_HWDEVICE_TYPE_DXVA2,
     AV_HWDEVICE_TYPE_D3D12VA,
 #elif defined(__FreeBSD__)
-    AV_HWDEVICE_TYPE_VAAPI,
     AV_HWDEVICE_TYPE_VDPAU,
-    AV_HWDEVICE_TYPE_DRM,
 #elif defined(__APPLE__)
     AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
 #elif defined(ANDROID)
@@ -107,17 +105,18 @@ Frame::~Frame() {
 Decoder::Decoder(Tegra::Host1x::NvdecCommon::VideoCodec codec) {
     const AVCodecID av_codec = [&] {
         switch (codec) {
-        case Tegra::Host1x::NvdecCommon::VideoCodec::H264:
-            return AV_CODEC_ID_H264;
-        case Tegra::Host1x::NvdecCommon::VideoCodec::VP8:
-            return AV_CODEC_ID_VP8;
-        case Tegra::Host1x::NvdecCommon::VideoCodec::VP9:
-            return AV_CODEC_ID_VP9;
-        default:
-            UNIMPLEMENTED_MSG("Unknown codec {}", codec);
-            return AV_CODEC_ID_NONE;
+            case Tegra::Host1x::NvdecCommon::VideoCodec::H264:
+                return AV_CODEC_ID_H264;
+            case Tegra::Host1x::NvdecCommon::VideoCodec::VP8:
+                return AV_CODEC_ID_VP8;
+            case Tegra::Host1x::NvdecCommon::VideoCodec::VP9:
+                return AV_CODEC_ID_VP9;
+            default:
+                UNIMPLEMENTED_MSG("Unknown codec {}", codec);
+                return AV_CODEC_ID_NONE;
         }
     }();
+
     m_codec = avcodec_find_decoder(av_codec);
 }
 

src/video_core/host1x/ffmpeg/ffmpeg.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project

src/video_core/host1x/host1x.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
@@ -12,12 +12,9 @@
 namespace Tegra::Host1x {
 
 Host1x::Host1x(Core::System& system_)
-    : system{system_}
-    , syncpoint_manager{}
-    , memory_manager(system.DeviceMemory())
-    , gmmu_manager{system, memory_manager, 32, 0, 12}
-    , allocator{1 << 12}
-{}
+    : system{system_}, syncpoint_manager{},
+      memory_manager(system.DeviceMemory()), gmmu_manager{system, memory_manager, 32, 0, 12},
+      allocator{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {}
 
 Host1x::~Host1x() = default;
 
@@ -27,13 +24,13 @@ void Host1x::StartDevice(s32 fd, ChannelType type, u32 syncpt) {
 #ifdef YUZU_LEGACY
         std::call_once(nvdec_first_init, []() {std::this_thread::sleep_for(std::chrono::milliseconds{500});}); // HACK: For Astroneer
 #endif
-        devices[fd] = std::make_unique<Tegra::Host1x::Nvdec>(*this, fd, syncpt);
+        devices[fd] = std::make_unique<Tegra::Host1x::Nvdec>(*this, fd, syncpt, frame_queue);
         break;
     case ChannelType::VIC:
 #ifdef YUZU_LEGACY
         std::call_once(vic_first_init, []() {std::this_thread::sleep_for(std::chrono::milliseconds{500});}); // HACK: For Astroneer
 #endif
-        devices[fd] = std::make_unique<Tegra::Host1x::Vic>(*this, fd, syncpt);
+        devices[fd] = std::make_unique<Tegra::Host1x::Vic>(*this, fd, syncpt, frame_queue);
         break;
     default:
         LOG_ERROR(HW_GPU, "Unimplemented host1x device {}", static_cast<u32>(type));

src/video_core/host1x/host1x.h

@@ -184,12 +184,20 @@ public:
         return memory_manager;
     }
 
+    Tegra::MemoryManager& GMMU() {
+        return gmmu_manager;
+    }
+
+    const Tegra::MemoryManager& GMMU() const {
+        return gmmu_manager;
+    }
+
     Common::FlatAllocator<u32, 0, 32>& Allocator() {
-        return allocator;
+        return *allocator;
     }
 
     const Common::FlatAllocator<u32, 0, 32>& Allocator() const {
-        return allocator;
+        return *allocator;
     }
 
     void StartDevice(s32 fd, ChannelType type, u32 syncpt);
@@ -203,11 +211,12 @@ public:
         it->second->PushEntries(std::move(entries));
     }
 
+private:
     Core::System& system;
     SyncpointManager syncpoint_manager;
     Tegra::MaxwellDeviceMemoryManager memory_manager;
     Tegra::MemoryManager gmmu_manager;
-    Common::FlatAllocator<u32, 0, 32> allocator;
+    std::unique_ptr<Common::FlatAllocator<u32, 0, 32>> allocator;
     FrameQueue frame_queue;
     ankerl::unordered_dense::map<s32, std::unique_ptr<CDmaPusher>> devices;
 #ifdef YUZU_LEGACY

src/video_core/host1x/nvdec.cpp

@@ -1,10 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <variant>
 #include "common/assert.h"
 
 #include "common/polyfill_thread.h"
@@ -20,13 +19,10 @@ namespace Tegra::Host1x {
 #define NVDEC_REG_INDEX(field_name)                                                                \
     (offsetof(NvdecCommon::NvdecRegisters, field_name) / sizeof(u64))
 
-Nvdec::Nvdec(Host1x& host1x_, s32 id_, u32 syncpt)
-    : CDmaPusher{host1x_, id_}
-    , id{id_}
-    , syncpoint{syncpt}
-{
+Nvdec::Nvdec(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_)
+    : CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt}, frame_queue{frame_queue_} {
     LOG_INFO(HW_GPU, "Created nvdec {}", id);
-    host1x.frame_queue.Open(id);
+    frame_queue.Open(id);
 }
 
 Nvdec::~Nvdec() {
@@ -47,22 +43,24 @@ void Nvdec::ProcessMethod(u32 method, u32 argument) {
 }
 
 void Nvdec::CreateDecoder(NvdecCommon::VideoCodec codec) {
-    if (std::holds_alternative<std::monostate>(decoder)) {
-        switch (codec) {
-        case NvdecCommon::VideoCodec::H264:
-            decoder.emplace<Decoders::H264>(host1x, regs, id);
-            break;
-        case NvdecCommon::VideoCodec::VP8:
-            decoder.emplace<Decoders::VP8>(host1x, regs, id);
-            break;
-        case NvdecCommon::VideoCodec::VP9:
-            decoder.emplace<Decoders::VP9>(host1x, regs, id);
-            break;
-        default:
-            break;
-        }
-        LOG_INFO(HW_GPU, "Created decoder {} for id {}", codec, id);
+    if (decoder.get()) {
+        return;
     }
+    switch (codec) {
+    case NvdecCommon::VideoCodec::H264:
+        decoder = std::make_unique<Decoders::H264>(host1x, regs, id, frame_queue);
+        break;
+    case NvdecCommon::VideoCodec::VP8:
+        decoder = std::make_unique<Decoders::VP8>(host1x, regs, id, frame_queue);
+        break;
+    case NvdecCommon::VideoCodec::VP9:
+        decoder = std::make_unique<Decoders::VP9>(host1x, regs, id, frame_queue);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Codec {}", decoder->GetCurrentCodecName());
+        break;
+    }
+    LOG_INFO(HW_GPU, "Created decoder {} for id {}", decoder->GetCurrentCodecName(), id);
 }
 
 void Nvdec::Execute() {
@@ -72,14 +70,15 @@ void Nvdec::Execute() {
         std::this_thread::sleep_for(std::chrono::milliseconds(8));
         return;
     }
-    if (auto* h264 = std::get_if<Decoders::H264>(&decoder)) {
-        h264->Decode();
-    } else if (auto* vp8 = std::get_if<Decoders::VP8>(&decoder)) {
-        vp8->Decode();
-    } else if (auto* vp9 = std::get_if<Decoders::VP9>(&decoder)) {
-        vp9->Decode();
-    } else {
-        LOG_ERROR(HW_GPU, "Unrecognized codec executed?");
+    switch (decoder->GetCurrentCodec()) {
+    case NvdecCommon::VideoCodec::H264:
+    case NvdecCommon::VideoCodec::VP8:
+    case NvdecCommon::VideoCodec::VP9:
+        decoder->Decode();
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Codec {}", decoder->GetCurrentCodecName());
+        break;
     }
 }
 

src/video_core/host1x/nvdec.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -8,14 +8,10 @@
 
 #include <memory>
 #include <vector>
-#include <variant>
 
 #include "common/common_types.h"
 #include "video_core/cdma_pusher.h"
 #include "video_core/host1x/codecs/decoder.h"
-#include "video_core/host1x/codecs/h264.h"
-#include "video_core/host1x/codecs/vp8.h"
-#include "video_core/host1x/codecs/vp9.h"
 
 namespace Tegra {
 
@@ -25,7 +21,7 @@ class FrameQueue;
 
 class Nvdec final : public CDmaPusher {
 public:
-    explicit Nvdec(Host1x& host1x, s32 id, u32 syncpt);
+    explicit Nvdec(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue_);
     ~Nvdec();
 
     /// Writes the method into the state, Invoke Execute() if encountered
@@ -42,15 +38,12 @@ private:
     /// Invoke codec to decode a frame
     void Execute();
 
-    NvdecCommon::NvdecRegisters regs{};
-    std::variant<
-        Decoders::H264,
-        Decoders::VP8,
-        Decoders::VP9,
-        std::monostate
-    > decoder = std::monostate{};
     s32 id;
     u32 syncpoint;
+    FrameQueue& frame_queue;
+
+    NvdecCommon::NvdecRegisters regs{};
+    std::unique_ptr<Decoder> decoder;
 };
 
 } // namespace Host1x

src/video_core/host1x/vic.cpp

@@ -85,17 +85,18 @@ void SwizzleSurface(std::span<u8> output, u32 out_stride, std::span<const u8> in
 
 } // namespace
 
-Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt) noexcept
-    : CDmaPusher{host1x_, id_}
+Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_) noexcept :
+    CDmaPusher{host1x_, id_}
     , id{id_}
     , syncpoint{syncpt}
+    , frame_queue{frame_queue_}
 {
     LOG_INFO(HW_GPU, "Created vic {}", id);
 }
 
 Vic::~Vic() noexcept {
     LOG_INFO(HW_GPU, "Destroying vic {}", id);
-    host1x.frame_queue.Close(id);
+    frame_queue.Close(id);
 }
 
 void Vic::ProcessMethod(u32 method, u32 arg) noexcept {
@@ -112,7 +113,7 @@ void Vic::ProcessMethod(u32 method, u32 arg) noexcept {
 
 void Vic::Execute() noexcept {
     ConfigStruct config{};
-    host1x.gmmu_manager.ReadBlock(regs.config_struct_offset.Address(), &config, sizeof(ConfigStruct));
+    memory_manager.ReadBlock(regs.config_struct_offset.Address(), &config, sizeof(ConfigStruct));
 
     auto output_width = config.output_surface_config.out_surface_width + 1;
     auto output_height = config.output_surface_config.out_surface_height + 1;
@@ -123,8 +124,8 @@ void Vic::Execute() noexcept {
             if (auto& slot_config = config.slot_structs[i]; slot_config.config.slot_enable) {
                 auto const luma_offset = regs.surfaces[i][SurfaceIndex::Current].luma.Address();
                 if (nvdec_id == -1)
-                    nvdec_id = host1x.frame_queue.VicFindNvdecFdFromOffset(luma_offset);
-                if (auto frame = host1x.frame_queue.GetFrame(nvdec_id, luma_offset); frame.get()) {
+                    nvdec_id = frame_queue.VicFindNvdecFdFromOffset(luma_offset);
+                if (auto frame = frame_queue.GetFrame(nvdec_id, luma_offset); frame.get()) {
                     switch (frame->GetPixelFormat()) {
                     case AV_PIX_FMT_YUV420P:
                         ReadY8__V8U8_N420(slot_config, regs.surfaces[i], std::move(frame), true);
@@ -880,8 +881,8 @@ void Vic::WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) n
         chroma_scratch.resize_destructive(out_chroma_size);
         Decode(luma_scratch.data(), chroma_scratch.data());
 
-        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(host1x.gmmu_manager, regs.output_surface.luma.Address(), out_luma_swizzle_size, &swizzle_scratch);
-        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_chroma(host1x.gmmu_manager, regs.output_surface.chroma_u.Address(), out_chroma_swizzle_size, &swizzle_scratch);
+        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(memory_manager, regs.output_surface.luma.Address(), out_luma_swizzle_size, &swizzle_scratch);
+        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_chroma(memory_manager, regs.output_surface.chroma_u.Address(), out_chroma_swizzle_size, &swizzle_scratch);
         if (block_height == 1) {
             SwizzleSurface(out_luma, out_luma_stride, luma_scratch, out_luma_stride, out_luma_height);
             SwizzleSurface(out_chroma, out_chroma_stride, chroma_scratch, out_chroma_stride, out_chroma_height);
@@ -909,8 +910,8 @@ void Vic::WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) n
         luma_scratch.resize_destructive(out_luma_size);
         chroma_scratch.resize_destructive(out_chroma_size);
         Decode(luma_scratch.data(), chroma_scratch.data());
-        host1x.gmmu_manager.WriteBlock(regs.output_surface.luma.Address(), luma_scratch.data(), out_luma_size);
-        host1x.gmmu_manager.WriteBlock(regs.output_surface.chroma_u.Address(), chroma_scratch.data(), out_chroma_size);
+        memory_manager.WriteBlock(regs.output_surface.luma.Address(), luma_scratch.data(), out_luma_size);
+        memory_manager.WriteBlock(regs.output_surface.chroma_u.Address(), chroma_scratch.data(), out_chroma_size);
     } break;
     default:
         UNREACHABLE();
@@ -1045,7 +1046,7 @@ void Vic::WriteABGR(const OutputSurfaceConfig& output_surface_config, VideoPixel
         luma_scratch.resize_destructive(out_luma_size);
         Decode(luma_scratch.data(), output_surface.data());
 
-        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(host1x.gmmu_manager, regs.output_surface.luma.Address(), out_swizzle_size, &swizzle_scratch);
+        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(memory_manager, regs.output_surface.luma.Address(), out_swizzle_size, &swizzle_scratch);
         if (block_height == 1) {
             SwizzleSurface(out_luma, out_luma_stride, luma_scratch, out_luma_stride, out_luma_height);
         } else {
@@ -1060,7 +1061,7 @@ void Vic::WriteABGR(const OutputSurfaceConfig& output_surface_config, VideoPixel
             surface_stride * surface_height * BytesPerPixel, out_luma_width, out_luma_height,
             out_luma_stride, out_luma_size);
         luma_scratch.resize_destructive(out_luma_size);
-        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(host1x.gmmu_manager, regs.output_surface.luma.Address(), out_luma_size, &luma_scratch);
+        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(memory_manager, regs.output_surface.luma.Address(), out_luma_size, &luma_scratch);
         Decode(out_luma.data(), output_surface.data());
     } break;
     default:

src/video_core/host1x/vic.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -15,7 +15,6 @@
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
 #include "video_core/cdma_pusher.h"
-#include "video_core/host1x/host1x.h"
 
 namespace Tegra::Host1x {
 class Host1x;
@@ -606,7 +605,7 @@ public:
         SetOutputSurfaceChromaUnusedOffset = offsetof(VicRegisters, output_surface.chroma_v)
     };
 
-    explicit Vic(Host1x& host1x, s32 id, u32 syncpt) noexcept;
+    explicit Vic(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue) noexcept;
     ~Vic() noexcept;
 
     /// Write to the device state.
@@ -621,17 +620,18 @@ private:
     void WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config) noexcept;
     void WriteABGR(const OutputSurfaceConfig& output_surface_config, VideoPixelFormat format) noexcept;
 
+    s32 id;
+    s32 nvdec_id{-1};
+    u32 syncpoint;
+
     VicRegisters regs{};
+    FrameQueue& frame_queue;
 
     Common::ScratchBuffer<u8> swizzle_scratch;
     Common::ScratchBuffer<Pixel> output_surface;
     Common::ScratchBuffer<Pixel> slot_surface;
     Common::ScratchBuffer<u8> luma_scratch;
     Common::ScratchBuffer<u8> chroma_scratch;
-
-    s32 id;
-    s32 nvdec_id{-1};
-    u32 syncpoint;
 };
 
 } // namespace Tegra::Host1x

src/video_core/host_shaders/resolve_conditional_render.comp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -8,22 +5,16 @@
 
 layout(local_size_x = 1) in;
 
-layout(std430, binding = 0) readonly buffer Query {
-    uint data[];
+layout(std430, binding = 0) buffer Query {
+    uvec2 initial;
+    uvec2 unknown;
+    uvec2 current;
 };
 
-layout(std430, binding = 1) writeonly buffer Result {
+layout(std430, binding = 1) buffer Result {
     uint result;
 };
 
-layout(push_constant) uniform PushConstants {
-    uint compare_to_zero;
-};
-
 void main() {
-    if (compare_to_zero != 0u) {
-        result = (data[0] != 0u && data[1] != 0u) ? 1u : 0u;
-    } else {
-        result = (data[0] == data[4] && data[1] == data[5]) ? 1u : 0u;
-    }
+    result = all(equal(initial, current)) ? 1 : 0;
 }

src/video_core/macro.cpp

@@ -285,11 +285,11 @@ void HLE_MultiDrawIndexedIndirectCount::Fallback(Engines::Maxwell3D& maxwell3d,
 }
 void HLE_DrawIndirectByteCount::Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method) {
     const bool force = maxwell3d.Rasterizer().HasDrawTransformFeedback();
-    if (!force) {
+    auto topology = Maxwell3D::Regs::PrimitiveTopology(parameters[0] & 0xFFFFU);
+    if (!force && (!maxwell3d.AnyParametersDirty() || !IsTopologySafe(topology))) {
         Fallback(maxwell3d, parameters);
         return;
     }
-    auto topology = Maxwell3D::Regs::PrimitiveTopology(parameters[0] & 0xFFFFU);
     auto& params = maxwell3d.draw_manager->GetIndirectParams();
     params.is_byte_count = true;
     params.is_indexed = false;

src/video_core/query_cache/query_cache.h

@@ -412,7 +412,6 @@ bool QueryCacheBase<Traits>::AccelerateHostConditionalRendering() {
                     .found_query = nullptr,
                 };
             }
-            it_current = it_current_2;
         }
         auto* query = impl->ObtainQuery(it_current->second);
         qc_dirty |= True(query->flags & QueryFlagBits::IsHostManaged) &&

src/video_core/query_cache/query_stream.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -78,7 +75,7 @@ public:
     }
 
     u64 GetDependentMask() const {
-        return dependent_mask;
+        return dependence_mask;
     }
 
     u64 GetAmendValue() const {

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -629,9 +629,6 @@ void RasterizerOpenGL::ReleaseFences(bool force) {
 
 void RasterizerOpenGL::FlushAndInvalidateRegion(DAddr addr, u64 size,
                                                 VideoCommon::CacheType which) {
-    if (Settings::IsGPULevelHigh()) {
-        FlushRegion(addr, size, which);
-    }
     InvalidateRegion(addr, size, which);
 }
 

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -190,7 +190,9 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
             }
         }
     }
-    dynamic_state.Refresh3(regs, features);
+    if (!extended_dynamic_state_3_enables) {
+        dynamic_state.Refresh3(regs);
+    }
     if (xfb_enabled) {
         RefreshXfbState(xfb_state, regs);
     }
@@ -293,22 +295,16 @@ void FixedPipelineState::DynamicState::Refresh2(const Maxwell& regs,
     depth_bias_enable.Assign(enabled_lut[POLYGON_OFFSET_ENABLE_LUT[topology_index]] != 0 ? 1 : 0);
 }
 
-void FixedPipelineState::DynamicState::Refresh3(const Maxwell& regs,
-                                                const DynamicFeatures& features) {
-    if (!features.has_dynamic_state3_logic_op_enable) {
-        logic_op_enable.Assign(regs.logic_op.enable != 0 ? 1 : 0);
-    }
-    if (!features.has_dynamic_state3_depth_clamp_enable) {
-        depth_clamp_disabled.Assign(regs.viewport_clip_control.geometry_clip ==
-                                        Maxwell::ViewportClipControl::GeometryClip::Passthrough ||
-                                    regs.viewport_clip_control.geometry_clip ==
-                                        Maxwell::ViewportClipControl::GeometryClip::FrustumXYZ ||
-                                    regs.viewport_clip_control.geometry_clip ==
-                                        Maxwell::ViewportClipControl::GeometryClip::FrustumZ);
-    }
-    if (!features.has_dynamic_state3_line_stipple_enable) {
-        line_stipple_enable.Assign(regs.line_stipple_enable);
-    }
+void FixedPipelineState::DynamicState::Refresh3(const Maxwell& regs) {
+    logic_op_enable.Assign(regs.logic_op.enable != 0 ? 1 : 0);
+    depth_clamp_disabled.Assign(regs.viewport_clip_control.geometry_clip ==
+                                    Maxwell::ViewportClipControl::GeometryClip::Passthrough ||
+                                regs.viewport_clip_control.geometry_clip ==
+                                    Maxwell::ViewportClipControl::GeometryClip::FrustumXYZ ||
+                                regs.viewport_clip_control.geometry_clip ==
+                                    Maxwell::ViewportClipControl::GeometryClip::FrustumZ);
+
+    line_stipple_enable.Assign(regs.line_stipple_enable);
 }
 
 size_t FixedPipelineState::Hash() const noexcept {

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -27,9 +27,6 @@ struct DynamicFeatures {
     bool has_extended_dynamic_state_2_patch_control_points;
     bool has_extended_dynamic_state_3_blend;
     bool has_extended_dynamic_state_3_enables;
-    bool has_dynamic_state3_depth_clamp_enable;
-    bool has_dynamic_state3_logic_op_enable;
-    bool has_dynamic_state3_line_stipple_enable;
     bool has_dynamic_vertex_input;
     bool has_provoking_vertex;
     bool has_provoking_vertex_first_mode;
@@ -178,7 +175,7 @@ struct FixedPipelineState {
         void Refresh(const Maxwell& regs);
         void Refresh2(const Maxwell& regs, Maxwell::PrimitiveTopology topology,
                       bool base_features_supported);
-        void Refresh3(const Maxwell& regs, const DynamicFeatures& features);
+        void Refresh3(const Maxwell& regs);
 
         Maxwell::ComparisonOp DepthTestFunc() const noexcept {
             return UnpackComparisonOp(depth_test_func);
@@ -268,7 +265,8 @@ struct FixedPipelineState {
             return sizeof(*this);
         }
         if (dynamic_vertex_input && extended_dynamic_state_3_blend) {
-            return offsetof(FixedPipelineState, attachments);
+            // Exclude dynamic state and attributes
+            return offsetof(FixedPipelineState, dynamic_state);
         }
         if (dynamic_vertex_input) {
             // Exclude dynamic state

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -8,7 +8,6 @@
 #include <array>
 #include <cstring>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <vector>
@@ -172,11 +171,7 @@ try
 
 RendererVulkan::~RendererVulkan() {
     scheduler.RegisterOnSubmit([] {});
-    scheduler.Finish();
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        void(device.GetLogical().WaitIdle());
-    }
+    void(device.GetLogical().WaitIdle());
 }
 
 void RendererVulkan::Composite(std::span<const Tegra::FramebufferConfig> framebuffers) {

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -8,7 +8,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <vulkan/vulkan_core.h>
-#include <mutex>
 #include "video_core/framebuffer_config.h"
 #include "video_core/present.h"
 #include "video_core/renderer_vulkan/present/filters.h"
@@ -32,10 +31,7 @@ BlitScreen::~BlitScreen() = default;
 void BlitScreen::WaitIdle() {
     present_manager.WaitPresent();
     scheduler.Finish();
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        device.GetLogical().WaitIdle();
-    }
+    device.GetLogical().WaitIdle();
 }
 
 void BlitScreen::SetWindowAdaptPass() {

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -637,10 +637,12 @@ void BufferCacheRuntime::BindTransformFeedbackBuffers(VideoCommon::HostBindings<
     for (u32 i = 0; i < bindings.buffers.size(); ++i) {
         auto handle = bindings.buffers[i]->Handle();
         if (handle == VK_NULL_HANDLE) {
-            ReserveNullBuffer();
-            handle = *null_buffer;
             bindings.offsets[i] = 0;
-            bindings.sizes[i] = 0;
+            bindings.sizes[i] = VK_WHOLE_SIZE;
+            if (!device.HasNullDescriptor()) {
+                ReserveNullBuffer();
+                handle = *null_buffer;
+            }
         }
         buffer_handles[i] = handle;
     }

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -228,10 +228,6 @@ struct QueriesPrefixScanPushConstants {
     u32 accumulation_limit;
     u32 buffer_offset;
 };
-
-struct ConditionalRenderingResolvePushConstants {
-    u32 compare_to_zero;
-};
 } // Anonymous namespace
 
 ComputePass::ComputePass(const Device& device_, DescriptorPool& descriptor_pool,
@@ -417,8 +413,7 @@ ConditionalRenderingResolvePass::ConditionalRenderingResolvePass(
     const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
     ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
     : ComputePass(device_, descriptor_pool_, INPUT_OUTPUT_DESCRIPTOR_SET_BINDINGS,
-                  INPUT_OUTPUT_DESCRIPTOR_UPDATE_TEMPLATE, INPUT_OUTPUT_BANK_INFO,
-                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(ConditionalRenderingResolvePushConstants)>,
+                  INPUT_OUTPUT_DESCRIPTOR_UPDATE_TEMPLATE, INPUT_OUTPUT_BANK_INFO, nullptr,
                   RESOLVE_CONDITIONAL_RENDER_COMP_SPV),
       scheduler{scheduler_}, compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
 
@@ -435,7 +430,7 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
     const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([this, descriptor_data, compare_to_zero](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([this, descriptor_data](vk::CommandBuffer cmdbuf) {
         static constexpr VkMemoryBarrier read_barrier{
             .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
             .pNext = nullptr,
@@ -448,9 +443,6 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
             .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
             .dstAccessMask = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
         };
-        const ConditionalRenderingResolvePushConstants uniforms{
-            .compare_to_zero = compare_to_zero ? 1U : 0U,
-        };
         const VkDescriptorSet set = descriptor_allocator.Commit();
         device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
 
@@ -458,11 +450,9 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
                                VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, read_barrier);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
-        cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
         cmdbuf.Dispatch(1, 1, 1);
         cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                               VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, 0,
-                               write_barrier);
+                               VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
     });
 }
 
@@ -530,7 +520,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
             const VkDescriptorSet set = descriptor_allocator.Commit();
             device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
 
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, read_barrier);
             cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
             cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -467,10 +467,6 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         bind_stage_info(4);
     }
 
-    if (regs.transform_feedback_enabled != 0) {
-        scheduler.RequestOutsideRenderPassOperationContext();
-    }
-
     buffer_cache.UpdateGraphicsBuffers(is_indexed);
     buffer_cache.BindHostGeometryBuffers(is_indexed);
 

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -485,12 +485,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         device.IsExtExtendedDynamicState3BlendingSupported();
     dynamic_features.has_extended_dynamic_state_3_enables =
         device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable =
-        device.SupportsDynamicState3DepthClampEnable();
-    dynamic_features.has_dynamic_state3_logic_op_enable =
-        device.SupportsDynamicState3LogicOpEnable();
-    dynamic_features.has_dynamic_state3_line_stipple_enable =
-        device.SupportsDynamicState3LineStippleEnable();
 
     // VIDS: Independent toggle (not affected by dyna_state levels)
     dynamic_features.has_dynamic_vertex_input =

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -189,7 +189,7 @@ void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat
     frame->image = memory_allocator.CreateImage({
         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
         .pNext = nullptr,
-        .flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+        .flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
         .imageType = VK_IMAGE_TYPE_2D,
         .format = swapchain.GetImageFormat(),
         .extent =

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -157,9 +157,8 @@ public:
         ReserveHostQuery();
 
         scheduler.Record([query_pool = current_query_pool,
-                          query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
+                                 query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
             const bool use_precise = Settings::IsGPULevelHigh();
-            cmdbuf.ResetQueryPool(query_pool, static_cast<u32>(query_index), 1);
             cmdbuf.BeginQuery(query_pool, static_cast<u32>(query_index),
                               use_precise ? VK_QUERY_CONTROL_PRECISE_BIT : 0);
         });
@@ -221,7 +220,8 @@ public:
         }
         PauseCounter();
         const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
             pending_sync.clear();
             sync_values_stash.clear();
             return;
@@ -666,18 +666,13 @@ public:
         offsets.fill(0);
         last_queries.fill(0);
         last_queries_stride.fill(1);
-        stream_to_slot.fill(INVALID_SLOT);
-        VkBufferUsageFlags counter_buffer_usage =
-            VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
-        if (device.IsExtTransformFeedbackSupported()) {
-            counter_buffer_usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
-        }
         const VkBufferCreateInfo buffer_ci = {
             .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
             .pNext = nullptr,
             .flags = 0,
             .size = TFBQueryBank::QUERY_SIZE * NUM_STREAMS,
-            .usage = counter_buffer_usage,
+            .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
+                     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
             .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
             .queueFamilyIndexCount = 0,
             .pQueueFamilyIndices = nullptr,
@@ -697,9 +692,6 @@ public:
     ~TFBCounterStreamer() = default;
 
     void StartCounter() override {
-        if (!device.IsExtTransformFeedbackSupported()) {
-            return;
-        }
         FlushBeginTFB();
         has_started = true;
     }
@@ -714,9 +706,7 @@ public:
 
     void CloseCounter() override {
         if (has_flushed_end_pending) {
-            if (scheduler.IsRenderPassActive()) {
-                FlushEndTFB();
-            }
+            FlushEndTFB();
         }
         runtime.View3DRegs([this](Maxwell3D& maxwell3d) {
             if (maxwell3d.regs.transform_feedback_enabled == 0) {
@@ -766,33 +756,18 @@ public:
         if (has_timestamp) {
             new_query->flags |= VideoCommon::QueryFlagBits::HasTimestamp;
         }
-        if (!device.IsExtTransformFeedbackSupported()) {
-            new_query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
-            return index;
-        }
         if (!subreport_) {
             new_query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
             return index;
         }
         const size_t subreport = static_cast<size_t>(*subreport_);
-        if (subreport >= NUM_STREAMS) {
-            new_query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
-            return index;
-        }
         last_queries[subreport] = address;
         if ((streams_mask & (1ULL << subreport)) == 0) {
             new_query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
             return index;
         }
-        const size_t slot = stream_to_slot[subreport];
-        if (slot >= NUM_STREAMS) {
-            new_query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
-            return index;
-        }
-        
-        scheduler.RequestOutsideRenderPassOperationContext();
         CloseCounter();
-        auto [bank_slot, data_slot] = ProduceCounterBuffer(slot);
+        auto [bank_slot, data_slot] = ProduceCounterBuffer(subreport);
         new_query->start_bank_id = static_cast<u32>(bank_slot);
         new_query->size_banks = 1;
         new_query->start_slot = static_cast<u32>(data_slot);
@@ -803,9 +778,6 @@ public:
     }
 
     std::optional<std::pair<DAddr, size_t>> GetLastQueryStream(size_t stream) {
-        if (stream >= NUM_STREAMS) {
-            return std::nullopt;
-        }
         if (last_queries[stream] != 0) {
             std::pair<DAddr, size_t> result(last_queries[stream], last_queries_stride[stream]);
             return result;
@@ -817,10 +789,6 @@ public:
         return out_topology;
     }
 
-    u32 GetPatchVertices() const {
-        return patch_vertices;
-    }
-
     bool HasUnsyncedQueries() const override {
         return !pending_flush_queries.empty();
     }
@@ -887,9 +855,6 @@ public:
 
 private:
     void FlushBeginTFB() {
-        if (!device.IsExtTransformFeedbackSupported()) [[unlikely]] {
-            return;
-        }
         if (has_flushed_end_pending) [[unlikely]] {
             return;
         }
@@ -903,24 +868,12 @@ private:
             });
             return;
         }
-        static constexpr VkMemoryBarrier COUNTER_RESUME_BARRIER{
-            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
-            .dstAccessMask = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
-        };
         scheduler.Record([this, total = static_cast<u32>(buffers_count)](vk::CommandBuffer cmdbuf) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
-                                   VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT, 0,
-                                   COUNTER_RESUME_BARRIER);
             cmdbuf.BeginTransformFeedbackEXT(0, total, counter_buffers.data(), offsets.data());
         });
     }
 
     void FlushEndTFB() {
-        if (!device.IsExtTransformFeedbackSupported()) [[unlikely]] {
-            return;
-        }
         if (!has_flushed_end_pending) [[unlikely]] {
             UNREACHABLE();
             return;
@@ -946,48 +899,28 @@ private:
     void UpdateBuffers() {
         last_queries.fill(0);
         last_queries_stride.fill(1);
-        stream_to_slot.fill(INVALID_SLOT);
         streams_mask = 0; // reset previously recorded streams
         runtime.View3DRegs([this](Maxwell3D& maxwell3d) {
             buffers_count = 0;
             out_topology = maxwell3d.draw_manager->GetDrawState().topology;
-            patch_vertices = std::max(maxwell3d.regs.patch_vertices, 1U);
-            if (out_topology == Maxwell3D::Regs::PrimitiveTopology::Patches) {
-                switch (maxwell3d.regs.tessellation.params.output_primitives.Value()) {
-                case Maxwell3D::Regs::Tessellation::OutputPrimitives::Points:
-                    out_topology = Maxwell3D::Regs::PrimitiveTopology::Points;
-                    break;
-                case Maxwell3D::Regs::Tessellation::OutputPrimitives::Lines:
-                    out_topology = Maxwell3D::Regs::PrimitiveTopology::LineStrip;
-                    break;
-                case Maxwell3D::Regs::Tessellation::OutputPrimitives::Triangles_CW:
-                case Maxwell3D::Regs::Tessellation::OutputPrimitives::Triangles_CCW:
-                    out_topology = Maxwell3D::Regs::PrimitiveTopology::TriangleStrip;
-                    break;
-                }
-            }
             for (size_t i = 0; i < Maxwell3D::Regs::NumTransformFeedbackBuffers; i++) {
                 const auto& tf = maxwell3d.regs.transform_feedback;
                 if (tf.buffers[i].enable == 0) {
                     continue;
                 }
-                buffers_count = std::max<size_t>(buffers_count, i + 1);
                 const size_t stream = tf.controls[i].stream;
                 if (stream >= last_queries_stride.size()) {
                     LOG_WARNING(Render_Vulkan, "TransformFeedback stream {} out of range", stream);
                     continue;
                 }
-                if ((streams_mask & (1ULL << stream)) != 0) {
-                    continue;
-                }
                 last_queries_stride[stream] = tf.controls[i].stride;
-                stream_to_slot[stream] = i;
                 streams_mask |= 1ULL << stream;
+                buffers_count = std::max<size_t>(buffers_count, stream + 1);
             }
         });
     }
 
-    std::pair<size_t, size_t> ProduceCounterBuffer(size_t slot_index) {
+    std::pair<size_t, size_t> ProduceCounterBuffer(size_t stream) {
         if (current_bank == nullptr || current_bank->IsClosed()) {
             current_bank_id =
                 bank_pool.ReserveBank([this](std::deque<TFBQueryBank>& queue, size_t index) {
@@ -1013,8 +946,7 @@ private:
         };
         scheduler.RequestOutsideRenderPassOperationContext();
         scheduler.Record([dst_buffer = current_bank->GetBuffer(),
-                          src_buffer = counter_buffers[slot_index],
-                          src_offset = offsets[slot_index],
+                          src_buffer = counter_buffers[stream], src_offset = offsets[stream],
                           slot](vk::CommandBuffer cmdbuf) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
@@ -1033,7 +965,6 @@ private:
     friend class PrimitivesSucceededStreamer;
 
     static constexpr size_t NUM_STREAMS = 4;
-    static constexpr size_t INVALID_SLOT = NUM_STREAMS;
 
     QueryCacheRuntime& runtime;
     const Device& device;
@@ -1063,9 +994,7 @@ private:
     std::array<VkDeviceSize, NUM_STREAMS> offsets{};
     std::array<DAddr, NUM_STREAMS> last_queries;
     std::array<size_t, NUM_STREAMS> last_queries_stride;
-    std::array<size_t, NUM_STREAMS> stream_to_slot;
     Maxwell3D::Regs::PrimitiveTopology out_topology;
-    u32 patch_vertices{1};
     u64 streams_mask;
 };
 
@@ -1086,7 +1015,6 @@ public:
     u64 stride{};
     DAddr dependant_address{};
     Maxwell3D::Regs::PrimitiveTopology topology{Maxwell3D::Regs::PrimitiveTopology::Points};
-    u32 patch_vertices{1};
     size_t dependant_index{};
     bool dependant_manage{};
 };
@@ -1103,10 +1031,6 @@ public:
 
     ~PrimitivesSucceededStreamer() = default;
 
-    void ResetCounter() override {
-        tfb_streamer.ResetCounter();
-    }
-
     size_t WriteCounter(DAddr address, bool has_timestamp, u32 value,
                         std::optional<u32> subreport_) override {
         auto index = BuildQuery();
@@ -1124,7 +1048,6 @@ public:
         auto dependant_address_opt = tfb_streamer.GetLastQueryStream(subreport);
         bool must_manage_dependance = false;
         new_query->topology = tfb_streamer.GetOutputTopology();
-        new_query->patch_vertices = tfb_streamer.GetPatchVertices();
         if (dependant_address_opt) {
             auto [dep_address, stride] = *dependant_address_opt;
             new_query->dependant_address = dep_address;
@@ -1145,7 +1068,6 @@ public:
             }
             new_query->stride = 1;
             runtime.View3DRegs([new_query, subreport](Maxwell3D& maxwell3d) {
-                new_query->patch_vertices = std::max(maxwell3d.regs.patch_vertices, 1U);
                 for (size_t i = 0; i < Maxwell3D::Regs::NumTransformFeedbackBuffers; i++) {
                     const auto& tf = maxwell3d.regs.transform_feedback;
                     if (tf.buffers[i].enable == 0) {
@@ -1209,39 +1131,27 @@ public:
                 }
             }
             query->value = [&]() -> u64 {
-                const auto saturating_subtract = [](u64 value, u64 amount) {
-                    return value > amount ? value - amount : 0;
-                };
                 switch (query->topology) {
                 case Maxwell3D::Regs::PrimitiveTopology::Points:
                     return num_vertices;
                 case Maxwell3D::Regs::PrimitiveTopology::Lines:
                     return num_vertices / 2;
                 case Maxwell3D::Regs::PrimitiveTopology::LineLoop:
-                    return num_vertices > 1 ? num_vertices : 0;
+                    return (num_vertices / 2) + 1;
                 case Maxwell3D::Regs::PrimitiveTopology::LineStrip:
-                    return saturating_subtract(num_vertices, 1);
-                case Maxwell3D::Regs::PrimitiveTopology::LinesAdjacency:
-                    return num_vertices / 4;
-                case Maxwell3D::Regs::PrimitiveTopology::LineStripAdjacency:
-                    return saturating_subtract(num_vertices, 3);
+                    return num_vertices - 1;
+                case Maxwell3D::Regs::PrimitiveTopology::Patches:
                 case Maxwell3D::Regs::PrimitiveTopology::Triangles:
-                    return num_vertices / 3;
                 case Maxwell3D::Regs::PrimitiveTopology::TrianglesAdjacency:
-                    return num_vertices / 6;
+                    return num_vertices / 3;
                 case Maxwell3D::Regs::PrimitiveTopology::TriangleFan:
                 case Maxwell3D::Regs::PrimitiveTopology::TriangleStrip:
-                    return saturating_subtract(num_vertices, 2);
                 case Maxwell3D::Regs::PrimitiveTopology::TriangleStripAdjacency:
-                    return num_vertices > 4 ? (num_vertices - 4) / 2 : 0;
+                    return num_vertices - 2;
                 case Maxwell3D::Regs::PrimitiveTopology::Quads:
                     return num_vertices / 4;
-                case Maxwell3D::Regs::PrimitiveTopology::QuadStrip:
-                    return num_vertices > 2 ? (num_vertices - 2) / 2 : 0;
                 case Maxwell3D::Regs::PrimitiveTopology::Polygon:
-                    return num_vertices >= 3 ? 1U : 0U;
-                case Maxwell3D::Regs::PrimitiveTopology::Patches:
-                    return num_vertices / std::max<u64>(query->patch_vertices, 1U);
+                    return 1U;
                 default:
                     return num_vertices;
                 }
@@ -1292,24 +1202,16 @@ struct QueryCacheRuntimeImpl {
         hcr_setup.pNext = nullptr;
         hcr_setup.flags = 0;
 
-        const bool has_conditional_rendering = device.IsExtConditionalRendering();
-        if (has_conditional_rendering) {
-            conditional_resolve_pass = std::make_unique<ConditionalRenderingResolvePass>(
-                device, scheduler, descriptor_pool, compute_pass_descriptor_queue);
-        }
-
-        VkBufferUsageFlags hcr_buffer_usage =
-            VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-        if (has_conditional_rendering) {
-            hcr_buffer_usage |= VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT;
-        }
+        conditional_resolve_pass = std::make_unique<ConditionalRenderingResolvePass>(
+            device, scheduler, descriptor_pool, compute_pass_descriptor_queue);
 
         const VkBufferCreateInfo buffer_ci = {
             .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
             .pNext = nullptr,
             .flags = 0,
             .size = sizeof(u32),
-            .usage = hcr_buffer_usage,
+            .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
+                     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
             .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
             .queueFamilyIndexCount = 0,
             .pQueueFamilyIndices = nullptr,
@@ -1436,17 +1338,15 @@ void QueryCacheRuntime::HostConditionalRenderingCompareValueImpl(VideoCommon::Lo
     }
 }
 
-void QueryCacheRuntime::HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal,
-                                                              bool compare_to_zero) {
+void QueryCacheRuntime::HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal) {
     VkBuffer to_resolve;
     u32 to_resolve_offset;
-    const u32 resolve_size = compare_to_zero ? 8 : 24;
     {
         std::scoped_lock lk(impl->buffer_cache.mutex);
-        const auto sync_info = VideoCommon::ObtainBufferSynchronize::FullSynchronize;
+        static constexpr auto sync_info = VideoCommon::ObtainBufferSynchronize::NoSynchronize;
         const auto post_op = VideoCommon::ObtainBufferOperation::DoNothing;
         const auto [buffer, offset] =
-            impl->buffer_cache.ObtainCPUBuffer(address, resolve_size, sync_info, post_op);
+            impl->buffer_cache.ObtainCPUBuffer(address, 24, sync_info, post_op);
         to_resolve = buffer->Handle();
         to_resolve_offset = static_cast<u32>(offset);
     }
@@ -1455,7 +1355,7 @@ void QueryCacheRuntime::HostConditionalRenderingCompareBCImpl(DAddr address, boo
         PauseHostConditionalRendering();
     }
     impl->conditional_resolve_pass->Resolve(*impl->hcr_resolve_buffer, to_resolve,
-                                            to_resolve_offset, compare_to_zero);
+                                            to_resolve_offset, false);
     impl->hcr_setup.buffer = *impl->hcr_resolve_buffer;
     impl->hcr_setup.offset = 0;
     impl->hcr_setup.flags = is_equal ? 0 : VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT;
@@ -1471,7 +1371,7 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValue(VideoCommon::Lookup
     if (!impl->device.IsExtConditionalRendering()) {
         return false;
     }
-    HostConditionalRenderingCompareBCImpl(object_1.address, true, true);
+    HostConditionalRenderingCompareValueImpl(object_1, false);
     return true;
 }
 
@@ -1520,8 +1420,7 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
     auto driver_id = impl->device.GetDriverID();
     const bool is_gpu_high = Settings::IsGPULevelHigh();
 
-    if ((!is_gpu_high && driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) || driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
-        EndHostConditionalRendering();
+    if ((!is_gpu_high && driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) || driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY || driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
         return true;
     }
 
@@ -1538,12 +1437,10 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
     }
 
     if (!is_gpu_high) {
-        EndHostConditionalRendering();
         return true;
     }
 
     if (!is_in_bc[0] && !is_in_bc[1]) {
-        EndHostConditionalRendering();
         return true;
     }
     HostConditionalRenderingCompareBCImpl(object_1.address, equal_check);

src/video_core/renderer_vulkan/vk_query_cache.h

@@ -63,8 +63,7 @@ public:
 
 private:
     void HostConditionalRenderingCompareValueImpl(VideoCommon::LookupData object, bool is_equal);
-    void HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal,
-                                               bool compare_to_zero = false);
+    void HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal);
     friend struct QueryCacheRuntimeImpl;
     std::unique_ptr<QueryCacheRuntimeImpl> impl;
 };

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -173,28 +173,6 @@ DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances,
     }
     return params;
 }
-
-bool SupportsPrimitiveRestart(VkPrimitiveTopology topology) {
-    switch (topology) {
-    case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-    case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-    case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
-    case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
-    case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
-    case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
-        return false;
-    default:
-        return true;
-    }
-}
-
-bool IsPrimitiveRestartSupported(const Device& device, VkPrimitiveTopology topology) {
-    return ((topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
-             device.IsTopologyListPrimitiveRestartSupported()) ||
-            SupportsPrimitiveRestart(topology) ||
-            (topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST &&
-             device.IsPatchListPrimitiveRestartSupported()));
-}
 } // Anonymous namespace
 
 RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
@@ -247,7 +225,6 @@ void RasterizerVulkan::PrepareDraw(bool is_indexed, Func&& draw_func) {
 
     UpdateDynamicStates();
 
-    query_cache.NotifySegment(true);
     HandleTransformFeedback();
     query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64,
                               maxwell3d->regs.zpass_pixel_count_enable);
@@ -359,7 +336,6 @@ void RasterizerVulkan::DrawTexture() {
 
     UpdateDynamicStates();
 
-    query_cache.NotifySegment(true);
     query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64,
                               maxwell3d->regs.zpass_pixel_count_enable);
     const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
@@ -599,17 +575,11 @@ void RasterizerVulkan::DispatchCompute() {
 }
 
 void RasterizerVulkan::ResetCounter(VideoCommon::QueryType type) {
-    switch (type) {
-    case VideoCommon::QueryType::ZPassPixelCount64:
-    case VideoCommon::QueryType::StreamingByteCount:
-    case VideoCommon::QueryType::StreamingPrimitivesSucceeded:
-    case VideoCommon::QueryType::VtgPrimitivesOut:
-        query_cache.CounterReset(type);
-        return;
-    default:
+    if (type != VideoCommon::QueryType::ZPassPixelCount64) {
         LOG_DEBUG(Render_Vulkan, "Unimplemented counter reset={}", type);
         return;
     }
+    query_cache.CounterReset(type);
 }
 
 void RasterizerVulkan::Query(GPUVAddr gpu_addr, VideoCommon::QueryType type,
@@ -796,9 +766,6 @@ void RasterizerVulkan::ReleaseFences(bool force) {
 
 void RasterizerVulkan::FlushAndInvalidateRegion(DAddr addr, u64 size,
                                                 VideoCommon::CacheType which) {
-    if (Settings::IsGPULevelHigh()) {
-        FlushRegion(addr, size, which);
-    }
     InvalidateRegion(addr, size, which);
 }
 
@@ -863,10 +830,6 @@ bool RasterizerVulkan::AccelerateConditionalRendering() {
     return query_cache.AccelerateHostConditionalRendering();
 }
 
-bool RasterizerVulkan::HasDrawTransformFeedback() {
-    return device.IsTransformFeedbackDrawSupported();
-}
-
 bool RasterizerVulkan::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Surface& src,
                                              const Tegra::Engines::Fermi2D::Surface& dst,
                                              const Tegra::Engines::Fermi2D::Config& copy_config) {
@@ -1013,12 +976,6 @@ bool AccelerateDMA::BufferToImage(const Tegra::DMA::ImageCopy& copy_info,
 
 void RasterizerVulkan::UpdateDynamicStates() {
     auto& regs = maxwell3d->regs;
-    auto& flags = maxwell3d->dirty.flags;
-    const auto topology = maxwell3d->draw_manager->GetDrawState().topology;
-    if (state_tracker.ChangePrimitiveTopology(topology)) {
-        flags[Dirty::DepthBiasEnable] = true;
-        flags[Dirty::PrimitiveRestartEnable] = true;
-    }
 
     // Core Dynamic States (Vulkan 1.0) - Always active regardless of dyna_state setting
     UpdateViewportsState(regs);
@@ -1127,9 +1084,6 @@ void RasterizerVulkan::UpdateViewportsState(Tegra::Engines::Maxwell3D::Regs& reg
     if (!state_tracker.TouchViewports()) {
         return;
     }
-
-    maxwell3d->dirty.flags[Dirty::Scissors] = true;
-
     if (!regs.viewport_scale_offset_enabled) {
         float x = static_cast<float>(regs.surface_clip.x);
         float y = static_cast<float>(regs.surface_clip.y);
@@ -1147,12 +1101,8 @@ void RasterizerVulkan::UpdateViewportsState(Tegra::Engines::Maxwell3D::Regs& reg
             .minDepth = 0.0f,
             .maxDepth = 1.0f,
         };
-        scheduler.Record([this, viewport](vk::CommandBuffer cmdbuf) {
-            const u32 num_viewports = std::min<u32>(device.GetMaxViewports(), Maxwell::NumViewports);
-            std::array<VkViewport, Maxwell::NumViewports> viewport_list{};
-            viewport_list.fill(viewport);
-            const vk::Span<VkViewport> viewports(viewport_list.data(), num_viewports);
-            cmdbuf.SetViewport(0, viewports);
+        scheduler.Record([viewport](vk::CommandBuffer cmdbuf) {
+            cmdbuf.SetViewport(0, viewport);
         });
         return;
     }
@@ -1192,12 +1142,8 @@ void RasterizerVulkan::UpdateScissorsState(Tegra::Engines::Maxwell3D::Regs& regs
         scissor.offset.y = static_cast<int32_t>(y);
         scissor.extent.width  = width;
         scissor.extent.height = height;
-        scheduler.Record([this, scissor](vk::CommandBuffer cmdbuf) {
-            const u32 num_scissors = std::min<u32>(device.GetMaxViewports(), Maxwell::NumViewports);
-            std::array<VkRect2D, Maxwell::NumViewports> scissor_list{};
-            scissor_list.fill(scissor);
-            const vk::Span<VkRect2D> scissors(scissor_list.data(), num_scissors);
-            cmdbuf.SetScissor(0, scissors);
+        scheduler.Record([scissor](vk::CommandBuffer cmdbuf) {
+            cmdbuf.SetScissor(0, scissor);
         });
         return;
     }
@@ -1442,17 +1388,7 @@ void RasterizerVulkan::UpdatePrimitiveRestartEnable(Tegra::Engines::Maxwell3D::R
     if (!state_tracker.TouchPrimitiveRestartEnable()) {
         return;
     }
-
-    bool enable = regs.primitive_restart.enabled != 0;
-    if (device.IsMoltenVK()) {
-        enable = true;
-    } else if (enable) {
-        const auto topology =
-            MaxwellToVK::PrimitiveTopology(device, maxwell3d->draw_manager->GetDrawState().topology);
-        enable = IsPrimitiveRestartSupported(device, topology);
-    }
-
-    scheduler.Record([enable](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([enable = regs.primitive_restart.enabled](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetPrimitiveRestartEnableEXT(enable);
     });
 }
@@ -1791,9 +1727,7 @@ void RasterizerVulkan::UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs&
 
 void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs) {
     auto& dirty{maxwell3d->dirty.flags};
-    const bool vertex_input_dirty = dirty[Dirty::VertexInput];
-    const bool vertex_buffers_dirty = dirty[VideoCommon::Dirty::VertexBuffers];
-    if (!vertex_input_dirty && !vertex_buffers_dirty) {
+    if (!dirty[Dirty::VertexInput]) {
         return;
     }
     dirty[Dirty::VertexInput] = false;
@@ -1801,31 +1735,38 @@ void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs)
     boost::container::static_vector<VkVertexInputBindingDescription2EXT, 32> bindings;
     boost::container::static_vector<VkVertexInputAttributeDescription2EXT, 32> attributes;
 
-    const u32 max_attributes =
-        static_cast<u32>(std::min<size_t>(Maxwell::NumVertexAttributes,
-                                          device.GetMaxVertexInputAttributes()));
-    const u32 max_bindings =
-        static_cast<u32>(std::min<size_t>(Maxwell::NumVertexArrays,
-                                          device.GetMaxVertexInputBindings()));
-
-
-    for (u32 index = 0; index < max_attributes; ++index) {
+    // There seems to be a bug on Nvidia's driver where updating only higher attributes ends up
+    // generating dirty state. Track the highest dirty attribute and update all attributes until
+    // that one.
+    size_t highest_dirty_attr{};
+    for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
+        if (dirty[Dirty::VertexAttribute0 + index]) {
+            highest_dirty_attr = index;
+        }
+    }
+    for (size_t index = 0; index < highest_dirty_attr; ++index) {
         const Maxwell::VertexAttribute attribute{regs.vertex_attrib_format[index]};
         const u32 binding{attribute.buffer};
-        if (attribute.constant || binding >= max_bindings) {
+        dirty[Dirty::VertexAttribute0 + index] = false;
+        dirty[Dirty::VertexBinding0 + static_cast<size_t>(binding)] = true;
+        if (!attribute.constant) {
+            attributes.push_back({
+                .sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
+                .pNext = nullptr,
+                .location = static_cast<u32>(index),
+                .binding = binding,
+                .format = MaxwellToVK::VertexFormat(device, attribute.type, attribute.size),
+                .offset = attribute.offset,
+            });
+        }
+    }
+    for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
+        if (!dirty[Dirty::VertexBinding0 + index]) {
             continue;
         }
-        attributes.push_back({
-            .sType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
-            .pNext = nullptr,
-            .location = index,
-            .binding = binding,
-            .format = MaxwellToVK::VertexFormat(device, attribute.type, attribute.size),
-            .offset = attribute.offset,
-        });
-    }
+        dirty[Dirty::VertexBinding0 + index] = false;
 
-    for (u32 binding = 0; binding < max_bindings; ++binding) {
+        const u32 binding{static_cast<u32>(index)};
         const auto& input_binding{regs.vertex_streams[binding]};
         const bool is_instanced{regs.vertex_stream_instances.IsInstancingEnabled(binding)};
         bindings.push_back({
@@ -1837,14 +1778,6 @@ void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs)
             .divisor = is_instanced ? input_binding.frequency : 1,
         });
     }
-
-    for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
-        dirty[Dirty::VertexAttribute0 + index] = false;
-    }
-    for (size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        dirty[Dirty::VertexBinding0 + index] = false;
-    }
-
     scheduler.Record([bindings, attributes](vk::CommandBuffer cmdbuf) {
         cmdbuf.SetVertexInputEXT(bindings, attributes);
     });

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -122,7 +122,6 @@ public:
     void FlushCommands() override;
     void TickFrame() override;
     bool AccelerateConditionalRendering() override;
-    bool HasDrawTransformFeedback() override;
     bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Surface& src,
                                const Tegra::Engines::Fermi2D::Surface& dst,
                                const Tegra::Engines::Fermi2D::Config& copy_config) override;

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -324,8 +324,6 @@ void Scheduler::EndRenderPass()
             return;
         }
 
-        query_cache->CounterClose(VideoCommon::QueryType::StreamingByteCount);
-
         // Log render pass end
         if (Settings::values.gpu_logging_enabled.GetValue() &&
             Settings::values.gpu_log_vulkan_calls.GetValue()) {

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -63,11 +63,6 @@ public:
     /// of a renderpass.
     void RequestOutsideRenderPassOperationContext();
 
-    /// Returns true when a render pass is currently active in the scheduler state.
-    bool IsRenderPassActive() const {
-        return state.renderpass != VK_NULL_HANDLE;
-    }
-
     /// Update the pipeline to the current execution context.
     bool UpdateGraphicsPipeline(GraphicsPipeline* pipeline);
 

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -87,7 +87,6 @@ Flags MakeInvalidationFlags() {
 void SetupDirtyViewports(Tables& tables) {
     FillBlock(tables[0], OFF(viewport_transform), NUM(viewport_transform), Viewports);
     FillBlock(tables[0], OFF(viewports), NUM(viewports), Viewports);
-    FillBlock(tables[1], OFF(surface_clip), NUM(surface_clip), Viewports);
     tables[0][OFF(viewport_scale_offset_enabled)] = Viewports;
     tables[1][OFF(window_origin)] = Viewports;
 }

src/video_core/renderer_vulkan/vk_state_tracker.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -176,18 +176,7 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
         .pViewFormats = view_formats.data(),
     };
     if (view_formats.size() > 1) {
-        image_ci.flags |=
-            VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
-
-        const bool has_storage_compatible_view =
-            std::any_of(view_formats.begin(), view_formats.end(), [&device](VkFormat view_format) {
-                return device.IsFormatSupported(view_format, VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
-                                                FormatType::Optimal);
-            });
-        if (has_storage_compatible_view) {
-            image_ci.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
-        }
-
+        image_ci.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
         if (device.IsKhrImageFormatListSupported()) {
             image_ci.pNext = &image_format_list;
         }
@@ -679,16 +668,11 @@ void CopyBufferToImage(vk::CommandBuffer cmdbuf, VkBuffer src_buffer, VkImage im
 }
 
 void TryTransformSwizzleIfNeeded(PixelFormat format, std::array<SwizzleSource, 4>& swizzle,
-                                 bool emulate_bgr565, bool emulate_a4b4g4r4) {
+                                 bool emulate_a4b4g4r4) {
     switch (format) {
     case PixelFormat::A1B5G5R5_UNORM:
         std::ranges::transform(swizzle, swizzle.begin(), SwapBlueRed);
         break;
-    case PixelFormat::B5G6R5_UNORM:
-        if (emulate_bgr565) {
-            std::ranges::transform(swizzle, swizzle.begin(), SwapBlueRed);
-        }
-        break;
     case PixelFormat::A5B5G5R1_UNORM:
         std::ranges::transform(swizzle, swizzle.begin(), SwapSpecial);
         break;
@@ -2135,21 +2119,22 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
     if (!info.IsRenderTarget()) {
         swizzle = info.Swizzle();
         TryTransformSwizzleIfNeeded(format, swizzle,
-                        device->MustEmulateBGR565(),
-                        !device->IsExt4444FormatsSupported());
+                                    !device->IsExt4444FormatsSupported());
         if ((aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != 0) {
             std::ranges::transform(swizzle, swizzle.begin(), ConvertGreenRed);
             SanitizeDepthStencilSwizzle(swizzle, device->SupportsDepthStencilSwizzleOne());
         }
     }
     const auto format_info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
-    const VkImageUsageFlags requested_view_usage = ImageUsageFlags(format_info, format);
-    const VkImageUsageFlags image_usage = image.UsageFlags();
-    const VkImageUsageFlags clamped_view_usage = requested_view_usage & image_usage;
+    if (ImageUsageFlags(format_info, format) != image.UsageFlags()) {
+        LOG_WARNING(Render_Vulkan,
+                    "Image view format {} has different usage flags than image format {}", format,
+                    image.info.format);
+    }
     const VkImageViewUsageCreateInfo image_view_usage{
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
         .pNext = nullptr,
-        .usage = clamped_view_usage,
+        .usage = ImageUsageFlags(format_info, format),
     };
     const VkImageViewCreateInfo create_info{
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@@ -2315,18 +2300,23 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
 
 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
     const auto& device = runtime.device;
-    const bool has_custom_border_extension = runtime.device.IsExtCustomBorderColorSupported();
-    const bool has_format_undefined =
-        has_custom_border_extension && runtime.device.IsCustomBorderColorWithoutFormatSupported();
-    const bool has_custom_border_colors =
-        has_format_undefined && runtime.device.IsCustomBorderColorsSupported();
+    // Check if custom border colors are supported
+    const bool has_custom_border_colors = runtime.device.IsCustomBorderColorsSupported();
+    const bool has_format_undefined = runtime.device.IsCustomBorderColorWithoutFormatSupported();
     const auto color = tsc.BorderColor();
 
+    // Determine border format based on available features:
+    // - If customBorderColorWithoutFormat is available: use VK_FORMAT_UNDEFINED (most flexible)
+    // - If only customBorderColors is available: use concrete format (R8G8B8A8_UNORM)
+    // - If neither is available: use standard border colors (handled by ConvertBorderColor)
+    const VkFormat border_format = has_format_undefined ? VK_FORMAT_UNDEFINED
+                                                        : VK_FORMAT_R8G8B8A8_UNORM;
+
     const VkSamplerCustomBorderColorCreateInfoEXT border_ci{
         .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
         .pNext = nullptr,
         .customBorderColor = std::bit_cast<VkClearColorValue>(color),
-        .format = VK_FORMAT_UNDEFINED,
+        .format = border_format,
     };
     const void* pnext = nullptr;
     if (has_custom_border_colors) {

src/video_core/transform_feedback.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -88,13 +88,13 @@ std::pair<std::array<Shader::TransformFeedbackVarying, 256>, u32> MakeTransformF
                 return 0;
             };
 
+            UNIMPLEMENTED_IF_MSG(layout.stream != 0, "Stream is not zero: {}", layout.stream);
             Shader::TransformFeedbackVarying varying{
                 .buffer = static_cast<u32>(buffer),
                 .stride = layout.stride,
                 .offset = offset * 4,
                 .components = 1,
             };
-                varying.stream = layout.stream;
             const u32 base_offset = offset;
             const auto attribute{get_attribute(offset)};
             if (std::ranges::find(VECTORS, Common::AlignDown(attribute, 4)) != VECTORS.end()) {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -869,10 +869,6 @@ bool Device::HasTimelineSemaphore() const {
     return features.timeline_semaphore.timelineSemaphore;
 }
 
-bool Device::MustEmulateBGR565() const {
-    return Settings::values.emulate_bgr565.GetValue();
-}
-
 bool Device::GetSuitability(bool requires_swapchain) {
     // Assume we will be suitable.
     bool suitable = true;
@@ -923,17 +919,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
     FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
     FOR_EACH_VK_EXTENSION(EXTENSION);
 
-    if (supported_extensions.contains(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)) {
-        loaded_extensions.erase(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
-        loaded_extensions.insert(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME);
-        extensions.robustness_2 = true;
-    } else if (supported_extensions.contains(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)) {
-        loaded_extensions.insert(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
-        extensions.robustness_2 = true;
-    } else {
-        extensions.robustness_2 = false;
-    }
-
 #undef FEATURE_EXTENSION
 #undef EXTENSION
 
@@ -1146,6 +1131,8 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
     if (u32(Settings::values.dyna_state.GetValue()) == 0) {
         LOG_INFO(Render_Vulkan, "Extended Dynamic State disabled by user setting, clearing all EDS features");
+        features.custom_border_color.customBorderColors = false;
+        features.custom_border_color.customBorderColorWithoutFormat = false;
         features.extended_dynamic_state.extendedDynamicState = false;
         features.extended_dynamic_state2.extendedDynamicState2 = false;
         features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
@@ -1161,13 +1148,24 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
 void Device::RemoveUnsuitableExtensions() {
     // VK_EXT_custom_border_color
+    // Enable extension if driver supports it, then check individual features
+    // - customBorderColors: Required to use VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
+    // - customBorderColorWithoutFormat: Optional, allows VK_FORMAT_UNDEFINED
+    // If only customBorderColors is available, we must provide a specific format
     if (extensions.custom_border_color) {
-        extensions.custom_border_color =
-            features.custom_border_color.customBorderColors &&
-            features.custom_border_color.customBorderColorWithoutFormat;
+        // Verify that at least customBorderColors is available
+        if (!features.custom_border_color.customBorderColors) {
+            LOG_WARNING(Render_Vulkan,
+                        "VK_EXT_custom_border_color reported but customBorderColors feature not available, disabling");
+            extensions.custom_border_color = false;
+        }
     }
     RemoveExtensionFeatureIfUnsuitable(extensions.custom_border_color, features.custom_border_color,
                                        VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+    // VK_KHR_unified_image_layouts
+    extensions.unified_image_layouts = features.unified_image_layouts.unifiedImageLayouts;
+    RemoveExtensionFeatureIfUnsuitable(extensions.unified_image_layouts, features.unified_image_layouts,
+                                       VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME);
 
     // VK_EXT_depth_bias_control
     extensions.depth_bias_control =
@@ -1253,22 +1251,16 @@ void Device::RemoveUnsuitableExtensions() {
                                        VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
 
     // VK_EXT_robustness2
-    features.robustness2.robustBufferAccess2 = VK_FALSE;
-    features.robustness2.robustImageAccess2 = VK_FALSE;
-    extensions.robustness_2 = features.robustness2.nullDescriptor;
-
-    const char* robustness2_extension_name =
-        loaded_extensions.contains(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)
-            ? VK_KHR_ROBUSTNESS_2_EXTENSION_NAME
-            : VK_EXT_ROBUSTNESS_2_EXTENSION_NAME;
+    extensions.robustness_2 = features.robustness2.robustBufferAccess2 ||
+                              features.robustness2.robustImageAccess2 ||
+                              features.robustness2.nullDescriptor;
 
     RemoveExtensionFeatureIfUnsuitable(extensions.robustness_2, features.robustness2,
-                                       robustness2_extension_name);
+                                       VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
 
-    // Image robustness
-    extensions.robust_image_access = features.robust_image_access.robustImageAccess;
-    RemoveExtensionFeatureIfUnsuitable(extensions.robust_image_access,
-                                       features.robust_image_access,
+    // VK_EXT_image_robustness
+    extensions.image_robustness = features.image_robustness.robustImageAccess;
+    RemoveExtensionFeatureIfUnsuitable(extensions.image_robustness, features.image_robustness,
                                        VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME);
 
     // VK_KHR_shader_atomic_int64
@@ -1296,7 +1288,8 @@ void Device::RemoveUnsuitableExtensions() {
     // VK_EXT_transform_feedback
     extensions.transform_feedback =
         features.transform_feedback.transformFeedback &&
-        properties.transform_feedback.maxTransformFeedbackBuffers > 0;
+        properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
+        properties.transform_feedback.transformFeedbackQueries;
     RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
                                        VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
 

src/video_core/vulkan_common/vulkan_device.h

@@ -38,7 +38,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(KHR, TimelineSemaphore, TIMELINE_SEMAPHORE, timeline_semaphore)
 
 #define FOR_EACH_VK_FEATURE_1_3(FEATURE)                                                           \
-    FEATURE(EXT, ImageRobustness, IMAGE_ROBUSTNESS, robust_image_access)                           \
+    FEATURE(EXT, ImageRobustness, IMAGE_ROBUSTNESS, image_robustness)                              \
     FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
             shader_demote_to_helper_invocation)                                                    \
     FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
@@ -68,7 +68,8 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
             pipeline_executable_properties)                                                        \
     FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
-            workgroup_memory_explicit_layout)
+            workgroup_memory_explicit_layout)                                                      \
+    FEATURE(KHR, UnifiedImageLayouts, UNIFIED_IMAGE_LAYOUTS, unified_image_layouts)
 
 
 // Define miscellaneous extensions which may be used by the implementation here.
@@ -123,6 +124,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION_NAME(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME)                                 \
     EXTENSION_NAME(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME)                                     \
     EXTENSION_NAME(VK_EXT_4444_FORMATS_EXTENSION_NAME)                                             \
+    EXTENSION_NAME(VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME)                                         \
     EXTENSION_NAME(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME)                                       \
     EXTENSION_NAME(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME)                                             \
     EXTENSION_NAME(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME)                               \
@@ -172,11 +174,13 @@ VK_DEFINE_HANDLE(VmaAllocator)
     FEATURE_NAME(depth_bias_control, depthBiasExact)                                               \
     FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
     FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4)                                                  \
-    FEATURE_NAME(robust_image_access, robustImageAccess)                                           \
+    FEATURE_NAME(image_robustness, robustImageAccess)                                              \
     FEATURE_NAME(index_type_uint8, indexTypeUint8)                                                 \
     FEATURE_NAME(primitive_topology_list_restart, primitiveTopologyListRestart)                    \
     FEATURE_NAME(provoking_vertex, provokingVertexLast)                                            \
     FEATURE_NAME(robustness2, nullDescriptor)                                                      \
+    FEATURE_NAME(robustness2, robustBufferAccess2)                                                 \
+    FEATURE_NAME(robustness2, robustImageAccess2)                                                  \
     FEATURE_NAME(shader_float16_int8, shaderFloat16)                                               \
     FEATURE_NAME(shader_float16_int8, shaderInt8)                                                  \
     FEATURE_NAME(timeline_semaphore, timelineSemaphore)                                            \
@@ -538,17 +542,6 @@ public:
         return extensions.transform_feedback;
     }
 
-    /// Returns true if transform feedback draw commands are supported.
-    bool IsTransformFeedbackDrawSupported() const {
-        return extensions.transform_feedback && properties.transform_feedback.transformFeedbackDraw;
-    }
-
-    /// Returns true if transform feedback query types are supported.
-    bool IsTransformFeedbackQueriesSupported() const {
-        return extensions.transform_feedback &&
-               properties.transform_feedback.transformFeedbackQueries;
-    }
-
     /// Returns true if the device supports VK_EXT_transform_feedback properly.
     bool AreTransformFeedbackGeometryStreamsSupported() const {
         return features.transform_feedback.geometryStreams;
@@ -559,6 +552,36 @@ public:
         return extensions.custom_border_color;
     }
 
+    /// Returns true if the device supports VK_EXT_image_robustness.
+    bool IsExtImageRobustnessSupported() const {
+        return extensions.image_robustness;
+    }
+
+    /// Returns true if robustImageAccess is supported.
+    bool IsRobustImageAccessSupported() const {
+        return features.image_robustness.robustImageAccess;
+    }
+
+    /// Returns true if the device supports VK_EXT_robustness2.
+    bool IsExtRobustness2Supported() const {
+        return extensions.robustness_2;
+    }
+
+    /// Returns true if robustBufferAccess2 is supported.
+    bool IsRobustBufferAccess2Supported() const {
+        return features.robustness2.robustBufferAccess2;
+    }
+
+    /// Returns true if robustImageAccess2 is supported.
+    bool IsRobustImageAccess2Supported() const {
+        return features.robustness2.robustImageAccess2;
+    }
+
+    /// Returns true if nullDescriptor is supported.
+    bool IsNullDescriptorSupported() const {
+        return features.robustness2.nullDescriptor;
+    }
+
     /// Returns true if customBorderColors feature is available.
     bool IsCustomBorderColorsSupported() const {
         return features.custom_border_color.customBorderColors;
@@ -782,8 +805,6 @@ public:
         return features.robustness2.nullDescriptor;
     }
 
-    bool MustEmulateBGR565() const;
-
     bool HasExactDepthBiasControl() const {
         return features.depth_bias_control.depthBiasExact;
     }

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -123,7 +123,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdEndDebugUtilsLabelEXT);
     X(vkCmdFillBuffer);
     X(vkCmdPipelineBarrier);
-    X(vkCmdResetQueryPool);
     X(vkCmdPushConstants);
     X(vkCmdPushDescriptorSetWithTemplateKHR);
     X(vkCmdSetBlendConstants);

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -225,7 +225,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT{};
     PFN_vkCmdFillBuffer vkCmdFillBuffer{};
     PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier{};
-    PFN_vkCmdResetQueryPool vkCmdResetQueryPool{};
     PFN_vkCmdPushConstants vkCmdPushConstants{};
     PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR{};
     PFN_vkCmdResolveImage vkCmdResolveImage{};
@@ -1169,10 +1168,6 @@ public:
         dld->vkCmdEndQuery(handle, query_pool, query);
     }
 
-    void ResetQueryPool(VkQueryPool query_pool, u32 first_query, u32 query_count) const noexcept {
-        dld->vkCmdResetQueryPool(handle, query_pool, first_query, query_count);
-    }
-
     void BindDescriptorSets(VkPipelineBindPoint bind_point, VkPipelineLayout layout, u32 first,
                             Span<VkDescriptorSet> sets, Span<u32> dynamic_offsets) const noexcept {
         dld->vkCmdBindDescriptorSets(handle, bind_point, layout, first, sets.size(), sets.data(),

src/yuzu/data_dialog.cpp

@@ -23,18 +23,27 @@ DataDialog::DataDialog(QWidget* parent) : QDialog(parent), ui(std::make_unique<U
 
     // TODO: Should we make this a single widget that pulls data from a model?
 #define WIDGET(label, name)                                                                        \
-    ui->pages->addTab(new DataWidget(FrontendCommon::DataManager::DataDir::name,                   \
-                                     QtCommon::StringLookup::DataManager##name##Tooltip,           \
-                                     QStringLiteral(#name), this),                                 \
-                      label);
+    ui->page->addWidget(new DataWidget(FrontendCommon::DataManager::DataDir::name,                 \
+                                       QtCommon::StringLookup::DataManager##name##Tooltip,         \
+                                       QStringLiteral(#name), this));                              \
+    ui->labels->addItem(label);
 
     WIDGET(tr("Shaders"), Shaders)
-    WIDGET(tr("User NAND"), UserNand)
-    WIDGET(tr("System NAND"), SysNand)
+    WIDGET(tr("UserNAND"), UserNand)
+    WIDGET(tr("SysNAND"), SysNand)
     WIDGET(tr("Mods"), Mods)
     WIDGET(tr("Saves"), Saves)
 
 #undef WIDGET
+
+    connect(ui->labels, &QListWidget::itemSelectionChanged, this, [this]() {
+        const auto items = ui->labels->selectedItems();
+        if (items.isEmpty()) {
+            return;
+        }
+
+        ui->page->setCurrentIndex(ui->labels->row(items[0]));
+    });
 }
 
 DataDialog::~DataDialog() = default;
@@ -62,29 +71,25 @@ DataWidget::DataWidget(FrontendCommon::DataManager::DataDir data_dir,
 }
 
 void DataWidget::clear() {
-    std::optional<std::string> user_id = selectProfile();
-    if (!user_id) return;
-    QtCommon::Content::ClearDataDir(m_dir, user_id.value());
+    std::string user_id = selectProfile();
+    QtCommon::Content::ClearDataDir(m_dir, user_id);
     scan();
 }
 
 void DataWidget::open() {
-    std::optional<std::string> user_id = selectProfile();
-    if (!user_id) return;
+    std::string user_id = selectProfile();
     QDesktopServices::openUrl(QUrl::fromLocalFile(
-        QString::fromStdString(FrontendCommon::DataManager::GetDataDirString(m_dir, user_id.value()))));
+        QString::fromStdString(FrontendCommon::DataManager::GetDataDirString(m_dir, user_id))));
 }
 
 void DataWidget::upload() {
-    std::optional<std::string> user_id = selectProfile();
-    if (!user_id) return;
-    QtCommon::Content::ExportDataDir(m_dir, user_id.value(), m_exportName);
+    std::string user_id = selectProfile();
+    QtCommon::Content::ExportDataDir(m_dir, user_id, m_exportName);
 }
 
 void DataWidget::download() {
-    std::optional<std::string> user_id = selectProfile();
-    if (!user_id) return;
-    QtCommon::Content::ImportDataDir(m_dir, user_id.value(), std::bind(&DataWidget::scan, this));
+    std::string user_id = selectProfile();
+    QtCommon::Content::ImportDataDir(m_dir, user_id, std::bind(&DataWidget::scan, this));
 }
 
 void DataWidget::scan() {
@@ -103,11 +108,10 @@ void DataWidget::scan() {
         QtConcurrent::run([this]() { return FrontendCommon::DataManager::DataDirSize(m_dir); }));
 }
 
-std::optional<std::string> DataWidget::selectProfile() {
+std::string DataWidget::selectProfile() {
     std::string user_id{};
     if (m_dir == FrontendCommon::DataManager::DataDir::Saves) {
         user_id = GetProfileIDString();
-        if (user_id.empty()) return std::nullopt;
     }
 
     return user_id;

src/yuzu/data_dialog.h

@@ -45,7 +45,7 @@ private:
     FrontendCommon::DataManager::DataDir m_dir;
     const QString m_exportName;
 
-    std::optional<std::string> selectProfile();
+    std::string selectProfile();
 };
 
 #endif // DATA_DIALOG_H