fix nvdec

[host1x] inline nvenc, fix ffmpeg not having va-api on freebsd
Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-08-14 04:24:31 +00:00 · 2026-04-24 20:26:48 +02:00 · 2026-04-24 20:26:48 +02:00 · 2026-04-24 18:40:49 +02:00 · 2026-04-24 16:37:18 +02:00
65 changed files with 977 additions and 828 deletions
@@ -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 API endpoint
+# Auto-updater metadata! Must somewhat mirror GitHub/Forgejo API endpoint
+
+set(BUILD_AUTO_UPDATE_API_PATH "/latest/release.json")
 if (NIGHTLY_BUILD)
    set(BUILD_AUTO_UPDATE_WEBSITE "https://git.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_API "nightly.eden-emu.dev")
    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 "git.eden-emu.dev")
-    set(BUILD_AUTO_UPDATE_API_PATH "/api/v1/repos/")
+    set(BUILD_AUTO_UPDATE_API "stable.eden-emu.dev")
    set(BUILD_AUTO_UPDATE_REPO "eden-emu/eden")
    set(REPO_NAME "Eden")
 endif()
@@ -17,6 +17,7 @@ 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"),
@@ -756,6 +756,13 @@ 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,
@@ -293,6 +293,7 @@ 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)
@@ -1726,9 +1726,8 @@ 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("{}/{}/releases/tag/{}",
-        std::string{Common::g_build_auto_update_website},
-        std::string{Common::g_build_auto_update_repo},
+    const std::string url = fmt::format("{}/{}",
+        std::string{Common::g_build_auto_update_api},
        version_str);
    env->ReleaseStringUTFChars(version, version_str);
    return env->NewStringUTF(url.c_str());
@@ -1760,11 +1759,10 @@ 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("{}/{}/releases/download/{}/{}",
-        std::string{Common::g_build_auto_update_website},
-        std::string{Common::g_build_auto_update_repo},
-        version_str,
-        apk_filename);
+
+    const std::string url = fmt::format("{}/{}/{}",
+        std::string{Common::g_build_auto_update_api},
+        version_str, apk_filename);

    env->ReleaseStringUTFChars(tag, version_str);
    env->ReleaseStringUTFChars(artifact, artifact_str);
@@ -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. Will crash on older drivers.</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="hacks">Hacks</string>

@@ -510,7 +510,9 @@
    <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 700), removes bloom in Burnout. Warning: may cause graphical artifacts in other games.</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="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>
@@ -555,6 +555,9 @@ 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};

@@ -584,7 +587,7 @@ struct Values {

    SwitchableSetting<ExtendedDynamicState> dyna_state{linkage,
 #if defined(ANDROID)
-                                           ExtendedDynamicState::EDS1,
+                                           ExtendedDynamicState::Disabled,
 #elif defined(__APPLE__)
                                           ExtendedDynamicState::Disabled,
 #else
@@ -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().Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
+        host1x.gmmu_manager.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,12 +169,8 @@ 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) {
-            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);
+            u32 address = host1x.Allocator().Allocate(u32(handle_description->aligned_size));
+            host1x.gmmu_manager.Map(GPUVAddr(address), handle_description->d_address, handle_description->aligned_size);
            handle_description->pin_virt_address = address;
        }
    };
@@ -80,55 +80,24 @@ std::optional<std::string> UpdateChecker::GetResponse(std::string url, std::stri
    }
 }

-std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease(bool include_prereleases) {
+std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease() {
 #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 = fmt::format("{}{}", std::string{Common::g_build_auto_update_api_path},
-                                         std::string{Common::g_build_auto_update_repo});
+    auto update_check_path = std::string{Common::g_build_auto_update_api_path};
    try {
-        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";
+        const auto response = UpdateChecker::GetResponse(update_check_url, update_check_path);

-            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);
+        if (!response)
+            return {};

-            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};
-        }
+        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};
    } catch (nlohmann::detail::out_of_range&) {
        LOG_ERROR(Frontend,
                  "Parsing JSON response from {}{} failed during update check: "
@@ -147,12 +116,8 @@ std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease(bool includ
 }

 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(is_prerelease);
+        UpdateChecker::GetLatestRelease();

    if (!latest_release_tag)
        goto empty;
@@ -18,6 +18,6 @@ typedef struct {
 } Update;

 std::optional<std::string> GetResponse(std::string url, std::string path);
-std::optional<Update> GetLatestRelease(bool include_prereleases);
+std::optional<Update> GetLatestRelease();
 std::optional<Update> GetUpdate();
 } // namespace UpdateChecker
@@ -178,6 +178,9 @@ 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)};
@@ -76,6 +76,7 @@ enum class TessSpacing {

 struct TransformFeedbackVarying {
    u32 buffer{};
+    u32 stream{};
    u32 stride{};
    u32 offset{};
    u32 components{};
@@ -8,7 +8,7 @@ add_subdirectory(host_shaders)
 add_subdirectory(gpu_logging)

 if(LIBVA_FOUND)
-    set_source_files_properties(host1x/ffmpeg/ffmpeg.cpp
+    set_source_files_properties(host1x/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/codecs/vp9_types.h
-    host1x/ffmpeg/ffmpeg.cpp
-    host1x/ffmpeg/ffmpeg.h
+    host1x/codec_types.h
+    host1x/ffmpeg.cpp
+    host1x/ffmpeg.h
    host1x/control.cpp
    host1x/control.h
    host1x/gpu_device_memory_manager.cpp
@@ -1067,26 +1067,29 @@ 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];
-        if (maxwell3d->regs.transform_feedback.controls[index].varying_count == 0 &&
-            maxwell3d->regs.transform_feedback.controls[index].stride == 0) {
-            break;
+        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;
        }
-        Buffer& buffer = slot_buffers[binding.buffer_id];
-        TouchBuffer(buffer, binding.buffer_id);
-        const u32 size = binding.size;
-        SynchronizeBuffer(buffer, binding.device_addr, size);

-        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.buffers.push_back(host_buffer);
        host_bindings.offsets.push_back(offset);
        host_bindings.sizes.push_back(size);
    }
-    if (host_bindings.buffers.size() > 0) {
-        runtime.BindTransformFeedbackBuffers(host_bindings);
-    }
+    runtime.BindTransformFeedbackBuffers(host_bindings);
 }

 template <class P>
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Ryujinx Team and Contributors
@@ -20,9 +20,10 @@
 namespace Tegra {

 CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
-    : host1x{host1x_}, memory_manager{host1x.GMMU()},
-      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
-                                                                      static_cast<ChClassId>(id)} {
+    : host_processor{std::make_unique<Host1x::Control>(host1x_)}
+    , host1x{host1x_}
+    , current_class{ChClassId(id)}
+{
    thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
 }

@@ -1,3 +1,6 @@
+// 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

@@ -117,9 +120,6 @@ 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);

-    std::unique_ptr<Host1x::Control> host_processor;
-
-    std::mutex command_mutex;
-    std::condition_variable_any command_cv;
-    std::deque<ChCommandHeaderList> command_lists;
-    std::jthread thread;
-
+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;
    ChClassId current_class;
 };

@@ -89,7 +89,7 @@ struct GPU::Impl {
        renderer = std::move(renderer_);
        rasterizer = renderer->ReadRasterizer();
        host1x.MemoryManager().BindInterface(rasterizer);
-        host1x.GMMU().BindRasterizer(rasterizer);
+        host1x.gmmu_manager.BindRasterizer(rasterizer);
    }

    /// Flush all current written commands into the host GPU for execution.
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -92,7 +92,16 @@ void ThreadManager::InvalidateRegion(DAddr addr, u64 size) {
 }

 void ThreadManager::FlushAndInvalidateRegion(DAddr addr, u64 size) {
-    // Skip flush on asynch mode, as FlushAndInvalidateRegion is not used for anything too important
+    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);
+        }
+    }
    rasterizer->OnCacheInvalidation(addr, size);
 }

@@ -1,3 +1,6 @@
+// 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

@@ -6,12 +9,192 @@
 #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,
@@ -287,10 +470,7 @@ struct RefPoolElement {
    bool refresh{};
 };

-#define ASSERT_POSITION(field_name, position)                                                      \
-    static_assert(offsetof(Vp9EntropyProbs, field_name) == position,                               \
-                  "Field " #field_name " has invalid position")
-
+#define ASSERT_POSITION(field_name, position) static_assert(offsetof(Vp9EntropyProbs, field_name) == position)
 ASSERT_POSITION(partition_prob, 0x0024);
 ASSERT_POSITION(switchable_interp_prob, 0x0724);
 ASSERT_POSITION(sign, 0x0772);
@@ -298,10 +478,7 @@ 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,                                   \
-                  "Field " #field_name " has invalid position")
-
+#define ASSERT_POSITION(field_name, position) static_assert(offsetof(PictureInfo, field_name) == position)
 ASSERT_POSITION(bitstream_size, 0x30);
 ASSERT_POSITION(last_frame_size, 0x48);
 ASSERT_POSITION(first_level, 0x70);
@@ -309,9 +486,7 @@ 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,                                  \
-                  "Field " #field_name " has invalid position")
+#define ASSERT_POSITION(field_name, position) static_assert(offsetof(EntropyProbs, field_name) == position)

 ASSERT_POSITION(inter_mode_prob, 0x400);
 ASSERT_POSITION(tx_8x8_prob, 0x470);
@@ -321,5 +496,47 @@ 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
@@ -1,3 +1,6 @@
+// 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

@@ -13,9 +16,12 @@
 namespace Tegra {

 Codec::Codec(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs)
-    : 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)) {}
+    : host1x(host1x_)
+    , state{regs}
+    , h264_decoder(host1x_)
+    , vp8_decoder(host1x_)
+    , vp9_decoder(host1x_)
+{}

 Codec::~Codec() = default;

@@ -32,13 +38,11 @@ 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;
@@ -46,13 +50,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>{};
@@ -81,19 +85,13 @@ 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:
@@ -1,3 +1,6 @@
+// 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

@@ -8,17 +11,14 @@
 #include <string_view>
 #include <queue>
 #include "common/common_types.h"
-#include "video_core/host1x/ffmpeg/ffmpeg.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/nvdec_common.h"

 namespace Tegra {

-namespace Decoder {
-class H264;
-class VP8;
-class VP9;
-} // namespace Decoder
-
 namespace Host1x {
 class Host1x;
 } // namespace Host1x
@@ -40,9 +40,6 @@ 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;

@@ -53,10 +50,9 @@ private:

    Host1x::Host1x& host1x;
    const Host1x::NvdecCommon::NvdecRegisters& state;
-    std::unique_ptr<Decoder::H264> h264_decoder;
-    std::unique_ptr<Decoder::VP8> vp8_decoder;
-    std::unique_ptr<Decoder::VP9> vp9_decoder;
-
+    Decoders::H264 h264_decoder;
+    Decoders::VP8 vp8_decoder;
+    Decoders::VP9 vp9_decoder;
    std::queue<std::unique_ptr<FFmpeg::Frame>> frames{};
 };

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

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -12,10 +12,11 @@

 namespace Tegra {

-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(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_)
+    : host1x(host1x_)
+    , regs{regs_}
+    , id{id_}
+{}

 Decoder::~Decoder() = default;

@@ -53,11 +54,11 @@ void Decoder::Decode() {
        }

        if (UsingDecodeOrder()) {
-            frame_queue.PushDecodeOrder(id, luma_top, std::move(frame));
-            frame_queue.PushDecodeOrder(id, luma_bottom, std::move(frame_copy));
+            host1x.frame_queue.PushDecodeOrder(id, luma_top, std::move(frame));
+            host1x.frame_queue.PushDecodeOrder(id, luma_bottom, std::move(frame_copy));
        } else {
-            frame_queue.PushPresentOrder(id, luma_top, std::move(frame));
-            frame_queue.PushPresentOrder(id, luma_bottom, std::move(frame_copy));
+            host1x.frame_queue.PushPresentOrder(id, luma_top, std::move(frame));
+            host1x.frame_queue.PushPresentOrder(id, luma_bottom, std::move(frame_copy));
        }
    } else {
        auto [luma_offset, chroma_offset] = GetProgressiveOffsets();
@@ -68,9 +69,9 @@ void Decoder::Decode() {
        }

        if (UsingDecodeOrder()) {
-            frame_queue.PushDecodeOrder(id, luma_offset, std::move(frame));
+            host1x.frame_queue.PushDecodeOrder(id, luma_offset, std::move(frame));
        } else {
-            frame_queue.PushPresentOrder(id, luma_offset, std::move(frame));
+            host1x.frame_queue.PushPresentOrder(id, luma_offset, std::move(frame));
        }
    }
 }
@@ -14,7 +14,7 @@
 #include <queue>

 #include "common/common_types.h"
-#include "video_core/host1x/ffmpeg/ffmpeg.h"
+#include "video_core/host1x/ffmpeg.h"
 #include "video_core/host1x/nvdec_common.h"

 namespace Tegra {
@@ -35,33 +35,23 @@ 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,
-                     Host1x::FrameQueue& frame_queue);
+    explicit Decoder(Host1x::Host1x& host1x, s32 id, const Host1x::NvdecCommon::NvdecRegisters& regs);

    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;
-    Host1x::FrameQueue& frame_queue;
-    Host1x::NvdecCommon::VideoCodec codec;
-    FFmpeg::DecodeApi decode_api;
-    bool initialized{};
-    bool vp9_hidden_frame{};
+    bool initialized : 1 = false;
+    bool vp9_hidden_frame : 1 = false;
 };

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

 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -14,25 +14,11 @@
 #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,
-};

-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(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_)
+    : Decoder{host1x_, id_, regs_}
+{
+    initialized = decode_api.Initialize(Host1x::NvdecCommon::VideoCodec::H264);
 }

 H264::~H264() = default;
@@ -65,14 +51,11 @@ bool H264::IsInterlaced() {
 }

 std::span<const u8> H264::ComposeFrame() {
-    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context,
-                             sizeof(H264DecoderContext));
-
+    host1x.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);
-        memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data(),
-                                 frame_scratch.size());
+        host1x.memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data(), frame_scratch.size());
        return frame_scratch;
    }

@@ -174,15 +157,13 @@ std::span<const u8> H264::ComposeFrame() {

    for (s32 index = 0; index < 6; index++) {
        writer.WriteBit(true);
-        std::span<const u8> matrix{current_context.weight_scale_4x4};
-        writer.WriteScalingList(scan_scratch, matrix, index * 16, 16);
+        writer.WriteScalingList(current_context.weight_scale_4x4, index * 16, 16);
    }

    if (current_context.h264_parameter_set.transform_8x8_mode_flag) {
        for (s32 index = 0; index < 2; index++) {
            writer.WriteBit(true);
-            std::span<const u8> matrix{current_context.weight_scale_8x8};
-            writer.WriteScalingList(scan_scratch, matrix, index * 64, 64);
+            writer.WriteScalingList(current_context.weight_scale_8x8, index * 64, 64);
        }
    }

@@ -196,11 +177,7 @@ 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());
-
-    memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(),
-                             frame_scratch.data() + encoded_header.size(),
-                             current_context.stream_len);
-
+    host1x.memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data() + encoded_header.size(), current_context.stream_len);
    return frame_scratch;
 }

@@ -229,23 +206,37 @@ void H264BitWriter::WriteBit(bool state) {
    WriteBits(state ? 1 : 0, 1);
 }

-void H264BitWriter::WriteScalingList(Common::ScratchBuffer<u8>& scan, std::span<const u8> list,
-                                     s32 start, s32 count) {
-    scan.resize_destructive(count);
+void H264BitWriter::WriteScalingList(std::span<const u8> list, s32 start, s32 count) {
    if (count == 16) {
-        std::memcpy(scan.data(), zig_zag_scan.data(), scan.size());
+        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;
+        }
    } else {
-        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;
+        // 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;
+        }
    }
 }

@@ -286,19 +277,15 @@ void H264BitWriter::WriteBits(s32 value, s32 bit_count) {

 void H264BitWriter::WriteExpGolombCodedInt(s32 value) {
    const s32 sign = value <= 0 ? 0 : 1;
-    if (value < 0) {
-        value = -value;
-    }
-    value = (value << 1) - sign;
-    WriteExpGolombCodedUInt(value);
+    if (!sign) value = -value;
+    WriteExpGolombCodedUInt((value << 1) - sign);
 }

 void H264BitWriter::WriteExpGolombCodedUInt(u32 value) {
    const s32 size = 32 - std::countl_zero(value + 1);
    WriteBits(1, size);
-
    value -= (1U << (size - 1)) - 1;
-    WriteBits(static_cast<s32>(value), size - 1);
+    WriteBits(s32(value), size - 1);
 }

 s32 H264BitWriter::GetFreeBufferBits() {
@@ -1,3 +1,6 @@
+// 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

@@ -6,11 +9,10 @@
 #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 {
@@ -40,8 +42,7 @@ 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(Common::ScratchBuffer<u8>& scan, std::span<const u8> list, s32 start,
-                          s32 count);
+    void WriteScalingList(std::span<const u8> list, s32 start, s32 count);

    /// Return the bitstream as a vector.
    [[nodiscard]] std::vector<u8>& GetByteArray();
@@ -61,188 +62,9 @@ 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,
-                  Host1x::FrameQueue& frame_queue);
+    explicit H264(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id);
    ~H264() override;

    H264(const H264&) = delete;
@@ -263,10 +85,10 @@ public:
    }

 private:
-    bool is_first_frame{true};
-    Common::ScratchBuffer<u8> frame_scratch;
-    Common::ScratchBuffer<u8> scan_scratch;
    H264DecoderContext current_context{};
+    std::array<u8, 64> scan_scratch;
+    Common::ScratchBuffer<u8> frame_scratch;
+    bool is_first_frame{true};
 };

 } // namespace Decoders
@@ -1,3 +1,6 @@
+// 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

@@ -8,11 +11,10 @@
 #include "video_core/memory_manager.h"

 namespace Tegra::Decoders {
-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(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_)
+    : Decoder{host1x_, id_, regs_}
+{
+    initialized = decode_api.Initialize(Host1x::NvdecCommon::VideoCodec::VP8);
 }

 VP8::~VP8() = default;
@@ -25,35 +27,30 @@ 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[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()};
+    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();
    return {luma_top, luma_bottom, chroma_top, chroma_bottom};
 }

 std::span<const u8> VP8::ComposeFrame() {
-    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context,
-                             sizeof(VP8PictureInfo));
+    host1x.gmmu_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 = static_cast<size_t>(current_context.vld_buffer_size);
+    const auto bitstream_size = 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] |=
-        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
+    frame_scratch[0] |= u8((current_context.version & 7u) << 1u); // 3-bit version number
+    frame_scratch[0] |= u8(1u << 4u);             // 1-bit show_frame flag

    // The next 19-bits are the first partition size
-    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);
+    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);

    if (is_key_frame) {
        frame_scratch[3] = 0x9du;
@@ -61,15 +58,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] = static_cast<u8>(current_context.frame_width & 0xff);
-        frame_scratch[7] = static_cast<u8>(((current_context.frame_width >> 8) & 0x3f));
+        frame_scratch[6] = u8(current_context.frame_width & 0xff);
+        frame_scratch[7] = u8(((current_context.frame_width >> 8) & 0x3f));
        // 16 bits:(2 bits Vertical Scale << 14) | Height (14 bits)
-        frame_scratch[8] = static_cast<u8>(current_context.frame_height & 0xff);
-        frame_scratch[9] = static_cast<u8>(((current_context.frame_height >> 8) & 0x3f));
+        frame_scratch[8] = u8(current_context.frame_height & 0xff);
+        frame_scratch[9] = u8(((current_context.frame_height >> 8) & 0x3f));
    }
-    const u64 bitstream_offset = regs.frame_bitstream_offset.Address();
-    memory_manager.ReadBlock(bitstream_offset, frame_scratch.data() + header_size, bitstream_size);

+    const u64 bitstream_offset = regs.frame_bitstream_offset.Address();
+    host1x.gmmu_manager.ReadBlock(bitstream_offset, frame_scratch.data() + header_size, bitstream_size);
    return frame_scratch;
 }

@@ -1,3 +1,6 @@
+// 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,6 +14,7 @@
 #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 {

@@ -28,8 +32,7 @@ enum class Vp8SurfaceIndex : u32 {

 class VP8 final : public Decoder {
 public:
-    explicit VP8(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
-                 Host1x::FrameQueue& frame_queue);
+    explicit VP8(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id);
    ~VP8() override;

    VP8(const VP8&) = delete;
@@ -52,51 +55,8 @@ public:
    }

 private:
-    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{};
+    Common::ScratchBuffer<u8> frame_scratch;
 };

 } // namespace Decoders
@@ -1,10 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// 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

 #include <algorithm> // for std::copy
+#include <bit>
 #include <numeric>

 #include "common/alignment.h"
@@ -15,11 +16,11 @@

 namespace Tegra::Decoders {
 namespace {
-constexpr u32 diff_update_probability = 252;
-constexpr u32 frame_sync_code = 0x498342;
+static constexpr u32 diff_update_probability = 252;
+static constexpr u32 frame_sync_code = 0x498342;

 // Default compressed header probabilities once frame context resets
-constexpr Vp9EntropyProbs default_probs{
+static 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,
@@ -158,34 +159,6 @@ 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) {
@@ -227,25 +200,17 @@ constexpr std::array<u8, 254> map_lut{
 [[nodiscard]] s32 RemapProbability(s32 new_prob, s32 old_prob) {
    new_prob--;
    old_prob--;
-
-    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]);
+    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);
 }
 } // Anonymous namespace

-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(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_)
+    : Decoder{host1x_, id_, regs_}
+{
+    initialized = decode_api.Initialize(Host1x::NvdecCommon::VideoCodec::VP9);
 }

 VP9::~VP9() = default;
@@ -377,8 +342,7 @@ void VP9::WriteSegmentation(VpxBitStreamWriter& writer) {

    if (update_map) {
        EntropyProbs entropy_probs{};
-        memory_manager.ReadBlock(regs.vp9_prob_tab_buffer_offset.Address(), &entropy_probs,
-                                 sizeof(entropy_probs));
+        host1x.gmmu_manager.ReadBlock(regs.vp9_prob_tab_buffer_offset.Address(), &entropy_probs, sizeof(entropy_probs));

        auto WriteProb = [&](u8 prob) {
            bool coded = prob != 255;
@@ -442,8 +406,7 @@ void VP9::WriteSegmentation(VpxBitStreamWriter& writer) {
 }

 Vp9PictureInfo VP9::GetVp9PictureInfo() {
-    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_picture_info,
-                             sizeof(PictureInfo));
+    host1x.gmmu_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);
@@ -459,7 +422,7 @@ Vp9PictureInfo VP9::GetVp9PictureInfo() {

 void VP9::InsertEntropy(u64 offset, Vp9EntropyProbs& dst) {
    EntropyProbs entropy;
-    memory_manager.ReadBlock(offset, &entropy, sizeof(EntropyProbs));
+    host1x.gmmu_manager.ReadBlock(offset, &entropy, sizeof(EntropyProbs));
    entropy.Convert(dst);
 }

@@ -469,9 +432,7 @@ Vp9FrameContainer VP9::GetCurrentFrame() {
        // gpu.SyncGuestHost(); epic, why?
        current_frame.info = GetVp9PictureInfo();
        current_frame.bit_stream.resize(current_frame.info.bitstream_size);
-        memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(),
-                                 current_frame.bit_stream.data(),
-                                 current_frame.info.bitstream_size);
+        host1x.gmmu_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{
@@ -893,13 +854,9 @@ 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();
 }

@@ -929,7 +886,7 @@ void VpxRangeEncoder::Write(bool bit, s32 probability) {
        local_range = range - split;
    }

-    s32 shift = static_cast<s32>(norm_lut[local_range]);
+    s32 shift = s32(local_range == 0 ? 0 : (std::countl_zero<uint32_t>(local_range) - 24));
    local_range <<= shift;
    count += shift;

@@ -1,3 +1,6 @@
+// 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,7 +14,7 @@
 #include "common/scratch_buffer.h"
 #include "common/stream.h"
 #include "video_core/host1x/codecs/decoder.h"
-#include "video_core/host1x/codecs/vp9_types.h"
+#include "video_core/host1x/codec_types.h"
 #include "video_core/host1x/nvdec_common.h"

 namespace Tegra {
@@ -113,8 +116,7 @@ private:

 class VP9 final : public Decoder {
 public:
-    explicit VP9(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
-                 Host1x::FrameQueue& frame_queue);
+    explicit VP9(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id);
    ~VP9() override;

    VP9(const VP9&) = delete;
@@ -193,11 +195,10 @@ 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{};
@@ -9,7 +9,7 @@
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "core/memory.h"
-#include "video_core/host1x/ffmpeg/ffmpeg.h"
+#include "video_core/host1x/ffmpeg.h"
 #include "video_core/memory_manager.h"

 extern "C" {
@@ -34,7 +34,9 @@ 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)
@@ -105,18 +107,17 @@ 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);
 }

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

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

 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
@@ -12,9 +12,12 @@
 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{std::make_unique<Common::FlatAllocator<u32, 0, 32>>(1 << 12)} {}
+    : system{system_}
+    , syncpoint_manager{}
+    , memory_manager(system.DeviceMemory())
+    , gmmu_manager{system, memory_manager, 32, 0, 12}
+    , allocator{1 << 12}
+{}

 Host1x::~Host1x() = default;

@@ -24,13 +27,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, frame_queue);
+        devices[fd] = std::make_unique<Tegra::Host1x::Nvdec>(*this, fd, syncpt);
        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, frame_queue);
+        devices[fd] = std::make_unique<Tegra::Host1x::Vic>(*this, fd, syncpt);
        break;
    default:
        LOG_ERROR(HW_GPU, "Unimplemented host1x device {}", static_cast<u32>(type));
@@ -184,20 +184,12 @@ 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);
@@ -211,12 +203,11 @@ public:
        it->second->PushEntries(std::move(entries));
    }

-private:
    Core::System& system;
    SyncpointManager syncpoint_manager;
    Tegra::MaxwellDeviceMemoryManager memory_manager;
    Tegra::MemoryManager gmmu_manager;
-    std::unique_ptr<Common::FlatAllocator<u32, 0, 32>> allocator;
+    Common::FlatAllocator<u32, 0, 32> allocator;
    FrameQueue frame_queue;
    ankerl::unordered_dense::map<s32, std::unique_ptr<CDmaPusher>> devices;
 #ifdef YUZU_LEGACY
@@ -1,9 +1,10 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// 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

+#include <variant>
 #include "common/assert.h"

 #include "common/polyfill_thread.h"
@@ -19,10 +20,13 @@ namespace Tegra::Host1x {
 #define NVDEC_REG_INDEX(field_name)                                                                \
    (offsetof(NvdecCommon::NvdecRegisters, field_name) / sizeof(u64))

-Nvdec::Nvdec(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_)
-    : CDmaPusher{host1x_, id_}, id{id_}, syncpoint{syncpt}, frame_queue{frame_queue_} {
+Nvdec::Nvdec(Host1x& host1x_, s32 id_, u32 syncpt)
+    : CDmaPusher{host1x_, id_}
+    , id{id_}
+    , syncpoint{syncpt}
+{
    LOG_INFO(HW_GPU, "Created nvdec {}", id);
-    frame_queue.Open(id);
+    host1x.frame_queue.Open(id);
 }

 Nvdec::~Nvdec() {
@@ -43,24 +47,22 @@ void Nvdec::ProcessMethod(u32 method, u32 argument) {
 }

 void Nvdec::CreateDecoder(NvdecCommon::VideoCodec codec) {
-    if (decoder.get()) {
-        return;
+    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);
    }
-    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() {
@@ -70,15 +72,14 @@ void Nvdec::Execute() {
        std::this_thread::sleep_for(std::chrono::milliseconds(8));
        return;
    }
-    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;
+    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?");
    }
 }

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

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -8,10 +8,14 @@

 #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 {

@@ -21,7 +25,7 @@ class FrameQueue;

 class Nvdec final : public CDmaPusher {
 public:
-    explicit Nvdec(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue_);
+    explicit Nvdec(Host1x& host1x, s32 id, u32 syncpt);
    ~Nvdec();

    /// Writes the method into the state, Invoke Execute() if encountered
@@ -38,12 +42,15 @@ 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
@@ -85,18 +85,17 @@ void SwizzleSurface(std::span<u8> output, u32 out_stride, std::span<const u8> in

 } // namespace

-Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt, FrameQueue& frame_queue_) noexcept :
-    CDmaPusher{host1x_, id_}
+Vic::Vic(Host1x& host1x_, s32 id_, u32 syncpt) 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);
-    frame_queue.Close(id);
+    host1x.frame_queue.Close(id);
 }

 void Vic::ProcessMethod(u32 method, u32 arg) noexcept {
@@ -113,7 +112,7 @@ void Vic::ProcessMethod(u32 method, u32 arg) noexcept {

 void Vic::Execute() noexcept {
    ConfigStruct config{};
-    memory_manager.ReadBlock(regs.config_struct_offset.Address(), &config, sizeof(ConfigStruct));
+    host1x.gmmu_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;
@@ -124,8 +123,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 = frame_queue.VicFindNvdecFdFromOffset(luma_offset);
-                if (auto frame = frame_queue.GetFrame(nvdec_id, luma_offset); frame.get()) {
+                    nvdec_id = host1x.frame_queue.VicFindNvdecFdFromOffset(luma_offset);
+                if (auto frame = host1x.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);
@@ -881,8 +880,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(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);
+        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);
        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);
@@ -910,8 +909,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());
-        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);
+        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);
    } break;
    default:
        UNREACHABLE();
@@ -1046,7 +1045,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(memory_manager, regs.output_surface.luma.Address(), out_swizzle_size, &swizzle_scratch);
+        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(host1x.gmmu_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 {
@@ -1061,7 +1060,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(memory_manager, regs.output_surface.luma.Address(), out_luma_size, &luma_scratch);
+        Tegra::Memory::GpuGuestMemoryScoped<u8, Core::Memory::GuestMemoryFlags::SafeWrite> out_luma(host1x.gmmu_manager, regs.output_surface.luma.Address(), out_luma_size, &luma_scratch);
        Decode(out_luma.data(), output_surface.data());
    } break;
    default:
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -15,6 +15,7 @@
 #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;
@@ -605,7 +606,7 @@ public:
        SetOutputSurfaceChromaUnusedOffset = offsetof(VicRegisters, output_surface.chroma_v)
    };

-    explicit Vic(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue) noexcept;
+    explicit Vic(Host1x& host1x, s32 id, u32 syncpt) noexcept;
    ~Vic() noexcept;

    /// Write to the device state.
@@ -620,18 +621,17 @@ 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
@@ -1,3 +1,6 @@
+// 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

@@ -5,16 +8,22 @@

 layout(local_size_x = 1) in;

-layout(std430, binding = 0) buffer Query {
-    uvec2 initial;
-    uvec2 unknown;
-    uvec2 current;
+layout(std430, binding = 0) readonly buffer Query {
+    uint data[];
 };

-layout(std430, binding = 1) buffer Result {
+layout(std430, binding = 1) writeonly buffer Result {
    uint result;
 };

+layout(push_constant) uniform PushConstants {
+    uint compare_to_zero;
+};
+
 void main() {
-    result = all(equal(initial, current)) ? 1 : 0;
+    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;
+    }
 }
@@ -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();
-    auto topology = Maxwell3D::Regs::PrimitiveTopology(parameters[0] & 0xFFFFU);
-    if (!force && (!maxwell3d.AnyParametersDirty() || !IsTopologySafe(topology))) {
+    if (!force) {
        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;
@@ -412,6 +412,7 @@ 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) &&
@@ -1,3 +1,6 @@
+// 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

@@ -75,7 +78,7 @@ public:
    }

    u64 GetDependentMask() const {
-        return dependence_mask;
+        return dependent_mask;
    }

    u64 GetAmendValue() const {
@@ -629,6 +629,9 @@ 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);
 }

@@ -190,9 +190,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
            }
        }
    }
-    if (!extended_dynamic_state_3_enables) {
-        dynamic_state.Refresh3(regs);
-    }
+    dynamic_state.Refresh3(regs, features);
    if (xfb_enabled) {
        RefreshXfbState(xfb_state, regs);
    }
@@ -295,16 +293,22 @@ 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) {
-    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);
+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);
+    }
 }

 size_t FixedPipelineState::Hash() const noexcept {
@@ -27,6 +27,9 @@ 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;
@@ -175,7 +178,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);
+        void Refresh3(const Maxwell& regs, const DynamicFeatures& features);

        Maxwell::ComparisonOp DepthTestFunc() const noexcept {
            return UnpackComparisonOp(depth_test_func);
@@ -265,8 +268,7 @@ struct FixedPipelineState {
            return sizeof(*this);
        }
        if (dynamic_vertex_input && extended_dynamic_state_3_blend) {
-            // Exclude dynamic state and attributes
-            return offsetof(FixedPipelineState, dynamic_state);
+            return offsetof(FixedPipelineState, attachments);
        }
        if (dynamic_vertex_input) {
            // Exclude dynamic state
@@ -8,6 +8,7 @@
 #include <array>
 #include <cstring>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <vector>
@@ -171,7 +172,11 @@ try

 RendererVulkan::~RendererVulkan() {
    scheduler.RegisterOnSubmit([] {});
-    void(device.GetLogical().WaitIdle());
+    scheduler.Finish();
+    {
+        std::scoped_lock lock{scheduler.submit_mutex};
+        void(device.GetLogical().WaitIdle());
+    }
 }

 void RendererVulkan::Composite(std::span<const Tegra::FramebufferConfig> framebuffers) {
@@ -8,6 +8,7 @@
 // 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"
@@ -31,7 +32,10 @@ BlitScreen::~BlitScreen() = default;
 void BlitScreen::WaitIdle() {
    present_manager.WaitPresent();
    scheduler.Finish();
-    device.GetLogical().WaitIdle();
+    {
+        std::scoped_lock lock{scheduler.submit_mutex};
+        device.GetLogical().WaitIdle();
+    }
 }

 void BlitScreen::SetWindowAdaptPass() {
@@ -637,12 +637,10 @@ 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] = VK_WHOLE_SIZE;
-            if (!device.HasNullDescriptor()) {
-                ReserveNullBuffer();
-                handle = *null_buffer;
-            }
+            bindings.sizes[i] = 0;
        }
        buffer_handles[i] = handle;
    }
@@ -228,6 +228,10 @@ struct QueriesPrefixScanPushConstants {
    u32 accumulation_limit;
    u32 buffer_offset;
 };
+
+struct ConditionalRenderingResolvePushConstants {
+    u32 compare_to_zero;
+};
 } // Anonymous namespace

 ComputePass::ComputePass(const Device& device_, DescriptorPool& descriptor_pool,
@@ -413,7 +417,8 @@ 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, nullptr,
+                  INPUT_OUTPUT_DESCRIPTOR_UPDATE_TEMPLATE, INPUT_OUTPUT_BANK_INFO,
+                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(ConditionalRenderingResolvePushConstants)>,
                  RESOLVE_CONDITIONAL_RENDER_COMP_SPV),
      scheduler{scheduler_}, compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}

@@ -430,7 +435,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](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([this, descriptor_data, compare_to_zero](vk::CommandBuffer cmdbuf) {
        static constexpr VkMemoryBarrier read_barrier{
            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
            .pNext = nullptr,
@@ -443,6 +448,9 @@ 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);

@@ -450,9 +458,11 @@ 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_ALL_COMMANDS_BIT, 0, write_barrier);
+                               VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, 0,
+                               write_barrier);
    });
 }

@@ -520,7 +530,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_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_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, {});
@@ -467,6 +467,10 @@ 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);

@@ -485,6 +485,12 @@ 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 =
@@ -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,
+        .flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
        .imageType = VK_IMAGE_TYPE_2D,
        .format = swapchain.GetImageFormat(),
        .extent =
@@ -157,8 +157,9 @@ 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);
        });
@@ -220,8 +221,7 @@ public:
        }
        PauseCounter();
        const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
            pending_sync.clear();
            sync_values_stash.clear();
            return;
@@ -666,13 +666,18 @@ 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 = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                     VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT,
+            .usage = counter_buffer_usage,
            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
            .queueFamilyIndexCount = 0,
            .pQueueFamilyIndices = nullptr,
@@ -692,6 +697,9 @@ public:
    ~TFBCounterStreamer() = default;

    void StartCounter() override {
+        if (!device.IsExtTransformFeedbackSupported()) {
+            return;
+        }
        FlushBeginTFB();
        has_started = true;
    }
@@ -706,7 +714,9 @@ public:

    void CloseCounter() override {
        if (has_flushed_end_pending) {
-            FlushEndTFB();
+            if (scheduler.IsRenderPassActive()) {
+                FlushEndTFB();
+            }
        }
        runtime.View3DRegs([this](Maxwell3D& maxwell3d) {
            if (maxwell3d.regs.transform_feedback_enabled == 0) {
@@ -756,18 +766,33 @@ 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(subreport);
+        auto [bank_slot, data_slot] = ProduceCounterBuffer(slot);
        new_query->start_bank_id = static_cast<u32>(bank_slot);
        new_query->size_banks = 1;
        new_query->start_slot = static_cast<u32>(data_slot);
@@ -778,6 +803,9 @@ 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;
@@ -789,6 +817,10 @@ public:
        return out_topology;
    }

+    u32 GetPatchVertices() const {
+        return patch_vertices;
+    }
+
    bool HasUnsyncedQueries() const override {
        return !pending_flush_queries.empty();
    }
@@ -855,6 +887,9 @@ public:

 private:
    void FlushBeginTFB() {
+        if (!device.IsExtTransformFeedbackSupported()) [[unlikely]] {
+            return;
+        }
        if (has_flushed_end_pending) [[unlikely]] {
            return;
        }
@@ -868,12 +903,24 @@ 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;
@@ -899,28 +946,48 @@ 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 stream) {
+    std::pair<size_t, size_t> ProduceCounterBuffer(size_t slot_index) {
        if (current_bank == nullptr || current_bank->IsClosed()) {
            current_bank_id =
                bank_pool.ReserveBank([this](std::deque<TFBQueryBank>& queue, size_t index) {
@@ -946,7 +1013,8 @@ private:
        };
        scheduler.RequestOutsideRenderPassOperationContext();
        scheduler.Record([dst_buffer = current_bank->GetBuffer(),
-                          src_buffer = counter_buffers[stream], src_offset = offsets[stream],
+                          src_buffer = counter_buffers[slot_index],
+                          src_offset = offsets[slot_index],
                          slot](vk::CommandBuffer cmdbuf) {
            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
@@ -965,6 +1033,7 @@ private:
    friend class PrimitivesSucceededStreamer;

    static constexpr size_t NUM_STREAMS = 4;
+    static constexpr size_t INVALID_SLOT = NUM_STREAMS;

    QueryCacheRuntime& runtime;
    const Device& device;
@@ -994,7 +1063,9 @@ 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;
 };

@@ -1015,6 +1086,7 @@ 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{};
 };
@@ -1031,6 +1103,10 @@ 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();
@@ -1048,6 +1124,7 @@ 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;
@@ -1068,6 +1145,7 @@ 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) {
@@ -1131,27 +1209,39 @@ 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 / 2) + 1;
+                    return num_vertices > 1 ? num_vertices : 0;
                case Maxwell3D::Regs::PrimitiveTopology::LineStrip:
-                    return num_vertices - 1;
-                case Maxwell3D::Regs::PrimitiveTopology::Patches:
+                    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);
                case Maxwell3D::Regs::PrimitiveTopology::Triangles:
-                case Maxwell3D::Regs::PrimitiveTopology::TrianglesAdjacency:
                    return num_vertices / 3;
+                case Maxwell3D::Regs::PrimitiveTopology::TrianglesAdjacency:
+                    return num_vertices / 6;
                case Maxwell3D::Regs::PrimitiveTopology::TriangleFan:
                case Maxwell3D::Regs::PrimitiveTopology::TriangleStrip:
+                    return saturating_subtract(num_vertices, 2);
                case Maxwell3D::Regs::PrimitiveTopology::TriangleStripAdjacency:
-                    return num_vertices - 2;
+                    return num_vertices > 4 ? (num_vertices - 4) / 2 : 0;
                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 1U;
+                    return num_vertices >= 3 ? 1U : 0U;
+                case Maxwell3D::Regs::PrimitiveTopology::Patches:
+                    return num_vertices / std::max<u64>(query->patch_vertices, 1U);
                default:
                    return num_vertices;
                }
@@ -1202,16 +1292,24 @@ struct QueryCacheRuntimeImpl {
        hcr_setup.pNext = nullptr;
        hcr_setup.flags = 0;

-        conditional_resolve_pass = std::make_unique<ConditionalRenderingResolvePass>(
-            device, scheduler, descriptor_pool, compute_pass_descriptor_queue);
+        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;
+        }

        const VkBufferCreateInfo buffer_ci = {
            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .size = sizeof(u32),
-            .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-                     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT,
+            .usage = hcr_buffer_usage,
            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
            .queueFamilyIndexCount = 0,
            .pQueueFamilyIndices = nullptr,
@@ -1338,15 +1436,17 @@ void QueryCacheRuntime::HostConditionalRenderingCompareValueImpl(VideoCommon::Lo
    }
 }

-void QueryCacheRuntime::HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal) {
+void QueryCacheRuntime::HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal,
+                                                              bool compare_to_zero) {
    VkBuffer to_resolve;
    u32 to_resolve_offset;
+    const u32 resolve_size = compare_to_zero ? 8 : 24;
    {
        std::scoped_lock lk(impl->buffer_cache.mutex);
-        static constexpr auto sync_info = VideoCommon::ObtainBufferSynchronize::NoSynchronize;
+        const auto sync_info = VideoCommon::ObtainBufferSynchronize::FullSynchronize;
        const auto post_op = VideoCommon::ObtainBufferOperation::DoNothing;
        const auto [buffer, offset] =
-            impl->buffer_cache.ObtainCPUBuffer(address, 24, sync_info, post_op);
+            impl->buffer_cache.ObtainCPUBuffer(address, resolve_size, sync_info, post_op);
        to_resolve = buffer->Handle();
        to_resolve_offset = static_cast<u32>(offset);
    }
@@ -1355,7 +1455,7 @@ void QueryCacheRuntime::HostConditionalRenderingCompareBCImpl(DAddr address, boo
        PauseHostConditionalRendering();
    }
    impl->conditional_resolve_pass->Resolve(*impl->hcr_resolve_buffer, to_resolve,
-                                            to_resolve_offset, false);
+                                            to_resolve_offset, compare_to_zero);
    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;
@@ -1371,7 +1471,7 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValue(VideoCommon::Lookup
    if (!impl->device.IsExtConditionalRendering()) {
        return false;
    }
-    HostConditionalRenderingCompareValueImpl(object_1, false);
+    HostConditionalRenderingCompareBCImpl(object_1.address, true, true);
    return true;
 }

@@ -1420,7 +1520,8 @@ 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_QUALCOMM_PROPRIETARY || driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+    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();
        return true;
    }

@@ -1437,10 +1538,12 @@ 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);
@@ -63,7 +63,8 @@ public:

 private:
    void HostConditionalRenderingCompareValueImpl(VideoCommon::LookupData object, bool is_equal);
-    void HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal);
+    void HostConditionalRenderingCompareBCImpl(DAddr address, bool is_equal,
+                                               bool compare_to_zero = false);
    friend struct QueryCacheRuntimeImpl;
    std::unique_ptr<QueryCacheRuntimeImpl> impl;
 };
@@ -173,6 +173,28 @@ 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_,
@@ -225,6 +247,7 @@ 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);
@@ -336,6 +359,7 @@ 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();
@@ -575,11 +599,17 @@ void RasterizerVulkan::DispatchCompute() {
 }

 void RasterizerVulkan::ResetCounter(VideoCommon::QueryType type) {
-    if (type != VideoCommon::QueryType::ZPassPixelCount64) {
+    switch (type) {
+    case VideoCommon::QueryType::ZPassPixelCount64:
+    case VideoCommon::QueryType::StreamingByteCount:
+    case VideoCommon::QueryType::StreamingPrimitivesSucceeded:
+    case VideoCommon::QueryType::VtgPrimitivesOut:
+        query_cache.CounterReset(type);
+        return;
+    default:
        LOG_DEBUG(Render_Vulkan, "Unimplemented counter reset={}", type);
        return;
    }
-    query_cache.CounterReset(type);
 }

 void RasterizerVulkan::Query(GPUVAddr gpu_addr, VideoCommon::QueryType type,
@@ -766,6 +796,9 @@ 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);
 }

@@ -830,6 +863,10 @@ 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) {
@@ -976,6 +1013,12 @@ 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);
@@ -1084,6 +1127,9 @@ 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);
@@ -1101,8 +1147,12 @@ void RasterizerVulkan::UpdateViewportsState(Tegra::Engines::Maxwell3D::Regs& reg
            .minDepth = 0.0f,
            .maxDepth = 1.0f,
        };
-        scheduler.Record([viewport](vk::CommandBuffer cmdbuf) {
-            cmdbuf.SetViewport(0, viewport);
+        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);
        });
        return;
    }
@@ -1142,8 +1192,12 @@ 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([scissor](vk::CommandBuffer cmdbuf) {
-            cmdbuf.SetScissor(0, scissor);
+        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);
        });
        return;
    }
@@ -1388,7 +1442,17 @@ void RasterizerVulkan::UpdatePrimitiveRestartEnable(Tegra::Engines::Maxwell3D::R
    if (!state_tracker.TouchPrimitiveRestartEnable()) {
        return;
    }
-    scheduler.Record([enable = regs.primitive_restart.enabled](vk::CommandBuffer cmdbuf) {
+
+    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) {
        cmdbuf.SetPrimitiveRestartEnableEXT(enable);
    });
 }
@@ -1727,7 +1791,9 @@ void RasterizerVulkan::UpdateStencilTestEnable(Tegra::Engines::Maxwell3D::Regs&

 void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs) {
    auto& dirty{maxwell3d->dirty.flags};
-    if (!dirty[Dirty::VertexInput]) {
+    const bool vertex_input_dirty = dirty[Dirty::VertexInput];
+    const bool vertex_buffers_dirty = dirty[VideoCommon::Dirty::VertexBuffers];
+    if (!vertex_input_dirty && !vertex_buffers_dirty) {
        return;
    }
    dirty[Dirty::VertexInput] = false;
@@ -1735,38 +1801,31 @@ void RasterizerVulkan::UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs)
    boost::container::static_vector<VkVertexInputBindingDescription2EXT, 32> bindings;
    boost::container::static_vector<VkVertexInputAttributeDescription2EXT, 32> attributes;

-    // 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 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) {
        const Maxwell::VertexAttribute attribute{regs.vertex_attrib_format[index]};
        const u32 binding{attribute.buffer};
-        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]) {
+        if (attribute.constant || binding >= max_bindings) {
            continue;
        }
-        dirty[Dirty::VertexBinding0 + index] = false;
+        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,
+        });
+    }

-        const u32 binding{static_cast<u32>(index)};
+    for (u32 binding = 0; binding < max_bindings; ++binding) {
        const auto& input_binding{regs.vertex_streams[binding]};
        const bool is_instanced{regs.vertex_stream_instances.IsInstancingEnabled(binding)};
        bindings.push_back({
@@ -1778,6 +1837,14 @@ 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);
    });
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -122,6 +122,7 @@ 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;
@@ -324,6 +324,8 @@ 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()) {
@@ -63,6 +63,11 @@ 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);

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

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -87,6 +87,7 @@ 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;
 }
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -176,7 +176,18 @@ 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;
+        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;
+        }
+
        if (device.IsKhrImageFormatListSupported()) {
            image_ci.pNext = &image_format_list;
        }
@@ -668,11 +679,16 @@ void CopyBufferToImage(vk::CommandBuffer cmdbuf, VkBuffer src_buffer, VkImage im
 }

 void TryTransformSwizzleIfNeeded(PixelFormat format, std::array<SwizzleSource, 4>& swizzle,
-                                 bool emulate_a4b4g4r4) {
+                                 bool emulate_bgr565, 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;
@@ -2119,22 +2135,21 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
    if (!info.IsRenderTarget()) {
        swizzle = info.Swizzle();
        TryTransformSwizzleIfNeeded(format, swizzle,
-                                    !device->IsExt4444FormatsSupported());
+                        device->MustEmulateBGR565(),
+                        !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);
-    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 VkImageUsageFlags requested_view_usage = ImageUsageFlags(format_info, format);
+    const VkImageUsageFlags image_usage = image.UsageFlags();
+    const VkImageUsageFlags clamped_view_usage = requested_view_usage & image_usage;
    const VkImageViewUsageCreateInfo image_view_usage{
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
        .pNext = nullptr,
-        .usage = ImageUsageFlags(format_info, format),
+        .usage = clamped_view_usage,
    };
    const VkImageViewCreateInfo create_info{
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@@ -2300,23 +2315,18 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_

 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
    const auto& device = runtime.device;
-    // 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 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();
    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 = border_format,
+        .format = VK_FORMAT_UNDEFINED,
    };
    const void* pnext = nullptr;
    if (has_custom_border_colors) {
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 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()) {
@@ -869,6 +869,10 @@ 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;
@@ -919,6 +923,17 @@ 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

@@ -1131,8 +1146,6 @@ 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;
@@ -1148,24 +1161,13 @@ 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) {
-        // 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;
-        }
+        extensions.custom_border_color =
+            features.custom_border_color.customBorderColors &&
+            features.custom_border_color.customBorderColorWithoutFormat;
    }
    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 =
@@ -1251,16 +1253,22 @@ void Device::RemoveUnsuitableExtensions() {
                                       VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);

    // VK_EXT_robustness2
-    extensions.robustness_2 = features.robustness2.robustBufferAccess2 ||
-                              features.robustness2.robustImageAccess2 ||
-                              features.robustness2.nullDescriptor;
+    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;

    RemoveExtensionFeatureIfUnsuitable(extensions.robustness_2, features.robustness2,
-                                       VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
+                                       robustness2_extension_name);

-    // VK_EXT_image_robustness
-    extensions.image_robustness = features.image_robustness.robustImageAccess;
-    RemoveExtensionFeatureIfUnsuitable(extensions.image_robustness, features.image_robustness,
+    // Image robustness
+    extensions.robust_image_access = features.robust_image_access.robustImageAccess;
+    RemoveExtensionFeatureIfUnsuitable(extensions.robust_image_access,
+                                       features.robust_image_access,
                                       VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME);

    // VK_KHR_shader_atomic_int64
@@ -1288,8 +1296,7 @@ void Device::RemoveUnsuitableExtensions() {
    // VK_EXT_transform_feedback
    extensions.transform_feedback =
        features.transform_feedback.transformFeedback &&
-        properties.transform_feedback.maxTransformFeedbackBuffers > 0 &&
-        properties.transform_feedback.transformFeedbackQueries;
+        properties.transform_feedback.maxTransformFeedbackBuffers > 0;
    RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
                                       VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);

@@ -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, image_robustness)                              \
+    FEATURE(EXT, ImageRobustness, IMAGE_ROBUSTNESS, robust_image_access)                           \
    FEATURE(EXT, ShaderDemoteToHelperInvocation, SHADER_DEMOTE_TO_HELPER_INVOCATION,               \
            shader_demote_to_helper_invocation)                                                    \
    FEATURE(EXT, SubgroupSizeControl, SUBGROUP_SIZE_CONTROL, subgroup_size_control)                \
@@ -68,8 +68,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
            pipeline_executable_properties)                                                        \
    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
-            workgroup_memory_explicit_layout)                                                      \
-    FEATURE(KHR, UnifiedImageLayouts, UNIFIED_IMAGE_LAYOUTS, unified_image_layouts)
+            workgroup_memory_explicit_layout)


 // Define miscellaneous extensions which may be used by the implementation here.
@@ -124,7 +123,6 @@ 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)                               \
@@ -174,13 +172,11 @@ VK_DEFINE_HANDLE(VmaAllocator)
    FEATURE_NAME(depth_bias_control, depthBiasExact)                                               \
    FEATURE_NAME(extended_dynamic_state, extendedDynamicState)                                     \
    FEATURE_NAME(format_a4b4g4r4, formatA4B4G4R4)                                                  \
-    FEATURE_NAME(image_robustness, robustImageAccess)                                              \
+    FEATURE_NAME(robust_image_access, 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)                                            \
@@ -542,6 +538,17 @@ 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;
@@ -552,36 +559,6 @@ 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;
@@ -805,6 +782,8 @@ public:
        return features.robustness2.nullDescriptor;
    }

+    bool MustEmulateBGR565() const;
+
    bool HasExactDepthBiasControl() const {
        return features.depth_bias_control.depthBiasExact;
    }
@@ -123,6 +123,7 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
    X(vkCmdEndDebugUtilsLabelEXT);
    X(vkCmdFillBuffer);
    X(vkCmdPipelineBarrier);
+    X(vkCmdResetQueryPool);
    X(vkCmdPushConstants);
    X(vkCmdPushDescriptorSetWithTemplateKHR);
    X(vkCmdSetBlendConstants);
@@ -225,6 +225,7 @@ struct DeviceDispatch : InstanceDispatch {
    PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT{};
    PFN_vkCmdFillBuffer vkCmdFillBuffer{};
    PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier{};
+    PFN_vkCmdResetQueryPool vkCmdResetQueryPool{};
    PFN_vkCmdPushConstants vkCmdPushConstants{};
    PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR{};
    PFN_vkCmdResolveImage vkCmdResolveImage{};
@@ -1168,6 +1169,10 @@ 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(),
Author	SHA1	Message	Date
lizzie	f6cab5068b	fix nvdec	2026-04-24 20:26:48 +02:00
lizzie	b5512f0708	[host1x] inline nvenc, fix ffmpeg not having va-api on freebsd Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-04-24 20:26:48 +02:00
crueter	26ce96297c	[frontend] Change update checker to use new endpoints (#3879 ) Related: [RFC3870](https://git.eden-emu.dev/eden-emu/eden/issues/3870) Nightly and stable releases are now served through `nightly.eden-emu.dev` and `stable.eden-emu.dev`, respectively. These are stored using Backblaze, and served and cached through the Cloudflare CDN. Ideally this will reduce costs, though I'll have to wait for my first invoice to be certain. These will serve as the new download locations going forward. Since we have full control over this API, we can make any adjustments we want as needed. For now, all it does is provide `tag_name`, `name`, and `body`, the latter of which will be used for the upcoming updater PR. Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3879 Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-04-24 18:40:49 +02:00
CamilleLaVey	b3cc8723c1	[vulkan] 2nd Vulkan Global Maintenance (#3853 ) This pr is a sequel to the one merged some days ago (#3839); which aims to improve stability, graphical accuracy and better Vulkan implementation and coherency among all platforms, contains the next changes: -> Removal of VK_EXT_unified_image_layouts: The removal of this ext was for cleaning purposes since the only part of this extension implemented was the activator; meanwhile a proper structure of use for this extension was not implemented, currently it's not viable to keep following an idea of a proper implementation due to complexity of this feature and the state of buffer cache and texture cache, which it's task that we must do near in the future, when this happens a better oportunity will arise to properly set layouts along a proper implementation of VK_EXT_descriptors_indexing, practically this feature was dead code. -> Adjustment of VK_EXT_custom_border_color: The implementation of this feature was handled poorly and worsened during the first tries of making ExtendedDynamicState stable, by gating it's use to the slider of EDS (dyna_state) if the counter was at least in 1, even tho this entered in a bug with the RemoveUnsuitableExtension, when is not a requirement for enabling in Vulkan's documentation and was my mistake, some time later in ExtendedDynamicState refactor (#3074) I tried to make the implementation more robust in comparison the Yuzu's implementation which had bans on vendor drivers, the new handling was requesting if extension was available and what kind of support feature it had, enabling what it was available and wiring an adequate path for said available feature; which leads us to today's change, after reading carefully how certain paths weren't triggered or caused mostly issues on how extension should work I did the next changes: - I removed the forced disabling with ExtendedDynamicState setting - Resolved the bug with RemoveUnsuitableExtension + dyna_state - Removed comments of explanation + log_debug warning - Set extension to be disabled if customBorderColorWithoutFormat is not available - Helps to solidify the removal of bans in vendor drivers This changes fixes the VUID 04015 for the handling with undefined format and made the usage of the extension more near to what Vulkan specification expects, yet there is still cases where we can't emulate properly samplers and some translucid black boxes will still appear, yet, now alleviated by allowing extension choose the proper custom available in Vulkan or degrade into a fallaback of solid colors. -> Adjustment of VK_EXT/KHR_robustness2: This feature was introduced in ExtendedDynamicState refactor (#3074), as safety measure for descriptors during the Write of buffers, providing robustness with an upgraded access to image, buffers and proper discard of null data in descriptors, however, despite the configuration the logs during debug sessions never stopped to bring the next VUID-VkWriteDescriptorSet-descriptorType-00324 and VUID-VkWriteDescriptorSet-descriptorType-00325, being the first one, the most constant issue plaguing logs; the approach was not only ensuring device can access between each of the version of this feature, whether is an EXT or KHR (drivers can report one of them or both, yet, if we call the one of them and it's not the version supported, driver would not load the feature, there's a priority to the KHR version) with a simplified configuration of the extension to use only nullDescritor to deflect properly buffers and other trash data outside of descriptors bound; ensuring to wire the path when it's and not available and also with BindVertexBuffers2EXT when it's or not available; fixing both VUID's. This changes helps to save some CPU resources and memory on binding routes. - Fixes VUID-VkWriteDescriptorSet-descriptorType-00324 - Fixes VUID-VkWriteDescriptorSet-descriptorType-00325 - Fixes VUID-vkCmdBindVertexBuffers-pBuffers-00621 (alongisde a latter adjustment for pStrides) -> Adjustment VK_EXT_image_robustness: As other features, this was implemented during the ExtendedDynamicState refactor (#3074), currently this change it's just to ensure more drivers are accessing this feature by changing the modality from extension to an explicit feature, some other redundant code was cleaned within this change. -> Restored gating flush operation on removed gpu accuracy: An issue report from an user called CaptFaraday in https://github.com/eden-emulator/Issue-Reports/issues/425, posted a behavior appearing after the rework of gpu accuracy levels (#3129), which broke the rendering in Paper Mario - The-Thousand-Year Door where some graphical issues such as black flash and missing rendering from many animations through the game thanks to the removal of the flush inside FlushAndInvalidateRegion gated with IsGPULevelExtreme and suggested a possible fix with resting the missing gating and flush; which I did and properly restoring the complete behavior of this functionality + wiring to the new IsGPULevelHigh for a better semantic correctness, the change was tested and didn't affected Yoshi's Crafted World graphical problems and main reason behind the deletion of this function, fixed in `fcfcee7247`. - Solves https://github.com/eden-emulator/Issue-Reports/issues/266 - Solves https://github.com/eden-emulator/Issue-Reports/issues/425 - Fixes Paper Mario - The-Thousand-Year Door - Keeps Yoshi's Crafted World issue still fixed -> Adjustment VK_EXT_conditional_rendering: Yuzu inherited us in their Vulkan backend multiple flaws which got worsened with the time as game and drivers changed, aside that, with the time studying this source code and especially the Vulkan-side of Eden, I started to learn and recognize some extensions that required a wide and robust modification to ensure the logic of the extension works as intended; currently ConditionalRendering had a lot of minimal modification: - Reordering the functions from "_NotifySegment_" to avoid a masive ram leak coming from query_cache (@weakboson) (#131) - Removing a function "_NotifySegment_" from rasterizer to ensure Metroid Prime 4 stopped crashing due to serious ram leaks in query_cache (@Maufeat) (#3142) And other intents to make ConditionalRendering fully working, such as happened in ExtendedDynamicState refactor (#3074) but only patched an horrible situation with how the extension was truly working, after spending more than 3 months studying how this and other sub-sequential and essential extensions touched in this PR worked in Vulkan, I dived once again to make it work properly; one of the first changes was to fix an invalid reference lookup of queries, which fixed the removal of "NotifySegment" inside rasterizer and start to adjusting other parts of the implementation of ConditionalRendering minimally and switching with heavy tests to ensure not a single game gets broken among the changes; yet the initial benefits from fixing the indirection in the lookups to query cache, was to reduce the amount of time of GPU was spending in the constant state of queries, which proved to reduce flickering in Pokémon ZA among others, with also an small increase of performance but more noticeable stability, starting to reduce stutering bit by bit. This advances allowed me to fix one of the the functions of IsGPULevelHigh, where existed a bypass to accelerate conditional rendering without the proper checks if the extension was truly supported, freeing QCOM from the flag of a fixated presync workaround; which also improved the usage of QCOM driver for 8 Elite devices and Unreal Engine 4 - 5 games, such as Dragon Ball Z - Sparking Zero; but that's not the only benefit from the current tries to make ConditionalRendering implementation more robust and accurate to specifications, but also started to show key points of where VK_EXT_transform_feedback was also failing to work properly. -> Adjustment VK_EXT_transform_feedback: Like many other features in this PR, this one was also adjusted minimally in ExtendedDynamicState refactor (#3074), with the ConditionalRendering refactor going on, the solutions for the usage of this extensions started by ensuring each key function is properly gated by a getter which would only be enabled if the extension was already being loaded in the virtual device, if wasn't the case I was making sure to wire the fallback correctly, which wasn't in place and didn't had a robust handling since ever, this way games started to not only improve graphical accuracy, like some games such as Zelda - Echoes Of Wisdom where the lightning and dark border moves/ reacts dynamically. Besides that, this change brought the possibility to finally get rid of the indirection of the buffers synchronization which often take a non-synchornization path to ensure a faster reply but with higher possibilities to cause graphical issues in among several games; aside that, also helped to ensure "_query_cache.CounterEnable(VideoCommon::QueryType::StreamingByteCount, false)_;" function is properly allocated and reset in a different place than where this was placed. - Maintain Metroid Prime 4 fixes even after returning the lines that caused the game to be unplayable, whether was an instant crash or crash after some minutes of gameplay, fixes that were introduced in other work (#3142). Within the first step in the refactor of this extension, this work was reviewed by @wildcard which made me notice of an issue of handling inside buffers, there existed a mismatch on the tracking of feedback buffers and since we're treating them as buffer_slot, counterstream was still tracking and consuming stream_buffers and not where data was really passing through; derivating the counter selection of counterBufferCount by stream indexes and not by slot, which could cause cases of _Stream =! slot_, a solution proposed for me was to add stream mapper function where the stream slot were located + updating UpdateBuffers() to calculate buffer counts per slot and not stream, allowing to fully map the map funtion of stream mapper; along other changes on the WriteBuffers + ProduceBufferCounter to avoid any misaligment. -> Other minimal adjustments: Alongside these important adjustment, others were also made to ensure logical coherency to this recent changes, such as ensuring FullSynchronization of buffers path, since GPU has mostly a syncing issue with certain type of textures and vertex calculations, the original behavior of jumping into a non-synchronize path of buffers let GPU ran without proper awareness of the textures being loaded, ensuring more performance if all the textures reached properly inside GPU, but with no safety provided for buffers, even we added a cases were dummies and mostly buffer trash data gets discarded by nullDescriptors, this won't ensure graphical artifacts or a bad calculation on the range of lightning/ gfx could appear. I dare to think this was thought to be implemented due to the original heavy costs on Yuzu's time, this along the removal of QCOM's drivers from Query's Presync funtions. A small adjustment to the mutable functions inside the CreateImageView structure to add the extended usage: "Because Switch's GPU creates incompatible views (sRGB and UNORM) on the same image. A sRGB image can't be used as storage but it is in a UNORM view. Which is exactly the use case of these flags." - @weakboson During all of this changes inside queries, we started to get in some devices "Device Loss" warning from Vulkan along 2 specific warnings: - [ 102.384895] Render.Vulkan <Critical> video_core/vulkan_common/vulkan_debug_callback.cpp:69:DebugUtilCallback: vkDeviceWaitIdle(): THREADING ERROR : object of type VkQueue is simultaneously used in current thread 517024609280 and thread 517864567808 - [ 114.003530] Render.Vulkan <Critical> video_core/vulkan_common/vulkan_debug_callback.cpp:69:DebugUtilCallback: vkCmdBeginQuery(): VkQueryPool 0x15e400000015e4 and query 172: query not reset. After query pool creation, each query must be reset (with vkCmdResetQueryPool or vkResetQueryPool) before it is used. Queries must also be reset between uses. Since before all of this adjustments, original GPU thread often take it's time to stop and look for a moment to synchronize with CPU (non-TimelineSemaphore), the whole flow data was improved that we were producing more data stale than we could really take due to the lack of a Reset to avoid pools being filled with old data, in order to get rid of this, another try to implement ResetQueryPool's appeared which was intented to be implemented some months ago and got removed in #3270, this time aligning the vkDeviceWaitIdle + ResetQueryPool was proved to be effective than first implementation and didn't caused major issues, now GPU can Vulkan can reset staling data, which can catalogued as old once they were used and displayed in frame, keeping a more fluid exchance and discard of data. - Fixes VUID-vkCmdBeginQuery-None-00807 - Fixes multithreading error with vkDeviceWaitIdle and data allocation We have some other changes to the coherency of ExtendedDynamicState2 and the feature of restart primitives, which now patches topologies once are processed if they pass through ExtendedDynamicState2 enabled and get reset before every draw to prevent another topology VUID; also I ensured refresh, reset, clamp and overall improve the math inside the Viewport/ Scissor feature operations inside DynamicState and later upgrades. --------------------------- UPDATE (23/04/2026): After passing a heavy testing phase, an issue was encountered with AMD drivers on Windows which based on the commit: `c07dfa6fb4`, Super Mario Odissey started to show vertex glitches on the the waterfall + water fog being rendered incorrectly, if VertexInputDynamicState was disabled caused black screen on ExtendedDynamicState (1 - 3) and hard crash if ExtendedDynamicState it was disabled; this situation was caused to the vertex input dynamic tied to ExtendedDynamicState1, AMD driver didn't allowed fast access to BindVertexBuffers2EXT without binding strides first, which caused a syncing problem between the binded vertex and the missing buffer in the same chain, this got fixed by removing the conditions for vertex input dynamic. Aside that; another pair of issues were addressed in the meantime of refining this PR, one of them was to solve the failing BGR565 formats to swizzle into RGBA5 which allows to swap between red and blue; solving the inverse situation of blue icons on Mario Kart 8 Deluxe for older QCOM drivers and SoC's, such as Snapdragon 855 - 870; which will also help some Exynos processors to render properly. This solution was converted into a toggle/hack because it's use it's very conditional on older hardware; newer SoC's such as 8 Elite won't longer require this handling to convert properly BGR565 texture even if the support for the format is not available. --------------------------- Here an small preview of what this pr has been fixed so far, but our testing range may be more limited than what this can actually do: - Allow to display new effect on games 1. Jump Force: New particle on stages and main menu. 2. The Legend Of Zelda - Echoes of Wisdom: darkness post processing effect on screen filter such as game intro and smokes on houses (8 Elite). 3. Reduce texture flickering on games such as EoW, Monster Hunter Rise. 4. Improved performance stability on various games with Android. 5. Improved Xenoblade games rendering with QCOM stock drivers by improve viewpoint handling (8 Elite). 6. Fixes vertex explosion on Xenoblade 3 with AMD GPU with extended dynamic state enabled. 7. Fixed Mario Kart 8 Deluxe rendering with VK_EXT_vertex_input_dynamic_state enabled. 8. Fixes certain angle of Pokemon Legend Z-A would look mono color with vertex input dynamic state. 9. Fixed graphical issue with VK_EXT_vertex_input_dynamic_state on mobile drivers. 10. Fixed vertex explosion with Turnip (8 Elite) on The Legend Of Zelda- Breath Of The Wild during loading screen. 11. Fixed issue of vertex on Pokémon Legends ZA with VK_EXT_vertex_input_dynamic_state enabled. 12. Improved rendering and stability of Inmortal Fenyx Rising, including QCOM drivers being able to reach into gameplay. 13. Fixes Paper Mario - The-Thousand-Year Door missing rendering on animations through the whole game. 14. Fixed Mario Kart 8 Deluxe blue tint icon on Snapdragon 855 - 870 (by enabling Emulated BGR565 hack toggle). 15. Fixed Naruto Ultimate Ninja Storm issue rendering on characters like Naruto being blue on older QCOM SoC's and Exynos (by enabling Emulated BGR565 hack toggle) 16. Fixed Dangaronpa Killing Harmony v3 issue rendering on characters with blue tint on older QCOM SoC's. --------------------------- _Special Thanks - Credits_ -> @Gidoly for being able to keep track of the intensive testing phase this pr required and the will to keep helping in development, you're a good friend and very useful. -> @CaptFaraday for the suggestion of the fix for Paper Mario. -> @wildcard for the review during the refactor of VK_EXT_transform_feedback, without this comment I would probably ran into many untrackable issues. -> @weakboson for the suggestion into the solution for sRGB's and UNORM's in the incompatible views. Co-authored-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3853 Reviewed-by: crueter <crueter@eden-emu.dev>	2026-04-24 16:37:18 +02:00