fix le crash

notably fixes TL:LTD grass
Authored-by: Mythrax <mythrax@mytrax-rs.org>

Signed-off-by: lizzie <lizzie@eden-emu.dev>

CMakeLists.txt

@@ -268,6 +268,11 @@ if (NOT EXISTS ${PROJECT_BINARY_DIR}/${compat_json})
     file(WRITE ${PROJECT_BINARY_DIR}/${compat_json} "")
 endif()
 
+if (YUZU_LEGACY)
+    message(WARNING "Making legacy build. Performance may suffer.")
+    add_compile_definitions(YUZU_LEGACY)
+endif()
+
 if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
     set(HAS_NCE 1)
     add_compile_definitions(HAS_NCE=1)
@@ -419,10 +424,10 @@ if (zstd_ADDED)
     add_library(zstd::libzstd ALIAS libzstd_static)
 endif()
 
-# nlohmann
-AddJsonPackage(nlohmann)
-
 if (NOT YUZU_STATIC_ROOM)
+    # nlohmann
+    AddJsonPackage(nlohmann)
+
     # zlib
     AddJsonPackage(zlib)
 
@@ -480,7 +485,7 @@ endfunction()
 # =============================================
 
 if (APPLE)
-    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security)
+    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia)
         find_library(${fw}_LIBRARY ${fw} REQUIRED)
         list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY})
     endforeach()

CMakeModules/GenerateSCMRev.cmake

@@ -33,11 +33,9 @@ endif()
 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
 
-# TODO(crueter): Stable releases feed.
-set(BUILD_AUTO_UPDATE_STABLE_REPO "eden-emu/eden")
-set(BUILD_AUTO_UPDATE_STABLE_API "git.eden-emu.dev")
-set(BUILD_AUTO_UPDATE_STABLE_API_PATH "/api/v1/repos/")
+# Auto-updater metadata! Must somewhat mirror GitHub/Forgejo API endpoint
 
 set(BUILD_AUTO_UPDATE_API_PATH "/latest/release.json")
 if (NIGHTLY_BUILD)

src/CMakeLists.txt

@@ -25,16 +25,6 @@ if (NIGHTLY_BUILD)
     add_compile_definitions(NIGHTLY_BUILD)
 endif()
 
-if (YUZU_LEGACY)
-    message(WARNING "Making legacy build. Performance may suffer.")
-    add_compile_definitions(YUZU_LEGACY)
-endif()
-
-if (GENSHIN_SPOOF)
-    message(WARNING "Making Genshin spoof build")
-    add_compile_definitions(GENSHIN_SPOOF)
-endif()
-
 # Set compilation flags
 if (MSVC AND NOT CXX_CLANG)
     set(CMAKE_CONFIGURATION_TYPES Debug Release CACHE STRING "" FORCE)

src/android/app/build.gradle.kts

@@ -88,7 +88,6 @@ android {
                         "-DBUILD_TESTING=OFF",
                         "-DYUZU_TESTS=OFF",
                         "-DDYNARMIC_TESTS=OFF",
-                        "-DENABLE_UPDATE_CHECKER=ON",
                         *extraCMakeArgs.toTypedArray()
                     )
                 )
@@ -193,12 +192,6 @@ android {
             manifestPlaceholders += mapOf("appNameBase" to "Eden")
             resValue("string", "app_name_suffixed", "Eden")
 
-            externalNativeBuild {
-                cmake {
-                    arguments.add("-DGENSHIN_SPOOF=ON")
-                }
-            }
-
             ndk {
                 abiFilters += listOf("arm64-v8a")
             }

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

@@ -33,18 +33,6 @@ import org.yuzu.yuzu_emu.applets.web.WebBrowser
  * with the native side of the Yuzu code.
  */
 object NativeLibrary {
-    data class UpdateResult(
-        var tag: String = "",
-        var title: String = "",
-        var body: String = "",
-        var url: String = "",
-        var assets: MutableList<String> = mutableListOf()
-    ) {
-        fun addAsset(asset: String) {
-            assets.add(asset)
-        }
-    }
-
     @JvmField
     var sEmulationActivity = WeakReference<EmulationActivity?>(null)
 
@@ -252,7 +240,17 @@ object NativeLibrary {
     /**
      * Checks for available updates.
      */
-    external fun checkForUpdate(): UpdateResult?
+    external fun checkForUpdate(): Array<String>?
+
+    /**
+     * Return the URL to the release page
+     */
+    external fun getUpdateUrl(version: String): String
+
+    /**
+     * Return the URL to download the APK for the given version
+     */
+    external fun getUpdateApkUrl(tag: String, artifact: String, packageId: String): String
 
     /**
      * Returns whether the update checker is enabled through CMAKE options.

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

@@ -175,25 +175,25 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             val latestVersion = NativeLibrary.checkForUpdate()
             if (latestVersion != null) {
                 runOnUiThread {
-                    showUpdateDialog(latestVersion)
+                    val tag: String = latestVersion[0]
+                    val name: String = latestVersion[1]
+                    showUpdateDialog(tag, name)
                 }
             }
         }.start()
     }
 
-    // TODO(crueter): body, "View on Forgejo" button
-    private fun showUpdateDialog(release: NativeLibrary.UpdateResult) {
+    private fun showUpdateDialog(tag: String, name: String) {
         MaterialAlertDialogBuilder(this)
             .setTitle(R.string.update_available)
-            .setMessage(getString(R.string.update_available_description, release.title))
+            .setMessage(getString(R.string.update_available_description, name))
             .setPositiveButton(android.R.string.ok) { _, _ ->
-                val assets = release.assets
-
-                if (assets.isEmpty()) {
-                    openLink(release.url)
-                } else {
-                    downloadAndInstallUpdate(release)
+                var artifact = tag
+                // Nightly builds have a slightly different format
+                if (NativeLibrary.isNightlyBuild()) {
+                    artifact = tag.substringAfter('.', tag)
                 }
+                downloadAndInstallUpdate(tag, artifact)
             }
             .setNeutralButton(R.string.cancel) { dialog, _ ->
                 dialog.dismiss()
@@ -206,23 +206,17 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             .show()
     }
 
-    private fun openLink(link: String) {
-        val intent = Intent(Intent.ACTION_VIEW, link.toUri())
-        startActivity(intent)
-    }
-
-    private fun downloadAndInstallUpdate(release: NativeLibrary.UpdateResult) {
+    private fun downloadAndInstallUpdate(version: String, artifact: String) {
         CoroutineScope(Dispatchers.IO).launch {
             val packageId = applicationContext.packageName
-            val asset = release.assets[0]
-            val artifact = asset.split("/").last()
+            val apkUrl = NativeLibrary.getUpdateApkUrl(version, artifact, packageId)
             val apkFile = File(cacheDir, "update-$artifact.apk")
 
             withContext(Dispatchers.Main) {
                 showDownloadProgressDialog()
             }
 
-            val downloader = APKDownloader(asset, apkFile)
+            val downloader = APKDownloader(apkUrl, apkFile)
             downloader.download(
                 onProgress = { progress ->
                     runOnUiThread {
@@ -254,7 +248,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                         } else {
                             Toast.makeText(
                                 this@MainActivity,
-                                getString(R.string.update_download_failed) + "\n\nURL: $asset",
+                                getString(R.string.update_download_failed) + "\n\nURL: $apkUrl",
                                 Toast.LENGTH_LONG
                             ).show()
                         }
@@ -283,7 +277,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
     private fun updateDownloadProgress(progress: Int) {
         progressBar?.progress = progress
-        progressMessage?.text = getString(R.string.percent, progress)
+        progressMessage?.text = "$progress%"
     }
 
     private fun dismissDownloadProgressDialog() {

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

@@ -1699,76 +1699,76 @@ JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_isNightlyBuild(
 #ifdef ENABLE_UPDATE_CHECKER
 
 
-JNIEXPORT jobject JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_checkForUpdate(
+JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_checkForUpdate(
         JNIEnv* env,
         jobject obj) {
-    std::optional<Common::Net::Release> release = UpdateChecker::GetUpdate();
+    std::optional<UpdateChecker::Update> release = UpdateChecker::GetUpdate();
     if (!release) return nullptr;
 
     const std::string tag = release->tag;
-    const std::string title = release->title;
-    const std::string body = release->body;
-    const std::string url = release->html_url;
+    const std::string name = release->name;
 
-    // Android *should* only ever define a single asset.
-    // If not, something has gone wrong, but the Kotlin side can handle it.
-    const auto assets = release->GetPlatformAssets();
+    jobjectArray result = env->NewObjectArray(2, env->FindClass("java/lang/String"), nullptr);
 
-    jclass updateResultClass = env->FindClass("org/yuzu/yuzu_emu/NativeLibrary$UpdateResult");
-    if (!updateResultClass) {
-        LOG_ERROR(Frontend, "Could not find UpdateResult class");
-        return nullptr;
-    }
-
-    jmethodID updateResultCtor = env->GetMethodID(updateResultClass, "<init>", "()V");
-
-    if (!updateResultCtor) {
-        LOG_ERROR(Frontend, "Could not find UpdateResult ctor");
-        env->DeleteLocalRef(updateResultClass);
-        return nullptr;
-    }
-
-    jmethodID setTag = env->GetMethodID(updateResultClass, "setTag", "(Ljava/lang/String;)V");
-    jmethodID setTitle = env->GetMethodID(updateResultClass, "setTitle", "(Ljava/lang/String;)V");
-    jmethodID setBody = env->GetMethodID(updateResultClass, "setBody", "(Ljava/lang/String;)V");
-    jmethodID setUrl = env->GetMethodID(updateResultClass, "setUrl", "(Ljava/lang/String;)V");
-    jmethodID addAsset = env->GetMethodID(updateResultClass, "addAsset", "(Ljava/lang/String;)V");
-
-    jobject updateResult = env->NewObject(updateResultClass, updateResultCtor);
-
-    LOG_DEBUG(Frontend, "Tag: {}", tag);
-    LOG_DEBUG(Frontend, "Title: {}", title);
-    LOG_DEBUG(Frontend, "Body: {}", body);
-    LOG_DEBUG(Frontend, "Url: {}", url);
-
-    const auto jtag = env->NewStringUTF(tag.c_str());
-    const auto jtitle = env->NewStringUTF(title.c_str());
-    const auto jbody = env->NewStringUTF(body.c_str());
-    const auto jurl = env->NewStringUTF(url.c_str());
-
-    env->CallVoidMethod(updateResult, setTag, jtag);
-    env->CallVoidMethod(updateResult, setTitle, jtitle);
-    env->CallVoidMethod(updateResult, setBody, jbody);
-    env->CallVoidMethod(updateResult, setUrl, jurl);
-
-    // TODO(crueter): Handling for multiple assets?
-    // Maybe another data class x(
-    for (const Common::Net::Asset &a : assets) {
-        const auto jaurl = env->NewStringUTF(a.path.c_str());
-        env->CallVoidMethod(updateResult, addAsset, jaurl);
-        env->DeleteLocalRef(jaurl);
-    }
+    const jstring jtag = env->NewStringUTF(tag.c_str());
+    const jstring jname = env->NewStringUTF(name.c_str());
 
+    env->SetObjectArrayElement(result, 0, jtag);
+    env->SetObjectArrayElement(result, 1, jname);
     env->DeleteLocalRef(jtag);
-    env->DeleteLocalRef(jtitle);
-    env->DeleteLocalRef(jbody);
-    env->DeleteLocalRef(jurl);
+    env->DeleteLocalRef(jname);
 
-    env->DeleteLocalRef(updateResultClass);
-
-    return updateResult;
+    return result;
 }
 
+JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateUrl(
+        JNIEnv* env,
+        jobject obj,
+        jstring version) {
+    const char* version_str = env->GetStringUTFChars(version, nullptr);
+    const std::string url = fmt::format("{}/{}",
+        std::string{Common::g_build_auto_update_api},
+        version_str);
+    env->ReleaseStringUTFChars(version, version_str);
+    return env->NewStringUTF(url.c_str());
+}
+
+JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateApkUrl(
+        JNIEnv* env,
+        jobject obj,
+        jstring tag,
+        jstring artifact,
+        jstring packageId) {
+    const char* version_str = env->GetStringUTFChars(tag, nullptr);
+    const char* artifact_str = env->GetStringUTFChars(artifact, nullptr);
+    const char* package_id_str = env->GetStringUTFChars(packageId, nullptr);
+
+    std::string variant;
+    std::string package_id(package_id_str);
+
+    if (package_id.find("dev.legacy.eden_emulator") != std::string::npos) {
+        variant = "legacy";
+    } else if (package_id.find("com.miHoYo.Yuanshen") != std::string::npos) {
+        variant = "optimized";
+    } else {
+#ifdef ARCHITECTURE_arm64
+        variant = "standard";
+#else
+        variant = "chromeos";
+#endif
+    }
+
+    const std::string apk_filename = fmt::format("Eden-Android-{}-{}.apk", artifact_str, variant);
+
+    const std::string url = fmt::format("https://{}/{}/{}",
+        std::string{Common::g_build_auto_update_api},
+        version_str, apk_filename);
+
+    env->ReleaseStringUTFChars(tag, version_str);
+    env->ReleaseStringUTFChars(artifact, artifact_str);
+    env->ReleaseStringUTFChars(packageId, package_id_str);
+    return env->NewStringUTF(url.c_str());
+}
 #endif
 
 JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getBuildVersion(

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

@@ -767,7 +767,7 @@
     <string name="version">Versión</string>
     <string name="copy_details">Copiar detalles</string>
     <string name="add_ons">Complementos</string>
-    <string name="add_ons_description">Alternar mods, actualizaciones y contenido descargable</string>
+    <string name="add_ons_description">Activa/desactiva mods, actualizaciones y contenidos descargables</string>
     <string name="playtime">Tiempo jugado:</string>
     <string name="reset_playtime">Borrar tiempo de juego</string>
     <string name="reset_playtime_description">Restablecer el tiempo de juego actual a 0 segundos</string>

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

@@ -1783,6 +1783,5 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
     <string name="external_content">External Content</string>
     <string name="add_folders">Add Folder</string>
-    <string name="percent">%1$d%%</string>
 
 </resources>

src/common/CMakeLists.txt

@@ -147,8 +147,7 @@ add_library(
     zstd_compression.h
     fs/ryujinx_compat.h fs/ryujinx_compat.cpp
     fs/symlink.h fs/symlink.cpp
-    httplib.h
-    net/net.h net/net.cpp)
+    httplib.h)
 
 if(WIN32)
     target_sources(common PRIVATE windows/timer_resolution.cpp
@@ -246,7 +245,7 @@ else()
     target_link_libraries(common PUBLIC Boost::headers)
 endif()
 
-target_link_libraries(common PUBLIC Boost::filesystem Boost::context httplib::httplib nlohmann_json::nlohmann_json)
+target_link_libraries(common PUBLIC Boost::filesystem Boost::context httplib::httplib)
 
 if (lz4_ADDED)
     target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)

src/common/net/net.cpp

@@ -1,287 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <optional>
-#include <boost/algorithm/string/classification.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/split.hpp>
-
-#include <fmt/format.h>
-#include "common/scm_rev.h"
-#include "net.h"
-
-#include "common/logging.h"
-
-#include "common/httplib.h"
-
-#ifdef YUZU_BUNDLED_OPENSSL
-#include <openssl/cert.h>
-#endif
-
-#define QT_TR_NOOP(x) x
-
-namespace Common::Net {
-
-std::vector<Asset> Release::GetPlatformAssets() const {
-    // TODO(crueter): Need better handling for this as a whole.
-#ifdef NIGHTLY_BUILD
-    std::vector<std::string> result;
-    boost::algorithm::split(result, tag, boost::is_any_of("."));
-    if (result.size() != 2)
-        return {};
-    const auto ref = result.at(1);
-#else
-    const auto ref = tag;
-#endif
-
-    std::vector<Asset> found_assets;
-
-    // FIXME: This is mildly inefficient.
-    // Finds assets based on a hierarchy of regex search strings.
-    const auto find_asset = [&found_assets, ref, this](const std::string& name,
-                                                       const std::vector<std::string>& suffixes) {
-        for (const std::string& asset : assets) {
-            for (const auto& suffix : suffixes) {
-                if (asset.ends_with(suffix)) {
-                    const std::string_view asset_sv = asset;
-                    const size_t pos = asset_sv.find_last_of('/');
-                    const std::string_view filename =
-                        (pos != std::string_view::npos) ? asset_sv.substr(pos + 1) : asset_sv;
-
-                    found_assets.emplace_back(Asset{
-                        .name = name,
-                        .url = host,
-                        .path = asset,
-                        .filename = std::string{filename},
-                    });
-                    return;
-                }
-            }
-        }
-    };
-
-#ifdef _WIN32
-#ifdef ARCHITECTURE_x86_64
-    find_asset("Standard", {"amd64-msvc-standard.exe", "amd64-msvc-standard.zip", "mingw-amd64-gcc-standard.exe", "mingw-amd64-gcc-standard.zip"});
-    find_asset("PGO", {"mingw-amd64-clang-pgo.exe", "mingw-amd64-clang-pgo.zip"});
-#elif defined(ARCHITECTURE_arm64)
-    find_asset("Standard", {"mingw-arm64-clang-standard.exe", "mingw-arm64-clang-standard.zip"});
-    find_asset("PGO", {"mingw-arm64-clang-pgo.exe", "mingw-arm64-clang-pgo.zip"});
-#endif
-#elif defined(__APPLE__)
-#ifdef ARCHITECTURE_arm64
-    find_asset("Standard", {".dmg", ".tar.gz"});
-#endif
-#elif defined(__ANDROID__)
-#ifdef ARCHITECTURE_x86_64
-    find_asset("Standard", {"chromeos.apk"});
-#elif defined(ARCHITECTURE_arm64)
-#ifdef YUZU_LEGACY
-    find_asset("Standard", {"legacy.apk"});
-#elif defined(GENSHIN_SPOOF)
-    find_asset("Standard", {"optimized.apk"});
-#else
-    find_asset("Standard", {"standard.apk"});
-#endif
-#endif
-#endif
-    return found_assets;
-}
-
-static inline u64 ParseIsoTimestamp(const std::string& iso) {
-    if (iso.empty())
-        return 0;
-
-    std::string buf = iso;
-    if (buf.back() == 'Z')
-        buf.pop_back();
-
-    std::tm tm{};
-    std::istringstream ss(buf);
-    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
-    if (ss.fail())
-        return 0;
-
-#ifdef _WIN32
-    return static_cast<u64>(_mkgmtime(&tm));
-#else
-    return static_cast<u64>(timegm(&tm));
-#endif
-}
-
-std::optional<Release> Release::FromJson(const nlohmann::json& json, const std::string& host,
-                                         const std::string& repo) {
-    Release rel;
-    if (!json.is_object())
-        return std::nullopt;
-
-    rel.tag = json.value("tag_name", std::string{});
-    if (rel.tag.empty())
-        return std::nullopt;
-
-    rel.title = json.value("name", rel.tag);
-    rel.id = json.value("id", std::hash<std::string>{}(rel.title));
-
-    rel.published = ParseIsoTimestamp(json.value("published_at", std::string{}));
-    rel.prerelease = json.value("prerelease", false);
-
-    auto body = json.value("body", rel.title);
-    boost::replace_all(body, "\\r", "");
-    boost::replace_all(body, "\\n", "\n");
-    rel.body = body;
-
-    rel.host = host;
-
-    const auto release_base =
-        fmt::format("{}/{}/releases", Common::g_build_auto_update_website, repo);
-    const auto fallback_html = fmt::format("{}/tag/{}", release_base, rel.tag);
-    rel.html_url = json.value("html_url", fallback_html);
-
-    // This is our own "fake" API.
-    if (json.contains("base")) {
-        const auto base = json.value("base", fmt::format("https://{}", Common::g_build_auto_update_api));
-        rel.base_download_url = fmt::format("{}/{}", base, rel.tag);
-
-        // Assets are easy :)
-        rel.assets = json.value("assets", std::vector<std::string>{});
-    } else {
-        const auto base_download_url = fmt::format("/{}/releases/download/{}", repo, rel.tag);
-
-        rel.base_download_url = base_download_url;
-
-        // assets are a bit more complex here. :(
-        std::vector<std::string> assets;
-        const nlohmann::json& arr = json["assets"];
-        for (const auto &obj : arr) {
-            const auto url = obj.value("browser_download_url", std::string{});
-            assets.emplace_back(url);
-        }
-
-        rel.assets = assets;
-    }
-
-    return rel;
-}
-
-std::optional<Release> Release::FromJson(const std::string_view& json, const std::string& host,
-                                         const std::string& repo) {
-    try {
-        return FromJson(nlohmann::json::parse(json), host, repo);
-    } catch (std::exception& e) {
-        LOG_WARNING(Common, "Failed to parse JSON: {}", e.what());
-    }
-
-    return {};
-}
-
-std::vector<Release> Release::ListFromJson(const nlohmann::json& json, const std::string& host,
-                                           const std::string& repo) {
-    if (!json.is_array())
-        return {};
-
-    std::vector<Release> releases;
-    for (const auto& obj : json) {
-        auto rel = Release::FromJson(obj, host, repo);
-        if (rel)
-            releases.emplace_back(rel.value());
-    }
-    return releases;
-}
-
-std::vector<Release> Release::ListFromJson(const std::string_view& json, const std::string& host,
-                                           const std::string& repo) {
-    try {
-        return ListFromJson(nlohmann::json::parse(json), host, repo);
-    } catch (std::exception& e) {
-        LOG_WARNING(Common, "Failed to parse JSON: {}", e.what());
-    }
-
-    return {};
-}
-
-std::optional<std::string> MakeRequest(const std::string& url, const std::string& path) {
-    try {
-        constexpr std::size_t timeout_seconds = 15;
-
-        std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(url);
-        client->set_connection_timeout(timeout_seconds);
-        client->set_read_timeout(timeout_seconds);
-        client->set_write_timeout(timeout_seconds);
-
-#ifdef YUZU_BUNDLED_OPENSSL
-        client->load_ca_cert_store(kCert, sizeof(kCert));
-#endif
-
-        if (client == nullptr) {
-            LOG_ERROR(Common, "Invalid URL {}{}", url, path);
-            return {};
-        }
-
-        httplib::Request request{
-            .method = "GET",
-            .path = path,
-        };
-
-        client->set_follow_location(true);
-        httplib::Result result = client->send(request);
-
-        if (!result) {
-            LOG_ERROR(Common, "GET to {}{} returned null", url, path);
-            return {};
-        }
-
-        const auto& response = result.value();
-        if (response.status >= 400) {
-            LOG_ERROR(Common, "GET to {}{} returned error status code: {}", url, path,
-                      response.status);
-            return {};
-        }
-        if (!response.headers.contains("content-type")) {
-            LOG_ERROR(Common, "GET to {}{} returned no content", url, path);
-            return {};
-        }
-
-        return response.body;
-    } catch (std::exception& e) {
-        LOG_ERROR(Common, "GET to {}{} failed during update check: {}", url, path, e.what());
-        return std::nullopt;
-    }
-}
-
-std::vector<Release> GetReleases() {
-    const auto body = GetReleasesBody();
-
-    if (!body) {
-        LOG_WARNING(Common, "Failed to get stable releases");
-        return {};
-    }
-
-    const std::string_view body_str = body.value();
-    const auto url = fmt::format("https://{}", Common::g_build_auto_update_stable_api);
-    return Release::ListFromJson(body_str, url, Common::g_build_auto_update_stable_repo);
-}
-
-std::optional<Release> GetLatestRelease() {
-    const auto releases_path =  Common::g_build_auto_update_api_path;
-    const auto url = fmt::format("https://{}", Common::g_build_auto_update_api);
-
-    const auto body = MakeRequest(url, releases_path);
-    if (!body) {
-        LOG_WARNING(Common, "Failed to get latest release");
-        return std::nullopt;
-    }
-
-    const std::string_view body_str = body.value();
-    return Release::FromJson(body_str, url, Common::g_build_auto_update_repo);
-}
-
-std::optional<std::string> GetReleasesBody() {
-    const auto releases_path =
-        fmt::format("/{}/{}/releases", Common::g_build_auto_update_stable_api_path,
-                    Common::g_build_auto_update_stable_repo);
-    const auto url = fmt::format("https://{}", Common::g_build_auto_update_stable_api);
-
-    return MakeRequest(url, releases_path);
-}
-
-} // namespace Common::Net

src/common/net/net.h

@@ -1,56 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <optional>
-#include <string>
-#include <vector>
-#include <nlohmann/json.hpp>
-#include "common/common_types.h"
-
-namespace Common::Net {
-
-typedef struct {
-    std::string name;
-    std::string url;
-    std::string path;
-    std::string filename;
-} Asset;
-
-typedef struct Release {
-    std::string title;
-    std::string body;
-    std::string tag;
-    std::string base_download_url;
-    std::string html_url;
-    std::string host;
-
-    std::vector<std::string> assets;
-
-    u64 id;
-    u64 published;
-    bool prerelease;
-
-    // Get the relevant list of assets for the current platform.
-    std::vector<Asset> GetPlatformAssets() const;
-
-    static std::optional<Release> FromJson(const nlohmann::json& json, const std::string &host, const std::string& repo);
-    static std::optional<Release> FromJson(const std::string_view& json, const std::string &host, const std::string& repo);
-    static std::vector<Release> ListFromJson(const nlohmann::json &json, const std::string &host, const std::string &repo);
-    static std::vector<Release> ListFromJson(const std::string_view &json, const std::string &host, const std::string &repo);
-} Release;
-
-// Make a request via httplib, and return the response body if applicable.
-std::optional<std::string> MakeRequest(const std::string &url, const std::string &path);
-
-// Get all of the latest stable releases.
-std::vector<Release> GetReleases();
-
-// Get all of the latest stable releases as text.
-std::optional<std::string> GetReleasesBody();
-
-// Get the latest release of the current channel.
-std::optional<Release> GetLatestRelease();
-
-}

src/common/scm_rev.cpp.in

@@ -22,9 +22,6 @@
 #define BUILD_AUTO_UPDATE_API "@BUILD_AUTO_UPDATE_API@"
 #define BUILD_AUTO_UPDATE_API_PATH "@BUILD_AUTO_UPDATE_API_PATH@"
 #define BUILD_AUTO_UPDATE_REPO "@BUILD_AUTO_UPDATE_REPO@"
-#define BUILD_AUTO_UPDATE_STABLE_API "@BUILD_AUTO_UPDATE_STABLE_API@"
-#define BUILD_AUTO_UPDATE_STABLE_API_PATH "@BUILD_AUTO_UPDATE_STABLE_API_PATH@"
-#define BUILD_AUTO_UPDATE_STABLE_REPO "@BUILD_AUTO_UPDATE_STABLE_REPO@"
 #define IS_NIGHTLY_BUILD @IS_NIGHTLY_BUILD@
 
 namespace Common {
@@ -48,8 +45,5 @@ constexpr const char g_build_auto_update_website[] = BUILD_AUTO_UPDATE_WEBSITE;
 constexpr const char g_build_auto_update_api[] = BUILD_AUTO_UPDATE_API;
 constexpr const char g_build_auto_update_api_path[] = BUILD_AUTO_UPDATE_API_PATH;
 constexpr const char g_build_auto_update_repo[] = BUILD_AUTO_UPDATE_REPO;
-constexpr const char g_build_auto_update_stable_api[] = BUILD_AUTO_UPDATE_STABLE_API;
-constexpr const char g_build_auto_update_stable_api_path[] = BUILD_AUTO_UPDATE_STABLE_API_PATH;
-constexpr const char g_build_auto_update_stable_repo[] = BUILD_AUTO_UPDATE_STABLE_REPO;
 
 } // namespace Common

src/common/scm_rev.h

@@ -28,8 +28,5 @@ extern const char g_build_auto_update_website[];
 extern const char g_build_auto_update_api[];
 extern const char g_build_auto_update_api_path[];
 extern const char g_build_auto_update_repo[];
-extern const char g_build_auto_update_stable_api[];
-extern const char g_build_auto_update_stable_api_path[];
-extern const char g_build_auto_update_stable_repo[];
 
 } // namespace Common

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

@@ -317,14 +317,12 @@ void WebBrowser::Execute() {
         return;
     }
 
-#ifndef ANDROID
     if (Settings::values.disable_web_applet) {
         LOG_WARNING(Service_AM, "(STUBBED) called, Web Browser Applet is disabled. shim_kind={}",
                     web_arg_header.shim_kind);
         WebBrowserExit(WebExitReason::EndButtonPressed);
         return;
     }
-#endif
 
     switch (web_arg_header.shim_kind) {
     case ShimKind::Shop:

src/core/hle/service/bcat/news/builtin_news.cpp

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#include "common/net/net.h"
-#include "common/scm_rev.h"
 #include "core/hle/service/bcat/news/builtin_news.h"
 #include "core/hle/service/bcat/news/msgpack.h"
 #include "core/hle/service/bcat/news/news_storage.h"
@@ -24,8 +22,10 @@
 #include <filesystem>
 #include <fstream>
 #include <future>
+#include <iomanip>
 #include <mutex>
 #include <optional>
+#include <sstream>
 #include <thread>
 
 #ifdef YUZU_BUNDLED_OPENSSL
@@ -35,6 +35,9 @@
 namespace Service::News {
 namespace {
 
+// TODO(crueter): COMPILE DEFINITION
+constexpr const char* GitHubAPI_EdenReleases = "/api/v1/repos/eden-emu/eden/releases";
+
 // Cached logo data
 std::vector<u8> default_logo_small;
 std::vector<u8> default_logo_large;
@@ -63,6 +66,24 @@ u32 HashToNewsId(std::string_view key) {
     return static_cast<u32>(std::hash<std::string_view>{}(key) & 0x7FFFFFFF);
 }
 
+u64 ParseIsoTimestamp(const std::string& iso) {
+    if (iso.empty()) return 0;
+
+    std::string buf = iso;
+    if (buf.back() == 'Z') buf.pop_back();
+
+    std::tm tm{};
+    std::istringstream ss(buf);
+    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
+    if (ss.fail()) return 0;
+
+#ifdef _WIN32
+    return static_cast<u64>(_mkgmtime(&tm));
+#else
+    return static_cast<u64>(timegm(&tm));
+#endif
+}
+
 std::vector<u8> TryLoadFromDisk(const std::filesystem::path& path) {
     if (!std::filesystem::exists(path)) return {};
 
@@ -79,9 +100,8 @@ std::vector<u8> TryLoadFromDisk(const std::filesystem::path& path) {
     return data;
 }
 
-// TODO(crueter): Migrate to use Common::Net
 std::vector<u8> DownloadImage(const std::string& url_path, const std::filesystem::path& cache_path) {
-    LOG_DEBUG(Service_BCAT, "Downloading image: https://eden-emu.dev{}", url_path);
+    LOG_INFO(Service_BCAT, "Downloading image: https://eden-emu.dev{}", url_path);
     try {
         httplib::Client cli("https://eden-emu.dev");
         cli.set_follow_location(true);
@@ -206,6 +226,67 @@ void WriteCachedJson(std::string_view json) {
     (void)Common::FS::WriteStringToFile(path, Common::FS::FileType::TextFile, json);
 }
 
+std::optional<std::string> DownloadReleasesJson() {
+    try {
+#ifdef YUZU_BUNDLED_OPENSSL
+        const auto url = "https://git.eden-emu.dev";
+#else
+        const auto url = "git.eden-emu.dev";
+#endif
+
+        // TODO(crueter): This is duplicated between frontend and here.
+        constexpr auto path = GitHubAPI_EdenReleases;
+
+        constexpr std::size_t timeout_seconds = 15;
+
+        std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(url);
+        client->set_connection_timeout(timeout_seconds);
+        client->set_read_timeout(timeout_seconds);
+        client->set_write_timeout(timeout_seconds);
+
+#ifdef YUZU_BUNDLED_OPENSSL
+        client->load_ca_cert_store(kCert, sizeof(kCert));
+#endif
+
+        if (client == nullptr) {
+            LOG_ERROR(Service_BCAT, "Invalid URL {}{}", url, path);
+            return {};
+        }
+
+        httplib::Request request{
+            .method = "GET",
+            .path = path,
+        };
+
+        client->set_follow_location(true);
+        httplib::Result result = client->send(request);
+
+        if (!result) {
+            LOG_ERROR(Service_BCAT, "GET to {}{} returned null", url, path);
+            return {};
+        } else if (result->status < 400) {
+            return result->body;
+        }
+
+        if (result->status >= 400) {
+            LOG_ERROR(Service_BCAT,
+                      "GET to {}{} returned error status code: {}",
+                      url,
+                      path,
+                      result->status);
+            return {};
+        }
+
+        if (!result->headers.contains("content-type")) {
+            LOG_ERROR(Service_BCAT, "GET to {}{} returned no content", url, path);
+            return {};
+        }
+    } catch (...) {
+        LOG_WARNING(Service_BCAT, " failed to download releases");
+    }
+    return std::nullopt;
+}
+
 // idk but News App does not render Markdown or HTML, so remove some formatting.
 std::string SanitizeMarkdown(std::string_view markdown) {
     std::string result;
@@ -261,7 +342,9 @@ std::string SanitizeMarkdown(std::string_view markdown) {
     return text;
 }
 
-std::string FormatBody(std::string body, const std::string_view &title) {
+std::string FormatBody(const nlohmann::json& release, std::string_view title) {
+    std::string body = release.value("body", std::string{});
+
     if (body.empty()) {
         return std::string(title);
     }
@@ -292,32 +375,52 @@ std::string FormatBody(std::string body, const std::string_view &title) {
     return body;
 }
 
-void ImportReleases(const std::vector<Common::Net::Release> &releases) {
+void ImportReleases(std::string_view json_text) {
+    nlohmann::json root;
+    try {
+        root = nlohmann::json::parse(json_text);
+    } catch (...) {
+        LOG_WARNING(Service_BCAT, "failed to parse JSON");
+        return;
+    }
+
+    if (!root.is_array()) return;
+
     std::vector<u32> news_ids;
-    for (const auto& rel : releases) {
-        const u32 news_id = u32(rel.id & 0x7FFFFFFF);
+    for (const auto& rel : root) {
+        if (!rel.is_object()) continue;
+        std::string title = rel.value("name", rel.value("tag_name", std::string{}));
+        if (title.empty()) continue;
+
+        const u64 release_id = rel.value("id", 0);
+        const u32 news_id = release_id ? static_cast<u32>(release_id & 0x7FFFFFFF) : HashToNewsId(title);
         news_ids.push_back(news_id);
     }
 
     PreloadNewsImages(news_ids);
 
-    for (const auto& rel : releases) {
-        const std::string title = rel.title;
-        const std::string body = rel.body;
-        const std::string html_url = rel.html_url;
+    for (const auto& rel : root) {
+        if (!rel.is_object()) continue;
 
-        const u32 news_id = u32(rel.id & 0x7FFFFFFF);
-        const u64 published = rel.published;
+        std::string title = rel.value("name", rel.value("tag_name", std::string{}));
+        if (title.empty()) continue;
+
+        const u64 release_id = rel.value("id", 0);
+        const u32 news_id = release_id ? static_cast<u32>(release_id & 0x7FFFFFFF) : HashToNewsId(title);
+        const u64 published = ParseIsoTimestamp(rel.value("published_at", std::string{}));
         const u64 pickup_limit = published + 600000000;
-        const u32 priority = rel.prerelease ? 1500 : 2500;
+        const u32 priority = rel.value("prerelease", false) ? 1500 : 2500;
 
-        std::string author = "Eden";
+        std::string author = "eden";
+        if (rel.contains("author") && rel["author"].is_object()) {
+            author = rel["author"].value("login", "eden");
+        }
 
-        auto payload = BuildMsgpack(title, FormatBody(body, title), title, published,
+        auto payload = BuildMsgpack(title, FormatBody(rel, title), title, published,
                                     pickup_limit, priority, {"en"}, author, {},
-                                    html_url, news_id);
+                                    rel.value("html_url", std::string{}), news_id);
 
-        const std::string news_id_str = fmt::format("LA{:020}", rel.id);
+        const std::string news_id_str = fmt::format("LA{:020}", news_id);
 
         GithubNewsMeta meta{
             .news_id = news_id_str,
@@ -462,21 +565,15 @@ void EnsureBuiltinNewsLoaded() {
         LoadDefaultLogos();
 
         if (const auto cached = ReadCachedJson()) {
-            const std::string_view body = cached.value();
-            const auto releases = Common::Net::Release::ListFromJson(body, Common::g_build_auto_update_stable_api, Common::g_build_auto_update_stable_repo);
-            ImportReleases(releases);
-
-            LOG_INFO(Service_BCAT, "news: {} entries loaded from cache", NewsStorage::Instance().ListAll().size());
+            ImportReleases(*cached);
+            LOG_DEBUG(Service_BCAT, "news: {} entries loaded from cache", NewsStorage::Instance().ListAll().size());
         }
 
         std::thread([] {
-            if (const auto fresh = Common::Net::GetReleasesBody()) {
-                const std::string_view body = fresh.value();
-                WriteCachedJson(body);
-                const auto releases = Common::Net::Release::ListFromJson(body, Common::g_build_auto_update_stable_api, Common::g_build_auto_update_stable_repo);
-                ImportReleases(releases);
-
-                LOG_INFO(Service_BCAT, "news: {} entries updated from Forgejo", NewsStorage::Instance().ListAll().size());
+            if (const auto fresh = DownloadReleasesJson()) {
+                WriteCachedJson(*fresh);
+                ImportReleases(*fresh);
+                LOG_DEBUG(Service_BCAT, "news: {} entries updated from Forgejo", NewsStorage::Instance().ListAll().size());
             }
         }).detach();
     });

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

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

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

@@ -10,7 +10,6 @@
 
 #include "common/alignment.h"
 #include "common/assert.h"
-#include "common/common_types.h"
 #include "common/logging.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/core/container.h"
@@ -131,12 +130,12 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
 
     const auto start_pages{static_cast<u32>(vm.va_range_start >> VM::PAGE_SIZE_BITS)};
     const auto end_pages{static_cast<u32>(vm.va_range_split >> VM::PAGE_SIZE_BITS)};
-    vm.small_page_allocator.emplace(start_pages, end_pages);
+    vm.small_page_allocator = std::make_shared<VM::Allocator>(start_pages, end_pages);
 
     const auto start_big_pages{static_cast<u32>(vm.va_range_split >> vm.big_page_size_bits)};
     const auto end_big_pages{
         static_cast<u32>((vm.va_range_end - vm.va_range_split) >> vm.big_page_size_bits)};
-    vm.big_page_allocator.emplace(start_big_pages, end_big_pages);
+    vm.big_page_allocator = std::make_unique<VM::Allocator>(start_big_pages, end_big_pages);
 
     gmmu = std::make_shared<Tegra::MemoryManager>(system, max_big_page_bits, vm.va_range_split,
                                                   vm.big_page_size_bits, VM::PAGE_SIZE_BITS);
@@ -189,8 +188,8 @@ NvResult nvhost_as_gpu::AllocateSpace(IoctlAllocSpace& params) {
     }
 
     allocation_map[params.offset] = {
-        .mappings{},
         .size = size,
+        .mappings{},
         .page_size = params.page_size,
         .sparse = (params.flags & MappingFlags::Sparse) != MappingFlags::None,
         .big_pages = params.page_size != VM::YUZU_PAGESIZE,
@@ -200,52 +199,71 @@ NvResult nvhost_as_gpu::AllocateSpace(IoctlAllocSpace& params) {
 }
 
 void nvhost_as_gpu::FreeMappingLocked(u64 offset) {
-    auto const it = mapping_map.find(offset);
-    auto const mapping = it->second;
-    if (!mapping.fixed) {
-        auto& allocator{mapping.big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
-        u32 page_size_bits{mapping.big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
-        u32 page_size{mapping.big_page ? vm.big_page_size : VM::YUZU_PAGESIZE};
-        u64 aligned_size{Common::AlignUp(mapping.size, page_size)};
-        allocator.Free(u32(mapping.offset >> page_size_bits), u32(aligned_size >> page_size_bits));
+    auto mapping{mapping_map.at(offset)};
+
+    if (!mapping->fixed) {
+        auto& allocator{mapping->big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
+        u32 page_size_bits{mapping->big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
+        u32 page_size{mapping->big_page ? vm.big_page_size : VM::YUZU_PAGESIZE};
+        u64 aligned_size{Common::AlignUp(mapping->size, page_size)};
+
+        allocator.Free(static_cast<u32>(mapping->offset >> page_size_bits),
+                       static_cast<u32>(aligned_size >> page_size_bits));
     }
-    nvmap.UnpinHandle(mapping.handle);
+
+    nvmap.UnpinHandle(mapping->handle);
+
     // Sparse mappings shouldn't be fully unmapped, just returned to their sparse state
     // Only FreeSpace can unmap them fully
-    if (mapping.sparse_alloc) {
-        gmmu->MapSparse(offset, mapping.size, mapping.big_page);
+    if (mapping->sparse_alloc) {
+        gmmu->MapSparse(offset, mapping->size, mapping->big_page);
     } else {
-        gmmu->Unmap(offset, mapping.size);
+        gmmu->Unmap(offset, mapping->size);
     }
-    mapping_map.erase(it);
+
+    mapping_map.erase(offset);
 }
 
 NvResult nvhost_as_gpu::FreeSpace(IoctlFreeSpace& params) {
-    LOG_DEBUG(Service_NVDRV, "called, offset={:X}, pages={:X}, page_size={:X}", params.offset, params.pages, params.page_size);
+    LOG_DEBUG(Service_NVDRV, "called, offset={:X}, pages={:X}, page_size={:X}", params.offset,
+              params.pages, params.page_size);
+
     std::scoped_lock lock(mutex);
+
     if (!vm.initialised) {
         return NvResult::BadValue;
     }
-    if (auto const it = allocation_map.find(params.offset); it != allocation_map.end()) {
-        auto const allocation = it->second;
-        if (allocation.page_size != params.page_size || allocation.size != (u64(params.pages) * params.page_size))
-            return NvResult::BadValue;
 
-        for (const auto mapping_offset : allocation.mappings)
-            FreeMappingLocked(mapping_offset);
+    try {
+        auto allocation{allocation_map[params.offset]};
+
+        if (allocation.page_size != params.page_size ||
+            allocation.size != (static_cast<u64>(params.pages) * params.page_size)) {
+            return NvResult::BadValue;
+        }
+
+        for (const auto& mapping : allocation.mappings) {
+            FreeMappingLocked(mapping->offset);
+        }
 
         // Unset sparse flag if required
-        if (allocation.sparse)
+        if (allocation.sparse) {
             gmmu->Unmap(params.offset, allocation.size);
+        }
 
-        auto& allocator{params.page_size == VM::YUZU_PAGESIZE ? *vm.small_page_allocator : *vm.big_page_allocator};
-        u32 page_size_bits{params.page_size == VM::YUZU_PAGESIZE ? VM::PAGE_SIZE_BITS : vm.big_page_size_bits};
+        auto& allocator{params.page_size == VM::YUZU_PAGESIZE ? *vm.small_page_allocator
+                                                              : *vm.big_page_allocator};
+        u32 page_size_bits{params.page_size == VM::YUZU_PAGESIZE ? VM::PAGE_SIZE_BITS
+                                                                 : vm.big_page_size_bits};
 
-        allocator.Free(u32(params.offset >> page_size_bits), u32(allocation.size >> page_size_bits));
+        allocator.Free(static_cast<u32>(params.offset >> page_size_bits),
+                       static_cast<u32>(allocation.size >> page_size_bits));
         allocation_map.erase(params.offset);
-        return NvResult::Success;
+    } catch (const std::out_of_range&) {
+        return NvResult::BadValue;
     }
-    return NvResult::BadValue;
+
+    return NvResult::Success;
 }
 
 NvResult nvhost_as_gpu::Remap(std::span<IoctlRemapEntry> entries) {
@@ -309,18 +327,26 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
 
     // Remaps a subregion of an existing mapping to a different PA
     if ((params.flags & MappingFlags::Remap) != MappingFlags::None) {
-        if (auto const it = mapping_map.find(params.offset); it != mapping_map.end()) {
-            auto const mapping = it->second;
-            if (mapping.size < params.mapping_size) {
-                LOG_WARNING(Service_NVDRV, "Cannot remap a partially mapped GPU address space region: {:#X}", params.offset);
+        try {
+            auto mapping{mapping_map.at(params.offset)};
+
+            if (mapping->size < params.mapping_size) {
+                LOG_WARNING(Service_NVDRV,
+                            "Cannot remap a partially mapped GPU address space region: {:#X}",
+                            params.offset);
                 return NvResult::BadValue;
             }
-            u64 gpu_address = u64(params.offset + params.buffer_offset);
-            VAddr device_address{mapping.ptr + params.buffer_offset};
-            gmmu->Map(gpu_address, device_address, params.mapping_size, Tegra::PTEKind(params.kind), mapping.big_page);
+
+            u64 gpu_address{static_cast<u64>(params.offset + params.buffer_offset)};
+            VAddr device_address{mapping->ptr + params.buffer_offset};
+
+            gmmu->Map(gpu_address, device_address, params.mapping_size,
+                      static_cast<Tegra::PTEKind>(params.kind), mapping->big_page);
+
             return NvResult::Success;
-        } else {
-            LOG_WARNING(Service_NVDRV, "Cannot remap an unmapped GPU address space region: {:#X}", params.offset);
+        } catch (const std::out_of_range&) {
+            LOG_WARNING(Service_NVDRV, "Cannot remap an unmapped GPU address space region: {:#X}",
+                        params.offset);
             return NvResult::BadValue;
         }
     }
@@ -330,7 +356,8 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         return NvResult::BadValue;
     }
 
-    DAddr device_address = DAddr(nvmap.PinHandle(params.handle, false) + params.buffer_offset);
+    DAddr device_address{
+        static_cast<DAddr>(nvmap.PinHandle(params.handle, false) + params.buffer_offset)};
     u64 size{params.mapping_size ? params.mapping_size : handle->orig_size};
 
     bool big_page{[&]() {
@@ -354,22 +381,32 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         }
 
         const bool use_big_pages = alloc->second.big_pages && big_page;
-        gmmu->Map(params.offset, device_address, size, static_cast<Tegra::PTEKind>(params.kind), use_big_pages);
+        gmmu->Map(params.offset, device_address, size, static_cast<Tegra::PTEKind>(params.kind),
+                  use_big_pages);
 
-        alloc->second.mappings.push_back(params.offset);
-        mapping_map.insert_or_assign(params.offset, Mapping(params.handle, device_address, params.offset, size, true, use_big_pages, alloc->second.sparse));
+        auto mapping{std::make_shared<Mapping>(params.handle, device_address, params.offset, size,
+                                               true, use_big_pages, alloc->second.sparse)};
+        alloc->second.mappings.push_back(mapping);
+        mapping_map[params.offset] = mapping;
     } else {
         auto& allocator{big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
         u32 page_size{big_page ? vm.big_page_size : VM::YUZU_PAGESIZE};
         u32 page_size_bits{big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
 
-        params.offset = u64(allocator.Allocate(u32(Common::AlignUp(size, page_size) >> page_size_bits))) << page_size_bits;
+        params.offset = static_cast<u64>(allocator.Allocate(
+                            static_cast<u32>(Common::AlignUp(size, page_size) >> page_size_bits)))
+                        << page_size_bits;
         if (!params.offset) {
             ASSERT_MSG(false, "Failed to allocate free space in the GPU AS!");
             return NvResult::InsufficientMemory;
         }
-        gmmu->Map(params.offset, device_address, Common::AlignUp(size, page_size), Tegra::PTEKind(params.kind), big_page);
-        mapping_map.insert_or_assign(params.offset, Mapping(params.handle, device_address, params.offset, size, false, big_page, false));
+
+        gmmu->Map(params.offset, device_address, Common::AlignUp(size, page_size),
+                  static_cast<Tegra::PTEKind>(params.kind), big_page);
+
+        auto mapping{std::make_shared<Mapping>(params.handle, device_address, params.offset, size,
+                                               false, big_page, false)};
+        mapping_map[params.offset] = mapping;
     }
 
     map_buffer_offsets.insert(params.offset);
@@ -378,32 +415,37 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
 }
 
 NvResult nvhost_as_gpu::UnmapBuffer(IoctlUnmapBuffer& params) {
-    std::scoped_lock lock(mutex);
-    if (auto const offset_it = map_buffer_offsets.find(params.offset); offset_it != map_buffer_offsets.end()) {
+    if (map_buffer_offsets.find(params.offset) != map_buffer_offsets.end()) {
         LOG_DEBUG(Service_NVDRV, "called, offset={:#X}", params.offset);
+
+        std::scoped_lock lock(mutex);
+
         if (!vm.initialised) {
             return NvResult::BadValue;
         }
 
-        auto const it = mapping_map.find(params.offset);
-        auto const mapping = it->second;
-        if (!mapping.fixed) {
-            auto& allocator{mapping.big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
-            u32 page_size_bits{mapping.big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
-            allocator.Free(u32(mapping.offset >> page_size_bits), u32(mapping.size >> page_size_bits));
+        auto mapping{mapping_map.at(params.offset)};
+
+        if (!mapping->fixed) {
+            auto& allocator{mapping->big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
+            u32 page_size_bits{mapping->big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
+
+            allocator.Free(static_cast<u32>(mapping->offset >> page_size_bits),
+                           static_cast<u32>(mapping->size >> page_size_bits));
         }
 
         // Sparse mappings shouldn't be fully unmapped, just returned to their sparse state
         // Only FreeSpace can unmap them fully
-        if (mapping.sparse_alloc) {
-            gmmu->MapSparse(params.offset, mapping.size, mapping.big_page);
+        if (mapping->sparse_alloc) {
+            gmmu->MapSparse(params.offset, mapping->size, mapping->big_page);
         } else {
-            gmmu->Unmap(params.offset, mapping.size);
+            gmmu->Unmap(params.offset, mapping->size);
         }
 
-        nvmap.UnpinHandle(mapping.handle);
-        mapping_map.erase(it);
-        map_buffer_offsets.erase(offset_it);
+        nvmap.UnpinHandle(mapping->handle);
+
+        mapping_map.erase(params.offset);
+        map_buffer_offsets.erase(params.offset);
     }
     return NvResult::Success;
 }
@@ -436,7 +478,8 @@ void nvhost_as_gpu::GetVARegionsImpl(IoctlGetVaRegions& params) {
 }
 
 NvResult nvhost_as_gpu::GetVARegions1(IoctlGetVaRegions& params) {
-    LOG_DEBUG(Service_NVDRV, "called, buf_addr={:X}, buf_size={:X}", params.buf_addr, params.buf_size);
+    LOG_DEBUG(Service_NVDRV, "called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
+              params.buf_size);
 
     std::scoped_lock lock(mutex);
 

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

@@ -165,36 +165,35 @@ private:
     NvCore::NvMap& nvmap;
 
     struct Mapping {
+        NvCore::NvMap::Handle::Id handle;
         DAddr ptr;
         u64 offset;
         u64 size;
-        NvCore::NvMap::Handle::Id handle;
-        bool fixed : 1;
-        bool big_page : 1; // Only valid if fixed == false
-        bool sparse_alloc : 1;
+        bool fixed;
+        bool big_page; // Only valid if fixed == false
+        bool sparse_alloc;
 
-        Mapping(NvCore::NvMap::Handle::Id handle_, DAddr ptr_, u64 offset_, u64 size_, bool fixed_, bool big_page_, bool sparse_alloc_)
-            : ptr(ptr_), offset(offset_), size(size_), handle(handle_)
-            , fixed(fixed_), big_page(big_page_), sparse_alloc(sparse_alloc_)
-        {}
+        Mapping(NvCore::NvMap::Handle::Id handle_, DAddr ptr_, u64 offset_, u64 size_, bool fixed_,
+                bool big_page_, bool sparse_alloc_)
+            : handle(handle_), ptr(ptr_), offset(offset_), size(size_), fixed(fixed_),
+              big_page(big_page_), sparse_alloc(sparse_alloc_) {}
     };
 
     struct Allocation {
-        std::vector<u64> mappings;
         u64 size;
+        std::list<std::shared_ptr<Mapping>> mappings;
         u32 page_size;
         bool sparse;
         bool big_pages;
     };
 
-    //!< This maps the base addresses of mapped buffers to their total sizes and
-    //!< mapping type, this is needed as what was originally a single buffer may
-    //!< have been split into multiple GPU side buffers with the remap flag.
-    std::map<u64, Mapping> mapping_map;
-    //!< Holds allocations created by AllocSpace from
-    //!< which fixed buffers can be mapped into
-    std::map<u64, Allocation> allocation_map;
-    std::mutex mutex; //!< Locks all AS operations
+    std::map<u64, std::shared_ptr<Mapping>>
+        mapping_map; //!< This maps the base addresses of mapped buffers to their total sizes and
+                     //!< mapping type, this is needed as what was originally a single buffer may
+                     //!< have been split into multiple GPU side buffers with the remap flag.
+    std::map<u64, Allocation> allocation_map; //!< Holds allocations created by AllocSpace from
+                                              //!< which fixed buffers can be mapped into
+    std::mutex mutex;                         //!< Locks all AS operations
 
     struct VM {
         static constexpr u32 YUZU_PAGESIZE{0x1000};
@@ -214,8 +213,9 @@ private:
 
         using Allocator = Common::FlatAllocator<u32, 0, 32>;
 
-        std::optional<Allocator> big_page_allocator;
-        std::optional<Allocator> small_page_allocator; //! Shared as this is also used by nvhost::GpuChannel
+        std::unique_ptr<Allocator> big_page_allocator;
+        std::shared_ptr<Allocator>
+            small_page_allocator; //! Shared as this is also used by nvhost::GpuChannel
 
         bool initialised{};
     } vm;

src/frontend_common/update_checker.cpp

@@ -5,45 +5,146 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#ifdef NIGHTLY_BUILD
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
-#endif
 
 #include <fmt/format.h>
-#include "common/net/net.h"
+#include "common/logging.h"
 #include "common/scm_rev.h"
 #include "update_checker.h"
 
-#include "common/logging.h"
+#include "common/httplib.h"
 
-std::optional<Common::Net::Release> UpdateChecker::GetUpdate() {
-    const auto latest = Common::Net::GetLatestRelease();
-    if (!latest) return std::nullopt;
-
-    LOG_INFO(Frontend, "Received update {}", latest->title);
-
-#ifdef NIGHTLY_BUILD
-    std::vector<std::string> result;
-
-    boost::split(result, latest->tag, boost::is_any_of("."));
-    if (result.size() != 2)
-        return std::nullopt;
-
-    const std::string tag = result[1];
-
-    boost::split(result, std::string{Common::g_build_version}, boost::is_any_of("-"));
-    if (result.empty())
-        return std::nullopt;
-
-    const std::string build = result[0];
-#else
-    const std::string tag = latest->tag;
-    const std::string build = Common::g_build_version;
+#ifdef YUZU_BUNDLED_OPENSSL
+#include <openssl/cert.h>
 #endif
 
-    if (tag != build)
-        return latest;
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <string>
 
+std::optional<std::string> UpdateChecker::GetResponse(std::string url, std::string path)
+{
+    try {
+        constexpr std::size_t timeout_seconds = 15;
+
+        std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(url);
+        client->set_connection_timeout(timeout_seconds);
+        client->set_read_timeout(timeout_seconds);
+        client->set_write_timeout(timeout_seconds);
+
+#ifdef YUZU_BUNDLED_OPENSSL
+        client->load_ca_cert_store(kCert, sizeof(kCert));
+#endif
+
+        if (client == nullptr) {
+            LOG_ERROR(Frontend, "Invalid URL {}{}", url, path);
+            return {};
+        }
+
+        httplib::Request request{
+            .method = "GET",
+            .path = path,
+        };
+
+        client->set_follow_location(true);
+        httplib::Result result = client->send(request);
+
+        if (!result) {
+            LOG_ERROR(Frontend, "GET to {}{} returned null", url, path);
+            return {};
+        }
+
+        const auto &response = result.value();
+        if (response.status >= 400) {
+            LOG_ERROR(Frontend,
+                      "GET to {}{} returned error status code: {}",
+                      url,
+                      path,
+                      response.status);
+            return {};
+        }
+        if (!response.headers.contains("content-type")) {
+            LOG_ERROR(Frontend, "GET to {}{} returned no content", url, path);
+            return {};
+        }
+
+        return response.body;
+    } catch (std::exception &e) {
+        LOG_ERROR(Frontend,
+                  "GET to {}{} failed during update check: {}",
+                  url,
+                  path,
+                  e.what());
+        return std::nullopt;
+    }
+}
+
+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 = std::string{Common::g_build_auto_update_api_path};
+    try {
+        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};
+    } catch (nlohmann::detail::out_of_range&) {
+        LOG_ERROR(Frontend,
+                  "Parsing JSON response from {}{} failed during update check: "
+                  "nlohmann::detail::out_of_range",
+                  update_check_url,
+                  update_check_path);
+        return {};
+    } catch (nlohmann::detail::type_error&) {
+        LOG_ERROR(Frontend,
+                  "Parsing JSON response from {}{} failed during update check: "
+                  "nlohmann::detail::type_error",
+                  update_check_url,
+                  update_check_path);
+        return {};
+    }
+}
+
+std::optional<UpdateChecker::Update> UpdateChecker::GetUpdate() {
+    const std::optional<UpdateChecker::Update> latest_release_tag =
+        UpdateChecker::GetLatestRelease();
+
+    if (!latest_release_tag)
+        goto empty;
+
+    {
+        std::string tag, build;
+        if (Common::g_is_nightly_build) {
+            std::vector<std::string> result;
+
+            boost::split(result, latest_release_tag->tag, boost::is_any_of("."));
+            if (result.size() != 2)
+                goto empty;
+            tag = result[1];
+
+            boost::split(result, std::string{Common::g_build_version}, boost::is_any_of("-"));
+            if (result.empty())
+                goto empty;
+            build = result[0];
+        } else {
+            tag = latest_release_tag->tag;
+            build = Common::g_build_version;
+        }
+
+        if (tag != build)
+            return latest_release_tag.value();
+    }
+
+empty:
     return std::nullopt;
 }

src/frontend_common/update_checker.h

@@ -8,10 +8,16 @@
 #pragma once
 
 #include <optional>
-#include "common/net/net.h"
+#include <string>
 
 namespace UpdateChecker {
 
-std::optional<Common::Net::Release> GetUpdate();
+typedef struct {
+    std::string tag;
+    std::string name;
+} Update;
 
+std::optional<std::string> GetResponse(std::string url, std::string path);
+std::optional<Update> GetLatestRelease();
+std::optional<Update> GetUpdate();
 } // namespace UpdateChecker

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -30,8 +30,9 @@ struct TextureInst {
 
 using TextureInstVector = boost::container::small_vector<TextureInst, 24>;
 
-constexpr u32 DESCRIPTOR_SIZE = 8;
-constexpr u32 DESCRIPTOR_SIZE_SHIFT = static_cast<u32>(std::countr_zero(DESCRIPTOR_SIZE));
+// TODO: We need to implement scatter/gather CBuf stuff
+constexpr u32 DESCRIPTOR_SIZE = 1024;
+constexpr u32 DESCRIPTOR_SIZE_SHIFT = u32(std::countr_zero(u32(8)));
 
 IR::Opcode IndexedInstruction(const IR::Inst& inst) {
     switch (inst.GetOpcode()) {
@@ -362,7 +363,7 @@ std::optional<ConstBufferAddr> TryGetConstBuffer(const IR::Inst* inst, Environme
         .secondary_offset = 0,
         .secondary_shift_left = 0,
         .dynamic_offset = dynamic_offset,
-        .count = 8,
+        .count = DESCRIPTOR_SIZE,
         .has_secondary = false,
     };
 }
@@ -406,15 +407,15 @@ u32 GetTextureHandle(Environment& env, const ConstBufferAddr& cbuf) {
     return lhs_raw | rhs_raw;
 }
 
-    [[maybe_unused]]TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
+[[maybe_unused]]TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {
     return env.ReadTextureType(GetTextureHandle(env, cbuf));
 }
 
-    [[maybe_unused]]TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
+[[maybe_unused]]TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAddr& cbuf) {
     return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
-    [[maybe_unused]]bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
+[[maybe_unused]]bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
     return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
 }
 
@@ -716,8 +717,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
             const auto insert_point{IR::Block::InstructionList::s_iterator_to(*inst)};
             IR::IREmitter ir{*texture_inst.block, insert_point};
             const IR::U32 shift{ir.Imm32(DESCRIPTOR_SIZE_SHIFT)};
-            inst->SetArg(0, ir.UMin(ir.ShiftRightLogical(cbuf.dynamic_offset, shift),
-                        ir.Imm32(DESCRIPTOR_SIZE - 1)));
+            inst->SetArg(0, ir.UMin(ir.ShiftRightLogical(cbuf.dynamic_offset, shift), ir.Imm32(DESCRIPTOR_SIZE - 1)));
         } else {
             inst->SetArg(0, IR::Value{});
         }

src/video_core/CMakeLists.txt

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

src/video_core/buffer_cache/buffer_cache.h

@@ -356,7 +356,7 @@ void BufferCache<P>::BindHostGeometryBuffers(bool is_indexed) {
     if (is_indexed) {
         BindHostIndexBuffer();
     } else if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const auto& draw_state = maxwell3d->draw_manager.draw_state;
+        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
             draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
             runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
@@ -740,25 +740,30 @@ void BufferCache<P>::BindHostIndexBuffer() {
     TouchBuffer(buffer, channel_state->index_buffer.buffer_id);
     const u32 offset = buffer.Offset(channel_state->index_buffer.device_addr);
     const u32 size = channel_state->index_buffer.size;
-    const auto& draw_state = maxwell3d->draw_manager.draw_state;
-    if (draw_state.inline_index_draw_indexes.empty()) {
-        SynchronizeBuffer(buffer, channel_state->index_buffer.device_addr, size);
-    } else {
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+    if (!draw_state.inline_index_draw_indexes.empty()) [[unlikely]] {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
             auto upload_staging = runtime.UploadStagingBuffer(size);
-            std::array<BufferCopy, 1> copies{{BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
-            std::memcpy(upload_staging.mapped_span.data(), draw_state.inline_index_draw_indexes.data(), size);
+            std::array<BufferCopy, 1> copies{
+                {BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
+            std::memcpy(upload_staging.mapped_span.data(),
+                        draw_state.inline_index_draw_indexes.data(), size);
             runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true);
         } else {
             buffer.ImmediateUpload(0, draw_state.inline_index_draw_indexes);
         }
+    } else {
+        SynchronizeBuffer(buffer, channel_state->index_buffer.device_addr, size);
     }
     if constexpr (HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const u32 new_offset = offset + draw_state.index_buffer.first * draw_state.index_buffer.FormatSizeInBytes();
+        const u32 new_offset =
+            offset + draw_state.index_buffer.first * draw_state.index_buffer.FormatSizeInBytes();
         runtime.BindIndexBuffer(buffer, new_offset, size);
     } else {
         buffer.MarkUsage(offset, size);
-        runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format, draw_state.index_buffer.first, draw_state.index_buffer.count, buffer, offset, size);
+        runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format,
+                                draw_state.index_buffer.first, draw_state.index_buffer.count,
+                                buffer, offset, size);
     }
 }
 
@@ -940,9 +945,10 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
             return alignment > 1 && (offset % alignment) != 0;
         }
     }();
-    const bool use_fast_buffer = needs_alignment_stream
-        || (has_host_buffer && size <= channel_state->uniform_buffer_skip_cache_size
-            && !memory_tracker.IsRegionGpuModified(device_addr, size));
+    const bool use_fast_buffer = needs_alignment_stream ||
+                                 (has_host_buffer &&
+                                  size <= channel_state->uniform_buffer_skip_cache_size &&
+                                  !memory_tracker.IsRegionGpuModified(device_addr, size));
     if (use_fast_buffer) {
         if constexpr (IS_OPENGL) {
             if (runtime.HasFastBufferSubData()) {
@@ -1223,7 +1229,7 @@ template <class P>
 void BufferCache<P>::UpdateIndexBuffer() {
     // We have to check for the dirty flags and index count
     // The index count is currently changed without updating the dirty flags
-    const auto& draw_state = maxwell3d->draw_manager.draw_state;
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     const auto& index_buffer_ref = draw_state.index_buffer;
     auto& flags = maxwell3d->dirty.flags;
     if (!flags[Dirty::IndexBuffer]) {

src/video_core/buffer_cache/buffer_cache_base.h

@@ -32,7 +32,7 @@
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/dirty_flags.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
@@ -305,7 +305,7 @@ public:
     [[nodiscard]] bool IsRegionCpuModified(DAddr addr, size_t size);
 
     void SetDrawIndirect(
-        const Tegra::Engines::Maxwell3D::DrawManager::IndirectParams* current_draw_indirect_) {
+        const Tegra::Engines::DrawManager::IndirectParams* current_draw_indirect_) {
         current_draw_indirect = current_draw_indirect_;
     }
 
@@ -480,7 +480,7 @@ private:
 #endif
     DelayedDestructionRing<Buffer, TICKS_TO_DESTROY> delayed_destruction_ring;
 
-    const Tegra::Engines::Maxwell3D::DrawManager::IndirectParams* current_draw_indirect{};
+    const Tegra::Engines::DrawManager::IndirectParams* current_draw_indirect{};
 
     u32 last_index_count = 0;
 

src/video_core/cdma_pusher.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Ryujinx Team and Contributors
@@ -20,101 +20,109 @@
 namespace Tegra {
 
 CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
-    : host_processor(host1x_)
-    , host1x{host1x_}
-    , current_class{ChClassId(id)}
-{
-    thread = std::jthread([this](std::stop_token stop_token) {
-        Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
-        ChCommandHeaderList command_list{host1x.System().ApplicationMemory(), 0, 0};
-        u32 count{};
-        u32 method_offset{};
-        u32 mask{};
-        bool incrementing{};
-        while (!stop_token.stop_requested()) {
-            {
-                std::unique_lock l{command_mutex};
-                command_cv.wait(l, stop_token, [this]() { return command_lists.size() > 0; });
-                if (stop_token.stop_requested()) {
-                    return;
-                }
-
-                command_list = std::move(command_lists.front());
-                command_lists.pop_front();
-            }
-
-            size_t i = 0;
-            for (const auto value : command_list) {
-                i++;
-                if (mask != 0) {
-                    const auto lbs = static_cast<u32>(std::countr_zero(mask));
-                    mask &= ~(1U << lbs);
-                    ExecuteCommand(method_offset + lbs, value.raw);
-                    continue;
-                } else if (count != 0) {
-                    --count;
-                    ExecuteCommand(method_offset, value.raw);
-                    if (incrementing) {
-                        ++method_offset;
-                    }
-                    continue;
-                }
-                const auto mode = value.submission_mode.Value();
-                switch (mode) {
-                case ChSubmissionMode::SetClass: {
-                    mask = value.value & 0x3f;
-                    method_offset = value.method_offset;
-                    current_class = ChClassId((value.value >> 6) & 0x3ff);
-                    break;
-                }
-                case ChSubmissionMode::Incrementing:
-                case ChSubmissionMode::NonIncrementing:
-                    count = value.value;
-                    method_offset = value.method_offset;
-                    incrementing = mode == ChSubmissionMode::Incrementing;
-                    break;
-                case ChSubmissionMode::Mask:
-                    mask = value.value;
-                    method_offset = value.method_offset;
-                    break;
-                case ChSubmissionMode::Immediate: {
-                    const u32 data = value.value & 0xfff;
-                    method_offset = value.method_offset;
-                    ExecuteCommand(method_offset, data);
-                    break;
-                }
-                default:
-                    LOG_ERROR(HW_GPU, "Bad command at index {} (bytes {:#X}), buffer size {}", i - 1, (i - 1) * sizeof(u32), command_list.size());
-                    UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!", u32(mode));
-                    break;
-                }
-            }
-        }
-    });
+    : host1x{host1x_}, memory_manager{host1x.GMMU()},
+      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
+                                                                      static_cast<ChClassId>(id)} {
+    thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
 }
 
 CDmaPusher::~CDmaPusher() = default;
 
+void CDmaPusher::ProcessEntries(std::stop_token stop_token) {
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+    ChCommandHeaderList command_list{host1x.System().ApplicationMemory(), 0, 0};
+    u32 count{};
+    u32 method_offset{};
+    u32 mask{};
+    bool incrementing{};
+
+    while (!stop_token.stop_requested()) {
+        {
+            std::unique_lock l{command_mutex};
+            command_cv.wait(l, stop_token,
+                            [this]() { return command_lists.size() > 0; });
+            if (stop_token.stop_requested()) {
+                return;
+            }
+
+            command_list = std::move(command_lists.front());
+            command_lists.pop_front();
+        }
+
+        size_t i = 0;
+        for (const auto value : command_list) {
+            i++;
+            if (mask != 0) {
+                const auto lbs = static_cast<u32>(std::countr_zero(mask));
+                mask &= ~(1U << lbs);
+                ExecuteCommand(method_offset + lbs, value.raw);
+                continue;
+            } else if (count != 0) {
+                --count;
+                ExecuteCommand(method_offset, value.raw);
+                if (incrementing) {
+                    ++method_offset;
+                }
+                continue;
+            }
+            const auto mode = value.submission_mode.Value();
+            switch (mode) {
+            case ChSubmissionMode::SetClass: {
+                mask = value.value & 0x3f;
+                method_offset = value.method_offset;
+                current_class = static_cast<ChClassId>((value.value >> 6) & 0x3ff);
+                break;
+            }
+            case ChSubmissionMode::Incrementing:
+            case ChSubmissionMode::NonIncrementing:
+                count = value.value;
+                method_offset = value.method_offset;
+                incrementing = mode == ChSubmissionMode::Incrementing;
+                break;
+            case ChSubmissionMode::Mask:
+                mask = value.value;
+                method_offset = value.method_offset;
+                break;
+            case ChSubmissionMode::Immediate: {
+                const u32 data = value.value & 0xfff;
+                method_offset = value.method_offset;
+                ExecuteCommand(method_offset, data);
+                break;
+            }
+            default:
+                LOG_ERROR(HW_GPU, "Bad command at index {} (bytes {:#X}), buffer size {}", i - 1,
+                          (i - 1) * sizeof(u32), command_list.size());
+                UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!",
+                                  static_cast<u32>(mode));
+                break;
+            }
+        }
+    }
+}
+
 void CDmaPusher::ExecuteCommand(u32 method, u32 arg) {
     switch (current_class) {
     case ChClassId::Control:
-        LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}", u32(current_class), method, arg);
-        host_processor.ProcessMethod(Host1x::Control::Method(method), arg);
+        LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}",
+                  static_cast<u32>(current_class), method, arg);
+        host_processor->ProcessMethod(static_cast<Host1x::Control::Method>(method), arg);
         break;
     default:
         thi_regs.reg_array[method] = arg;
         switch (static_cast<ThiMethod>(method)) {
         case ThiMethod::IncSyncpt: {
-            const auto syncpoint_id = u32(arg & 0xFF);
-            [[maybe_unused]] const auto cond = u32((arg >> 8) & 0xFF);
-            LOG_TRACE(Service_NVDRV, "Class {} IncSyncpt Method, syncpt {} cond {}", u32(current_class), syncpoint_id, cond);
+            const auto syncpoint_id = static_cast<u32>(arg & 0xFF);
+            [[maybe_unused]] const auto cond = static_cast<u32>((arg >> 8) & 0xFF);
+            LOG_TRACE(Service_NVDRV, "Class {} IncSyncpt Method, syncpt {} cond {}",
+                      static_cast<u32>(current_class), syncpoint_id, cond);
             auto& syncpoint_manager = host1x.GetSyncpointManager();
             syncpoint_manager.IncrementGuest(syncpoint_id);
             syncpoint_manager.IncrementHost(syncpoint_id);
             break;
         }
         case ThiMethod::SetMethod1:
-            LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}", u32(current_class), u32(thi_regs.method_0), arg);
+            LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}",
+                      static_cast<u32>(current_class), static_cast<u32>(thi_regs.method_0), arg);
             ProcessMethod(thi_regs.method_0, arg);
             break;
         default:

src/video_core/cdma_pusher.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,11 +15,11 @@
 #include "common/common_types.h"
 #include "common/polyfill_thread.h"
 #include "core/memory.h"
-#include "video_core/host1x/control.h"
 
 namespace Tegra {
 
 namespace Host1x {
+class Control;
 class Host1x;
 class Nvdec;
 class SyncptIncrManager;
@@ -120,19 +117,25 @@ 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);
+
     /// Invoke command class devices to execute the command based on the current state
     void ExecuteCommand(u32 state_offset, u32 data);
 
-protected:
-    ThiRegisters thi_regs{};
-    std::deque<ChCommandHeaderList> command_lists;
-    std::condition_variable_any command_cv;
-    Host1x::Control host_processor;
+    std::unique_ptr<Host1x::Control> host_processor;
+
     std::mutex command_mutex;
-    Host1x::Host1x& host1x;
-    ChClassId current_class;
+    std::condition_variable_any command_cv;
+    std::deque<ChCommandHeaderList> command_lists;
     std::jthread thread;
+
+    ThiRegisters thi_regs{};
+    ChClassId current_class;
 };
 
 } // namespace Tegra

src/video_core/engines/draw_manager.cpp

@@ -1,24 +1,23 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/settings.h"
 #include "video_core/dirty_flags.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/rasterizer_interface.h"
 
 namespace Tegra::Engines {
+DrawManager::DrawManager(Maxwell3D* maxwell3d_) : maxwell3d(maxwell3d_) {}
 
-void Maxwell3D::DrawManager::ProcessMethodCall(Maxwell3D& maxwell3d, u32 method, u32 argument) {
+void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
+    const auto& regs{maxwell3d->regs};
     switch (method) {
     case MAXWELL3D_REG_INDEX(clear_surface):
-        return Clear(maxwell3d, 1);
+        return Clear(1);
     case MAXWELL3D_REG_INDEX(draw.begin):
-        return DrawBegin(maxwell3d);
+        return DrawBegin();
     case MAXWELL3D_REG_INDEX(draw.end):
-        return DrawEnd(maxwell3d);
+        return DrawEnd();
     case MAXWELL3D_REG_INDEX(vertex_buffer.first):
     case MAXWELL3D_REG_INDEX(vertex_buffer.count):
     case MAXWELL3D_REG_INDEX(index_buffer.first):
@@ -34,29 +33,33 @@ void Maxwell3D::DrawManager::ProcessMethodCall(Maxwell3D& maxwell3d, u32 method,
     case MAXWELL3D_REG_INDEX(index_buffer32_first):
     case MAXWELL3D_REG_INDEX(index_buffer16_first):
     case MAXWELL3D_REG_INDEX(index_buffer8_first):
-        return DrawIndexSmall(maxwell3d, argument);
+        return DrawIndexSmall(argument);
     case MAXWELL3D_REG_INDEX(draw_inline_index):
-        SetInlineIndexBuffer(maxwell3d, argument);
+        SetInlineIndexBuffer(argument);
         break;
     case MAXWELL3D_REG_INDEX(inline_index_2x16.even):
-        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_2x16.even);
-        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_2x16.odd);
+        SetInlineIndexBuffer(regs.inline_index_2x16.even);
+        SetInlineIndexBuffer(regs.inline_index_2x16.odd);
         break;
     case MAXWELL3D_REG_INDEX(inline_index_4x8.index0):
-        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index0);
-        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index1);
-        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index2);
-        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index3);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index0);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index1);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index2);
+        SetInlineIndexBuffer(regs.inline_index_4x8.index3);
         break;
     case MAXWELL3D_REG_INDEX(vertex_array_instance_first):
-        DrawArrayInstanced(maxwell3d, maxwell3d.regs.vertex_array_instance_first.topology.Value(), maxwell3d.regs.vertex_array_instance_first.start.Value(), maxwell3d.regs.vertex_array_instance_first.count.Value(), false);
+        DrawArrayInstanced(regs.vertex_array_instance_first.topology.Value(),
+                           regs.vertex_array_instance_first.start.Value(),
+                           regs.vertex_array_instance_first.count.Value(), false);
         break;
     case MAXWELL3D_REG_INDEX(vertex_array_instance_subsequent): {
-        DrawArrayInstanced(maxwell3d, maxwell3d.regs.vertex_array_instance_subsequent.topology.Value(), maxwell3d.regs.vertex_array_instance_subsequent.start.Value(), maxwell3d.regs.vertex_array_instance_subsequent.count.Value(), true);
+        DrawArrayInstanced(regs.vertex_array_instance_subsequent.topology.Value(),
+                           regs.vertex_array_instance_subsequent.start.Value(),
+                           regs.vertex_array_instance_subsequent.count.Value(), true);
         break;
     }
     case MAXWELL3D_REG_INDEX(draw_texture.src_y0): {
-        DrawTexture(maxwell3d);
+        DrawTexture();
         break;
     }
     default:
@@ -64,87 +67,101 @@ void Maxwell3D::DrawManager::ProcessMethodCall(Maxwell3D& maxwell3d, u32 method,
     }
 }
 
-void Maxwell3D::DrawManager::Clear(Maxwell3D& maxwell3d, u32 layer_count) {
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.rasterizer->Clear(layer_count);
+void DrawManager::Clear(u32 layer_count) {
+    if (maxwell3d->ShouldExecute()) {
+        maxwell3d->rasterizer->Clear(layer_count);
     }
 }
 
-void Maxwell3D::DrawManager::DrawDeferred(Maxwell3D& maxwell3d) {
+void DrawManager::DrawDeferred() {
     if (draw_state.draw_mode != DrawMode::Instance || draw_state.instance_count == 0) {
         return;
     }
-    DrawEnd(maxwell3d, draw_state.instance_count + 1, true);
+    DrawEnd(draw_state.instance_count + 1, true);
     draw_state.instance_count = 0;
 }
 
-void Maxwell3D::DrawManager::DrawArray(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 vertex_first, u32 vertex_count, u32 base_instance, u32 num_instances) {
+void DrawManager::DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
+                            u32 base_instance, u32 num_instances) {
     draw_state.topology = topology;
     draw_state.vertex_buffer.first = vertex_first;
     draw_state.vertex_buffer.count = vertex_count;
     draw_state.base_instance = base_instance;
-    ProcessDraw(maxwell3d, false, num_instances);
+    ProcessDraw(false, num_instances);
 }
 
-void Maxwell3D::DrawManager::DrawArrayInstanced(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 vertex_first, u32 vertex_count, bool subsequent) {
+void DrawManager::DrawArrayInstanced(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
+                                     bool subsequent) {
     draw_state.topology = topology;
     draw_state.vertex_buffer.first = vertex_first;
     draw_state.vertex_buffer.count = vertex_count;
+
     if (!subsequent) {
         draw_state.instance_count = 1;
     }
+
     draw_state.base_instance = draw_state.instance_count - 1;
     draw_state.draw_mode = DrawMode::Instance;
     draw_state.instance_count++;
-    ProcessDraw(maxwell3d, false, 1);
+    ProcessDraw(false, 1);
 }
 
-void Maxwell3D::DrawManager::DrawIndex(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count, u32 base_index, u32 base_instance, u32 num_instances) {
+void DrawManager::DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count,
+                            u32 base_index, u32 base_instance, u32 num_instances) {
+    const auto& regs{maxwell3d->regs};
     draw_state.topology = topology;
-    draw_state.index_buffer = maxwell3d.regs.index_buffer;
+    draw_state.index_buffer = regs.index_buffer;
     draw_state.index_buffer.first = index_first;
     draw_state.index_buffer.count = index_count;
     draw_state.base_index = base_index;
     draw_state.base_instance = base_instance;
-    ProcessDraw(maxwell3d, true, num_instances);
+    ProcessDraw(true, num_instances);
 }
 
-void Maxwell3D::DrawManager::DrawArrayIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology) {
+void DrawManager::DrawArrayIndirect(PrimitiveTopology topology) {
     draw_state.topology = topology;
-    ProcessDrawIndirect(maxwell3d);
+
+    ProcessDrawIndirect();
 }
 
-void Maxwell3D::DrawManager::DrawIndexedIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count) {
+void DrawManager::DrawIndexedIndirect(PrimitiveTopology topology, u32 index_first,
+                                      u32 index_count) {
+    const auto& regs{maxwell3d->regs};
     draw_state.topology = topology;
-    draw_state.index_buffer = maxwell3d.regs.index_buffer;
+    draw_state.index_buffer = regs.index_buffer;
     draw_state.index_buffer.first = index_first;
     draw_state.index_buffer.count = index_count;
-    ProcessDrawIndirect(maxwell3d);
+
+    ProcessDrawIndirect();
 }
 
-void Maxwell3D::DrawManager::SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 index) {
-    draw_state.inline_index_draw_indexes.push_back(u8(index & 0x000000ff));
-    draw_state.inline_index_draw_indexes.push_back(u8((index & 0x0000ff00) >> 8));
-    draw_state.inline_index_draw_indexes.push_back(u8((index & 0x00ff0000) >> 16));
-    draw_state.inline_index_draw_indexes.push_back(u8((index & 0xff000000) >> 24));
+void DrawManager::SetInlineIndexBuffer(u32 index) {
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>(index & 0x000000ff));
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x0000ff00) >> 8));
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x00ff0000) >> 16));
+    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0xff000000) >> 24));
     draw_state.draw_mode = DrawMode::InlineIndex;
 }
 
-void Maxwell3D::DrawManager::DrawBegin(Maxwell3D& maxwell3d) {
-    auto reset_instance_count = maxwell3d.regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First;
-    auto increment_instance_count = maxwell3d.regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent;
+void DrawManager::DrawBegin() {
+    const auto& regs{maxwell3d->regs};
+    auto reset_instance_count = regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First;
+    auto increment_instance_count =
+        regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent;
     if (reset_instance_count) {
-        DrawDeferred(maxwell3d);
+        DrawDeferred();
         draw_state.instance_count = 0;
         draw_state.draw_mode = DrawMode::General;
     } else if (increment_instance_count) {
         draw_state.instance_count++;
         draw_state.draw_mode = DrawMode::Instance;
     }
-    draw_state.topology = maxwell3d.regs.draw.topology;
+
+    draw_state.topology = regs.draw.topology;
 }
 
-void Maxwell3D::DrawManager::DrawEnd(Maxwell3D& maxwell3d, u32 instance_count, bool force_draw) {
+void DrawManager::DrawEnd(u32 instance_count, bool force_draw) {
+    const auto& regs{maxwell3d->regs};
     switch (draw_state.draw_mode) {
     case DrawMode::Instance:
         if (!force_draw) {
@@ -152,100 +169,119 @@ void Maxwell3D::DrawManager::DrawEnd(Maxwell3D& maxwell3d, u32 instance_count, b
         }
         [[fallthrough]];
     case DrawMode::General:
-        draw_state.base_instance = maxwell3d.regs.global_base_instance_index;
-        draw_state.base_index = maxwell3d.regs.global_base_vertex_index;
+        draw_state.base_instance = regs.global_base_instance_index;
+        draw_state.base_index = regs.global_base_vertex_index;
         if (draw_state.draw_indexed) {
-            draw_state.index_buffer = maxwell3d.regs.index_buffer;
-            ProcessDraw(maxwell3d, true, instance_count);
+            draw_state.index_buffer = regs.index_buffer;
+            ProcessDraw(true, instance_count);
         } else {
-            draw_state.vertex_buffer = maxwell3d.regs.vertex_buffer;
-            ProcessDraw(maxwell3d, false, instance_count);
+            draw_state.vertex_buffer = regs.vertex_buffer;
+            ProcessDraw(false, instance_count);
         }
         draw_state.draw_indexed = false;
         break;
     case DrawMode::InlineIndex:
-        draw_state.base_instance = maxwell3d.regs.global_base_instance_index;
-        draw_state.base_index = maxwell3d.regs.global_base_vertex_index;
-        draw_state.index_buffer = maxwell3d.regs.index_buffer;
-        draw_state.index_buffer.count = u32(draw_state.inline_index_draw_indexes.size() / 4);
+        draw_state.base_instance = regs.global_base_instance_index;
+        draw_state.base_index = regs.global_base_vertex_index;
+        draw_state.index_buffer = regs.index_buffer;
+        draw_state.index_buffer.count =
+            static_cast<u32>(draw_state.inline_index_draw_indexes.size() / 4);
         draw_state.index_buffer.format = Maxwell3D::Regs::IndexFormat::UnsignedInt;
-        maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        ProcessDraw(maxwell3d, true, instance_count);
+        maxwell3d->dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        ProcessDraw(true, instance_count);
         draw_state.inline_index_draw_indexes.clear();
         break;
     }
 }
 
-void Maxwell3D::DrawManager::DrawIndexSmall(Maxwell3D& maxwell3d, u32 argument) {
-    Maxwell3D::Regs::IndexBufferSmall index_small_params{argument};
-    draw_state.base_instance = maxwell3d.regs.global_base_instance_index;
-    draw_state.base_index = maxwell3d.regs.global_base_vertex_index;
-    draw_state.index_buffer = maxwell3d.regs.index_buffer;
+void DrawManager::DrawIndexSmall(u32 argument) {
+    const auto& regs{maxwell3d->regs};
+    IndexBufferSmall index_small_params{argument};
+    draw_state.base_instance = regs.global_base_instance_index;
+    draw_state.base_index = regs.global_base_vertex_index;
+    draw_state.index_buffer = regs.index_buffer;
     draw_state.index_buffer.first = index_small_params.first;
     draw_state.index_buffer.count = index_small_params.count;
     draw_state.topology = index_small_params.topology;
-    maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-    ProcessDraw(maxwell3d, true, 1);
+    maxwell3d->dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+    ProcessDraw(true, 1);
 }
 
-void Maxwell3D::DrawManager::DrawTexture(Maxwell3D& maxwell3d) {
-    draw_texture_state.dst_x0 = f32(maxwell3d.regs.draw_texture.dst_x0) / 4096.f;
-    draw_texture_state.dst_y0 = f32(maxwell3d.regs.draw_texture.dst_y0) / 4096.f;
-    const auto dst_width = f32(maxwell3d.regs.draw_texture.dst_width) / 4096.f;
-    const auto dst_height = f32(maxwell3d.regs.draw_texture.dst_height) / 4096.f;
-    const bool lower_left{maxwell3d.regs.window_origin.mode != Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
+void DrawManager::DrawTexture() {
+    const auto& regs{maxwell3d->regs};
+    draw_texture_state.dst_x0 = static_cast<float>(regs.draw_texture.dst_x0) / 4096.f;
+    draw_texture_state.dst_y0 = static_cast<float>(regs.draw_texture.dst_y0) / 4096.f;
+    const auto dst_width = static_cast<float>(regs.draw_texture.dst_width) / 4096.f;
+    const auto dst_height = static_cast<float>(regs.draw_texture.dst_height) / 4096.f;
+    const bool lower_left{regs.window_origin.mode !=
+                          Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
     if (lower_left) {
-        draw_texture_state.dst_y0 = f32(maxwell3d.regs.surface_clip.height) - draw_texture_state.dst_y0;
+        draw_texture_state.dst_y0 =
+            static_cast<f32>(regs.surface_clip.height) - draw_texture_state.dst_y0;
     }
     draw_texture_state.dst_x1 = draw_texture_state.dst_x0 + dst_width;
     draw_texture_state.dst_y1 = draw_texture_state.dst_y0 + dst_height;
-    draw_texture_state.src_x0 = f32(maxwell3d.regs.draw_texture.src_x0) / 4096.f;
-    draw_texture_state.src_y0 = f32(maxwell3d.regs.draw_texture.src_y0) / 4096.f;
-    draw_texture_state.src_x1 = (f32(maxwell3d.regs.draw_texture.dx_du) / 4294967296.f) * dst_width + draw_texture_state.src_x0;
-    draw_texture_state.src_y1 = (f32(maxwell3d.regs.draw_texture.dy_dv) / 4294967296.f) * dst_height + draw_texture_state.src_y0;
-    draw_texture_state.src_sampler = maxwell3d.regs.draw_texture.src_sampler;
-    draw_texture_state.src_texture = maxwell3d.regs.draw_texture.src_texture;
-    maxwell3d.rasterizer->DrawTexture();
+    draw_texture_state.src_x0 = static_cast<float>(regs.draw_texture.src_x0) / 4096.f;
+    draw_texture_state.src_y0 = static_cast<float>(regs.draw_texture.src_y0) / 4096.f;
+    draw_texture_state.src_x1 =
+        (static_cast<float>(regs.draw_texture.dx_du) / 4294967296.f) * dst_width +
+        draw_texture_state.src_x0;
+    draw_texture_state.src_y1 =
+        (static_cast<float>(regs.draw_texture.dy_dv) / 4294967296.f) * dst_height +
+        draw_texture_state.src_y0;
+    draw_texture_state.src_sampler = regs.draw_texture.src_sampler;
+    draw_texture_state.src_texture = regs.draw_texture.src_texture;
+    maxwell3d->rasterizer->DrawTexture();
 }
 
-void Maxwell3D::DrawManager::UpdateTopology(Maxwell3D& maxwell3d) {
-    switch (maxwell3d.regs.primitive_topology_control) {
-    case Maxwell3D::Regs::PrimitiveTopologyControl::UseInBeginMethods:
+void DrawManager::UpdateTopology() {
+    const auto& regs{maxwell3d->regs};
+    switch (regs.primitive_topology_control) {
+    case PrimitiveTopologyControl::UseInBeginMethods:
         break;
-    case Maxwell3D::Regs::PrimitiveTopologyControl::UseSeparateState:
-        switch (maxwell3d.regs.topology_override) {
-        case Maxwell3D::Regs::PrimitiveTopologyOverride::None:
+    case PrimitiveTopologyControl::UseSeparateState:
+        switch (regs.topology_override) {
+        case PrimitiveTopologyOverride::None:
             break;
-        case Maxwell3D::Regs::PrimitiveTopologyOverride::Points:
-            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology::Points;
+        case PrimitiveTopologyOverride::Points:
+            draw_state.topology = PrimitiveTopology::Points;
             break;
-        case Maxwell3D::Regs::PrimitiveTopologyOverride::Lines:
-            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology::Lines;
+        case PrimitiveTopologyOverride::Lines:
+            draw_state.topology = PrimitiveTopology::Lines;
             break;
-        case Maxwell3D::Regs::PrimitiveTopologyOverride::LineStrip:
-            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology::LineStrip;
+        case PrimitiveTopologyOverride::LineStrip:
+            draw_state.topology = PrimitiveTopology::LineStrip;
             break;
         default:
-            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology(maxwell3d.regs.topology_override);
+            draw_state.topology = static_cast<PrimitiveTopology>(regs.topology_override);
             break;
         }
         break;
     }
 }
 
-void Maxwell3D::DrawManager::ProcessDraw(Maxwell3D& maxwell3d, bool draw_indexed, u32 instance_count) {
-    LOG_TRACE(HW_GPU, "called, topology={}, count={}", draw_state.topology, draw_indexed ? draw_state.index_buffer.count : draw_state.vertex_buffer.count);
-    UpdateTopology(maxwell3d);
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.rasterizer->Draw(draw_indexed, instance_count);
+void DrawManager::ProcessDraw(bool draw_indexed, u32 instance_count) {
+    LOG_TRACE(HW_GPU, "called, topology={}, count={}", draw_state.topology,
+              draw_indexed ? draw_state.index_buffer.count : draw_state.vertex_buffer.count);
+
+    UpdateTopology();
+
+    if (maxwell3d->ShouldExecute()) {
+        maxwell3d->rasterizer->Draw(draw_indexed, instance_count);
     }
 }
 
-void Maxwell3D::DrawManager::ProcessDrawIndirect(Maxwell3D& maxwell3d) {
-    LOG_TRACE(HW_GPU, "called, topology={}, is_indexed={}, includes_count={}, buffer_size={}, max_draw_count={}", draw_state.topology, indirect_state.is_indexed, indirect_state.include_count, indirect_state.buffer_size, indirect_state.max_draw_counts);
-    UpdateTopology(maxwell3d);
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.rasterizer->DrawIndirect();
+void DrawManager::ProcessDrawIndirect() {
+    LOG_TRACE(
+        HW_GPU,
+        "called, topology={}, is_indexed={}, includes_count={}, buffer_size={}, max_draw_count={}",
+        draw_state.topology, indirect_state.is_indexed, indirect_state.include_count,
+        indirect_state.buffer_size, indirect_state.max_draw_counts);
+
+    UpdateTopology();
+
+    if (maxwell3d->ShouldExecute()) {
+        maxwell3d->rasterizer->DrawIndirect();
     }
 }
 } // namespace Tegra::Engines

src/video_core/engines/draw_manager.h

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+#include "common/common_types.h"
+#include "video_core/engines/maxwell_3d.h"
+
+namespace VideoCore {
+class RasterizerInterface;
+}
+
+namespace Tegra::Engines {
+using PrimitiveTopologyControl = Maxwell3D::Regs::PrimitiveTopologyControl;
+using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology;
+using PrimitiveTopologyOverride = Maxwell3D::Regs::PrimitiveTopologyOverride;
+using IndexBuffer = Maxwell3D::Regs::IndexBuffer;
+using VertexBuffer = Maxwell3D::Regs::VertexBuffer;
+using IndexBufferSmall = Maxwell3D::Regs::IndexBufferSmall;
+
+class DrawManager {
+public:
+    enum class DrawMode : u32 { General = 0, Instance, InlineIndex };
+    struct State {
+        PrimitiveTopology topology{};
+        DrawMode draw_mode{};
+        bool draw_indexed{};
+        u32 base_index{};
+        VertexBuffer vertex_buffer;
+        IndexBuffer index_buffer;
+        u32 base_instance{};
+        u32 instance_count{};
+        std::vector<u8> inline_index_draw_indexes;
+    };
+
+    struct DrawTextureState {
+        f32 dst_x0;
+        f32 dst_y0;
+        f32 dst_x1;
+        f32 dst_y1;
+        f32 src_x0;
+        f32 src_y0;
+        f32 src_x1;
+        f32 src_y1;
+        u32 src_sampler;
+        u32 src_texture;
+    };
+
+    struct IndirectParams {
+        bool is_byte_count;
+        bool is_indexed;
+        bool include_count;
+        GPUVAddr count_start_address;
+        GPUVAddr indirect_start_address;
+        size_t buffer_size;
+        size_t max_draw_counts;
+        size_t stride;
+    };
+
+    explicit DrawManager(Maxwell3D* maxwell_3d);
+
+    void ProcessMethodCall(u32 method, u32 argument);
+
+    void Clear(u32 layer_count);
+
+    void DrawDeferred();
+
+    void DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
+                   u32 base_instance, u32 num_instances);
+    void DrawArrayInstanced(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
+                            bool subsequent);
+
+    void DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count, u32 base_index,
+                   u32 base_instance, u32 num_instances);
+
+    void DrawArrayIndirect(PrimitiveTopology topology);
+
+    void DrawIndexedIndirect(PrimitiveTopology topology, u32 index_first, u32 index_count);
+
+    const State& GetDrawState() const {
+        return draw_state;
+    }
+
+    const DrawTextureState& GetDrawTextureState() const {
+        return draw_texture_state;
+    }
+
+    IndirectParams& GetIndirectParams() {
+        return indirect_state;
+    }
+
+    const IndirectParams& GetIndirectParams() const {
+        return indirect_state;
+    }
+
+private:
+    void SetInlineIndexBuffer(u32 index);
+
+    void DrawBegin();
+
+    void DrawEnd(u32 instance_count = 1, bool force_draw = false);
+
+    void DrawIndexSmall(u32 argument);
+
+    void DrawTexture();
+
+    void UpdateTopology();
+
+    void ProcessDraw(bool draw_indexed, u32 instance_count);
+
+    void ProcessDrawIndirect();
+
+    Maxwell3D* maxwell3d{};
+    State draw_state{};
+    DrawTextureState draw_texture_state{};
+    IndirectParams indirect_state{};
+};
+} // namespace Tegra::Engines

src/video_core/engines/maxwell_3d.cpp

@@ -13,7 +13,7 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "video_core/dirty_flags.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
@@ -26,8 +26,7 @@ namespace Tegra::Engines {
 constexpr u32 MacroRegistersStart = 0xE00;
 
 Maxwell3D::Maxwell3D(Core::System& system_, MemoryManager& memory_manager_)
-    : draw_manager()
-    , system{system_}
+    : draw_manager{std::make_unique<DrawManager>(this)}, system{system_}
     , memory_manager{memory_manager_}
 #ifdef ARCHITECTURE_x86_64
     , macro_engine(bool(Settings::values.disable_macro_jit))
@@ -374,7 +373,8 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
     case MAXWELL3D_REG_INDEX(sync_info):
         return ProcessSyncPoint();
     case MAXWELL3D_REG_INDEX(launch_dma):
-        return upload_state.ProcessExec(regs.launch_dma.memory_layout.Value() == Regs::LaunchDMA::Layout::Pitch);
+        return upload_state.ProcessExec(regs.launch_dma.memory_layout.Value() ==
+                                        Regs::LaunchDMA::Layout::Pitch);
     case MAXWELL3D_REG_INDEX(inline_data):
         upload_state.ProcessData(argument, is_last_call);
         return;
@@ -386,7 +386,7 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
     case MAXWELL3D_REG_INDEX(tiled_cache_barrier):
         return rasterizer->TiledCacheBarrier();
     default:
-        draw_manager.ProcessMethodCall(*this, method, argument);
+        draw_manager->ProcessMethodCall(method, argument);
         break;
     }
 }
@@ -401,7 +401,8 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
 
     // Execute the current macro.
     macro_engine.Execute(*this, macro_positions[entry], parameters);
-    draw_manager.DrawDeferred(*this);
+
+    draw_manager->DrawDeferred();
 }
 
 void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {

src/video_core/engines/maxwell_3d.h

@@ -25,7 +25,6 @@
 #include "video_core/gpu.h"
 #include "video_core/macro.h"
 #include "video_core/textures/texture.h"
-#include "video_core/engines/maxwell_3d.h"
 
 namespace Core {
 class System;
@@ -41,6 +40,8 @@ class RasterizerInterface;
 
 namespace Tegra::Engines {
 
+class DrawManager;
+
 /**
  * This Engine is known as GF100_3D. Documentation can be found in:
  * https://github.com/NVIDIA/open-gpu-doc/blob/master/classes/3d/clb197.h
@@ -542,7 +543,7 @@ public:
             }
             GPUVAddr StorageLimitAddress() const {
                 return (GPUVAddr{storage_limit_address_high} << 32) |
-                        GPUVAddr{storage_limit_address_low};
+                       GPUVAddr{storage_limit_address_low};
             }
         };
 
@@ -818,7 +819,7 @@ public:
 
             u32 Map(std::size_t index) const {
                 const std::array<u32, NumRenderTargets> maps{target0, target1, target2, target3,
-                                                                target4, target5, target6, target7};
+                                                             target4, target5, target6, target7};
                 ASSERT(index < maps.size());
                 return maps[index];
             }
@@ -1830,7 +1831,7 @@ public:
 
             bool AnyEnabled() const {
                 return output0_enable || output1_enable || output2_enable || output3_enable ||
-                        output4_enable || output5_enable || output6_enable || output7_enable;
+                       output4_enable || output5_enable || output6_enable || output7_enable;
             }
         };
 
@@ -1869,7 +1870,7 @@ public:
 
                 bool AnyEnabled() const {
                     return plane0 || plane1 || plane2 || plane3 || plane4 || plane5 || plane6 ||
-                            plane7;
+                           plane7;
                 }
             };
 
@@ -3022,7 +3023,8 @@ public:
                 u32 bindless_texture_const_buffer_slot;                                ///< 0x2608
                 u32 trap_handler;                                                      ///< 0x260C
                 INSERT_PADDING_BYTES_NOINIT(0x1F0);
-                std::array<std::array<StreamOutLayout, 32>, NumTransformFeedbackBuffers> stream_out_layout;                                                 ///< 0x2800
+                std::array<std::array<StreamOutLayout, 32>, NumTransformFeedbackBuffers>
+                    stream_out_layout;                                                 ///< 0x2800
                 INSERT_PADDING_BYTES_NOINIT(0x93C);
                 ShaderPerformance shader_performance;                                  ///< 0x333C
                 INSERT_PADDING_BYTES_NOINIT(0x18);
@@ -3033,62 +3035,6 @@ public:
     };
     // clang-format on
 
-    struct DrawManager {
-        enum class DrawMode : u32 { General = 0, Instance, InlineIndex };
-        struct State {
-            Maxwell3D::Regs::PrimitiveTopology topology{};
-            DrawMode draw_mode{};
-            bool draw_indexed{};
-            u32 base_index{};
-            Maxwell3D::Regs::VertexBuffer vertex_buffer;
-            Maxwell3D::Regs::IndexBuffer index_buffer;
-            u32 base_instance{};
-            u32 instance_count{};
-            std::vector<u8> inline_index_draw_indexes;
-        };
-        struct DrawTextureState {
-            f32 dst_x0;
-            f32 dst_y0;
-            f32 dst_x1;
-            f32 dst_y1;
-            f32 src_x0;
-            f32 src_y0;
-            f32 src_x1;
-            f32 src_y1;
-            u32 src_sampler;
-            u32 src_texture;
-        };
-        struct IndirectParams {
-            bool is_byte_count;
-            bool is_indexed;
-            bool include_count;
-            GPUVAddr count_start_address;
-            GPUVAddr indirect_start_address;
-            size_t buffer_size;
-            size_t max_draw_counts;
-            size_t stride;
-        };
-        void ProcessMethodCall(Maxwell3D& maxwell3d, u32 method, u32 argument);
-        void Clear(Maxwell3D& maxwell3d, u32 layer_count);
-        void DrawDeferred(Maxwell3D& maxwell3d);
-        void DrawArray(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 vertex_first, u32 vertex_count, u32 base_instance, u32 num_instances);
-        void DrawArrayInstanced(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 vertex_first, u32 vertex_count, bool subsequent);
-        void DrawIndex(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count, u32 base_index, u32 base_instance, u32 num_instances);
-        void DrawArrayIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology);
-        void DrawIndexedIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count);
-        void SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 index);
-        void DrawBegin(Maxwell3D& maxwell3d);
-        void DrawEnd(Maxwell3D& maxwell3d, u32 instance_count = 1, bool force_draw = false);
-        void DrawIndexSmall(Maxwell3D& maxwell3d, u32 argument);
-        void DrawTexture(Maxwell3D& maxwell3d);
-        void UpdateTopology(Maxwell3D& maxwell3d);
-        void ProcessDraw(Maxwell3D& maxwell3d, bool draw_indexed, u32 instance_count);
-        void ProcessDrawIndirect(Maxwell3D& maxwell3d);
-        State draw_state{};
-        DrawTextureState draw_texture_state{};
-        IndirectParams indirect_state{};
-    };
-
     Regs regs{};
 
     /// Store temporary hw register values, used by some calls to restore state after a operation
@@ -3156,7 +3102,8 @@ public:
         Tables tables{};
     } dirty;
 
-    DrawManager draw_manager;
+    std::unique_ptr<DrawManager> draw_manager;
+    friend class DrawManager;
 
     GPUVAddr GetMacroAddress(size_t index) const {
         return macro_addresses[index];

src/video_core/gpu.cpp

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

src/video_core/gpu_thread.cpp

@@ -19,45 +19,56 @@
 
 namespace VideoCommon::GPUThread {
 
+/// Runs the GPU thread
+static void RunThread(std::stop_token stop_token, Core::System& system,
+                      VideoCore::RendererBase& renderer, Core::Frontend::GraphicsContext& context,
+                      Tegra::Control::Scheduler& scheduler, SynchState& state) {
+    Common::SetCurrentThreadName("GPU");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
+    system.RegisterHostThread();
+
+    auto current_context = context.Acquire();
+    VideoCore::RasterizerInterface* const rasterizer = renderer.ReadRasterizer();
+
+    CommandDataContainer next;
+
+    while (!stop_token.stop_requested()) {
+        state.queue.PopWait(next, stop_token);
+        if (stop_token.stop_requested()) {
+            break;
+        }
+        if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
+            scheduler.Push(submit_list->channel, std::move(submit_list->entries));
+        } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
+            system.GPU().TickWork();
+        } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
+            rasterizer->FlushRegion(flush->addr, flush->size);
+        } else if (const auto* invalidate = std::get_if<InvalidateRegionCommand>(&next.data)) {
+            rasterizer->OnCacheInvalidation(invalidate->addr, invalidate->size);
+        } else {
+            ASSERT(false);
+        }
+        state.signaled_fence.store(next.fence);
+        if (next.block) {
+            // We have to lock the write_lock to ensure that the condition_variable wait not get a
+            // race between the check and the lock itself.
+            std::scoped_lock lk{state.write_lock};
+            state.cv.notify_all();
+        }
+    }
+}
+
 ThreadManager::ThreadManager(Core::System& system_, bool is_async_)
     : system{system_}, is_async{is_async_} {}
 
 ThreadManager::~ThreadManager() = default;
 
-void ThreadManager::StartThread(VideoCore::RendererBase& renderer, Core::Frontend::GraphicsContext& context, Tegra::Control::Scheduler& scheduler) {
+void ThreadManager::StartThread(VideoCore::RendererBase& renderer,
+                                Core::Frontend::GraphicsContext& context,
+                                Tegra::Control::Scheduler& scheduler) {
     rasterizer = renderer.ReadRasterizer();
-    thread = std::jthread([&](std::stop_token stop_token) {
-        Common::SetCurrentThreadName("GPU");
-        Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
-        system.RegisterHostThread();
-
-        auto current_context = context.Acquire();
-        CommandDataContainer next;
-        while (!stop_token.stop_requested()) {
-            state.queue.PopWait(next, stop_token);
-            if (stop_token.stop_requested()) {
-                break;
-            }
-            if (auto* submit_list = std::get_if<SubmitListCommand>(&next.data)) {
-                scheduler.Push(submit_list->channel, std::move(submit_list->entries));
-            } else if (std::holds_alternative<GPUTickCommand>(next.data)) {
-                system.GPU().TickWork();
-            } else if (const auto* flush = std::get_if<FlushRegionCommand>(&next.data)) {
-                renderer.ReadRasterizer()->FlushRegion(flush->addr, flush->size);
-            } else if (const auto* invalidate = std::get_if<InvalidateRegionCommand>(&next.data)) {
-                renderer.ReadRasterizer()->OnCacheInvalidation(invalidate->addr, invalidate->size);
-            } else {
-                ASSERT(false);
-            }
-            state.signaled_fence.store(next.fence);
-            if (next.block) {
-                // We have to lock the write_lock to ensure that the condition_variable wait not get a
-                // race between the check and the lock itself.
-                std::scoped_lock lk{state.write_lock};
-                state.cv.notify_all();
-            }
-        }
-    });
+    thread = std::jthread(RunThread, std::ref(system), std::ref(renderer), std::ref(context),
+                          std::ref(scheduler), std::ref(state));
 }
 
 void ThreadManager::SubmitList(s32 channel, Tegra::CommandList&& entries) {

src/video_core/host1x/codecs/codec.cpp

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

src/video_core/host1x/codecs/codec.h

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

src/video_core/host1x/codecs/decoder.cpp

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

src/video_core/host1x/codecs/decoder.h

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

src/video_core/host1x/codecs/h264.cpp

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

src/video_core/host1x/codecs/h264.h

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

src/video_core/host1x/codecs/vp8.cpp

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

src/video_core/host1x/codecs/vp8.h

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

src/video_core/host1x/codecs/vp9.cpp

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

src/video_core/host1x/codecs/vp9.h

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

src/video_core/host1x/codecs/vp9_types.h

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

src/video_core/host1x/ffmpeg/ffmpeg.cpp

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

src/video_core/host1x/ffmpeg/ffmpeg.h

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

src/video_core/host1x/host1x.cpp

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

src/video_core/host1x/host1x.h

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

src/video_core/host1x/nvdec.cpp

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

src/video_core/host1x/nvdec.h

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

src/video_core/host1x/vic.cpp

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

src/video_core/host1x/vic.h

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

src/video_core/macro.cpp

@@ -31,7 +31,7 @@
 #include "common/settings.h"
 #include "common/container_hash.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/dirty_flags.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/macro.h"
@@ -83,7 +83,7 @@ void HLE_DrawArraysIndirect::Execute(Engines::Maxwell3D& maxwell3d, std::span<co
         return;
     }
 
-    auto& params = maxwell3d.draw_manager.indirect_state;
+    auto& params = maxwell3d.draw_manager->GetIndirectParams();
     params.is_byte_count = false;
     params.is_indexed = false;
     params.include_count = false;
@@ -98,7 +98,7 @@ void HLE_DrawArraysIndirect::Execute(Engines::Maxwell3D& maxwell3d, std::span<co
         maxwell3d.SetHLEReplacementAttributeType(0, 0x640, Maxwell3D::HLEReplacementAttributeType::BaseInstance);
     }
 
-    maxwell3d.draw_manager.DrawArrayIndirect(maxwell3d, topology);
+    maxwell3d.draw_manager->DrawArrayIndirect(topology);
 
     if (extended) {
         maxwell3d.engine_state = Maxwell3D::EngineHint::None;
@@ -127,7 +127,7 @@ void HLE_DrawArraysIndirect::Fallback(Engines::Maxwell3D& maxwell3d, std::span<c
         maxwell3d.engine_state = Maxwell3D::EngineHint::OnHLEMacro;
         maxwell3d.SetHLEReplacementAttributeType(0, 0x640, Maxwell3D::HLEReplacementAttributeType::BaseInstance);
     }
-    maxwell3d.draw_manager.DrawArray(maxwell3d, topology, vertex_first, vertex_count, base_instance, instance_count);
+    maxwell3d.draw_manager->DrawArray(topology, vertex_first, vertex_count, base_instance, instance_count);
     if (extended) {
         maxwell3d.regs.global_base_instance_index = 0;
         maxwell3d.engine_state = Maxwell3D::EngineHint::None;
@@ -154,7 +154,7 @@ void HLE_DrawIndexedIndirect::Execute(Engines::Maxwell3D& maxwell3d, std::span<c
         maxwell3d.SetHLEReplacementAttributeType(0, 0x640, Maxwell3D::HLEReplacementAttributeType::BaseVertex);
         maxwell3d.SetHLEReplacementAttributeType(0, 0x644, Maxwell3D::HLEReplacementAttributeType::BaseInstance);
     }
-    auto& params = maxwell3d.draw_manager.indirect_state;
+    auto& params = maxwell3d.draw_manager->GetIndirectParams();
     params.is_byte_count = false;
     params.is_indexed = true;
     params.include_count = false;
@@ -164,7 +164,7 @@ void HLE_DrawIndexedIndirect::Execute(Engines::Maxwell3D& maxwell3d, std::span<c
     params.max_draw_counts = 1;
     params.stride = 0;
     maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-    maxwell3d.draw_manager.DrawIndexedIndirect(maxwell3d, topology, 0, estimate);
+    maxwell3d.draw_manager->DrawIndexedIndirect(topology, 0, estimate);
     maxwell3d.regs.vertex_id_base = 0x0;
     maxwell3d.regs.global_base_vertex_index = 0x0;
     maxwell3d.regs.global_base_instance_index = 0x0;
@@ -187,7 +187,7 @@ void HLE_DrawIndexedIndirect::Fallback(Engines::Maxwell3D& maxwell3d, std::span<
         maxwell3d.SetHLEReplacementAttributeType(0, 0x640, Maxwell3D::HLEReplacementAttributeType::BaseVertex);
         maxwell3d.SetHLEReplacementAttributeType(0, 0x644, Maxwell3D::HLEReplacementAttributeType::BaseInstance);
     }
-    maxwell3d.draw_manager.DrawIndex(maxwell3d, Tegra::Maxwell3D::Regs::PrimitiveTopology(parameters[0]), parameters[3], parameters[1], element_base, base_instance, instance_count);
+    maxwell3d.draw_manager->DrawIndex(Tegra::Maxwell3D::Regs::PrimitiveTopology(parameters[0]), parameters[3], parameters[1], element_base, base_instance, instance_count);
     maxwell3d.regs.vertex_id_base = 0x0;
     maxwell3d.regs.global_base_vertex_index = 0x0;
     maxwell3d.regs.global_base_instance_index = 0x0;
@@ -206,7 +206,7 @@ void HLE_MultiLayerClear::Execute(Engines::Maxwell3D& maxwell3d, std::span<const
     ASSERT(clear_params.layer == 0);
 
     maxwell3d.regs.clear_surface.raw = clear_params.raw;
-    maxwell3d.draw_manager.Clear(maxwell3d, num_layers);
+    maxwell3d.draw_manager->Clear(num_layers);
 }
 void HLE_MultiDrawIndexedIndirectCount::Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method) {
     const auto topology = Maxwell3D::Regs::PrimitiveTopology(parameters[2]);
@@ -230,7 +230,7 @@ void HLE_MultiDrawIndexedIndirectCount::Execute(Engines::Maxwell3D& maxwell3d, s
     const std::size_t draw_count = end_indirect - start_indirect;
     const u32 estimate = static_cast<u32>(maxwell3d.EstimateIndexBufferSize());
     maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-    auto& params = maxwell3d.draw_manager.indirect_state;
+    auto& params = maxwell3d.draw_manager->GetIndirectParams();
     params.is_byte_count = false;
     params.is_indexed = true;
     params.include_count = true;
@@ -244,7 +244,7 @@ void HLE_MultiDrawIndexedIndirectCount::Execute(Engines::Maxwell3D& maxwell3d, s
     maxwell3d.SetHLEReplacementAttributeType(0, 0x640, Maxwell3D::HLEReplacementAttributeType::BaseVertex);
     maxwell3d.SetHLEReplacementAttributeType(0, 0x644, Maxwell3D::HLEReplacementAttributeType::BaseInstance);
     maxwell3d.SetHLEReplacementAttributeType(0, 0x648, Maxwell3D::HLEReplacementAttributeType::DrawID);
-    maxwell3d.draw_manager.DrawIndexedIndirect(maxwell3d, topology, 0, estimate);
+    maxwell3d.draw_manager->DrawIndexedIndirect(topology, 0, estimate);
     maxwell3d.engine_state = Maxwell3D::EngineHint::None;
     maxwell3d.replace_table.clear();
 }
@@ -280,7 +280,7 @@ void HLE_MultiDrawIndexedIndirectCount::Fallback(Engines::Maxwell3D& maxwell3d,
         maxwell3d.CallMethod(0x8e3, 0x648, true);
         maxwell3d.CallMethod(0x8e4, static_cast<u32>(index), true);
         maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        maxwell3d.draw_manager.DrawIndex(maxwell3d, topology, parameters[base + 2], parameters[base], base_vertex, base_instance, parameters[base + 1]);
+        maxwell3d.draw_manager->DrawIndex(topology, parameters[base + 2], parameters[base], base_vertex, base_instance, parameters[base + 1]);
     }
 }
 void HLE_DrawIndirectByteCount::Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method) {
@@ -290,7 +290,7 @@ void HLE_DrawIndirectByteCount::Execute(Engines::Maxwell3D& maxwell3d, std::span
         return;
     }
     auto topology = Maxwell3D::Regs::PrimitiveTopology(parameters[0] & 0xFFFFU);
-    auto& params = maxwell3d.draw_manager.indirect_state;
+    auto& params = maxwell3d.draw_manager->GetIndirectParams();
     params.is_byte_count = true;
     params.is_indexed = false;
     params.include_count = false;
@@ -302,14 +302,18 @@ void HLE_DrawIndirectByteCount::Execute(Engines::Maxwell3D& maxwell3d, std::span
     maxwell3d.regs.draw.begin = parameters[0];
     maxwell3d.regs.draw_auto_stride = parameters[1];
     maxwell3d.regs.draw_auto_byte_count = parameters[2];
-    maxwell3d.draw_manager.DrawArrayIndirect(maxwell3d, topology);
+    maxwell3d.draw_manager->DrawArrayIndirect(topology);
 }
 void HLE_DrawIndirectByteCount::Fallback(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters) {
     maxwell3d.RefreshParameters();
+
     maxwell3d.regs.draw.begin = parameters[0];
     maxwell3d.regs.draw_auto_stride = parameters[1];
     maxwell3d.regs.draw_auto_byte_count = parameters[2];
-    maxwell3d.draw_manager.DrawArray(maxwell3d, maxwell3d.regs.draw.topology, 0, maxwell3d.regs.draw_auto_byte_count / maxwell3d.regs.draw_auto_stride, 0, 1);
+
+    maxwell3d.draw_manager->DrawArray(
+        maxwell3d.regs.draw.topology, 0,
+        maxwell3d.regs.draw_auto_byte_count / maxwell3d.regs.draw_auto_stride, 0, 1);
 }
 void HLE_C713C83D8F63CCF3::Execute(Engines::Maxwell3D& maxwell3d, std::span<const u32> parameters, [[maybe_unused]] u32 method) {
     maxwell3d.RefreshParameters();

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -245,7 +245,7 @@ void RasterizerOpenGL::PrepareDraw(bool is_indexed, Func&& draw_func) {
 
     SyncState();
 
-    const auto& draw_state = maxwell3d->draw_manager.draw_state;
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
 
     const GLenum primitive_mode = MaxwellToGL::PrimitiveTopology(draw_state.topology);
     BeginTransformFeedback(pipeline, primitive_mode);
@@ -260,12 +260,12 @@ void RasterizerOpenGL::PrepareDraw(bool is_indexed, Func&& draw_func) {
 
 void RasterizerOpenGL::Draw(bool is_indexed, u32 instance_count) {
     PrepareDraw(is_indexed, [this, is_indexed, instance_count](GLenum primitive_mode) {
-        const auto& draw_state = maxwell3d->draw_manager.draw_state;
-        const GLuint base_instance = GLuint(draw_state.base_instance);
-        const GLsizei num_instances = GLsizei(instance_count);
+        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+        const GLuint base_instance = static_cast<GLuint>(draw_state.base_instance);
+        const GLsizei num_instances = static_cast<GLsizei>(instance_count);
         if (is_indexed) {
-            const GLint base_vertex = GLint(draw_state.base_index);
-            const GLsizei num_vertices = GLsizei(draw_state.index_buffer.count);
+            const GLint base_vertex = static_cast<GLint>(draw_state.base_index);
+            const GLsizei num_vertices = static_cast<GLsizei>(draw_state.index_buffer.count);
             const GLvoid* const offset = buffer_cache_runtime.IndexOffset();
             const GLenum format = MaxwellToGL::IndexFormat(draw_state.index_buffer.format);
             if (num_instances == 1 && base_instance == 0 && base_vertex == 0) {
@@ -302,7 +302,7 @@ void RasterizerOpenGL::Draw(bool is_indexed, u32 instance_count) {
 }
 
 void RasterizerOpenGL::DrawIndirect() {
-    const auto& params = maxwell3d->draw_manager.indirect_state;
+    const auto& params = maxwell3d->draw_manager->GetIndirectParams();
     buffer_cache.SetDrawIndirect(&params);
     PrepareDraw(params.is_indexed, [this, &params](GLenum primitive_mode) {
         if (params.is_byte_count) {
@@ -358,12 +358,12 @@ void RasterizerOpenGL::DrawTexture() {
 
     SyncState();
 
-    const auto& draw_texture_state = maxwell3d->draw_manager.draw_texture_state;
+    const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
 
     const auto Scale = [&](auto dim) -> s32 {
-        return Settings::values.resolution_info.ScaleUp(s32(dim));
+        return Settings::values.resolution_info.ScaleUp(static_cast<s32>(dim));
     };
 
     Region2D dst_region = {

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -25,7 +25,7 @@
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
 #include "shader_recompiler/frontend/maxwell/translate_program.h"
 #include "shader_recompiler/profile.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
@@ -357,7 +357,7 @@ GraphicsPipeline* ShaderCache::CurrentGraphicsPipeline() {
     const auto& regs{maxwell3d->regs};
     graphics_key.raw = 0;
     graphics_key.early_z.Assign(regs.mandated_early_z != 0 ? 1 : 0);
-    graphics_key.gs_input_topology.Assign(maxwell3d->draw_manager.draw_state.topology);
+    graphics_key.gs_input_topology.Assign(maxwell3d->draw_manager->GetDrawState().topology);
     graphics_key.tessellation_primitive.Assign(regs.tessellation.params.domain_type.Value());
     graphics_key.tessellation_spacing.Assign(regs.tessellation.params.spacing.Value());
     graphics_key.tessellation_clockwise.Assign(
@@ -397,7 +397,7 @@ GraphicsPipeline* ShaderCache::BuiltPipeline(GraphicsPipeline* pipeline) const n
     // If games are using a small index count, we can assume these are full screen quads.
     // Usually these shaders are only used once for building textures so we can assume they
     // can't be built async
-    const auto& draw_state = maxwell3d->draw_manager.draw_state;
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     if (draw_state.index_buffer.count <= 6 || draw_state.vertex_buffer.count <= 6) {
         return pipeline;
     }

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -12,7 +12,7 @@
 #include "common/cityhash.h"
 #include "common/common_types.h"
 #include "common/settings.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 
@@ -54,7 +54,7 @@ void RefreshXfbState(VideoCommon::TransformFeedbackState& state, const Maxwell&
 
 void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFeatures& features) {
     const Maxwell& regs = maxwell3d.regs;
-    const auto topology_ = maxwell3d.draw_manager.draw_state.topology;
+    const auto topology_ = maxwell3d.draw_manager->GetDrawState().topology;
 
     raw1 = 0;
     extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -127,9 +127,8 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
 
     texture_cache.SynchronizeComputeDescriptors();
 
-    static constexpr size_t max_elements = 64;
-    boost::container::static_vector<VideoCommon::ImageViewInOut, max_elements> views;
-    boost::container::static_vector<VideoCommon::SamplerId, max_elements> samplers;
+    boost::container::small_vector<VideoCommon::ImageViewInOut, 64> views;
+    boost::container::small_vector<VideoCommon::SamplerId, 64> samplers;
 
     const auto& qmd{kepler_compute.launch_description};
     const auto& cbufs{qmd.const_buffer_config};

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -696,7 +696,7 @@ GraphicsPipeline* PipelineCache::BuiltPipeline(GraphicsPipeline* pipeline) const
     // If games are using a small index count, we can assume these are full screen quads.
     // Usually these shaders are only used once for building textures so we can assume they
     // can't be built async
-    const auto& draw_state = maxwell3d->draw_manager.draw_state;
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     if (draw_state.index_buffer.count <= 6 || draw_state.vertex_buffer.count <= 6) {
         return pipeline;
     }

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -16,7 +16,7 @@
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "common/bit_util.h"
 #include "common/common_types.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/query_cache/query_cache.h"
 #include "video_core/rasterizer_interface.h"
@@ -950,7 +950,7 @@ private:
         streams_mask = 0; // reset previously recorded streams
         runtime.View3DRegs([this](Maxwell3D& maxwell3d) {
             buffers_count = 0;
-            out_topology = maxwell3d.draw_manager.draw_state.topology;
+            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()) {

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -20,7 +20,7 @@
 #include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/gpu_logging/gpu_logging.h"
 #include "video_core/control/channel_state.h"
-#include "video_core/engines/maxwell_3d.h"
+#include "video_core/engines/draw_manager.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
@@ -46,6 +46,7 @@
 namespace Vulkan {
 
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
+using MaxwellDrawState = Tegra::Engines::DrawManager::State;
 using VideoCommon::ImageViewId;
 using VideoCommon::ImageViewType;
 
@@ -150,7 +151,7 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
     return scissor;
 }
 
-DrawParams MakeDrawParams(const Tegra::Engines::Maxwell3D::DrawManager::State& draw_state, u32 num_instances, bool is_indexed) {
+DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed) {
     DrawParams params{
         .base_instance = draw_state.base_instance,
         .num_instances = num_instances,
@@ -248,13 +249,15 @@ void RasterizerVulkan::PrepareDraw(bool is_indexed, Func&& draw_func) {
 
     query_cache.NotifySegment(true);
     HandleTransformFeedback();
-    query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64, maxwell3d->regs.zpass_pixel_count_enable);
+    query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64,
+                              maxwell3d->regs.zpass_pixel_count_enable);
+
     draw_func();
 }
 
 void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     PrepareDraw(is_indexed, [this, is_indexed, instance_count] {
-        const auto& draw_state = maxwell3d->draw_manager.draw_state;
+        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         const u32 num_instances{instance_count};
         const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed)};
 
@@ -286,7 +289,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
 }
 
 void RasterizerVulkan::DrawIndirect() {
-    const auto& params = maxwell3d->draw_manager.indirect_state;
+    const auto& params = maxwell3d->draw_manager->GetIndirectParams();
     buffer_cache.SetDrawIndirect(&params);
     PrepareDraw(params.is_indexed, [this, &params] {
         const auto indirect_buffer = buffer_cache.GetDrawIndirectBuffer();
@@ -357,8 +360,9 @@ 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.draw_texture_state;
+    query_cache.CounterEnable(VideoCommon::QueryType::ZPassPixelCount64,
+                              maxwell3d->regs.zpass_pixel_count_enable);
+    const auto& draw_texture_state = maxwell3d->draw_manager->GetDrawTextureState();
     const auto& sampler = texture_cache.GetGraphicsSampler(draw_texture_state.src_sampler);
     const auto& texture = texture_cache.GetImageView(draw_texture_state.src_texture);
     const auto* framebuffer = texture_cache.GetFramebuffer();
@@ -1010,7 +1014,7 @@ 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.draw_state.topology;
+    const auto topology = maxwell3d->draw_manager->GetDrawState().topology;
     if (state_tracker.ChangePrimitiveTopology(topology)) {
         flags[Dirty::DepthBiasEnable] = true;
         flags[Dirty::PrimitiveRestartEnable] = true;
@@ -1443,7 +1447,8 @@ void RasterizerVulkan::UpdatePrimitiveRestartEnable(Tegra::Engines::Maxwell3D::R
     if (device.IsMoltenVK()) {
         enable = true;
     } else if (enable) {
-        const auto topology = MaxwellToVK::PrimitiveTopology(device, maxwell3d->draw_manager.draw_state.topology);
+        const auto topology =
+            MaxwellToVK::PrimitiveTopology(device, maxwell3d->draw_manager->GetDrawState().topology);
         enable = IsPrimitiveRestartSupported(device, topology);
     }
 
@@ -1557,9 +1562,10 @@ void RasterizerVulkan::UpdateDepthBiasEnable(Tegra::Engines::Maxwell3D::Regs& re
         regs.polygon_offset_line_enable,
         regs.polygon_offset_fill_enable,
     };
-    const u32 topology_index = u32(maxwell3d->draw_manager.draw_state.topology);
+    const u32 topology_index = static_cast<u32>(maxwell3d->draw_manager->GetDrawState().topology);
     const u32 enable = enabled_lut[POLYGON_OFFSET_ENABLE_LUT[topology_index]];
-    scheduler.Record([enable](vk::CommandBuffer cmdbuf) { cmdbuf.SetDepthBiasEnableEXT(enable != 0); });
+    scheduler.Record(
+        [enable](vk::CommandBuffer cmdbuf) { cmdbuf.SetDepthBiasEnableEXT(enable != 0); });
 }
 
 void RasterizerVulkan::UpdateLogicOpEnable(Tegra::Engines::Maxwell3D::Regs& regs) {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -500,10 +500,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         features.shader_atomic_int64.shaderSharedInt64Atomics = false;
         features.features.shaderInt64 = false;
 
-        LOG_WARNING(Render_Vulkan,
-                    "Qualcomm drivers have a slow VK_KHR_push_descriptor implementation");
-        RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
-
 #if defined(ANDROID) && defined(ARCHITECTURE_arm64)
         // BCn patching only safe on Android 9+ (API 28+). Older versions crash on driver load.
         const auto major = (properties.properties.driverVersion >> 24) << 2;

src/yuzu/CMakeLists.txt

@@ -245,8 +245,6 @@ add_executable(yuzu
 
     render/performance_overlay.h render/performance_overlay.cpp render/performance_overlay.ui
     libqt_common.h libqt_common.cpp
-    updater/update_dialog.h updater/update_dialog.cpp updater/update_dialog.ui
-
 )
 
 set_target_properties(yuzu PROPERTIES OUTPUT_NAME "eden")

src/yuzu/configuration/configure_per_game_addons.cpp

@@ -330,6 +330,7 @@ void ConfigurePerGameAddons::LoadConfiguration() {
         if (is_external_update) {
             first_item->setData(static_cast<quint32>(patch.numeric_version), NUMERIC_VERSION);
         } else if (is_mod) {
+            // qDebug() << patch.location;
             first_item->setData(QString::fromStdString(patch.location), PATCH_LOCATION);
         }
 

src/yuzu/main_window.cpp

@@ -8,7 +8,6 @@
 #include "frontend_common/settings_generator.h"
 #include "qt_common/qt_string_lookup.h"
 #include "render/performance_overlay.h"
-#include "updater/update_dialog.h"
 #if defined(QT_STATICPLUGIN) && !defined(__APPLE__)
 #undef VMA_IMPLEMENTATION
 #endif
@@ -540,7 +539,7 @@ MainWindow::MainWindow(bool has_broken_vulkan)
 #ifdef ENABLE_UPDATE_CHECKER
     if (UISettings::values.check_for_updates) {
         update_future = QtConcurrent::run(
-            []() -> std::optional<Common::Net::Release> { return UpdateChecker::GetUpdate(); });
+            []() -> std::optional<UpdateChecker::Update> { return UpdateChecker::GetUpdate(); });
         update_watcher.connect(&update_watcher, &QFutureWatcher<QString>::finished, this,
                                &MainWindow::OnEmulatorUpdateAvailable);
         update_watcher.setFuture(update_future);
@@ -4219,12 +4218,23 @@ void MainWindow::OnCaptureScreenshot() {
 
 #ifdef ENABLE_UPDATE_CHECKER
 void MainWindow::OnEmulatorUpdateAvailable() {
-    std::optional<Common::Net::Release> version = update_future.result();
+    std::optional<UpdateChecker::Update> version = update_future.result();
     if (!version)
         return;
 
-    UpdateDialog dialog(version.value(), this);
-    dialog.exec();
+    QMessageBox update_prompt(this);
+    update_prompt.setWindowTitle(tr("Update Available"));
+    update_prompt.setIcon(QMessageBox::Information);
+    update_prompt.addButton(QMessageBox::Yes);
+    update_prompt.addButton(QMessageBox::Ignore);
+    update_prompt.setText(tr("Download %1?").arg(QString::fromStdString(version->name)));
+    update_prompt.exec();
+    if (update_prompt.button(QMessageBox::Yes) == update_prompt.clickedButton()) {
+        auto const full_url =
+            fmt::format("{}/{}/releases/tag/", std::string{Common::g_build_auto_update_website},
+                        std::string{Common::g_build_auto_update_repo});
+        QDesktopServices::openUrl(QUrl(QString::fromStdString(full_url + version->tag)));
+    }
 }
 #endif
 

src/yuzu/main_window.h

@@ -493,8 +493,8 @@ private:
     std::shared_ptr<InputCommon::InputSubsystem> input_subsystem;
 
 #ifdef ENABLE_UPDATE_CHECKER
-    QFuture<std::optional<Common::Net::Release>> update_future;
-    QFutureWatcher<std::optional<Common::Net::Release>> update_watcher;
+    QFuture<std::optional<UpdateChecker::Update>> update_future;
+    QFutureWatcher<std::optional<UpdateChecker::Update>> update_watcher;
 #endif
 
     MultiplayerState* multiplayer_state = nullptr;

src/yuzu/updater/update_dialog.cpp

@@ -1,178 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include <QRadioButton>
-#include <QSaveFile>
-#include <QStandardPaths>
-#include <qdesktopservices.h>
-#include "common/logging.h"
-#include "qt_common/abstract/frontend.h"
-#include "qt_common/abstract/progress.h"
-#include "ui_update_dialog.h"
-#include "update_dialog.h"
-
-#include "common/httplib.h"
-
-#ifdef YUZU_BUNDLED_OPENSSL
-#include <openssl/cert.h>
-#endif
-
-#include <QDesktopServices>
-
-#undef GetSaveFileName
-
-UpdateDialog::UpdateDialog(const Common::Net::Release& release, QWidget* parent)
-    : QDialog(parent), ui(new Ui::UpdateDialog) {
-    ui->setupUi(this);
-
-    ui->version->setText(
-        tr("%1 is available for download.").arg(QString::fromStdString(release.title)));
-    ui->url->setText(
-        tr("<a href=\"%1\">View on Forgejo</a>").arg(QString::fromStdString(release.html_url)));
-
-    std::string text{release.body};
-    if (auto pos = text.find("# Packages"); pos != std::string::npos) {
-        text = text.substr(0, pos);
-    }
-
-    ui->body->setMarkdown(QString::fromStdString(text));
-
-    // TODO(crueter): Find a way to set default
-    const auto assets = release.GetPlatformAssets();
-
-    if (assets.empty()) {
-        ui->groupBox->setHidden(true);
-        connect(this, &QDialog::accepted, this, [release]() {
-            QDesktopServices::openUrl(QUrl{QString::fromStdString(release.html_url)});
-        });
-    } else if (assets.size() == 1) {
-        m_asset = assets[0];
-
-        connect(this, &QDialog::accepted, this, &UpdateDialog::Download);
-    } else {
-        u32 i = 0;
-        for (const Common::Net::Asset& a : assets) {
-            QRadioButton* r = new QRadioButton(tr(a.name.c_str()), this);
-            connect(r, &QRadioButton::toggled, this, [a, this](bool checked) {
-                if (checked)
-                    m_asset = a;
-            });
-
-            if (i == 0)
-                r->setChecked(true);
-            ++i;
-
-            ui->radioButtons->addWidget(r);
-        }
-
-        connect(this, &QDialog::accepted, this, &UpdateDialog::Download);
-    }
-}
-
-UpdateDialog::~UpdateDialog() {
-    delete ui;
-}
-
-void UpdateDialog::Download() {
-    const auto filename = QtCommon::Frontend::GetSaveFileName(
-        tr("New Version Location"),
-        qApp->applicationDirPath() % QStringLiteral("/") % QString::fromStdString(m_asset.filename),
-        tr("All Files (*.*)"));
-
-    if (filename.isEmpty())
-        return;
-
-    QSaveFile file(filename);
-    if (!file.open(QIODevice::Truncate | QIODevice::WriteOnly)) {
-        LOG_WARNING(Frontend, "Could not open file {}", filename.toStdString());
-        QtCommon::Frontend::Critical(tr("Failed to save file"),
-                                     tr("Could not open file %1 for writing.").arg(filename));
-        return;
-    }
-
-    // TODO(crueter): Move to net.cpp
-    constexpr std::size_t timeout_seconds = 15;
-
-    std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(m_asset.url);
-    client->set_connection_timeout(timeout_seconds);
-    client->set_read_timeout(timeout_seconds);
-    client->set_write_timeout(timeout_seconds);
-
-#ifdef YUZU_BUNDLED_OPENSSL
-    client->load_ca_cert_store(kCert, sizeof(kCert));
-#endif
-
-    if (client == nullptr) {
-        LOG_ERROR(Frontend, "Invalid URL {}{}", m_asset.url, m_asset.path);
-        return;
-    }
-
-    auto progress =
-        QtCommon::Frontend::newProgressDialog(tr("Downloading..."), tr("Cancel"), 0, 100);
-    progress->show();
-
-    QGuiApplication::processEvents();
-
-    // Progress dialog.
-    auto progress_callback = [&](size_t processed_size, size_t total_size) {
-        QGuiApplication::processEvents();
-        progress->setValue(static_cast<int>((processed_size * 100) / total_size));
-        return !progress->wasCanceled();
-    };
-
-    // Write file in chunks.
-    auto content_receiver = [&file, filename](const char* t_data, size_t data_length) -> bool {
-        if (file.write(t_data, data_length) == -1) {
-            LOG_WARNING(Frontend, "Could not write {} bytes to file {}", data_length,
-                        filename.toStdString());
-            QtCommon::Frontend::Critical(tr("Failed to save file"),
-                                         tr("Could not write to file %1.").arg(filename));
-            return false;
-        }
-
-        return true;
-    };
-
-    // Now send off request
-    auto result = client->Get(m_asset.path, content_receiver, progress_callback);
-    progress->close();
-
-    // commit to file
-    if (!file.commit()) {
-        LOG_WARNING(Frontend, "Could not commit to file {}", filename.toStdString());
-        QtCommon::Frontend::Critical(tr("Failed to save file"),
-                                     tr("Could not commit to file %1.").arg(filename));
-    }
-
-    if (!result) {
-        LOG_ERROR(Frontend, "GET to {}{} returned null", m_asset.url, m_asset.path);
-        return;
-    }
-
-    const auto& response = result.value();
-    if (response.status >= 400) {
-        LOG_ERROR(Frontend, "GET to {}{} returned error status code: {}", m_asset.url, m_asset.path,
-                  response.status);
-        QtCommon::Frontend::Critical(tr("Failed to download file"),
-                                     tr("Could not download from %1%2\nError code: %3")
-                                         .arg(QString::fromStdString(m_asset.url),
-                                              QString::fromStdString(m_asset.path),
-                                              QString::number(response.status)));
-        return;
-    }
-    if (!response.headers.contains("content-type")) {
-        LOG_ERROR(Frontend, "GET to {}{} returned no content", m_asset.url, m_asset.path);
-        return;
-    }
-
-    // Download is complete. User may choose to open in the file manager.
-    auto button =
-        QtCommon::Frontend::Question(tr("Download Complete"),
-                                     tr("Successfully downloaded %1. Would you like to open it?")
-                                         .arg(QString::fromStdString(m_asset.filename)),
-                                     QtCommon::Frontend::Yes | QtCommon::Frontend::No);
-
-    if (button == QtCommon::Frontend::Yes) {
-        QDesktopServices::openUrl(QUrl::fromLocalFile(filename));
-    }
-}

src/yuzu/updater/update_dialog.h

@@ -1,28 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <QDialog>
-#include "common/net/net.h"
-
-class QRadioButton;
-namespace Ui {
-class UpdateDialog;
-}
-
-class UpdateDialog : public QDialog {
-    Q_OBJECT
-
-public:
-    explicit UpdateDialog(const Common::Net::Release &release, QWidget* parent = nullptr);
-    ~UpdateDialog();
-
-private slots:
-    void Download();
-
-private:
-    Ui::UpdateDialog* ui;
-    QList<QRadioButton *> m_buttons;
-    Common::Net::Asset m_asset;
-};

src/yuzu/updater/update_dialog.ui

@@ -1,112 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>UpdateDialog</class>
- <widget class="QDialog" name="UpdateDialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>655</width>
-    <height>551</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Update Available</string>
-  </property>
-  <layout class="QGridLayout" name="gridLayout">
-   <item row="0" column="1">
-    <widget class="QLabel" name="url">
-     <property name="text">
-      <string>&lt;a href=&quot;%1&quot;&gt;View on Forgejo&lt;/a&gt;</string>
-     </property>
-     <property name="alignment">
-      <set>Qt::AlignmentFlag::AlignRight|Qt::AlignmentFlag::AlignTrailing|Qt::AlignmentFlag::AlignVCenter</set>
-     </property>
-     <property name="openExternalLinks">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
-   <item row="3" column="0" colspan="2">
-    <widget class="QLabel" name="label_2">
-     <property name="text">
-      <string>Would you like to install this update?</string>
-     </property>
-    </widget>
-   </item>
-   <item row="4" column="0" colspan="2">
-    <widget class="QDialogButtonBox" name="buttonBox">
-     <property name="orientation">
-      <enum>Qt::Orientation::Horizontal</enum>
-     </property>
-     <property name="standardButtons">
-      <set>QDialogButtonBox::StandardButton::No|QDialogButtonBox::StandardButton::Yes</set>
-     </property>
-    </widget>
-   </item>
-   <item row="2" column="0" colspan="2">
-    <widget class="QGroupBox" name="groupBox">
-     <property name="title">
-      <string>Available Versions</string>
-     </property>
-     <layout class="QVBoxLayout" name="radioButtons"/>
-    </widget>
-   </item>
-   <item row="0" column="0">
-    <widget class="QLabel" name="version">
-     <property name="text">
-      <string>%1 is available for download.</string>
-     </property>
-    </widget>
-   </item>
-   <item row="1" column="0" colspan="2">
-    <widget class="QTextBrowser" name="body">
-     <property name="horizontalScrollBarPolicy">
-      <enum>Qt::ScrollBarPolicy::ScrollBarAlwaysOff</enum>
-     </property>
-     <property name="readOnly">
-      <bool>true</bool>
-     </property>
-     <property name="openExternalLinks">
-      <bool>true</bool>
-     </property>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>UpdateDialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>248</x>
-     <y>254</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>157</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>UpdateDialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>316</x>
-     <y>260</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>286</x>
-     <y>274</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>