Android 249

README.md

@@ -1,3 +1,17 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+| [10529](https://github.com/yuzu-emu/yuzu//pull/10529) | [`368bf2211`](https://github.com/yuzu-emu/yuzu//pull/10529/files) | caches: make critical reclamation less eager and possible in more cases | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12461](https://github.com/yuzu-emu/yuzu//pull/12461) | [`acc26667b`](https://github.com/yuzu-emu/yuzu//pull/12461/files) | Rework Nvdec and VIC to fix out-of-order videos, and speed up decoding. | [Kelebek1](https://github.com/Kelebek1/) | Yes |
+| [12749](https://github.com/yuzu-emu/yuzu//pull/12749) | [`aad4b0d6f`](https://github.com/yuzu-emu/yuzu//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [13000](https://github.com/yuzu-emu/yuzu//pull/13000) | [`461eaca7e`](https://github.com/yuzu-emu/yuzu//pull/13000/files) | device_memory_manager: skip unregistered interfaces on invalidate | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [13011](https://github.com/yuzu-emu/yuzu//pull/13011) | [`1842df1da`](https://github.com/yuzu-emu/yuzu//pull/13011/files) | vi: rewrite for new IPC | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [13016](https://github.com/yuzu-emu/yuzu//pull/13016) | [`caf16982d`](https://github.com/yuzu-emu/yuzu//pull/13016/files) | service: set: Migrate ISystemSettingsServer to new IPC | [german77](https://github.com/german77/) | Yes |
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

externals/CMakeLists.txt

@@ -314,3 +314,10 @@ endif()
 if (NOT TARGET SimpleIni::SimpleIni)
     add_subdirectory(simpleini)
 endif()
+
+# sse2neon
+if (ARCHITECTURE_arm64 AND NOT TARGET sse2neon)
+    add_library(sse2neon INTERFACE)
+    target_include_directories(sse2neon INTERFACE sse2neon)
+endif()
+

src/CMakeLists.txt

@@ -164,6 +164,7 @@ else()
 
     if (MINGW)
         add_definitions(-DMINGW_HAS_SECURE_API)
+        add_compile_options("-msse4.1")
 
         if (MINGW_STATIC_BUILD)
             add_definitions(-DQT_STATICPLUGIN)

src/core/CMakeLists.txt

@@ -959,14 +959,26 @@ add_library(core STATIC
     hle/service/vi/display/vi_display.h
     hle/service/vi/layer/vi_layer.cpp
     hle/service/vi/layer/vi_layer.h
+    hle/service/vi/application_display_service.cpp
+    hle/service/vi/application_display_service.h
+    hle/service/vi/application_root_service.cpp
+    hle/service/vi/application_root_service.h
+    hle/service/vi/hos_binder_driver.cpp
+    hle/service/vi/hos_binder_driver.h
+    hle/service/vi/manager_display_service.cpp
+    hle/service/vi/manager_display_service.h
+    hle/service/vi/manager_root_service.cpp
+    hle/service/vi/manager_root_service.h
+    hle/service/vi/service_creator.cpp
+    hle/service/vi/service_creator.h
+    hle/service/vi/system_display_service.cpp
+    hle/service/vi/system_display_service.h
+    hle/service/vi/system_root_service.cpp
+    hle/service/vi/system_root_service.h
+    hle/service/vi/vi_results.h
+    hle/service/vi/vi_types.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
-    hle/service/vi/vi_m.cpp
-    hle/service/vi/vi_m.h
-    hle/service/vi/vi_s.cpp
-    hle/service/vi/vi_s.h
-    hle/service/vi/vi_u.cpp
-    hle/service/vi/vi_u.h
     internal_network/network.cpp
     internal_network/network.h
     internal_network/network_interface.cpp

src/core/device_memory_manager.h

@@ -43,6 +43,8 @@ public:
     DeviceMemoryManager(const DeviceMemory& device_memory);
     ~DeviceMemoryManager();
 
+    static constexpr bool HAS_FLUSH_INVALIDATION = true;
+
     void BindInterface(DeviceInterface* device_inter);
 
     DAddr Allocate(size_t size);

src/core/device_memory_manager.inc

@@ -522,13 +522,17 @@ void DeviceMemoryManager<Traits>::UpdatePagesCachedCount(DAddr addr, size_t size
     auto* memory_device_inter = registered_processes[asid.id];
     const auto release_pending = [&] {
         if (uncache_bytes > 0) {
+            if (memory_device_inter != nullptr) {
                 MarkRegionCaching(memory_device_inter, uncache_begin << Memory::YUZU_PAGEBITS,
                                   uncache_bytes, false);
+            }
             uncache_bytes = 0;
         }
         if (cache_bytes > 0) {
+            if (memory_device_inter != nullptr) {
                 MarkRegionCaching(memory_device_inter, cache_begin << Memory::YUZU_PAGEBITS,
                                   cache_bytes, true);
+            }
             cache_bytes = 0;
         }
     };

src/core/guest_memory.h

@@ -44,15 +44,32 @@ public:
     GuestMemory() = delete;
     explicit GuestMemory(M& memory, u64 addr, std::size_t size,
                          Common::ScratchBuffer<T>* backup = nullptr)
-        : m_memory{memory}, m_addr{addr}, m_size{size} {
+        : m_memory{&memory}, m_addr{addr}, m_size{size} {
         static_assert(FLAGS & GuestMemoryFlags::Read || FLAGS & GuestMemoryFlags::Write);
-        if constexpr (FLAGS & GuestMemoryFlags::Read) {
+        if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
+            if (!this->TrySetSpan()) {
+                if (backup) {
+                    backup->resize_destructive(this->size());
+                    m_data_span = *backup;
+                    m_span_valid = true;
+                    m_is_data_copy = true;
+                } else {
+                    m_data_copy.resize(this->size());
+                    m_data_span = std::span(m_data_copy);
+                    m_span_valid = true;
+                    m_is_data_copy = true;
+                }
+            }
+        } else if constexpr (FLAGS & GuestMemoryFlags::Read) {
             Read(addr, size, backup);
         }
     }
 
     ~GuestMemory() = default;
 
+    GuestMemory(GuestMemory&& rhs) = default;
+    GuestMemory& operator=(GuestMemory&& rhs) = default;
+
     T* data() noexcept {
         return m_data_span.data();
     }
@@ -109,8 +126,8 @@ public:
         }
 
         if (this->TrySetSpan()) {
-            if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                m_memory.FlushRegion(m_addr, this->size_bytes());
+            if constexpr (FLAGS & GuestMemoryFlags::Safe && M::HAS_FLUSH_INVALIDATION) {
+                m_memory->FlushRegion(m_addr, this->size_bytes());
             }
         } else {
             if (backup) {
@@ -123,9 +140,9 @@ public:
             m_is_data_copy = true;
             m_span_valid = true;
             if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                m_memory.ReadBlock(m_addr, this->data(), this->size_bytes());
+                m_memory->ReadBlock(m_addr, this->data(), this->size_bytes());
             } else {
-                m_memory.ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
+                m_memory->ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
             }
         }
         return m_data_span;
@@ -133,18 +150,19 @@ public:
 
     void Write(std::span<T> write_data) noexcept {
         if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-            m_memory.WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
+            m_memory->WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
         } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-            m_memory.WriteBlock(m_addr, write_data.data(), this->size_bytes());
+            m_memory->WriteBlock(m_addr, write_data.data(), this->size_bytes());
         } else {
-            m_memory.WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
+            m_memory->WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
         }
     }
 
     bool TrySetSpan() noexcept {
-        if (u8* ptr = m_memory.GetSpan(m_addr, this->size_bytes()); ptr) {
+        if (u8* ptr = m_memory->GetSpan(m_addr, this->size_bytes()); ptr) {
             m_data_span = {reinterpret_cast<T*>(ptr), this->size()};
             m_span_valid = true;
+            m_is_data_copy = false;
             return true;
         }
         return false;
@@ -159,7 +177,7 @@ protected:
         return m_addr_changed;
     }
 
-    M& m_memory;
+    M* m_memory;
     u64 m_addr{};
     size_t m_size{};
     std::span<T> m_data_span{};
@@ -175,17 +193,7 @@ public:
     GuestMemoryScoped() = delete;
     explicit GuestMemoryScoped(M& memory, u64 addr, std::size_t size,
                                Common::ScratchBuffer<T>* backup = nullptr)
-        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {
-        if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
-            if (!this->TrySetSpan()) {
-                if (backup) {
-                    this->m_data_span = *backup;
-                    this->m_span_valid = true;
-                    this->m_is_data_copy = true;
-                }
-            }
-        }
-    }
+        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {}
 
     ~GuestMemoryScoped() {
         if constexpr (FLAGS & GuestMemoryFlags::Write) {
@@ -196,15 +204,17 @@ public:
             if (this->AddressChanged() || this->IsDataCopy()) {
                 ASSERT(this->m_span_valid);
                 if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-                    this->m_memory.WriteBlockCached(this->m_addr, this->data(), this->size_bytes());
+                    this->m_memory->WriteBlockCached(this->m_addr, this->data(),
+                                                     this->size_bytes());
                 } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                    this->m_memory.WriteBlock(this->m_addr, this->data(), this->size_bytes());
+                    this->m_memory->WriteBlock(this->m_addr, this->data(), this->size_bytes());
                 } else {
-                    this->m_memory.WriteBlockUnsafe(this->m_addr, this->data(), this->size_bytes());
+                    this->m_memory->WriteBlockUnsafe(this->m_addr, this->data(),
+                                                     this->size_bytes());
                 }
             } else if constexpr ((FLAGS & GuestMemoryFlags::Safe) ||
                                  (FLAGS & GuestMemoryFlags::Cached)) {
-                this->m_memory.InvalidateRegion(this->m_addr, this->size_bytes());
+                this->m_memory->InvalidateRegion(this->m_addr, this->size_bytes());
             }
         }
     }

src/core/hle/service/am/service/common_state_getter.cpp

@@ -11,6 +11,7 @@
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/vi/vi.h"
+#include "core/hle/service/vi/vi_types.h"
 
 namespace Service::AM {
 

src/core/hle/service/audio/audctl.cpp

@@ -106,7 +106,7 @@ void AudCtl::GetAudioOutputMode(HLERequestContext& ctx) {
     const auto target{rp.PopEnum<Set::AudioOutputModeTarget>()};
 
     Set::AudioOutputMode output_mode{};
-    const auto result = m_set_sys->GetAudioOutputMode(output_mode, target);
+    const auto result = m_set_sys->GetAudioOutputMode(&output_mode, target);
 
     LOG_INFO(Service_SET, "called, target={}, output_mode={}", target, output_mode);
 
@@ -188,7 +188,7 @@ void AudCtl::SetSpeakerAutoMuteEnabled(HLERequestContext& ctx) {
 
 void AudCtl::IsSpeakerAutoMuteEnabled(HLERequestContext& ctx) {
     bool is_speaker_auto_mute_enabled{};
-    const auto result = m_set_sys->GetSpeakerAutoMuteFlag(is_speaker_auto_mute_enabled);
+    const auto result = m_set_sys->GetSpeakerAutoMuteFlag(&is_speaker_auto_mute_enabled);
 
     LOG_WARNING(Audio, "(STUBBED) called, is_speaker_auto_mute_enabled={}",
                 is_speaker_auto_mute_enabled);

src/core/hle/service/glue/time/manager.cpp

@@ -21,19 +21,6 @@
 
 namespace Service::Glue::Time {
 namespace {
-
-template <typename T>
-T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
-                       const char* category, const char* name) {
-    std::vector<u8> interval_buf;
-    auto res = set_sys->GetSettingsItemValue(interval_buf, category, name);
-    ASSERT(res == ResultSuccess);
-
-    T v{};
-    std::memcpy(&v, interval_buf.data(), sizeof(T));
-    return v;
-}
-
 s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
     constexpr auto is_leap = [](s32 year) -> bool {
         return (((year) % 4) == 0 && (((year) % 100) != 0 || ((year) % 400) == 0));
@@ -65,13 +52,15 @@ s64 CalendarTimeToEpoch(Service::PSC::Time::CalendarTime calendar) {
 
 s64 GetEpochTimeFromInitialYear(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys) {
     Service::PSC::Time::CalendarTime calendar{
-        .year = GetSettingsItemValue<s16>(set_sys, "time", "standard_user_clock_initial_year"),
+        .year = 2000,
         .month = 1,
         .day = 1,
         .hour = 0,
         .minute = 0,
         .second = 0,
     };
+    set_sys->GetSettingsItemValueImpl<s16>(calendar.year, "time",
+                                           "standard_user_clock_initial_year");
     return CalendarTimeToEpoch(calendar);
 }
 
@@ -124,7 +113,7 @@ TimeManager::TimeManager(Core::System& system)
     ASSERT(res == ResultSuccess);
 
     Service::PSC::Time::SystemClockContext user_clock_context{};
-    res = m_set_sys->GetUserSystemClockContext(user_clock_context);
+    res = m_set_sys->GetUserSystemClockContext(&user_clock_context);
     ASSERT(res == ResultSuccess);
 
     // TODO the local clock should initialise with this epoch time, and be updated somewhere else on
@@ -140,11 +129,12 @@ TimeManager::TimeManager(Core::System& system)
     ASSERT(res == ResultSuccess);
 
     Service::PSC::Time::SystemClockContext network_clock_context{};
-    res = m_set_sys->GetNetworkSystemClockContext(network_clock_context);
+    res = m_set_sys->GetNetworkSystemClockContext(&network_clock_context);
     ASSERT(res == ResultSuccess);
 
-    auto network_accuracy_m{GetSettingsItemValue<s32>(
-        m_set_sys, "time", "standard_network_clock_sufficient_accuracy_minutes")};
+    s32 network_accuracy_m{};
+    m_set_sys->GetSettingsItemValueImpl<s32>(network_accuracy_m, "time",
+                                             "standard_network_clock_sufficient_accuracy_minutes");
     auto one_minute_ns{
         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()};
     s64 network_accuracy_ns{network_accuracy_m * one_minute_ns};
@@ -153,12 +143,12 @@ TimeManager::TimeManager(Core::System& system)
     ASSERT(res == ResultSuccess);
 
     bool is_automatic_correction_enabled{};
-    res = m_set_sys->IsUserSystemClockAutomaticCorrectionEnabled(is_automatic_correction_enabled);
+    res = m_set_sys->IsUserSystemClockAutomaticCorrectionEnabled(&is_automatic_correction_enabled);
     ASSERT(res == ResultSuccess);
 
     Service::PSC::Time::SteadyClockTimePoint automatic_correction_time_point{};
     res = m_set_sys->GetUserSystemClockAutomaticCorrectionUpdatedTime(
-        automatic_correction_time_point);
+        &automatic_correction_time_point);
     ASSERT(res == ResultSuccess);
 
     res = m_time_m->SetupStandardUserSystemClockCore(is_automatic_correction_enabled,
@@ -198,11 +188,11 @@ TimeManager::TimeManager(Core::System& system)
 
 Result TimeManager::SetupStandardSteadyClockCore() {
     Common::UUID external_clock_source_id{};
-    auto res = m_set_sys->GetExternalSteadyClockSourceId(external_clock_source_id);
+    auto res = m_set_sys->GetExternalSteadyClockSourceId(&external_clock_source_id);
     ASSERT(res == ResultSuccess);
 
     s64 external_steady_clock_internal_offset_s{};
-    res = m_set_sys->GetExternalSteadyClockInternalOffset(external_steady_clock_internal_offset_s);
+    res = m_set_sys->GetExternalSteadyClockInternalOffset(&external_steady_clock_internal_offset_s);
     ASSERT(res == ResultSuccess);
 
     auto one_second_ns{
@@ -210,8 +200,9 @@ Result TimeManager::SetupStandardSteadyClockCore() {
     s64 external_steady_clock_internal_offset_ns{external_steady_clock_internal_offset_s *
                                                  one_second_ns};
 
-    s32 standard_steady_clock_test_offset_m{
-        GetSettingsItemValue<s32>(m_set_sys, "time", "standard_steady_clock_test_offset_minutes")};
+    s32 standard_steady_clock_test_offset_m{};
+    m_set_sys->GetSettingsItemValueImpl<s32>(standard_steady_clock_test_offset_m, "time",
+                                             "standard_steady_clock_test_offset_minutes");
     auto one_minute_ns{
         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::minutes(1)).count()};
     s64 standard_steady_clock_test_offset_ns{standard_steady_clock_test_offset_m * one_minute_ns};
@@ -237,7 +228,7 @@ Result TimeManager::SetupStandardSteadyClockCore() {
 
 Result TimeManager::SetupTimeZoneServiceCore() {
     Service::PSC::Time::LocationName name{};
-    auto res = m_set_sys->GetDeviceTimeZoneLocationName(name);
+    auto res = m_set_sys->GetDeviceTimeZoneLocationName(&name);
     ASSERT(res == ResultSuccess);
 
     auto configured_zone = GetTimeZoneString(name);
@@ -255,7 +246,7 @@ Result TimeManager::SetupTimeZoneServiceCore() {
     }
 
     Service::PSC::Time::SteadyClockTimePoint time_point{};
-    res = m_set_sys->GetDeviceTimeZoneLocationUpdatedTime(time_point);
+    res = m_set_sys->GetDeviceTimeZoneLocationUpdatedTime(&time_point);
     ASSERT(res == ResultSuccess);
 
     auto location_count = GetTimeZoneCount();

src/core/hle/service/glue/time/static.cpp

@@ -20,19 +20,6 @@
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::Glue::Time {
-namespace {
-template <typename T>
-T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
-                       const char* category, const char* name) {
-    std::vector<u8> interval_buf;
-    auto res = set_sys->GetSettingsItemValue(interval_buf, category, name);
-    ASSERT(res == ResultSuccess);
-
-    T v{};
-    std::memcpy(&v, interval_buf.data(), sizeof(T));
-    return v;
-}
-} // namespace
 
 StaticService::StaticService(Core::System& system_,
                              Service::PSC::Time::StaticServiceSetupInfo setup_info,
@@ -181,8 +168,8 @@ Result StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled(
 Result StaticService::GetStandardUserSystemClockInitialYear(Out<s32> out_year) {
     SCOPE_EXIT({ LOG_DEBUG(Service_Time, "called. out_year={}", *out_year); });
 
-    *out_year = GetSettingsItemValue<s32>(m_set_sys, "time", "standard_user_clock_initial_year");
-    R_SUCCEED();
+    R_RETURN(m_set_sys->GetSettingsItemValueImpl<s32>(*out_year, "time",
+                                                      "standard_user_clock_initial_year"));
 }
 
 Result StaticService::IsStandardNetworkSystemClockAccuracySufficient(Out<bool> out_is_sufficient) {

src/core/hle/service/glue/time/worker.cpp

@@ -27,7 +27,7 @@ template <typename T>
 T GetSettingsItemValue(std::shared_ptr<Service::Set::ISystemSettingsServer>& set_sys,
                        const char* category, const char* name) {
     std::vector<u8> interval_buf;
-    auto res = set_sys->GetSettingsItemValue(interval_buf, category, name);
+    auto res = set_sys->GetSettingsItemValueImpl(interval_buf, category, name);
     ASSERT(res == ResultSuccess);
 
     T v{};

src/core/hle/service/mii/mii.cpp

@@ -207,7 +207,8 @@ private:
 
     Result DestroyFile() {
         bool is_db_test_mode_enabled{};
-        m_set_sys->GetSettingsItemValue(is_db_test_mode_enabled, "mii", "is_db_test_mode_enabled");
+        m_set_sys->GetSettingsItemValueImpl(is_db_test_mode_enabled, "mii",
+                                            "is_db_test_mode_enabled");
 
         LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled);
         R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly);
@@ -217,7 +218,8 @@ private:
 
     Result DeleteFile() {
         bool is_db_test_mode_enabled{};
-        m_set_sys->GetSettingsItemValue(is_db_test_mode_enabled, "mii", "is_db_test_mode_enabled");
+        m_set_sys->GetSettingsItemValueImpl(is_db_test_mode_enabled, "mii",
+                                            "is_db_test_mode_enabled");
 
         LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled);
         R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly);
@@ -227,7 +229,8 @@ private:
 
     Result Format() {
         bool is_db_test_mode_enabled{};
-        m_set_sys->GetSettingsItemValue(is_db_test_mode_enabled, "mii", "is_db_test_mode_enabled");
+        m_set_sys->GetSettingsItemValueImpl(is_db_test_mode_enabled, "mii",
+                                            "is_db_test_mode_enabled");
 
         LOG_INFO(Service_Mii, "called is_db_test_mode_enabled={}", is_db_test_mode_enabled);
         R_UNLESS(is_db_test_mode_enabled, ResultTestModeOnly);

src/core/hle/service/nvdrv/core/container.h

@@ -68,10 +68,7 @@ public:
     const SyncpointManager& GetSyncpointManager() const;
 
     struct Host1xDeviceFileData {
-        std::unordered_map<DeviceFD, u32> fd_to_id{};
         std::deque<u32> syncpts_accumulated{};
-        u32 nvdec_next_id{};
-        u32 vic_next_id{};
     };
 
     Host1xDeviceFileData& Host1xDeviceFile();

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

@@ -8,6 +8,7 @@
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
+#include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
@@ -21,13 +22,8 @@ NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> in
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
-        case 0x1: {
-            auto& host1x_file = core.Host1xDeviceFile();
-            if (!host1x_file.fd_to_id.contains(fd)) {
-                host1x_file.fd_to_id[fd] = host1x_file.nvdec_next_id++;
-            }
+        case 0x1:
             return WrapFixedVariable(this, &nvhost_nvdec::Submit, input, output, fd);
-        }
         case 0x2:
             return WrapFixed(this, &nvhost_nvdec::GetSyncpoint, input, output);
         case 0x3:
@@ -72,15 +68,12 @@ void nvhost_nvdec::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream started");
     system.SetNVDECActive(true);
     sessions[fd] = session_id;
+    host1x.StartDevice(fd, Tegra::Host1x::ChannelType::NvDec, channel_syncpoint);
 }
 
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
-    auto& host1x_file = core.Host1xDeviceFile();
-    const auto iter = host1x_file.fd_to_id.find(fd);
-    if (iter != host1x_file.fd_to_id.end()) {
-        system.GPU().ClearCdmaInstance(iter->second);
-    }
+    host1x.StopDevice(fd, Tegra::Host1x::ChannelType::NvDec);
     system.SetNVDECActive(false);
     auto it = sessions.find(fd);
     if (it != sessions.end()) {

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

@@ -55,8 +55,9 @@ std::size_t WriteVectors(std::span<u8> dst, const std::vector<T>& src, std::size
 
 nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system_, NvCore::Container& core_,
                                          NvCore::ChannelType channel_type_)
-    : nvdevice{system_}, core{core_}, syncpoint_manager{core.GetSyncpointManager()},
-      nvmap{core.GetNvMapFile()}, channel_type{channel_type_} {
+    : nvdevice{system_}, host1x{system_.Host1x()}, core{core_},
+      syncpoint_manager{core.GetSyncpointManager()}, nvmap{core.GetNvMapFile()},
+      channel_type{channel_type_} {
     auto& syncpts_accumulated = core.Host1xDeviceFile().syncpts_accumulated;
     if (syncpts_accumulated.empty()) {
         channel_syncpoint = syncpoint_manager.AllocateSyncpoint(false);
@@ -95,24 +96,24 @@ NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, De
     offset += SliceVectors(data, syncpt_increments, params.syncpoint_count, offset);
     offset += SliceVectors(data, fence_thresholds, params.fence_count, offset);
 
-    auto& gpu = system.GPU();
     auto* session = core.GetSession(sessions[fd]);
 
-    if (gpu.UseNvdec()) {
     for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
         const SyncptIncr& syncpt_incr = syncpt_increments[i];
         fence_thresholds[i] =
             syncpoint_manager.IncrementSyncpointMaxExt(syncpt_incr.id, syncpt_incr.increments);
     }
-    }
+
     for (const auto& cmd_buffer : command_buffers) {
         const auto object = nvmap.GetHandle(cmd_buffer.memory_id);
         ASSERT_OR_EXECUTE(object, return NvResult::InvalidState;);
-        Tegra::ChCommandHeaderList cmdlist(cmd_buffer.word_count);
-        session->process->GetMemory().ReadBlock(object->address + cmd_buffer.offset, cmdlist.data(),
-                                                cmdlist.size() * sizeof(u32));
-        gpu.PushCommandBuffer(core.Host1xDeviceFile().fd_to_id[fd], cmdlist);
+        Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader,
+                                     Core::Memory::GuestMemoryFlags::SafeRead>
+            cmdlist(session->process->GetMemory(), object->address + cmd_buffer.offset,
+                    cmd_buffer.word_count);
+        host1x.PushEntries(fd, std::move(cmdlist));
     }
+
     // Some games expect command_buffers to be written back
     offset = 0;
     offset += WriteVectors(data, command_buffers, offset);

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

@@ -119,6 +119,7 @@ protected:
 
     Kernel::KEvent* QueryEvent(u32 event_id) override;
 
+    Tegra::Host1x::Host1x& host1x;
     u32 channel_syncpoint;
     s32_le nvmap_fd{};
     u32_le submit_timeout{};

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

@@ -7,6 +7,7 @@
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/devices/ioctl_serialization.h"
 #include "core/hle/service/nvdrv/devices/nvhost_vic.h"
+#include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
@@ -21,13 +22,8 @@ NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, std::span<const u8> inpu
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
-        case 0x1: {
-            auto& host1x_file = core.Host1xDeviceFile();
-            if (!host1x_file.fd_to_id.contains(fd)) {
-                host1x_file.fd_to_id[fd] = host1x_file.vic_next_id++;
-            }
+        case 0x1:
             return WrapFixedVariable(this, &nvhost_vic::Submit, input, output, fd);
-        }
         case 0x2:
             return WrapFixed(this, &nvhost_vic::GetSyncpoint, input, output);
         case 0x3:
@@ -70,14 +66,11 @@ NvResult nvhost_vic::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> inpu
 
 void nvhost_vic::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     sessions[fd] = session_id;
+    host1x.StartDevice(fd, Tegra::Host1x::ChannelType::VIC, channel_syncpoint);
 }
 
 void nvhost_vic::OnClose(DeviceFD fd) {
-    auto& host1x_file = core.Host1xDeviceFile();
-    const auto iter = host1x_file.fd_to_id.find(fd);
-    if (iter != host1x_file.fd_to_id.end()) {
-        system.GPU().ClearCdmaInstance(iter->second);
-    }
+    host1x.StopDevice(fd, Tegra::Host1x::ChannelType::VIC);
     sessions.erase(fd);
 }
 

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

@@ -6,6 +6,8 @@
 
 #pragma once
 
+#include <span>
+
 #include "common/common_types.h"
 
 namespace Kernel {
@@ -38,7 +40,8 @@ enum class TransactionId {
 class IBinder {
 public:
     virtual ~IBinder() = default;
-    virtual void Transact(HLERequestContext& ctx, android::TransactionId code, u32 flags) = 0;
+    virtual void Transact(android::TransactionId code, u32 flags, std::span<const u8> parcel_data,
+                          std::span<u8> parcel_reply) = 0;
     virtual Kernel::KReadableEvent& GetNativeHandle() = 0;
 };
 

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

@@ -807,9 +807,10 @@ Status BufferQueueProducer::SetPreallocatedBuffer(s32 slot,
     return Status::NoError;
 }
 
-void BufferQueueProducer::Transact(HLERequestContext& ctx, TransactionId code, u32 flags) {
+void BufferQueueProducer::Transact(TransactionId code, u32 flags, std::span<const u8> parcel_data,
+                                   std::span<u8> parcel_reply) {
     Status status{Status::NoError};
-    InputParcel parcel_in{ctx.ReadBuffer()};
+    InputParcel parcel_in{parcel_data};
     OutputParcel parcel_out{};
 
     switch (code) {
@@ -917,7 +918,9 @@ void BufferQueueProducer::Transact(HLERequestContext& ctx, TransactionId code, u
 
     parcel_out.Write(status);
 
-    ctx.WriteBuffer(parcel_out.Serialize());
+    const auto serialized = parcel_out.Serialize();
+    std::memcpy(parcel_reply.data(), serialized.data(),
+                std::min(parcel_reply.size(), serialized.size()));
 }
 
 Kernel::KReadableEvent& BufferQueueProducer::GetNativeHandle() {

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

@@ -47,7 +47,8 @@ public:
                                  Service::Nvidia::NvCore::NvMap& nvmap_);
     ~BufferQueueProducer();
 
-    void Transact(HLERequestContext& ctx, android::TransactionId code, u32 flags) override;
+    void Transact(android::TransactionId code, u32 flags, std::span<const u8> parcel_data,
+                  std::span<u8> parcel_reply) override;
 
     Kernel::KReadableEvent& GetNativeHandle() override;
 

src/core/hle/service/set/setting_formats/system_settings.h

@@ -244,7 +244,7 @@ struct SystemSettings {
     INSERT_PADDING_BYTES(0x60); // Reserved
 
     // nn::settings::system::AccountNotificationSettings
-    u32 account_notification_settings_count;
+    s32 account_notification_settings_count;
     INSERT_PADDING_BYTES(0xC); // Reserved
     std::array<AccountNotificationSettings, 8> account_notification_settings;
     INSERT_PADDING_BYTES(0x140); // Reserved
@@ -308,7 +308,7 @@ struct SystemSettings {
     INSERT_PADDING_BYTES(0x34); // Reserved
 
     // nn::settings::system::EulaVersion
-    u32 eula_version_count;
+    s32 eula_version_count;
     INSERT_PADDING_BYTES(0xC); // Reserved
     std::array<EulaVersion, 32> eula_versions;
     INSERT_PADDING_BYTES(0x200); // Reserved

src/core/hle/service/set/settings_types.h

@@ -12,6 +12,7 @@
 #include "core/hle/service/psc/time/common.h"
 
 namespace Service::Set {
+using SettingItemName = std::array<u8, 0x48>;
 
 /// This is nn::settings::system::AudioOutputMode
 enum class AudioOutputMode : u32 {
@@ -413,16 +414,18 @@ struct FirmwareVersionFormat {
     u8 major;
     u8 minor;
     u8 micro;
-    INSERT_PADDING_BYTES(1);
+    INSERT_PADDING_BYTES_NOINIT(1);
     u8 revision_major;
     u8 revision_minor;
-    INSERT_PADDING_BYTES(2);
+    INSERT_PADDING_BYTES_NOINIT(2);
     std::array<char, 0x20> platform;
     std::array<u8, 0x40> version_hash;
     std::array<char, 0x18> display_version;
     std::array<char, 0x80> display_title;
 };
 static_assert(sizeof(FirmwareVersionFormat) == 0x100, "FirmwareVersionFormat is an invalid size");
+static_assert(std::is_trivial_v<FirmwareVersionFormat>,
+              "FirmwareVersionFormat type must be trivially copyable.");
 
 /// This is nn::settings::system::HomeMenuScheme
 struct HomeMenuScheme {

src/core/hle/service/set/system_settings_server.h

@@ -11,6 +11,7 @@
 #include "common/polyfill_thread.h"
 #include "common/uuid.h"
 #include "core/hle/result.h"
+#include "core/hle/service/cmif_types.h"
 #include "core/hle/service/psc/time/common.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/set/setting_formats/appln_settings.h"
@@ -33,13 +34,14 @@ public:
     explicit ISystemSettingsServer(Core::System& system_);
     ~ISystemSettingsServer() override;
 
-    Result GetSettingsItemValue(std::vector<u8>& out_value, const std::string& category,
+    Result GetSettingsItemValueImpl(std::vector<u8>& out_value, const std::string& category,
                                     const std::string& name);
 
     template <typename T>
-    Result GetSettingsItemValue(T& value, const std::string& category, const std::string& name) {
+    Result GetSettingsItemValueImpl(T& value, const std::string& category,
+                                    const std::string& name) {
         std::vector<u8> data;
-        const auto result = GetSettingsItemValue(data, category, name);
+        const auto result = GetSettingsItemValueImpl(data, category, name);
         if (result.IsError()) {
             return result;
         }
@@ -48,120 +50,114 @@ public:
         return result;
     }
 
-    Result GetVibrationMasterVolume(f32& out_volume) const;
-    Result SetVibrationMasterVolume(f32 volume);
-    Result GetAudioOutputMode(AudioOutputMode& out_output_mode, AudioOutputModeTarget target) const;
+public:
+    Result SetLanguageCode(LanguageCode language_code);
+    Result GetFirmwareVersion(
+        OutLargeData<FirmwareVersionFormat, BufferAttr_HipcPointer> out_firmware_data);
+    Result GetFirmwareVersion2(
+        OutLargeData<FirmwareVersionFormat, BufferAttr_HipcPointer> out_firmware_data);
+    Result GetLockScreenFlag(Out<bool> out_lock_screen_flag);
+    Result SetLockScreenFlag(bool lock_screen_flag);
+    Result GetExternalSteadyClockSourceId(Out<Common::UUID> out_clock_source_id);
+    Result SetExternalSteadyClockSourceId(const Common::UUID& clock_source_id);
+    Result GetUserSystemClockContext(Out<Service::PSC::Time::SystemClockContext> out_clock_context);
+    Result SetUserSystemClockContext(const Service::PSC::Time::SystemClockContext& clock_context);
+    Result GetAccountSettings(Out<AccountSettings> out_account_settings);
+    Result SetAccountSettings(AccountSettings account_settings);
+    Result GetEulaVersions(Out<s32> out_count,
+                           OutArray<EulaVersion, BufferAttr_HipcMapAlias> out_eula_versions);
+    Result SetEulaVersions(InArray<EulaVersion, BufferAttr_HipcMapAlias> eula_versions);
+    Result GetColorSetId(Out<ColorSet> out_color_set_id);
+    Result SetColorSetId(ColorSet color_set_id);
+    Result GetNotificationSettings(Out<NotificationSettings> out_notification_settings);
+    Result SetNotificationSettings(const NotificationSettings& notification_settings);
+    Result GetAccountNotificationSettings(
+        Out<s32> out_count, OutArray<AccountNotificationSettings, BufferAttr_HipcMapAlias>
+                                out_account_notification_settings);
+    Result SetAccountNotificationSettings(
+        InArray<AccountNotificationSettings, BufferAttr_HipcMapAlias>
+            account_notification_settings);
+    Result GetVibrationMasterVolume(Out<f32> vibration_master_volume);
+    Result SetVibrationMasterVolume(f32 vibration_master_volume);
+    Result GetSettingsItemValueSize(
+        Out<u64> out_size,
+        InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer,
+        InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buf);
+    Result GetSettingsItemValue(
+        OutBuffer<BufferAttr_HipcMapAlias> out_data,
+        InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_category_buffer,
+        InLargeData<SettingItemName, BufferAttr_HipcPointer> setting_name_buffer);
+    Result GetTvSettings(Out<TvSettings> out_tv_settings);
+    Result SetTvSettings(TvSettings tv_settings);
+    Result GetAudioOutputMode(Out<AudioOutputMode> out_output_mode, AudioOutputModeTarget target);
     Result SetAudioOutputMode(AudioOutputModeTarget target, AudioOutputMode output_mode);
-    Result GetSpeakerAutoMuteFlag(bool& is_auto_mute) const;
-    Result SetSpeakerAutoMuteFlag(bool auto_mute);
-    Result GetExternalSteadyClockSourceId(Common::UUID& out_id) const;
-    Result SetExternalSteadyClockSourceId(const Common::UUID& id);
-    Result GetUserSystemClockContext(Service::PSC::Time::SystemClockContext& out_context) const;
-    Result SetUserSystemClockContext(const Service::PSC::Time::SystemClockContext& context);
-    Result GetDeviceTimeZoneLocationName(Service::PSC::Time::LocationName& out_name) const;
+    Result GetSpeakerAutoMuteFlag(Out<bool> out_force_mute_on_headphone_removed);
+    Result SetSpeakerAutoMuteFlag(bool force_mute_on_headphone_removed);
+    Result GetQuestFlag(Out<QuestFlag> out_quest_flag);
+    Result SetQuestFlag(QuestFlag quest_flag);
+    Result GetDeviceTimeZoneLocationName(Out<Service::PSC::Time::LocationName> out_name);
     Result SetDeviceTimeZoneLocationName(const Service::PSC::Time::LocationName& name);
-    Result GetNetworkSystemClockContext(Service::PSC::Time::SystemClockContext& out_context) const;
+    Result SetRegionCode(SystemRegionCode region_code);
+    Result GetNetworkSystemClockContext(Out<Service::PSC::Time::SystemClockContext> out_context);
     Result SetNetworkSystemClockContext(const Service::PSC::Time::SystemClockContext& context);
-    Result IsUserSystemClockAutomaticCorrectionEnabled(bool& out_enabled) const;
-    Result SetUserSystemClockAutomaticCorrectionEnabled(bool enabled);
+    Result IsUserSystemClockAutomaticCorrectionEnabled(Out<bool> out_automatic_correction_enabled);
+    Result SetUserSystemClockAutomaticCorrectionEnabled(bool automatic_correction_enabled);
+    Result GetDebugModeFlag(Out<bool> is_debug_mode_enabled);
+    Result GetPrimaryAlbumStorage(Out<PrimaryAlbumStorage> out_primary_album_storage);
+    Result SetPrimaryAlbumStorage(PrimaryAlbumStorage primary_album_storage);
+    Result GetBatteryLot(Out<BatteryLot> out_battery_lot);
+    Result GetSerialNumber(Out<SerialNumber> out_console_serial);
+    Result GetNfcEnableFlag(Out<bool> out_nfc_enable_flag);
+    Result SetNfcEnableFlag(bool nfc_enable_flag);
+    Result GetSleepSettings(Out<SleepSettings> out_sleep_settings);
+    Result SetSleepSettings(SleepSettings sleep_settings);
+    Result GetWirelessLanEnableFlag(Out<bool> out_wireless_lan_enable_flag);
+    Result SetWirelessLanEnableFlag(bool wireless_lan_enable_flag);
+    Result GetInitialLaunchSettings(Out<InitialLaunchSettings> out_initial_launch_settings);
+    Result SetInitialLaunchSettings(InitialLaunchSettings initial_launch_settings);
+    Result GetDeviceNickName(
+        OutLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> out_device_name);
+    Result SetDeviceNickName(
+        InLargeData<std::array<u8, 0x80>, BufferAttr_HipcMapAlias> device_name_buffer);
+    Result GetProductModel(Out<u32> out_product_model);
+    Result GetBluetoothEnableFlag(Out<bool> out_bluetooth_enable_flag);
+    Result SetBluetoothEnableFlag(bool bluetooth_enable_flag);
+    Result GetMiiAuthorId(Out<Common::UUID> out_mii_author_id);
+    Result GetAutoUpdateEnableFlag(Out<bool> out_auto_update_enable_flag);
+    Result SetAutoUpdateEnableFlag(bool auto_update_enable_flag);
+    Result GetBatteryPercentageFlag(Out<bool> out_battery_percentage_flag);
+    Result SetBatteryPercentageFlag(bool battery_percentage_flag);
     Result SetExternalSteadyClockInternalOffset(s64 offset);
-    Result GetExternalSteadyClockInternalOffset(s64& out_offset) const;
+    Result GetExternalSteadyClockInternalOffset(Out<s64> out_offset);
+    Result GetPushNotificationActivityModeOnSleep(
+        Out<s32> out_push_notification_activity_mode_on_sleep);
+    Result SetPushNotificationActivityModeOnSleep(s32 push_notification_activity_mode_on_sleep);
+    Result GetErrorReportSharePermission(
+        Out<ErrorReportSharePermission> out_error_report_share_permission);
+    Result SetErrorReportSharePermission(ErrorReportSharePermission error_report_share_permission);
+    Result GetAppletLaunchFlags(Out<u32> out_applet_launch_flag);
+    Result SetAppletLaunchFlags(u32 applet_launch_flag);
+    Result GetKeyboardLayout(Out<KeyboardLayout> out_keyboard_layout);
+    Result SetKeyboardLayout(KeyboardLayout keyboard_layout);
     Result GetDeviceTimeZoneLocationUpdatedTime(
-        Service::PSC::Time::SteadyClockTimePoint& out_time_point) const;
+        Out<Service::PSC::Time::SteadyClockTimePoint> out_time_point);
     Result SetDeviceTimeZoneLocationUpdatedTime(
         const Service::PSC::Time::SteadyClockTimePoint& time_point);
     Result GetUserSystemClockAutomaticCorrectionUpdatedTime(
-        Service::PSC::Time::SteadyClockTimePoint& out_time_point) const;
+        Out<Service::PSC::Time::SteadyClockTimePoint> out_time_point);
     Result SetUserSystemClockAutomaticCorrectionUpdatedTime(
-        const Service::PSC::Time::SteadyClockTimePoint& time_point);
-    Result GetTouchScreenMode(TouchScreenMode& touch_screen_mode) const;
+        const Service::PSC::Time::SteadyClockTimePoint& out_time_point);
+    Result GetChineseTraditionalInputMethod(
+        Out<ChineseTraditionalInputMethod> out_chinese_traditional_input_method);
+    Result GetHomeMenuScheme(Out<HomeMenuScheme> out_home_menu_scheme);
+    Result GetHomeMenuSchemeModel(Out<u32> out_home_menu_scheme_model);
+    Result GetTouchScreenMode(Out<TouchScreenMode> out_touch_screen_mode);
     Result SetTouchScreenMode(TouchScreenMode touch_screen_mode);
+    Result GetFieldTestingFlag(Out<bool> out_field_testing_flag);
+    Result GetPanelCrcMode(Out<s32> out_panel_crc_mode);
+    Result SetPanelCrcMode(s32 panel_crc_mode);
 
 private:
-    void SetLanguageCode(HLERequestContext& ctx);
-    void GetFirmwareVersion(HLERequestContext& ctx);
-    void GetFirmwareVersion2(HLERequestContext& ctx);
-    void GetLockScreenFlag(HLERequestContext& ctx);
-    void SetLockScreenFlag(HLERequestContext& ctx);
-    void GetExternalSteadyClockSourceId(HLERequestContext& ctx);
-    void SetExternalSteadyClockSourceId(HLERequestContext& ctx);
-    void GetUserSystemClockContext(HLERequestContext& ctx);
-    void SetUserSystemClockContext(HLERequestContext& ctx);
-    void GetAccountSettings(HLERequestContext& ctx);
-    void SetAccountSettings(HLERequestContext& ctx);
-    void GetEulaVersions(HLERequestContext& ctx);
-    void SetEulaVersions(HLERequestContext& ctx);
-    void GetColorSetId(HLERequestContext& ctx);
-    void SetColorSetId(HLERequestContext& ctx);
-    void GetNotificationSettings(HLERequestContext& ctx);
-    void SetNotificationSettings(HLERequestContext& ctx);
-    void GetAccountNotificationSettings(HLERequestContext& ctx);
-    void SetAccountNotificationSettings(HLERequestContext& ctx);
-    void GetVibrationMasterVolume(HLERequestContext& ctx);
-    void SetVibrationMasterVolume(HLERequestContext& ctx);
-    void GetSettingsItemValueSize(HLERequestContext& ctx);
-    void GetSettingsItemValue(HLERequestContext& ctx);
-    void GetTvSettings(HLERequestContext& ctx);
-    void SetTvSettings(HLERequestContext& ctx);
-    void GetAudioOutputMode(HLERequestContext& ctx);
-    void SetAudioOutputMode(HLERequestContext& ctx);
-    void GetSpeakerAutoMuteFlag(HLERequestContext& ctx);
-    void SetSpeakerAutoMuteFlag(HLERequestContext& ctx);
-    void GetDebugModeFlag(HLERequestContext& ctx);
-    void GetQuestFlag(HLERequestContext& ctx);
-    void SetQuestFlag(HLERequestContext& ctx);
-    void GetDeviceTimeZoneLocationName(HLERequestContext& ctx);
-    void SetDeviceTimeZoneLocationName(HLERequestContext& ctx);
-    void SetRegionCode(HLERequestContext& ctx);
-    void GetNetworkSystemClockContext(HLERequestContext& ctx);
-    void SetNetworkSystemClockContext(HLERequestContext& ctx);
-    void IsUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx);
-    void SetUserSystemClockAutomaticCorrectionEnabled(HLERequestContext& ctx);
-    void GetPrimaryAlbumStorage(HLERequestContext& ctx);
-    void SetPrimaryAlbumStorage(HLERequestContext& ctx);
-    void GetBatteryLot(HLERequestContext& ctx);
-    void GetSerialNumber(HLERequestContext& ctx);
-    void GetNfcEnableFlag(HLERequestContext& ctx);
-    void SetNfcEnableFlag(HLERequestContext& ctx);
-    void GetSleepSettings(HLERequestContext& ctx);
-    void SetSleepSettings(HLERequestContext& ctx);
-    void GetWirelessLanEnableFlag(HLERequestContext& ctx);
-    void SetWirelessLanEnableFlag(HLERequestContext& ctx);
-    void GetInitialLaunchSettings(HLERequestContext& ctx);
-    void SetInitialLaunchSettings(HLERequestContext& ctx);
-    void GetDeviceNickName(HLERequestContext& ctx);
-    void SetDeviceNickName(HLERequestContext& ctx);
-    void GetProductModel(HLERequestContext& ctx);
-    void GetBluetoothEnableFlag(HLERequestContext& ctx);
-    void SetBluetoothEnableFlag(HLERequestContext& ctx);
-    void GetMiiAuthorId(HLERequestContext& ctx);
-    void GetAutoUpdateEnableFlag(HLERequestContext& ctx);
-    void SetAutoUpdateEnableFlag(HLERequestContext& ctx);
-    void GetBatteryPercentageFlag(HLERequestContext& ctx);
-    void SetBatteryPercentageFlag(HLERequestContext& ctx);
-    void SetExternalSteadyClockInternalOffset(HLERequestContext& ctx);
-    void GetExternalSteadyClockInternalOffset(HLERequestContext& ctx);
-    void GetPushNotificationActivityModeOnSleep(HLERequestContext& ctx);
-    void SetPushNotificationActivityModeOnSleep(HLERequestContext& ctx);
-    void GetErrorReportSharePermission(HLERequestContext& ctx);
-    void SetErrorReportSharePermission(HLERequestContext& ctx);
-    void GetAppletLaunchFlags(HLERequestContext& ctx);
-    void SetAppletLaunchFlags(HLERequestContext& ctx);
-    void GetKeyboardLayout(HLERequestContext& ctx);
-    void SetKeyboardLayout(HLERequestContext& ctx);
-    void GetDeviceTimeZoneLocationUpdatedTime(HLERequestContext& ctx);
-    void SetDeviceTimeZoneLocationUpdatedTime(HLERequestContext& ctx);
-    void GetUserSystemClockAutomaticCorrectionUpdatedTime(HLERequestContext& ctx);
-    void SetUserSystemClockAutomaticCorrectionUpdatedTime(HLERequestContext& ctx);
-    void GetChineseTraditionalInputMethod(HLERequestContext& ctx);
-    void GetHomeMenuScheme(HLERequestContext& ctx);
-    void GetHomeMenuSchemeModel(HLERequestContext& ctx);
-    void GetTouchScreenMode(HLERequestContext& ctx);
-    void SetTouchScreenMode(HLERequestContext& ctx);
-    void GetFieldTestingFlag(HLERequestContext& ctx);
-    void GetPanelCrcMode(HLERequestContext& ctx);
-    void SetPanelCrcMode(HLERequestContext& ctx);
-
     bool LoadSettingsFile(std::filesystem::path& path, auto&& default_func);
     bool StoreSettingsFile(std::filesystem::path& path, auto& settings);
     void SetupSettings();

src/core/hle/service/vi/application_display_service.cpp

@@ -0,0 +1,319 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
+#include "core/hle/service/nvnflinger/parcel.h"
+#include "core/hle/service/vi/application_display_service.h"
+#include "core/hle/service/vi/hos_binder_driver.h"
+#include "core/hle/service/vi/manager_display_service.h"
+#include "core/hle/service/vi/system_display_service.h"
+#include "core/hle/service/vi/vi_results.h"
+
+namespace Service::VI {
+
+IApplicationDisplayService::IApplicationDisplayService(
+    Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server)
+    : ServiceFramework{system_, "IApplicationDisplayService"}, m_nvnflinger{nvnflinger},
+      m_hos_binder_driver_server{hos_binder_driver_server} {
+
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {100, C<&IApplicationDisplayService::GetRelayService>, "GetRelayService"},
+        {101, C<&IApplicationDisplayService::GetSystemDisplayService>, "GetSystemDisplayService"},
+        {102, C<&IApplicationDisplayService::GetManagerDisplayService>, "GetManagerDisplayService"},
+        {103, C<&IApplicationDisplayService::GetIndirectDisplayTransactionService>, "GetIndirectDisplayTransactionService"},
+        {1000, C<&IApplicationDisplayService::ListDisplays>, "ListDisplays"},
+        {1010, C<&IApplicationDisplayService::OpenDisplay>, "OpenDisplay"},
+        {1011, C<&IApplicationDisplayService::OpenDefaultDisplay>, "OpenDefaultDisplay"},
+        {1020, C<&IApplicationDisplayService::CloseDisplay>, "CloseDisplay"},
+        {1101, C<&IApplicationDisplayService::SetDisplayEnabled>, "SetDisplayEnabled"},
+        {1102, C<&IApplicationDisplayService::GetDisplayResolution>, "GetDisplayResolution"},
+        {2020, C<&IApplicationDisplayService::OpenLayer>, "OpenLayer"},
+        {2021, C<&IApplicationDisplayService::CloseLayer>, "CloseLayer"},
+        {2030, C<&IApplicationDisplayService::CreateStrayLayer>, "CreateStrayLayer"},
+        {2031, C<&IApplicationDisplayService::DestroyStrayLayer>, "DestroyStrayLayer"},
+        {2101, C<&IApplicationDisplayService::SetLayerScalingMode>, "SetLayerScalingMode"},
+        {2102, C<&IApplicationDisplayService::ConvertScalingMode>, "ConvertScalingMode"},
+        {2450, C<&IApplicationDisplayService::GetIndirectLayerImageMap>, "GetIndirectLayerImageMap"},
+        {2451, nullptr, "GetIndirectLayerImageCropMap"},
+        {2460, C<&IApplicationDisplayService::GetIndirectLayerImageRequiredMemoryInfo>, "GetIndirectLayerImageRequiredMemoryInfo"},
+        {5202, C<&IApplicationDisplayService::GetDisplayVsyncEvent>, "GetDisplayVsyncEvent"},
+        {5203, nullptr, "GetDisplayVsyncEventForDebug"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IApplicationDisplayService::~IApplicationDisplayService() {
+    for (const auto layer_id : m_stray_layer_ids) {
+        m_nvnflinger.DestroyLayer(layer_id);
+    }
+}
+
+Result IApplicationDisplayService::GetRelayService(
+    Out<SharedPointer<IHOSBinderDriver>> out_relay_service) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    *out_relay_service = std::make_shared<IHOSBinderDriver>(system, m_hos_binder_driver_server);
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::GetSystemDisplayService(
+    Out<SharedPointer<ISystemDisplayService>> out_system_display_service) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    *out_system_display_service = std::make_shared<ISystemDisplayService>(system, m_nvnflinger);
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::GetManagerDisplayService(
+    Out<SharedPointer<IManagerDisplayService>> out_manager_display_service) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    *out_manager_display_service = std::make_shared<IManagerDisplayService>(system, m_nvnflinger);
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::GetIndirectDisplayTransactionService(
+    Out<SharedPointer<IHOSBinderDriver>> out_indirect_display_transaction_service) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+    *out_indirect_display_transaction_service =
+        std::make_shared<IHOSBinderDriver>(system, m_hos_binder_driver_server);
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::OpenDisplay(Out<u64> out_display_id, DisplayName display_name) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+
+    display_name[display_name.size() - 1] = '\0';
+    ASSERT_MSG(strcmp(display_name.data(), "Default") == 0,
+               "Non-default displays aren't supported yet");
+
+    const auto display_id = m_nvnflinger.OpenDisplay(display_name.data());
+    if (!display_id) {
+        LOG_ERROR(Service_VI, "Display not found! display_name={}", display_name.data());
+        R_THROW(VI::ResultNotFound);
+    }
+
+    *out_display_id = *display_id;
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::OpenDefaultDisplay(Out<u64> out_display_id) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(this->OpenDisplay(out_display_id, DisplayName{"Default"}));
+}
+
+Result IApplicationDisplayService::CloseDisplay(u64 display_id) {
+    LOG_DEBUG(Service_VI, "called");
+    R_SUCCEED_IF(m_nvnflinger.CloseDisplay(display_id));
+    R_THROW(ResultUnknown);
+}
+
+Result IApplicationDisplayService::SetDisplayEnabled(u32 state, u64 display_id) {
+    LOG_DEBUG(Service_VI, "called");
+
+    // This literally does nothing internally in the actual service itself,
+    // and just returns a successful result code regardless of the input.
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::GetDisplayResolution(Out<s64> out_width, Out<s64> out_height,
+                                                        u64 display_id) {
+    LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
+
+    // This only returns the fixed values of 1280x720 and makes no distinguishing
+    // between docked and undocked dimensions.
+    *out_width = static_cast<s64>(DisplayResolution::UndockedWidth);
+    *out_height = static_cast<s64>(DisplayResolution::UndockedHeight);
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::SetLayerScalingMode(NintendoScaleMode scale_mode, u64 layer_id) {
+    LOG_DEBUG(Service_VI, "called. scale_mode={}, unknown=0x{:016X}", scale_mode, layer_id);
+
+    if (scale_mode > NintendoScaleMode::PreserveAspectRatio) {
+        LOG_ERROR(Service_VI, "Invalid scaling mode provided.");
+        R_THROW(VI::ResultOperationFailed);
+    }
+
+    if (scale_mode != NintendoScaleMode::ScaleToWindow &&
+        scale_mode != NintendoScaleMode::PreserveAspectRatio) {
+        LOG_ERROR(Service_VI, "Unsupported scaling mode supplied.");
+        R_THROW(VI::ResultNotSupported);
+    }
+
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::ListDisplays(
+    Out<u64> out_count, OutArray<DisplayInfo, BufferAttr_HipcMapAlias> out_displays) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+
+    if (out_displays.size() > 0) {
+        out_displays[0] = DisplayInfo{};
+        *out_count = 1;
+    } else {
+        *out_count = 0;
+    }
+
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::OpenLayer(Out<u64> out_size,
+                                             OutBuffer<BufferAttr_HipcMapAlias> out_native_window,
+                                             DisplayName display_name, u64 layer_id,
+                                             ClientAppletResourceUserId aruid) {
+    display_name[display_name.size() - 1] = '\0';
+
+    LOG_DEBUG(Service_VI, "called. layer_id={}, aruid={:#x}", layer_id, aruid.pid);
+
+    const auto display_id = m_nvnflinger.OpenDisplay(display_name.data());
+    if (!display_id) {
+        LOG_ERROR(Service_VI, "Layer not found! layer_id={}", layer_id);
+        R_THROW(VI::ResultNotFound);
+    }
+
+    const auto buffer_queue_id = m_nvnflinger.FindBufferQueueId(*display_id, layer_id);
+    if (!buffer_queue_id) {
+        LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", *display_id);
+        R_THROW(VI::ResultNotFound);
+    }
+
+    if (!m_nvnflinger.OpenLayer(layer_id)) {
+        LOG_WARNING(Service_VI, "Tried to open layer which was already open");
+        R_THROW(VI::ResultOperationFailed);
+    }
+
+    android::OutputParcel parcel;
+    parcel.WriteInterface(NativeWindow{*buffer_queue_id});
+
+    const auto buffer = parcel.Serialize();
+    std::memcpy(out_native_window.data(), buffer.data(),
+                std::min(out_native_window.size(), buffer.size()));
+    *out_size = buffer.size();
+
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::CloseLayer(u64 layer_id) {
+    LOG_DEBUG(Service_VI, "called. layer_id={}", layer_id);
+
+    if (!m_nvnflinger.CloseLayer(layer_id)) {
+        LOG_WARNING(Service_VI, "Tried to close layer which was not open");
+        R_THROW(VI::ResultOperationFailed);
+    }
+
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::CreateStrayLayer(
+    Out<u64> out_layer_id, Out<u64> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_native_window,
+    u32 flags, u64 display_id) {
+    LOG_DEBUG(Service_VI, "called. flags={}, display_id={}", flags, display_id);
+
+    const auto layer_id = m_nvnflinger.CreateLayer(display_id);
+    if (!layer_id) {
+        LOG_ERROR(Service_VI, "Layer not found! display_id={}", display_id);
+        R_THROW(VI::ResultNotFound);
+    }
+
+    m_stray_layer_ids.push_back(*layer_id);
+    const auto buffer_queue_id = m_nvnflinger.FindBufferQueueId(display_id, *layer_id);
+    if (!buffer_queue_id) {
+        LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", display_id);
+        R_THROW(VI::ResultNotFound);
+    }
+
+    android::OutputParcel parcel;
+    parcel.WriteInterface(NativeWindow{*buffer_queue_id});
+
+    const auto buffer = parcel.Serialize();
+    std::memcpy(out_native_window.data(), buffer.data(),
+                std::min(out_native_window.size(), buffer.size()));
+
+    *out_layer_id = *layer_id;
+    *out_size = buffer.size();
+
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::DestroyStrayLayer(u64 layer_id) {
+    LOG_WARNING(Service_VI, "(STUBBED) called. layer_id={}", layer_id);
+    m_nvnflinger.DestroyLayer(layer_id);
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::GetDisplayVsyncEvent(
+    OutCopyHandle<Kernel::KReadableEvent> out_vsync_event, u64 display_id) {
+    LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
+
+    const auto result = m_nvnflinger.FindVsyncEvent(out_vsync_event, display_id);
+    if (result != ResultSuccess) {
+        if (result == ResultNotFound) {
+            LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
+        }
+
+        R_THROW(result);
+    }
+
+    R_UNLESS(!m_vsync_event_fetched, VI::ResultPermissionDenied);
+    m_vsync_event_fetched = true;
+
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::ConvertScalingMode(Out<ConvertedScaleMode> out_scaling_mode,
+                                                      NintendoScaleMode mode) {
+    LOG_DEBUG(Service_VI, "called mode={}", mode);
+
+    switch (mode) {
+    case NintendoScaleMode::None:
+        *out_scaling_mode = ConvertedScaleMode::None;
+        R_SUCCEED();
+    case NintendoScaleMode::Freeze:
+        *out_scaling_mode = ConvertedScaleMode::Freeze;
+        R_SUCCEED();
+    case NintendoScaleMode::ScaleToWindow:
+        *out_scaling_mode = ConvertedScaleMode::ScaleToWindow;
+        R_SUCCEED();
+    case NintendoScaleMode::ScaleAndCrop:
+        *out_scaling_mode = ConvertedScaleMode::ScaleAndCrop;
+        R_SUCCEED();
+    case NintendoScaleMode::PreserveAspectRatio:
+        *out_scaling_mode = ConvertedScaleMode::PreserveAspectRatio;
+        R_SUCCEED();
+    default:
+        LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
+        R_THROW(VI::ResultOperationFailed);
+    }
+}
+
+Result IApplicationDisplayService::GetIndirectLayerImageMap(
+    Out<u64> out_size, Out<u64> out_stride,
+    OutBuffer<BufferAttr_HipcMapTransferAllowsNonSecure | BufferAttr_HipcMapAlias> out_buffer,
+    s64 width, s64 height, u64 indirect_layer_consumer_handle, ClientAppletResourceUserId aruid) {
+    LOG_WARNING(
+        Service_VI,
+        "(STUBBED) called, width={}, height={}, indirect_layer_consumer_handle={}, aruid={:#x}",
+        width, height, indirect_layer_consumer_handle, aruid.pid);
+    *out_size = 0;
+    *out_stride = 0;
+    R_SUCCEED();
+}
+
+Result IApplicationDisplayService::GetIndirectLayerImageRequiredMemoryInfo(Out<s64> out_size,
+                                                                           Out<s64> out_alignment,
+                                                                           s64 width, s64 height) {
+    LOG_DEBUG(Service_VI, "called width={}, height={}", width, height);
+
+    constexpr u64 base_size = 0x20000;
+    const auto texture_size = width * height * 4;
+
+    *out_alignment = 0x1000;
+    *out_size = (texture_size + base_size - 1) / base_size * base_size;
+
+    R_SUCCEED();
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/application_display_service.h

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/vi/vi_types.h"
+
+namespace Kernel {
+class KReadableEvent;
+}
+
+namespace Service::VI {
+
+class IHOSBinderDriver;
+class IManagerDisplayService;
+class ISystemDisplayService;
+
+class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
+public:
+    IApplicationDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+                               Nvnflinger::HosBinderDriverServer& hos_binder_driver_server);
+    ~IApplicationDisplayService() override;
+
+private:
+    Result GetRelayService(Out<SharedPointer<IHOSBinderDriver>> out_relay_service);
+    Result GetSystemDisplayService(
+        Out<SharedPointer<ISystemDisplayService>> out_system_display_service);
+    Result GetManagerDisplayService(
+        Out<SharedPointer<IManagerDisplayService>> out_manager_display_service);
+    Result GetIndirectDisplayTransactionService(
+        Out<SharedPointer<IHOSBinderDriver>> out_indirect_display_transaction_service);
+    Result OpenDisplay(Out<u64> out_display_id, DisplayName display_name);
+    Result OpenDefaultDisplay(Out<u64> out_display_id);
+    Result CloseDisplay(u64 display_id);
+    Result SetDisplayEnabled(u32 state, u64 display_id);
+    Result GetDisplayResolution(Out<s64> out_width, Out<s64> out_height, u64 display_id);
+    Result SetLayerScalingMode(NintendoScaleMode scale_mode, u64 layer_id);
+    Result ListDisplays(Out<u64> out_count,
+                        OutArray<DisplayInfo, BufferAttr_HipcMapAlias> out_displays);
+    Result OpenLayer(Out<u64> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_native_window,
+                     DisplayName display_name, u64 layer_id, ClientAppletResourceUserId aruid);
+    Result CloseLayer(u64 layer_id);
+    Result CreateStrayLayer(Out<u64> out_layer_id, Out<u64> out_size,
+                            OutBuffer<BufferAttr_HipcMapAlias> out_native_window, u32 flags,
+                            u64 display_id);
+    Result DestroyStrayLayer(u64 layer_id);
+    Result GetDisplayVsyncEvent(OutCopyHandle<Kernel::KReadableEvent> out_vsync_event,
+                                u64 display_id);
+    Result ConvertScalingMode(Out<ConvertedScaleMode> out_scaling_mode, NintendoScaleMode mode);
+    Result GetIndirectLayerImageMap(
+        Out<u64> out_size, Out<u64> out_stride,
+        OutBuffer<BufferAttr_HipcMapTransferAllowsNonSecure | BufferAttr_HipcMapAlias> out_buffer,
+        s64 width, s64 height, u64 indirect_layer_consumer_handle,
+        ClientAppletResourceUserId aruid);
+    Result GetIndirectLayerImageRequiredMemoryInfo(Out<s64> out_size, Out<s64> out_alignment,
+                                                   s64 width, s64 height);
+
+private:
+    Nvnflinger::Nvnflinger& m_nvnflinger;
+    Nvnflinger::HosBinderDriverServer& m_hos_binder_driver_server;
+    std::vector<u64> m_stray_layer_ids;
+    bool m_vsync_event_fetched{false};
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/application_root_service.cpp

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/vi/application_display_service.h"
+#include "core/hle/service/vi/application_root_service.h"
+#include "core/hle/service/vi/service_creator.h"
+#include "core/hle/service/vi/vi.h"
+#include "core/hle/service/vi/vi_types.h"
+
+namespace Service::VI {
+
+IApplicationRootService::IApplicationRootService(
+    Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server)
+    : ServiceFramework{system_, "vi:u"}, m_nvnflinger{nvnflinger}, m_hos_binder_driver_server{
+                                                                       hos_binder_driver_server} {
+    static const FunctionInfo functions[] = {
+        {0, C<&IApplicationRootService::GetDisplayService>, "GetDisplayService"},
+        {1, nullptr, "GetDisplayServiceWithProxyNameExchange"},
+    };
+    RegisterHandlers(functions);
+}
+
+IApplicationRootService::~IApplicationRootService() = default;
+
+Result IApplicationRootService::GetDisplayService(
+    Out<SharedPointer<IApplicationDisplayService>> out_application_display_service, Policy policy) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(GetApplicationDisplayService(out_application_display_service, system, m_nvnflinger,
+                                          m_hos_binder_driver_server, Permission::User, policy));
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/application_root_service.h

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Nvnflinger {
+class HosBinderDriverServer;
+class Nvnflinger;
+} // namespace Service::Nvnflinger
+
+namespace Service::VI {
+
+class IApplicationDisplayService;
+enum class Policy : u32;
+
+class IApplicationRootService final : public ServiceFramework<IApplicationRootService> {
+public:
+    explicit IApplicationRootService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+                                     Nvnflinger::HosBinderDriverServer& hos_binder_driver_server);
+    ~IApplicationRootService() override;
+
+private:
+    Result GetDisplayService(
+        Out<SharedPointer<IApplicationDisplayService>> out_application_display_service,
+        Policy policy);
+
+private:
+    Nvnflinger::Nvnflinger& m_nvnflinger;
+    Nvnflinger::HosBinderDriverServer& m_hos_binder_driver_server;
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/hos_binder_driver.cpp

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/nvnflinger/binder.h"
+#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
+#include "core/hle/service/vi/hos_binder_driver.h"
+
+namespace Service::VI {
+
+IHOSBinderDriver::IHOSBinderDriver(Core::System& system_, Nvnflinger::HosBinderDriverServer& server)
+    : ServiceFramework{system_, "IHOSBinderDriver"}, m_server(server) {
+    static const FunctionInfo functions[] = {
+        {0, C<&IHOSBinderDriver::TransactParcel>, "TransactParcel"},
+        {1, C<&IHOSBinderDriver::AdjustRefcount>, "AdjustRefcount"},
+        {2, C<&IHOSBinderDriver::GetNativeHandle>, "GetNativeHandle"},
+        {3, C<&IHOSBinderDriver::TransactParcelAuto>, "TransactParcelAuto"},
+    };
+    RegisterHandlers(functions);
+}
+
+IHOSBinderDriver::~IHOSBinderDriver() = default;
+
+Result IHOSBinderDriver::TransactParcel(s32 binder_id, android::TransactionId transaction_id,
+                                        InBuffer<BufferAttr_HipcMapAlias> parcel_data,
+                                        OutBuffer<BufferAttr_HipcMapAlias> parcel_reply,
+                                        u32 flags) {
+    LOG_DEBUG(Service_VI, "called. id={} transaction={}, flags={}", binder_id, transaction_id,
+              flags);
+    m_server.TryGetProducer(binder_id)->Transact(transaction_id, flags, parcel_data, parcel_reply);
+    R_SUCCEED();
+}
+
+Result IHOSBinderDriver::AdjustRefcount(s32 binder_id, s32 addval, s32 type) {
+    LOG_WARNING(Service_VI, "(STUBBED) called id={}, addval={}, type={}", binder_id, addval, type);
+    R_SUCCEED();
+}
+
+Result IHOSBinderDriver::GetNativeHandle(s32 binder_id, u32 type_id,
+                                         OutCopyHandle<Kernel::KReadableEvent> out_handle) {
+    LOG_WARNING(Service_VI, "(STUBBED) called id={}, type_id={}", binder_id, type_id);
+    *out_handle = &m_server.TryGetProducer(binder_id)->GetNativeHandle();
+    R_SUCCEED();
+}
+
+Result IHOSBinderDriver::TransactParcelAuto(s32 binder_id, android::TransactionId transaction_id,
+                                            InBuffer<BufferAttr_HipcAutoSelect> parcel_data,
+                                            OutBuffer<BufferAttr_HipcAutoSelect> parcel_reply,
+                                            u32 flags) {
+    R_RETURN(this->TransactParcel(binder_id, transaction_id, parcel_data, parcel_reply, flags));
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/hos_binder_driver.h

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/nvnflinger/binder.h"
+#include "core/hle/service/service.h"
+
+namespace Service::VI {
+
+class IHOSBinderDriver final : public ServiceFramework<IHOSBinderDriver> {
+public:
+    explicit IHOSBinderDriver(Core::System& system_, Nvnflinger::HosBinderDriverServer& server);
+    ~IHOSBinderDriver() override;
+
+private:
+    Result TransactParcel(s32 binder_id, android::TransactionId transaction_id,
+                          InBuffer<BufferAttr_HipcMapAlias> parcel_data,
+                          OutBuffer<BufferAttr_HipcMapAlias> parcel_reply, u32 flags);
+    Result AdjustRefcount(s32 binder_id, s32 addval, s32 type);
+    Result GetNativeHandle(s32 binder_id, u32 type_id,
+                           OutCopyHandle<Kernel::KReadableEvent> out_handle);
+    Result TransactParcelAuto(s32 binder_id, android::TransactionId transaction_id,
+                              InBuffer<BufferAttr_HipcAutoSelect> parcel_data,
+                              OutBuffer<BufferAttr_HipcAutoSelect> parcel_reply, u32 flags);
+
+private:
+    Nvnflinger::HosBinderDriverServer& m_server;
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/manager_display_service.cpp

@@ -0,0 +1,130 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
+#include "core/hle/service/vi/manager_display_service.h"
+#include "core/hle/service/vi/vi_results.h"
+
+namespace Service::VI {
+
+IManagerDisplayService::IManagerDisplayService(Core::System& system_,
+                                               Nvnflinger::Nvnflinger& nvnflinger)
+    : ServiceFramework{system_, "IManagerDisplayService"}, m_nvnflinger{nvnflinger} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {200, nullptr, "AllocateProcessHeapBlock"},
+        {201, nullptr, "FreeProcessHeapBlock"},
+        {1102, nullptr, "GetDisplayResolution"},
+        {2010, C<&IManagerDisplayService::CreateManagedLayer>, "CreateManagedLayer"},
+        {2011, nullptr, "DestroyManagedLayer"},
+        {2012, nullptr, "CreateStrayLayer"},
+        {2050, nullptr, "CreateIndirectLayer"},
+        {2051, nullptr, "DestroyIndirectLayer"},
+        {2052, nullptr, "CreateIndirectProducerEndPoint"},
+        {2053, nullptr, "DestroyIndirectProducerEndPoint"},
+        {2054, nullptr, "CreateIndirectConsumerEndPoint"},
+        {2055, nullptr, "DestroyIndirectConsumerEndPoint"},
+        {2060, nullptr, "CreateWatermarkCompositor"},
+        {2062, nullptr, "SetWatermarkText"},
+        {2063, nullptr, "SetWatermarkLayerStacks"},
+        {2300, nullptr, "AcquireLayerTexturePresentingEvent"},
+        {2301, nullptr, "ReleaseLayerTexturePresentingEvent"},
+        {2302, nullptr, "GetDisplayHotplugEvent"},
+        {2303, nullptr, "GetDisplayModeChangedEvent"},
+        {2402, nullptr, "GetDisplayHotplugState"},
+        {2501, nullptr, "GetCompositorErrorInfo"},
+        {2601, nullptr, "GetDisplayErrorEvent"},
+        {2701, nullptr, "GetDisplayFatalErrorEvent"},
+        {4201, nullptr, "SetDisplayAlpha"},
+        {4203, nullptr, "SetDisplayLayerStack"},
+        {4205, nullptr, "SetDisplayPowerState"},
+        {4206, nullptr, "SetDefaultDisplay"},
+        {4207, nullptr, "ResetDisplayPanel"},
+        {4208, nullptr, "SetDisplayFatalErrorEnabled"},
+        {4209, nullptr, "IsDisplayPanelOn"},
+        {4300, nullptr, "GetInternalPanelId"},
+        {6000, C<&IManagerDisplayService::AddToLayerStack>, "AddToLayerStack"},
+        {6001, nullptr, "RemoveFromLayerStack"},
+        {6002, C<&IManagerDisplayService::SetLayerVisibility>, "SetLayerVisibility"},
+        {6003, nullptr, "SetLayerConfig"},
+        {6004, nullptr, "AttachLayerPresentationTracer"},
+        {6005, nullptr, "DetachLayerPresentationTracer"},
+        {6006, nullptr, "StartLayerPresentationRecording"},
+        {6007, nullptr, "StopLayerPresentationRecording"},
+        {6008, nullptr, "StartLayerPresentationFenceWait"},
+        {6009, nullptr, "StopLayerPresentationFenceWait"},
+        {6010, nullptr, "GetLayerPresentationAllFencesExpiredEvent"},
+        {6011, nullptr, "EnableLayerAutoClearTransitionBuffer"},
+        {6012, nullptr, "DisableLayerAutoClearTransitionBuffer"},
+        {6013, nullptr, "SetLayerOpacity"},
+        {6014, nullptr, "AttachLayerWatermarkCompositor"},
+        {6015, nullptr, "DetachLayerWatermarkCompositor"},
+        {7000, nullptr, "SetContentVisibility"},
+        {8000, nullptr, "SetConductorLayer"},
+        {8001, nullptr, "SetTimestampTracking"},
+        {8100, nullptr, "SetIndirectProducerFlipOffset"},
+        {8200, nullptr, "CreateSharedBufferStaticStorage"},
+        {8201, nullptr, "CreateSharedBufferTransferMemory"},
+        {8202, nullptr, "DestroySharedBuffer"},
+        {8203, nullptr, "BindSharedLowLevelLayerToManagedLayer"},
+        {8204, nullptr, "BindSharedLowLevelLayerToIndirectLayer"},
+        {8207, nullptr, "UnbindSharedLowLevelLayer"},
+        {8208, nullptr, "ConnectSharedLowLevelLayerToSharedBuffer"},
+        {8209, nullptr, "DisconnectSharedLowLevelLayerFromSharedBuffer"},
+        {8210, nullptr, "CreateSharedLayer"},
+        {8211, nullptr, "DestroySharedLayer"},
+        {8216, nullptr, "AttachSharedLayerToLowLevelLayer"},
+        {8217, nullptr, "ForceDetachSharedLayerFromLowLevelLayer"},
+        {8218, nullptr, "StartDetachSharedLayerFromLowLevelLayer"},
+        {8219, nullptr, "FinishDetachSharedLayerFromLowLevelLayer"},
+        {8220, nullptr, "GetSharedLayerDetachReadyEvent"},
+        {8221, nullptr, "GetSharedLowLevelLayerSynchronizedEvent"},
+        {8222, nullptr, "CheckSharedLowLevelLayerSynchronized"},
+        {8223, nullptr, "RegisterSharedBufferImporterAruid"},
+        {8224, nullptr, "UnregisterSharedBufferImporterAruid"},
+        {8227, nullptr, "CreateSharedBufferProcessHeap"},
+        {8228, nullptr, "GetSharedLayerLayerStacks"},
+        {8229, nullptr, "SetSharedLayerLayerStacks"},
+        {8291, nullptr, "PresentDetachedSharedFrameBufferToLowLevelLayer"},
+        {8292, nullptr, "FillDetachedSharedFrameBufferColor"},
+        {8293, nullptr, "GetDetachedSharedFrameBufferImage"},
+        {8294, nullptr, "SetDetachedSharedFrameBufferImage"},
+        {8295, nullptr, "CopyDetachedSharedFrameBufferImage"},
+        {8296, nullptr, "SetDetachedSharedFrameBufferSubImage"},
+        {8297, nullptr, "GetSharedFrameBufferContentParameter"},
+        {8298, nullptr, "ExpandStartupLogoOnSharedFrameBuffer"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IManagerDisplayService::~IManagerDisplayService() = default;
+
+Result IManagerDisplayService::CreateManagedLayer(Out<u64> out_layer_id, u32 unknown,
+                                                  u64 display_id, AppletResourceUserId aruid) {
+    LOG_WARNING(Service_VI, "(STUBBED) called. unknown={}, display={}, aruid={}", unknown,
+                display_id, aruid.pid);
+
+    const auto layer_id = m_nvnflinger.CreateLayer(display_id);
+    if (!layer_id) {
+        LOG_ERROR(Service_VI, "Layer not found! display={}", display_id);
+        R_THROW(VI::ResultNotFound);
+    }
+
+    *out_layer_id = *layer_id;
+    R_SUCCEED();
+}
+
+Result IManagerDisplayService::AddToLayerStack(u32 stack_id, u64 layer_id) {
+    LOG_WARNING(Service_VI, "(STUBBED) called. stack_id={}, layer_id={}", stack_id, layer_id);
+    R_SUCCEED();
+}
+
+Result IManagerDisplayService::SetLayerVisibility(bool visible, u64 layer_id) {
+    LOG_WARNING(Service_VI, "(STUBBED) called, layer_id={}, visible={}", layer_id, visible);
+    R_SUCCEED();
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/manager_display_service.h

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Service::VI {
+
+class IManagerDisplayService final : public ServiceFramework<IManagerDisplayService> {
+public:
+    explicit IManagerDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger);
+    ~IManagerDisplayService() override;
+
+private:
+    Result CreateManagedLayer(Out<u64> out_layer_id, u32 unknown, u64 display_id,
+                              AppletResourceUserId aruid);
+    Result AddToLayerStack(u32 stack_id, u64 layer_id);
+    Result SetLayerVisibility(bool visible, u64 layer_id);
+
+private:
+    Nvnflinger::Nvnflinger& m_nvnflinger;
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/manager_root_service.cpp

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/vi/application_display_service.h"
+#include "core/hle/service/vi/manager_root_service.h"
+#include "core/hle/service/vi/service_creator.h"
+#include "core/hle/service/vi/vi.h"
+#include "core/hle/service/vi/vi_types.h"
+
+namespace Service::VI {
+
+IManagerRootService::IManagerRootService(
+    Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server)
+    : ServiceFramework{system_, "vi:m"}, m_nvnflinger{nvnflinger}, m_hos_binder_driver_server{
+                                                                       hos_binder_driver_server} {
+    static const FunctionInfo functions[] = {
+        {2, C<&IManagerRootService::GetDisplayService>, "GetDisplayService"},
+        {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},
+        {100, nullptr, "PrepareFatal"},
+        {101, nullptr, "ShowFatal"},
+        {102, nullptr, "DrawFatalRectangle"},
+        {103, nullptr, "DrawFatalText32"},
+    };
+    RegisterHandlers(functions);
+}
+
+IManagerRootService::~IManagerRootService() = default;
+
+Result IManagerRootService::GetDisplayService(
+    Out<SharedPointer<IApplicationDisplayService>> out_application_display_service, Policy policy) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(GetApplicationDisplayService(out_application_display_service, system, m_nvnflinger,
+                                          m_hos_binder_driver_server, Permission::Manager, policy));
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/manager_root_service.h

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Nvnflinger {
+class HosBinderDriverServer;
+class Nvnflinger;
+} // namespace Service::Nvnflinger
+
+namespace Service::VI {
+
+class IApplicationDisplayService;
+enum class Policy : u32;
+
+class IManagerRootService final : public ServiceFramework<IManagerRootService> {
+public:
+    explicit IManagerRootService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+                                 Nvnflinger::HosBinderDriverServer& hos_binder_driver_server);
+    ~IManagerRootService() override;
+
+private:
+    Result GetDisplayService(
+        Out<SharedPointer<IApplicationDisplayService>> out_application_display_service,
+        Policy policy);
+
+    Nvnflinger::Nvnflinger& m_nvnflinger;
+    Nvnflinger::HosBinderDriverServer& m_hos_binder_driver_server;
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/service_creator.cpp

@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/vi/application_display_service.h"
+#include "core/hle/service/vi/service_creator.h"
+#include "core/hle/service/vi/vi_results.h"
+#include "core/hle/service/vi/vi_types.h"
+
+namespace Service::VI {
+
+static bool IsValidServiceAccess(Permission permission, Policy policy) {
+    if (permission == Permission::User) {
+        return policy == Policy::User;
+    }
+
+    if (permission == Permission::System || permission == Permission::Manager) {
+        return policy == Policy::User || policy == Policy::Compositor;
+    }
+
+    return false;
+}
+
+Result GetApplicationDisplayService(
+    std::shared_ptr<IApplicationDisplayService>* out_application_display_service,
+    Core::System& system, Nvnflinger::Nvnflinger& nvnflinger,
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server, Permission permission,
+    Policy policy) {
+
+    if (!IsValidServiceAccess(permission, policy)) {
+        LOG_ERROR(Service_VI, "Permission denied for policy {}", policy);
+        R_THROW(ResultPermissionDenied);
+    }
+
+    *out_application_display_service =
+        std::make_shared<IApplicationDisplayService>(system, nvnflinger, hos_binder_driver_server);
+    R_SUCCEED();
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/service_creator.h

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Nvnflinger {
+class HosBinderDriverServer;
+class Nvnflinger;
+} // namespace Service::Nvnflinger
+
+union Result;
+
+namespace Service::VI {
+
+class IApplicationDisplayService;
+enum class Permission;
+enum class Policy : u32;
+
+Result GetApplicationDisplayService(
+    std::shared_ptr<IApplicationDisplayService>* out_application_display_service,
+    Core::System& system, Nvnflinger::Nvnflinger& nvnflinger,
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server, Permission permission,
+    Policy policy);
+
+} // namespace Service::VI

src/core/hle/service/vi/system_display_service.cpp

@@ -0,0 +1,145 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/settings.h"
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/nvnflinger/fb_share_buffer_manager.h"
+#include "core/hle/service/vi/system_display_service.h"
+#include "core/hle/service/vi/vi_types.h"
+
+namespace Service::VI {
+
+ISystemDisplayService::ISystemDisplayService(Core::System& system_,
+                                             Nvnflinger::Nvnflinger& nvnflinger)
+    : ServiceFramework{system_, "ISystemDisplayService"}, m_nvnflinger{nvnflinger} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {1200, nullptr, "GetZOrderCountMin"},
+        {1202, nullptr, "GetZOrderCountMax"},
+        {1203, nullptr, "GetDisplayLogicalResolution"},
+        {1204, nullptr, "SetDisplayMagnification"},
+        {2201, nullptr, "SetLayerPosition"},
+        {2203, nullptr, "SetLayerSize"},
+        {2204, nullptr, "GetLayerZ"},
+        {2205, C<&ISystemDisplayService::SetLayerZ>, "SetLayerZ"},
+        {2207, C<&ISystemDisplayService::SetLayerVisibility>, "SetLayerVisibility"},
+        {2209, nullptr, "SetLayerAlpha"},
+        {2210, nullptr, "SetLayerPositionAndSize"},
+        {2312, nullptr, "CreateStrayLayer"},
+        {2400, nullptr, "OpenIndirectLayer"},
+        {2401, nullptr, "CloseIndirectLayer"},
+        {2402, nullptr, "FlipIndirectLayer"},
+        {3000, nullptr, "ListDisplayModes"},
+        {3001, nullptr, "ListDisplayRgbRanges"},
+        {3002, nullptr, "ListDisplayContentTypes"},
+        {3200, C<&ISystemDisplayService::GetDisplayMode>, "GetDisplayMode"},
+        {3201, nullptr, "SetDisplayMode"},
+        {3202, nullptr, "GetDisplayUnderscan"},
+        {3203, nullptr, "SetDisplayUnderscan"},
+        {3204, nullptr, "GetDisplayContentType"},
+        {3205, nullptr, "SetDisplayContentType"},
+        {3206, nullptr, "GetDisplayRgbRange"},
+        {3207, nullptr, "SetDisplayRgbRange"},
+        {3208, nullptr, "GetDisplayCmuMode"},
+        {3209, nullptr, "SetDisplayCmuMode"},
+        {3210, nullptr, "GetDisplayContrastRatio"},
+        {3211, nullptr, "SetDisplayContrastRatio"},
+        {3214, nullptr, "GetDisplayGamma"},
+        {3215, nullptr, "SetDisplayGamma"},
+        {3216, nullptr, "GetDisplayCmuLuma"},
+        {3217, nullptr, "SetDisplayCmuLuma"},
+        {3218, nullptr, "SetDisplayCrcMode"},
+        {6013, nullptr, "GetLayerPresentationSubmissionTimestamps"},
+        {8225, C<&ISystemDisplayService::GetSharedBufferMemoryHandleId>, "GetSharedBufferMemoryHandleId"},
+        {8250, C<&ISystemDisplayService::OpenSharedLayer>, "OpenSharedLayer"},
+        {8251, nullptr, "CloseSharedLayer"},
+        {8252, C<&ISystemDisplayService::ConnectSharedLayer>, "ConnectSharedLayer"},
+        {8253, nullptr, "DisconnectSharedLayer"},
+        {8254, C<&ISystemDisplayService::AcquireSharedFrameBuffer>, "AcquireSharedFrameBuffer"},
+        {8255, C<&ISystemDisplayService::PresentSharedFrameBuffer>, "PresentSharedFrameBuffer"},
+        {8256, C<&ISystemDisplayService::GetSharedFrameBufferAcquirableEvent>, "GetSharedFrameBufferAcquirableEvent"},
+        {8257, nullptr, "FillSharedFrameBufferColor"},
+        {8258, nullptr, "CancelSharedFrameBuffer"},
+        {9000, nullptr, "GetDp2hdmiController"},
+    };
+    // clang-format on
+    RegisterHandlers(functions);
+}
+
+ISystemDisplayService::~ISystemDisplayService() = default;
+
+Result ISystemDisplayService::SetLayerZ(u32 z_value, u64 layer_id) {
+    LOG_WARNING(Service_VI, "(STUBBED) called. layer_id={}, z_value={}", layer_id, z_value);
+    R_SUCCEED();
+}
+
+// This function currently does nothing but return a success error code in
+// the vi library itself, so do the same thing, but log out the passed in values.
+Result ISystemDisplayService::SetLayerVisibility(bool visible, u64 layer_id) {
+    LOG_DEBUG(Service_VI, "called, layer_id={}, visible={}", layer_id, visible);
+    R_SUCCEED();
+}
+
+Result ISystemDisplayService::GetDisplayMode(Out<u32> out_width, Out<u32> out_height,
+                                             Out<f32> out_refresh_rate, Out<u32> out_unknown) {
+    LOG_WARNING(Service_VI, "(STUBBED) called");
+
+    if (Settings::IsDockedMode()) {
+        *out_width = static_cast<u32>(DisplayResolution::DockedWidth);
+        *out_height = static_cast<u32>(DisplayResolution::DockedHeight);
+    } else {
+        *out_width = static_cast<u32>(DisplayResolution::UndockedWidth);
+        *out_height = static_cast<u32>(DisplayResolution::UndockedHeight);
+    }
+
+    *out_refresh_rate = 60.f; // This wouldn't seem to be correct for 30 fps games.
+    *out_unknown = 0;
+
+    R_SUCCEED();
+}
+
+Result ISystemDisplayService::GetSharedBufferMemoryHandleId(
+    Out<s32> out_nvmap_handle, Out<u64> out_size,
+    OutLargeData<Nvnflinger::SharedMemoryPoolLayout, BufferAttr_HipcMapAlias> out_pool_layout,
+    u64 buffer_id, ClientAppletResourceUserId aruid) {
+    LOG_INFO(Service_VI, "called. buffer_id={}, aruid={:#x}", buffer_id, aruid.pid);
+
+    R_RETURN(m_nvnflinger.GetSystemBufferManager().GetSharedBufferMemoryHandleId(
+        out_size, out_nvmap_handle, out_pool_layout, buffer_id, aruid.pid));
+}
+
+Result ISystemDisplayService::OpenSharedLayer(u64 layer_id) {
+    LOG_INFO(Service_VI, "(STUBBED) called. layer_id={}", layer_id);
+    R_SUCCEED();
+}
+
+Result ISystemDisplayService::ConnectSharedLayer(u64 layer_id) {
+    LOG_INFO(Service_VI, "(STUBBED) called. layer_id={}", layer_id);
+    R_SUCCEED();
+}
+
+Result ISystemDisplayService::AcquireSharedFrameBuffer(Out<android::Fence> out_fence,
+                                                       Out<std::array<s32, 4>> out_slots,
+                                                       Out<s64> out_target_slot, u64 layer_id) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(m_nvnflinger.GetSystemBufferManager().AcquireSharedFrameBuffer(
+        out_fence, *out_slots, out_target_slot, layer_id));
+}
+
+Result ISystemDisplayService::PresentSharedFrameBuffer(android::Fence fence,
+                                                       Common::Rectangle<s32> crop_region,
+                                                       u32 window_transform, s32 swap_interval,
+                                                       u64 layer_id, s64 surface_id) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(m_nvnflinger.GetSystemBufferManager().PresentSharedFrameBuffer(
+        fence, crop_region, window_transform, swap_interval, layer_id, surface_id));
+}
+
+Result ISystemDisplayService::GetSharedFrameBufferAcquirableEvent(
+    OutCopyHandle<Kernel::KReadableEvent> out_event, u64 layer_id) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(m_nvnflinger.GetSystemBufferManager().GetSharedFrameBufferAcquirableEvent(out_event,
+                                                                                       layer_id));
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/system_display_service.h

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/math_util.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
+#include "core/hle/service/service.h"
+
+namespace Service::Nvnflinger {
+struct SharedMemoryPoolLayout;
+}
+
+namespace Service::VI {
+
+class ISystemDisplayService final : public ServiceFramework<ISystemDisplayService> {
+public:
+    explicit ISystemDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger);
+    ~ISystemDisplayService() override;
+
+private:
+    Result SetLayerZ(u32 z_value, u64 layer_id);
+    Result SetLayerVisibility(bool visible, u64 layer_id);
+    Result GetDisplayMode(Out<u32> out_width, Out<u32> out_height, Out<f32> out_refresh_rate,
+                          Out<u32> out_unknown);
+
+    Result GetSharedBufferMemoryHandleId(
+        Out<s32> out_nvmap_handle, Out<u64> out_size,
+        OutLargeData<Nvnflinger::SharedMemoryPoolLayout, BufferAttr_HipcMapAlias> out_pool_layout,
+        u64 buffer_id, ClientAppletResourceUserId aruid);
+    Result OpenSharedLayer(u64 layer_id);
+    Result ConnectSharedLayer(u64 layer_id);
+    Result GetSharedFrameBufferAcquirableEvent(OutCopyHandle<Kernel::KReadableEvent> out_event,
+                                               u64 layer_id);
+    Result AcquireSharedFrameBuffer(Out<android::Fence> out_fence,
+                                    Out<std::array<s32, 4>> out_slots, Out<s64> out_target_slot,
+                                    u64 layer_id);
+    Result PresentSharedFrameBuffer(android::Fence fence, Common::Rectangle<s32> crop_region,
+                                    u32 window_transform, s32 swap_interval, u64 layer_id,
+                                    s64 surface_id);
+
+private:
+    Nvnflinger::Nvnflinger& m_nvnflinger;
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/system_root_service.cpp

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/vi/application_display_service.h"
+#include "core/hle/service/vi/service_creator.h"
+#include "core/hle/service/vi/system_root_service.h"
+#include "core/hle/service/vi/vi.h"
+#include "core/hle/service/vi/vi_types.h"
+
+namespace Service::VI {
+
+ISystemRootService::ISystemRootService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+                                       Nvnflinger::HosBinderDriverServer& hos_binder_driver_server)
+    : ServiceFramework{system_, "vi:s"}, m_nvnflinger{nvnflinger}, m_hos_binder_driver_server{
+                                                                       hos_binder_driver_server} {
+    static const FunctionInfo functions[] = {
+        {1, C<&ISystemRootService::GetDisplayService>, "GetDisplayService"},
+        {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},
+    };
+    RegisterHandlers(functions);
+}
+
+ISystemRootService::~ISystemRootService() = default;
+
+Result ISystemRootService::GetDisplayService(
+    Out<SharedPointer<IApplicationDisplayService>> out_application_display_service, Policy policy) {
+    LOG_DEBUG(Service_VI, "called");
+    R_RETURN(GetApplicationDisplayService(out_application_display_service, system, m_nvnflinger,
+                                          m_hos_binder_driver_server, Permission::System, policy));
+}
+
+} // namespace Service::VI

src/core/hle/service/vi/system_root_service.h

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Nvnflinger {
+class HosBinderDriverServer;
+class Nvnflinger;
+} // namespace Service::Nvnflinger
+
+namespace Service::VI {
+
+class IApplicationDisplayService;
+enum class Policy : u32;
+
+class ISystemRootService final : public ServiceFramework<ISystemRootService> {
+public:
+    explicit ISystemRootService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger,
+                                Nvnflinger::HosBinderDriverServer& hos_binder_driver_server);
+    ~ISystemRootService() override;
+
+private:
+    Result GetDisplayService(
+        Out<SharedPointer<IApplicationDisplayService>> out_application_display_service,
+        Policy policy);
+
+    Nvnflinger::Nvnflinger& m_nvnflinger;
+    Nvnflinger::HosBinderDriverServer& m_hos_binder_driver_server;
+};
+
+} // namespace Service::VI

src/core/hle/service/vi/vi.cpp

@@ -1,974 +1,25 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include <memory>
-#include <optional>
-#include <type_traits>
-#include <utility>
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/common_funcs.h"
-#include "common/logging/log.h"
-#include "common/math_util.h"
-#include "common/settings.h"
-#include "common/string_util.h"
-#include "common/swap.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/k_readable_event.h"
-#include "core/hle/kernel/k_thread.h"
-#include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/nvdrv/devices/nvmap.h"
-#include "core/hle/service/nvdrv/nvdata.h"
-#include "core/hle/service/nvdrv/nvdrv.h"
-#include "core/hle/service/nvnflinger/binder.h"
-#include "core/hle/service/nvnflinger/buffer_queue_producer.h"
-#include "core/hle/service/nvnflinger/fb_share_buffer_manager.h"
-#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
-#include "core/hle/service/nvnflinger/nvnflinger.h"
-#include "core/hle/service/nvnflinger/parcel.h"
 #include "core/hle/service/server_manager.h"
-#include "core/hle/service/service.h"
+#include "core/hle/service/vi/application_display_service.h"
+#include "core/hle/service/vi/application_root_service.h"
+#include "core/hle/service/vi/manager_root_service.h"
+#include "core/hle/service/vi/system_root_service.h"
 #include "core/hle/service/vi/vi.h"
-#include "core/hle/service/vi/vi_m.h"
-#include "core/hle/service/vi/vi_results.h"
-#include "core/hle/service/vi/vi_s.h"
-#include "core/hle/service/vi/vi_u.h"
 
 namespace Service::VI {
 
-struct DisplayInfo {
-    /// The name of this particular display.
-    char display_name[0x40]{"Default"};
-
-    /// Whether or not the display has a limited number of layers.
-    u8 has_limited_layers{1};
-    INSERT_PADDING_BYTES(7);
-
-    /// Indicates the total amount of layers supported by the display.
-    /// @note This is only valid if has_limited_layers is set.
-    u64 max_layers{1};
-
-    /// Maximum width in pixels.
-    u64 width{1920};
-
-    /// Maximum height in pixels.
-    u64 height{1080};
-};
-static_assert(sizeof(DisplayInfo) == 0x60, "DisplayInfo has wrong size");
-
-class NativeWindow final {
-public:
-    constexpr explicit NativeWindow(u32 id_) : id{id_} {}
-    constexpr explicit NativeWindow(const NativeWindow& other) = default;
-
-private:
-    const u32 magic = 2;
-    const u32 process_id = 1;
-    const u64 id;
-    INSERT_PADDING_WORDS(2);
-    std::array<u8, 8> dispdrv = {'d', 'i', 's', 'p', 'd', 'r', 'v', '\0'};
-    INSERT_PADDING_WORDS(2);
-};
-static_assert(sizeof(NativeWindow) == 0x28, "NativeWindow has wrong size");
-
-class IHOSBinderDriver final : public ServiceFramework<IHOSBinderDriver> {
-public:
-    explicit IHOSBinderDriver(Core::System& system_, Nvnflinger::HosBinderDriverServer& server_)
-        : ServiceFramework{system_, "IHOSBinderDriver"}, server(server_) {
-        static const FunctionInfo functions[] = {
-            {0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
-            {1, &IHOSBinderDriver::AdjustRefcount, "AdjustRefcount"},
-            {2, &IHOSBinderDriver::GetNativeHandle, "GetNativeHandle"},
-            {3, &IHOSBinderDriver::TransactParcel, "TransactParcelAuto"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void TransactParcel(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 id = rp.Pop<u32>();
-        const auto transaction = static_cast<android::TransactionId>(rp.Pop<u32>());
-        const u32 flags = rp.Pop<u32>();
-
-        LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
-                  transaction, flags);
-
-        server.TryGetProducer(id)->Transact(ctx, transaction, flags);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void AdjustRefcount(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 id = rp.Pop<u32>();
-        const s32 addval = rp.PopRaw<s32>();
-        const u32 type = rp.Pop<u32>();
-
-        LOG_WARNING(Service_VI, "(STUBBED) called id={}, addval={:08X}, type={:08X}", id, addval,
-                    type);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void GetNativeHandle(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 id = rp.Pop<u32>();
-        const u32 unknown = rp.Pop<u32>();
-
-        LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(server.TryGetProducer(id)->GetNativeHandle());
-    }
-
-private:
-    Nvnflinger::HosBinderDriverServer& server;
-};
-
-class ISystemDisplayService final : public ServiceFramework<ISystemDisplayService> {
-public:
-    explicit ISystemDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger_)
-        : ServiceFramework{system_, "ISystemDisplayService"}, nvnflinger{nvnflinger_} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {1200, nullptr, "GetZOrderCountMin"},
-            {1202, nullptr, "GetZOrderCountMax"},
-            {1203, nullptr, "GetDisplayLogicalResolution"},
-            {1204, nullptr, "SetDisplayMagnification"},
-            {2201, nullptr, "SetLayerPosition"},
-            {2203, nullptr, "SetLayerSize"},
-            {2204, nullptr, "GetLayerZ"},
-            {2205, &ISystemDisplayService::SetLayerZ, "SetLayerZ"},
-            {2207, &ISystemDisplayService::SetLayerVisibility, "SetLayerVisibility"},
-            {2209, nullptr, "SetLayerAlpha"},
-            {2210, nullptr, "SetLayerPositionAndSize"},
-            {2312, nullptr, "CreateStrayLayer"},
-            {2400, nullptr, "OpenIndirectLayer"},
-            {2401, nullptr, "CloseIndirectLayer"},
-            {2402, nullptr, "FlipIndirectLayer"},
-            {3000, nullptr, "ListDisplayModes"},
-            {3001, nullptr, "ListDisplayRgbRanges"},
-            {3002, nullptr, "ListDisplayContentTypes"},
-            {3200, &ISystemDisplayService::GetDisplayMode, "GetDisplayMode"},
-            {3201, nullptr, "SetDisplayMode"},
-            {3202, nullptr, "GetDisplayUnderscan"},
-            {3203, nullptr, "SetDisplayUnderscan"},
-            {3204, nullptr, "GetDisplayContentType"},
-            {3205, nullptr, "SetDisplayContentType"},
-            {3206, nullptr, "GetDisplayRgbRange"},
-            {3207, nullptr, "SetDisplayRgbRange"},
-            {3208, nullptr, "GetDisplayCmuMode"},
-            {3209, nullptr, "SetDisplayCmuMode"},
-            {3210, nullptr, "GetDisplayContrastRatio"},
-            {3211, nullptr, "SetDisplayContrastRatio"},
-            {3214, nullptr, "GetDisplayGamma"},
-            {3215, nullptr, "SetDisplayGamma"},
-            {3216, nullptr, "GetDisplayCmuLuma"},
-            {3217, nullptr, "SetDisplayCmuLuma"},
-            {3218, nullptr, "SetDisplayCrcMode"},
-            {6013, nullptr, "GetLayerPresentationSubmissionTimestamps"},
-            {8225, &ISystemDisplayService::GetSharedBufferMemoryHandleId, "GetSharedBufferMemoryHandleId"},
-            {8250, &ISystemDisplayService::OpenSharedLayer, "OpenSharedLayer"},
-            {8251, nullptr, "CloseSharedLayer"},
-            {8252, &ISystemDisplayService::ConnectSharedLayer, "ConnectSharedLayer"},
-            {8253, nullptr, "DisconnectSharedLayer"},
-            {8254, &ISystemDisplayService::AcquireSharedFrameBuffer, "AcquireSharedFrameBuffer"},
-            {8255, &ISystemDisplayService::PresentSharedFrameBuffer, "PresentSharedFrameBuffer"},
-            {8256, &ISystemDisplayService::GetSharedFrameBufferAcquirableEvent, "GetSharedFrameBufferAcquirableEvent"},
-            {8257, nullptr, "FillSharedFrameBufferColor"},
-            {8258, nullptr, "CancelSharedFrameBuffer"},
-            {9000, nullptr, "GetDp2hdmiController"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetSharedBufferMemoryHandleId(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 buffer_id = rp.PopRaw<u64>();
-        const u64 aruid = ctx.GetPID();
-
-        LOG_INFO(Service_VI, "called. buffer_id={:#x}, aruid={:#x}", buffer_id, aruid);
-
-        struct OutputParameters {
-            s32 nvmap_handle;
-            u64 size;
-        };
-
-        OutputParameters out{};
-        Nvnflinger::SharedMemoryPoolLayout layout{};
-        const auto result = nvnflinger.GetSystemBufferManager().GetSharedBufferMemoryHandleId(
-            &out.size, &out.nvmap_handle, &layout, buffer_id, aruid);
-
-        ctx.WriteBuffer(&layout, sizeof(layout));
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(result);
-        rb.PushRaw(out);
-    }
-
-    void OpenSharedLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.PopRaw<u64>();
-
-        LOG_INFO(Service_VI, "(STUBBED) called. layer_id={:#x}", layer_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void ConnectSharedLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.PopRaw<u64>();
-
-        LOG_INFO(Service_VI, "(STUBBED) called. layer_id={:#x}", layer_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void GetSharedFrameBufferAcquirableEvent(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called");
-
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.PopRaw<u64>();
-
-        Kernel::KReadableEvent* event{};
-        const auto result = nvnflinger.GetSystemBufferManager().GetSharedFrameBufferAcquirableEvent(
-            &event, layer_id);
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(result);
-        rb.PushCopyObjects(event);
-    }
-
-    void AcquireSharedFrameBuffer(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called");
-
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.PopRaw<u64>();
-
-        struct OutputParameters {
-            android::Fence fence;
-            std::array<s32, 4> slots;
-            s64 target_slot;
-        };
-        static_assert(sizeof(OutputParameters) == 0x40, "OutputParameters has wrong size");
-
-        OutputParameters out{};
-        const auto result = nvnflinger.GetSystemBufferManager().AcquireSharedFrameBuffer(
-            &out.fence, out.slots, &out.target_slot, layer_id);
-
-        IPC::ResponseBuilder rb{ctx, 18};
-        rb.Push(result);
-        rb.PushRaw(out);
-    }
-
-    void PresentSharedFrameBuffer(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called");
-
-        struct InputParameters {
-            android::Fence fence;
-            Common::Rectangle<s32> crop_region;
-            u32 window_transform;
-            s32 swap_interval;
-            u64 layer_id;
-            s64 surface_id;
-        };
-        static_assert(sizeof(InputParameters) == 0x50, "InputParameters has wrong size");
-
-        IPC::RequestParser rp{ctx};
-        auto input = rp.PopRaw<InputParameters>();
-
-        const auto result = nvnflinger.GetSystemBufferManager().PresentSharedFrameBuffer(
-            input.fence, input.crop_region, input.window_transform, input.swap_interval,
-            input.layer_id, input.surface_id);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-    }
-
-    void SetLayerZ(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.Pop<u64>();
-        const u64 z_value = rp.Pop<u64>();
-
-        LOG_WARNING(Service_VI, "(STUBBED) called. layer_id=0x{:016X}, z_value=0x{:016X}", layer_id,
-                    z_value);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    // This function currently does nothing but return a success error code in
-    // the vi library itself, so do the same thing, but log out the passed in values.
-    void SetLayerVisibility(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.Pop<u64>();
-        const bool visibility = rp.Pop<bool>();
-
-        LOG_DEBUG(Service_VI, "called, layer_id=0x{:08X}, visibility={}", layer_id, visibility);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void GetDisplayMode(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-
-        if (Settings::IsDockedMode()) {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth));
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight));
-        } else {
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth));
-            rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight));
-        }
-
-        rb.PushRaw<float>(60.0f); // This wouldn't seem to be correct for 30 fps games.
-        rb.Push<u32>(0);
-    }
-
-private:
-    Nvnflinger::Nvnflinger& nvnflinger;
-};
-
-class IManagerDisplayService final : public ServiceFramework<IManagerDisplayService> {
-public:
-    explicit IManagerDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger_)
-        : ServiceFramework{system_, "IManagerDisplayService"}, nvnflinger{nvnflinger_} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {200, nullptr, "AllocateProcessHeapBlock"},
-            {201, nullptr, "FreeProcessHeapBlock"},
-            {1020, &IManagerDisplayService::CloseDisplay, "CloseDisplay"},
-            {1102, nullptr, "GetDisplayResolution"},
-            {2010, &IManagerDisplayService::CreateManagedLayer, "CreateManagedLayer"},
-            {2011, nullptr, "DestroyManagedLayer"},
-            {2012, nullptr, "CreateStrayLayer"},
-            {2050, nullptr, "CreateIndirectLayer"},
-            {2051, nullptr, "DestroyIndirectLayer"},
-            {2052, nullptr, "CreateIndirectProducerEndPoint"},
-            {2053, nullptr, "DestroyIndirectProducerEndPoint"},
-            {2054, nullptr, "CreateIndirectConsumerEndPoint"},
-            {2055, nullptr, "DestroyIndirectConsumerEndPoint"},
-            {2060, nullptr, "CreateWatermarkCompositor"},
-            {2062, nullptr, "SetWatermarkText"},
-            {2063, nullptr, "SetWatermarkLayerStacks"},
-            {2300, nullptr, "AcquireLayerTexturePresentingEvent"},
-            {2301, nullptr, "ReleaseLayerTexturePresentingEvent"},
-            {2302, nullptr, "GetDisplayHotplugEvent"},
-            {2303, nullptr, "GetDisplayModeChangedEvent"},
-            {2402, nullptr, "GetDisplayHotplugState"},
-            {2501, nullptr, "GetCompositorErrorInfo"},
-            {2601, nullptr, "GetDisplayErrorEvent"},
-            {2701, nullptr, "GetDisplayFatalErrorEvent"},
-            {4201, nullptr, "SetDisplayAlpha"},
-            {4203, nullptr, "SetDisplayLayerStack"},
-            {4205, nullptr, "SetDisplayPowerState"},
-            {4206, nullptr, "SetDefaultDisplay"},
-            {4207, nullptr, "ResetDisplayPanel"},
-            {4208, nullptr, "SetDisplayFatalErrorEnabled"},
-            {4209, nullptr, "IsDisplayPanelOn"},
-            {4300, nullptr, "GetInternalPanelId"},
-            {6000, &IManagerDisplayService::AddToLayerStack, "AddToLayerStack"},
-            {6001, nullptr, "RemoveFromLayerStack"},
-            {6002, &IManagerDisplayService::SetLayerVisibility, "SetLayerVisibility"},
-            {6003, nullptr, "SetLayerConfig"},
-            {6004, nullptr, "AttachLayerPresentationTracer"},
-            {6005, nullptr, "DetachLayerPresentationTracer"},
-            {6006, nullptr, "StartLayerPresentationRecording"},
-            {6007, nullptr, "StopLayerPresentationRecording"},
-            {6008, nullptr, "StartLayerPresentationFenceWait"},
-            {6009, nullptr, "StopLayerPresentationFenceWait"},
-            {6010, nullptr, "GetLayerPresentationAllFencesExpiredEvent"},
-            {6011, nullptr, "EnableLayerAutoClearTransitionBuffer"},
-            {6012, nullptr, "DisableLayerAutoClearTransitionBuffer"},
-            {6013, nullptr, "SetLayerOpacity"},
-            {6014, nullptr, "AttachLayerWatermarkCompositor"},
-            {6015, nullptr, "DetachLayerWatermarkCompositor"},
-            {7000, nullptr, "SetContentVisibility"},
-            {8000, nullptr, "SetConductorLayer"},
-            {8001, nullptr, "SetTimestampTracking"},
-            {8100, nullptr, "SetIndirectProducerFlipOffset"},
-            {8200, nullptr, "CreateSharedBufferStaticStorage"},
-            {8201, nullptr, "CreateSharedBufferTransferMemory"},
-            {8202, nullptr, "DestroySharedBuffer"},
-            {8203, nullptr, "BindSharedLowLevelLayerToManagedLayer"},
-            {8204, nullptr, "BindSharedLowLevelLayerToIndirectLayer"},
-            {8207, nullptr, "UnbindSharedLowLevelLayer"},
-            {8208, nullptr, "ConnectSharedLowLevelLayerToSharedBuffer"},
-            {8209, nullptr, "DisconnectSharedLowLevelLayerFromSharedBuffer"},
-            {8210, nullptr, "CreateSharedLayer"},
-            {8211, nullptr, "DestroySharedLayer"},
-            {8216, nullptr, "AttachSharedLayerToLowLevelLayer"},
-            {8217, nullptr, "ForceDetachSharedLayerFromLowLevelLayer"},
-            {8218, nullptr, "StartDetachSharedLayerFromLowLevelLayer"},
-            {8219, nullptr, "FinishDetachSharedLayerFromLowLevelLayer"},
-            {8220, nullptr, "GetSharedLayerDetachReadyEvent"},
-            {8221, nullptr, "GetSharedLowLevelLayerSynchronizedEvent"},
-            {8222, nullptr, "CheckSharedLowLevelLayerSynchronized"},
-            {8223, nullptr, "RegisterSharedBufferImporterAruid"},
-            {8224, nullptr, "UnregisterSharedBufferImporterAruid"},
-            {8227, nullptr, "CreateSharedBufferProcessHeap"},
-            {8228, nullptr, "GetSharedLayerLayerStacks"},
-            {8229, nullptr, "SetSharedLayerLayerStacks"},
-            {8291, nullptr, "PresentDetachedSharedFrameBufferToLowLevelLayer"},
-            {8292, nullptr, "FillDetachedSharedFrameBufferColor"},
-            {8293, nullptr, "GetDetachedSharedFrameBufferImage"},
-            {8294, nullptr, "SetDetachedSharedFrameBufferImage"},
-            {8295, nullptr, "CopyDetachedSharedFrameBufferImage"},
-            {8296, nullptr, "SetDetachedSharedFrameBufferSubImage"},
-            {8297, nullptr, "GetSharedFrameBufferContentParameter"},
-            {8298, nullptr, "ExpandStartupLogoOnSharedFrameBuffer"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void CloseDisplay(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 display = rp.Pop<u64>();
-
-        const Result rc = nvnflinger.CloseDisplay(display) ? ResultSuccess : ResultUnknown;
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(rc);
-    }
-
-    void CreateManagedLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 unknown = rp.Pop<u32>();
-        rp.Skip(1, false);
-        const u64 display = rp.Pop<u64>();
-        const u64 aruid = rp.Pop<u64>();
-
-        LOG_WARNING(Service_VI,
-                    "(STUBBED) called. unknown=0x{:08X}, display=0x{:016X}, aruid=0x{:016X}",
-                    unknown, display, aruid);
-
-        const auto layer_id = nvnflinger.CreateLayer(display);
-        if (!layer_id) {
-            LOG_ERROR(Service_VI, "Layer not found! display=0x{:016X}", display);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultNotFound);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push(*layer_id);
-    }
-
-    void AddToLayerStack(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 stack = rp.Pop<u32>();
-        const u64 layer_id = rp.Pop<u64>();
-
-        LOG_WARNING(Service_VI, "(STUBBED) called. stack=0x{:08X}, layer_id=0x{:016X}", stack,
-                    layer_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void SetLayerVisibility(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.Pop<u64>();
-        const bool visibility = rp.Pop<bool>();
-
-        LOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:X}, visibility={}", layer_id,
-                    visibility);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    Nvnflinger::Nvnflinger& nvnflinger;
-};
-
-class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
-public:
-    IApplicationDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger_,
-                               Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
-        : ServiceFramework{system_, "IApplicationDisplayService"}, nvnflinger{nvnflinger_},
-          hos_binder_driver_server{hos_binder_driver_server_} {
-
-        static const FunctionInfo functions[] = {
-            {100, &IApplicationDisplayService::GetRelayService, "GetRelayService"},
-            {101, &IApplicationDisplayService::GetSystemDisplayService, "GetSystemDisplayService"},
-            {102, &IApplicationDisplayService::GetManagerDisplayService,
-             "GetManagerDisplayService"},
-            {103, &IApplicationDisplayService::GetIndirectDisplayTransactionService,
-             "GetIndirectDisplayTransactionService"},
-            {1000, &IApplicationDisplayService::ListDisplays, "ListDisplays"},
-            {1010, &IApplicationDisplayService::OpenDisplay, "OpenDisplay"},
-            {1011, &IApplicationDisplayService::OpenDefaultDisplay, "OpenDefaultDisplay"},
-            {1020, &IApplicationDisplayService::CloseDisplay, "CloseDisplay"},
-            {1101, &IApplicationDisplayService::SetDisplayEnabled, "SetDisplayEnabled"},
-            {1102, &IApplicationDisplayService::GetDisplayResolution, "GetDisplayResolution"},
-            {2020, &IApplicationDisplayService::OpenLayer, "OpenLayer"},
-            {2021, &IApplicationDisplayService::CloseLayer, "CloseLayer"},
-            {2030, &IApplicationDisplayService::CreateStrayLayer, "CreateStrayLayer"},
-            {2031, &IApplicationDisplayService::DestroyStrayLayer, "DestroyStrayLayer"},
-            {2101, &IApplicationDisplayService::SetLayerScalingMode, "SetLayerScalingMode"},
-            {2102, &IApplicationDisplayService::ConvertScalingMode, "ConvertScalingMode"},
-            {2450, &IApplicationDisplayService::GetIndirectLayerImageMap,
-             "GetIndirectLayerImageMap"},
-            {2451, nullptr, "GetIndirectLayerImageCropMap"},
-            {2460, &IApplicationDisplayService::GetIndirectLayerImageRequiredMemoryInfo,
-             "GetIndirectLayerImageRequiredMemoryInfo"},
-            {5202, &IApplicationDisplayService::GetDisplayVsyncEvent, "GetDisplayVsyncEvent"},
-            {5203, nullptr, "GetDisplayVsyncEventForDebug"},
-        };
-        RegisterHandlers(functions);
-    }
-
-    ~IApplicationDisplayService() {
-        for (const auto layer_id : stray_layer_ids) {
-            nvnflinger.DestroyLayer(layer_id);
-        }
-    }
-
-private:
-    enum class ConvertedScaleMode : u64 {
-        Freeze = 0,
-        ScaleToWindow = 1,
-        ScaleAndCrop = 2,
-        None = 3,
-        PreserveAspectRatio = 4,
-    };
-
-    enum class NintendoScaleMode : u32 {
-        None = 0,
-        Freeze = 1,
-        ScaleToWindow = 2,
-        ScaleAndCrop = 3,
-        PreserveAspectRatio = 4,
-    };
-
-    void GetRelayService(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IHOSBinderDriver>(system, hos_binder_driver_server);
-    }
-
-    void GetSystemDisplayService(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISystemDisplayService>(system, nvnflinger);
-    }
-
-    void GetManagerDisplayService(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IManagerDisplayService>(system, nvnflinger);
-    }
-
-    void GetIndirectDisplayTransactionService(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(ResultSuccess);
-        rb.PushIpcInterface<IHOSBinderDriver>(system, hos_binder_driver_server);
-    }
-
-    void OpenDisplay(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        IPC::RequestParser rp{ctx};
-        const auto name_buf = rp.PopRaw<std::array<char, 0x40>>();
-
-        OpenDisplayImpl(ctx, std::string_view{name_buf.data(), name_buf.size()});
-    }
-
-    void OpenDefaultDisplay(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called");
-
-        OpenDisplayImpl(ctx, "Default");
-    }
-
-    void OpenDisplayImpl(HLERequestContext& ctx, std::string_view name) {
-        const auto trim_pos = name.find('\0');
-
-        if (trim_pos != std::string_view::npos) {
-            name.remove_suffix(name.size() - trim_pos);
-        }
-
-        ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
-
-        const auto display_id = nvnflinger.OpenDisplay(name);
-        if (!display_id) {
-            LOG_ERROR(Service_VI, "Display not found! display_name={}", name);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultNotFound);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<u64>(*display_id);
-    }
-
-    void CloseDisplay(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 display_id = rp.Pop<u64>();
-
-        const Result rc = nvnflinger.CloseDisplay(display_id) ? ResultSuccess : ResultUnknown;
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(rc);
-    }
-
-    // This literally does nothing internally in the actual service itself,
-    // and just returns a successful result code regardless of the input.
-    void SetDisplayEnabled(HLERequestContext& ctx) {
-        LOG_DEBUG(Service_VI, "called.");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void GetDisplayResolution(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 display_id = rp.Pop<u64>();
-
-        LOG_DEBUG(Service_VI, "called. display_id=0x{:016X}", display_id);
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-
-        // This only returns the fixed values of 1280x720 and makes no distinguishing
-        // between docked and undocked dimensions. We take the liberty of applying
-        // the resolution scaling factor here.
-        rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth));
-        rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight));
-    }
-
-    void SetLayerScalingMode(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto scaling_mode = rp.PopEnum<NintendoScaleMode>();
-        const u64 unknown = rp.Pop<u64>();
-
-        LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}", scaling_mode,
-                  unknown);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-
-        if (scaling_mode > NintendoScaleMode::PreserveAspectRatio) {
-            LOG_ERROR(Service_VI, "Invalid scaling mode provided.");
-            rb.Push(ResultOperationFailed);
-            return;
-        }
-
-        if (scaling_mode != NintendoScaleMode::ScaleToWindow &&
-            scaling_mode != NintendoScaleMode::PreserveAspectRatio) {
-            LOG_ERROR(Service_VI, "Unsupported scaling mode supplied.");
-            rb.Push(ResultNotSupported);
-            return;
-        }
-
-        rb.Push(ResultSuccess);
-    }
-
-    void ListDisplays(HLERequestContext& ctx) {
-        LOG_WARNING(Service_VI, "(STUBBED) called");
-
-        const DisplayInfo display_info;
-        ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<u64>(1);
-    }
-
-    void OpenLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
-        const std::string display_name(Common::StringFromBuffer(name_buf));
-
-        const u64 layer_id = rp.Pop<u64>();
-        const u64 aruid = rp.Pop<u64>();
-
-        LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}, aruid=0x{:016X}", layer_id, aruid);
-
-        const auto display_id = nvnflinger.OpenDisplay(display_name);
-        if (!display_id) {
-            LOG_ERROR(Service_VI, "Layer not found! layer_id={}", layer_id);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultNotFound);
-            return;
-        }
-
-        const auto buffer_queue_id = nvnflinger.FindBufferQueueId(*display_id, layer_id);
-        if (!buffer_queue_id) {
-            LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", *display_id);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultNotFound);
-            return;
-        }
-
-        if (!nvnflinger.OpenLayer(layer_id)) {
-            LOG_WARNING(Service_VI, "Tried to open layer which was already open");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultOperationFailed);
-            return;
-        }
-
-        android::OutputParcel parcel;
-        parcel.WriteInterface(NativeWindow{*buffer_queue_id});
-
-        const auto buffer_size = ctx.WriteBuffer(parcel.Serialize());
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<u64>(buffer_size);
-    }
-
-    void CloseLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto layer_id{rp.Pop<u64>()};
-
-        LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}", layer_id);
-
-        if (!nvnflinger.CloseLayer(layer_id)) {
-            LOG_WARNING(Service_VI, "Tried to close layer which was not open");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultOperationFailed);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void CreateStrayLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u32 flags = rp.Pop<u32>();
-        rp.Pop<u32>(); // padding
-        const u64 display_id = rp.Pop<u64>();
-
-        LOG_DEBUG(Service_VI, "called. flags=0x{:08X}, display_id=0x{:016X}", flags, display_id);
-
-        // TODO(Subv): What's the difference between a Stray and a Managed layer?
-
-        const auto layer_id = nvnflinger.CreateLayer(display_id);
-        if (!layer_id) {
-            LOG_ERROR(Service_VI, "Layer not found! display_id={}", display_id);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultNotFound);
-            return;
-        }
-
-        stray_layer_ids.push_back(*layer_id);
-        const auto buffer_queue_id = nvnflinger.FindBufferQueueId(display_id, *layer_id);
-        if (!buffer_queue_id) {
-            LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", display_id);
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ResultNotFound);
-            return;
-        }
-
-        android::OutputParcel parcel;
-        parcel.WriteInterface(NativeWindow{*buffer_queue_id});
-
-        const auto buffer_size = ctx.WriteBuffer(parcel.Serialize());
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-        rb.Push(*layer_id);
-        rb.Push<u64>(buffer_size);
-    }
-
-    void DestroyStrayLayer(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 layer_id = rp.Pop<u64>();
-
-        LOG_WARNING(Service_VI, "(STUBBED) called. layer_id=0x{:016X}", layer_id);
-        nvnflinger.DestroyLayer(layer_id);
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultSuccess);
-    }
-
-    void GetDisplayVsyncEvent(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const u64 display_id = rp.Pop<u64>();
-
-        LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
-
-        Kernel::KReadableEvent* vsync_event{};
-        const auto result = nvnflinger.FindVsyncEvent(&vsync_event, display_id);
-        if (result != ResultSuccess) {
-            if (result == ResultNotFound) {
-                LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
-            }
-
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result);
-            return;
-        }
-        if (vsync_event_fetched) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(VI::ResultPermissionDenied);
-            return;
-        }
-        vsync_event_fetched = true;
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(ResultSuccess);
-        rb.PushCopyObjects(vsync_event);
-    }
-
-    void ConvertScalingMode(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto mode = rp.PopEnum<NintendoScaleMode>();
-        LOG_DEBUG(Service_VI, "called mode={}", mode);
-
-        ConvertedScaleMode converted_mode{};
-        const auto result = ConvertScalingModeImpl(&converted_mode, mode);
-
-        if (result == ResultSuccess) {
-            IPC::ResponseBuilder rb{ctx, 4};
-            rb.Push(ResultSuccess);
-            rb.PushEnum(converted_mode);
-        } else {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result);
-        }
-    }
-
-    void GetIndirectLayerImageMap(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto width = rp.Pop<s64>();
-        const auto height = rp.Pop<s64>();
-        const auto indirect_layer_consumer_handle = rp.Pop<u64>();
-        const auto applet_resource_user_id = rp.Pop<u64>();
-
-        LOG_WARNING(Service_VI,
-                    "(STUBBED) called, width={}, height={}, indirect_layer_consumer_handle={}, "
-                    "applet_resource_user_id={}",
-                    width, height, indirect_layer_consumer_handle, applet_resource_user_id);
-
-        std::vector<u8> out_buffer(0x46);
-        ctx.WriteBuffer(out_buffer);
-
-        // TODO: Figure out what these are
-
-        constexpr s64 unknown_result_1 = 0;
-        constexpr s64 unknown_result_2 = 0;
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(unknown_result_1);
-        rb.Push(unknown_result_2);
-        rb.Push(ResultSuccess);
-    }
-
-    void GetIndirectLayerImageRequiredMemoryInfo(HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto width = rp.Pop<u64>();
-        const auto height = rp.Pop<u64>();
-        LOG_DEBUG(Service_VI, "called width={}, height={}", width, height);
-
-        constexpr u64 base_size = 0x20000;
-        constexpr u64 alignment = 0x1000;
-        const auto texture_size = width * height * 4;
-        const auto out_size = (texture_size + base_size - 1) / base_size * base_size;
-
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-        rb.Push(out_size);
-        rb.Push(alignment);
-    }
-
-    static Result ConvertScalingModeImpl(ConvertedScaleMode* out_scaling_mode,
-                                         NintendoScaleMode mode) {
-        switch (mode) {
-        case NintendoScaleMode::None:
-            *out_scaling_mode = ConvertedScaleMode::None;
-            return ResultSuccess;
-        case NintendoScaleMode::Freeze:
-            *out_scaling_mode = ConvertedScaleMode::Freeze;
-            return ResultSuccess;
-        case NintendoScaleMode::ScaleToWindow:
-            *out_scaling_mode = ConvertedScaleMode::ScaleToWindow;
-            return ResultSuccess;
-        case NintendoScaleMode::ScaleAndCrop:
-            *out_scaling_mode = ConvertedScaleMode::ScaleAndCrop;
-            return ResultSuccess;
-        case NintendoScaleMode::PreserveAspectRatio:
-            *out_scaling_mode = ConvertedScaleMode::PreserveAspectRatio;
-            return ResultSuccess;
-        default:
-            LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
-            return ResultOperationFailed;
-        }
-    }
-
-    Nvnflinger::Nvnflinger& nvnflinger;
-    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
-    std::vector<u64> stray_layer_ids;
-    bool vsync_event_fetched{false};
-};
-
-static bool IsValidServiceAccess(Permission permission, Policy policy) {
-    if (permission == Permission::User) {
-        return policy == Policy::User;
-    }
-
-    if (permission == Permission::System || permission == Permission::Manager) {
-        return policy == Policy::User || policy == Policy::Compositor;
-    }
-
-    return false;
-}
-
-void detail::GetDisplayServiceImpl(HLERequestContext& ctx, Core::System& system,
-                                   Nvnflinger::Nvnflinger& nvnflinger,
-                                   Nvnflinger::HosBinderDriverServer& hos_binder_driver_server,
-                                   Permission permission) {
-    IPC::RequestParser rp{ctx};
-    const auto policy = rp.PopEnum<Policy>();
-
-    if (!IsValidServiceAccess(permission, policy)) {
-        LOG_ERROR(Service_VI, "Permission denied for policy {}", policy);
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultPermissionDenied);
-        return;
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IApplicationDisplayService>(system, nvnflinger, hos_binder_driver_server);
-}
-
 void LoopProcess(Core::System& system, Nvnflinger::Nvnflinger& nvnflinger,
                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
+    server_manager->RegisterNamedService("vi:m", std::make_shared<IManagerRootService>(
+                                                     system, nvnflinger, hos_binder_driver_server));
     server_manager->RegisterNamedService(
-        "vi:m", std::make_shared<VI_M>(system, nvnflinger, hos_binder_driver_server));
-    server_manager->RegisterNamedService(
-        "vi:s", std::make_shared<VI_S>(system, nvnflinger, hos_binder_driver_server));
-    server_manager->RegisterNamedService(
-        "vi:u", std::make_shared<VI_U>(system, nvnflinger, hos_binder_driver_server));
+        "vi:s", std::make_shared<ISystemRootService>(system, nvnflinger, hos_binder_driver_server));
+    server_manager->RegisterNamedService("vi:u", std::make_shared<IApplicationRootService>(
+                                                     system, nvnflinger, hos_binder_driver_server));
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/vi/vi.h

@@ -3,16 +3,10 @@
 
 #pragma once
 
-#include "common/common_types.h"
-
 namespace Core {
 class System;
 }
 
-namespace Service {
-class HLERequestContext;
-}
-
 namespace Service::Nvnflinger {
 class HosBinderDriverServer;
 class Nvnflinger;
@@ -20,34 +14,6 @@ class Nvnflinger;
 
 namespace Service::VI {
 
-enum class DisplayResolution : u32 {
-    DockedWidth = 1920,
-    DockedHeight = 1080,
-    UndockedWidth = 1280,
-    UndockedHeight = 720,
-};
-
-/// Permission level for a particular VI service instance
-enum class Permission {
-    User,
-    System,
-    Manager,
-};
-
-/// A policy type that may be requested via GetDisplayService and
-/// GetDisplayServiceWithProxyNameExchange
-enum class Policy {
-    User,
-    Compositor,
-};
-
-namespace detail {
-void GetDisplayServiceImpl(HLERequestContext& ctx, Core::System& system,
-                           Nvnflinger::Nvnflinger& nv_flinger,
-                           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server,
-                           Permission permission);
-} // namespace detail
-
 void LoopProcess(Core::System& system, Nvnflinger::Nvnflinger& nvnflinger,
                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server);
 

src/core/hle/service/vi/vi_m.cpp

@@ -1,34 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/logging/log.h"
-#include "core/hle/service/vi/vi.h"
-#include "core/hle/service/vi/vi_m.h"
-
-namespace Service::VI {
-
-VI_M::VI_M(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
-           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
-    : ServiceFramework{system_, "vi:m"}, nv_flinger{nv_flinger_}, hos_binder_driver_server{
-                                                                      hos_binder_driver_server_} {
-    static const FunctionInfo functions[] = {
-        {2, &VI_M::GetDisplayService, "GetDisplayService"},
-        {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},
-        {100, nullptr, "PrepareFatal"},
-        {101, nullptr, "ShowFatal"},
-        {102, nullptr, "DrawFatalRectangle"},
-        {103, nullptr, "DrawFatalText32"},
-    };
-    RegisterHandlers(functions);
-}
-
-VI_M::~VI_M() = default;
-
-void VI_M::GetDisplayService(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_VI, "called");
-
-    detail::GetDisplayServiceImpl(ctx, system, nv_flinger, hos_binder_driver_server,
-                                  Permission::Manager);
-}
-
-} // namespace Service::VI

src/core/hle/service/vi/vi_m.h

@@ -1,32 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Nvnflinger {
-class HosBinderDriverServer;
-class Nvnflinger;
-} // namespace Service::Nvnflinger
-
-namespace Service::VI {
-
-class VI_M final : public ServiceFramework<VI_M> {
-public:
-    explicit VI_M(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
-                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_);
-    ~VI_M() override;
-
-private:
-    void GetDisplayService(HLERequestContext& ctx);
-
-    Nvnflinger::Nvnflinger& nv_flinger;
-    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
-};
-
-} // namespace Service::VI

src/core/hle/service/vi/vi_s.cpp

@@ -1,30 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/logging/log.h"
-#include "core/hle/service/vi/vi.h"
-#include "core/hle/service/vi/vi_s.h"
-
-namespace Service::VI {
-
-VI_S::VI_S(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
-           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
-    : ServiceFramework{system_, "vi:s"}, nv_flinger{nv_flinger_}, hos_binder_driver_server{
-                                                                      hos_binder_driver_server_} {
-    static const FunctionInfo functions[] = {
-        {1, &VI_S::GetDisplayService, "GetDisplayService"},
-        {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},
-    };
-    RegisterHandlers(functions);
-}
-
-VI_S::~VI_S() = default;
-
-void VI_S::GetDisplayService(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_VI, "called");
-
-    detail::GetDisplayServiceImpl(ctx, system, nv_flinger, hos_binder_driver_server,
-                                  Permission::System);
-}
-
-} // namespace Service::VI

src/core/hle/service/vi/vi_s.h

@@ -1,32 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Nvnflinger {
-class HosBinderDriverServer;
-class Nvnflinger;
-} // namespace Service::Nvnflinger
-
-namespace Service::VI {
-
-class VI_S final : public ServiceFramework<VI_S> {
-public:
-    explicit VI_S(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
-                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_);
-    ~VI_S() override;
-
-private:
-    void GetDisplayService(HLERequestContext& ctx);
-
-    Nvnflinger::Nvnflinger& nv_flinger;
-    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
-};
-
-} // namespace Service::VI

src/core/hle/service/vi/vi_types.h

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+
+namespace Service::VI {
+
+enum class DisplayResolution : u32 {
+    DockedWidth = 1920,
+    DockedHeight = 1080,
+    UndockedWidth = 1280,
+    UndockedHeight = 720,
+};
+
+/// Permission level for a particular VI service instance
+enum class Permission {
+    User,
+    System,
+    Manager,
+};
+
+/// A policy type that may be requested via GetDisplayService and
+/// GetDisplayServiceWithProxyNameExchange
+enum class Policy : u32 {
+    User,
+    Compositor,
+};
+
+enum class ConvertedScaleMode : u64 {
+    Freeze = 0,
+    ScaleToWindow = 1,
+    ScaleAndCrop = 2,
+    None = 3,
+    PreserveAspectRatio = 4,
+};
+
+enum class NintendoScaleMode : u32 {
+    None = 0,
+    Freeze = 1,
+    ScaleToWindow = 2,
+    ScaleAndCrop = 3,
+    PreserveAspectRatio = 4,
+};
+
+using DisplayName = std::array<char, 0x40>;
+
+struct DisplayInfo {
+    /// The name of this particular display.
+    DisplayName display_name{"Default"};
+
+    /// Whether or not the display has a limited number of layers.
+    u8 has_limited_layers{1};
+    INSERT_PADDING_BYTES(7);
+
+    /// Indicates the total amount of layers supported by the display.
+    /// @note This is only valid if has_limited_layers is set.
+    u64 max_layers{1};
+
+    /// Maximum width in pixels.
+    u64 width{1920};
+
+    /// Maximum height in pixels.
+    u64 height{1080};
+};
+static_assert(sizeof(DisplayInfo) == 0x60, "DisplayInfo has wrong size");
+
+class NativeWindow final {
+public:
+    constexpr explicit NativeWindow(u32 id_) : id{id_} {}
+    constexpr explicit NativeWindow(const NativeWindow& other) = default;
+
+private:
+    const u32 magic = 2;
+    const u32 process_id = 1;
+    const u64 id;
+    INSERT_PADDING_WORDS(2);
+    std::array<u8, 8> dispdrv = {'d', 'i', 's', 'p', 'd', 'r', 'v', '\0'};
+    INSERT_PADDING_WORDS(2);
+};
+static_assert(sizeof(NativeWindow) == 0x28, "NativeWindow has wrong size");
+
+} // namespace Service::VI

src/core/hle/service/vi/vi_u.cpp

@@ -1,30 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/logging/log.h"
-#include "core/hle/service/vi/vi.h"
-#include "core/hle/service/vi/vi_u.h"
-
-namespace Service::VI {
-
-VI_U::VI_U(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
-           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
-    : ServiceFramework{system_, "vi:u"}, nv_flinger{nv_flinger_}, hos_binder_driver_server{
-                                                                      hos_binder_driver_server_} {
-    static const FunctionInfo functions[] = {
-        {0, &VI_U::GetDisplayService, "GetDisplayService"},
-        {1, nullptr, "GetDisplayServiceWithProxyNameExchange"},
-    };
-    RegisterHandlers(functions);
-}
-
-VI_U::~VI_U() = default;
-
-void VI_U::GetDisplayService(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_VI, "called");
-
-    detail::GetDisplayServiceImpl(ctx, system, nv_flinger, hos_binder_driver_server,
-                                  Permission::User);
-}
-
-} // namespace Service::VI

src/core/hle/service/vi/vi_u.h

@@ -1,32 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Nvnflinger {
-class HosBinderDriverServer;
-class Nvnflinger;
-} // namespace Service::Nvnflinger
-
-namespace Service::VI {
-
-class VI_U final : public ServiceFramework<VI_U> {
-public:
-    explicit VI_U(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
-                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_);
-    ~VI_U() override;
-
-private:
-    void GetDisplayService(HLERequestContext& ctx);
-
-    Nvnflinger::Nvnflinger& nv_flinger;
-    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
-};
-
-} // namespace Service::VI

src/core/memory.h

@@ -64,6 +64,8 @@ public:
     Memory(Memory&&) = default;
     Memory& operator=(Memory&&) = delete;
 
+    static constexpr bool HAS_FLUSH_INVALIDATION = false;
+
     /**
      * Resets the state of the Memory system.
      */

src/hid_core/resources/hid_firmware_settings.cpp

@@ -22,29 +22,30 @@ void HidFirmwareSettings::LoadSettings(bool reload_config) {
         return;
     }
 
-    m_set_sys->GetSettingsItemValue<bool>(is_debug_pad_enabled, "hid_debug", "enables_debugpad");
-    m_set_sys->GetSettingsItemValue<bool>(is_device_managed, "hid_debug", "manages_devices");
-    m_set_sys->GetSettingsItemValue<bool>(is_touch_i2c_managed, "hid_debug",
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_debug_pad_enabled, "hid_debug",
+                                              "enables_debugpad");
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_device_managed, "hid_debug", "manages_devices");
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_touch_i2c_managed, "hid_debug",
                                               "manages_touch_ic_i2c");
-    m_set_sys->GetSettingsItemValue<bool>(is_future_devices_emulated, "hid_debug",
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_future_devices_emulated, "hid_debug",
                                               "emulate_future_device");
-    m_set_sys->GetSettingsItemValue<bool>(is_mcu_hardware_error_emulated, "hid_debug",
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_mcu_hardware_error_emulated, "hid_debug",
                                               "emulate_mcu_hardware_error");
-    m_set_sys->GetSettingsItemValue<bool>(is_rail_enabled, "hid_debug", "enables_rail");
-    m_set_sys->GetSettingsItemValue<bool>(is_firmware_update_failure_emulated, "hid_debug",
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_rail_enabled, "hid_debug", "enables_rail");
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_firmware_update_failure_emulated, "hid_debug",
                                               "emulate_firmware_update_failure");
     is_firmware_update_failure = {};
-    m_set_sys->GetSettingsItemValue<bool>(is_ble_disabled, "hid_debug", "ble_disabled");
-    m_set_sys->GetSettingsItemValue<bool>(is_dscale_disabled, "hid_debug", "dscale_disabled");
-    m_set_sys->GetSettingsItemValue<bool>(is_handheld_forced, "hid_debug", "force_handheld");
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_ble_disabled, "hid_debug", "ble_disabled");
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_dscale_disabled, "hid_debug", "dscale_disabled");
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_handheld_forced, "hid_debug", "force_handheld");
     features_per_id_disabled = {};
-    m_set_sys->GetSettingsItemValue<bool>(is_touch_firmware_auto_update_disabled, "hid_debug",
+    m_set_sys->GetSettingsItemValueImpl<bool>(is_touch_firmware_auto_update_disabled, "hid_debug",
                                               "touch_firmware_auto_update_disabled");
 
     bool has_rail_interface{};
     bool has_sio_mcu{};
-    m_set_sys->GetSettingsItemValue<bool>(has_rail_interface, "hid", "has_rail_interface");
-    m_set_sys->GetSettingsItemValue<bool>(has_sio_mcu, "hid", "has_sio_mcu");
+    m_set_sys->GetSettingsItemValueImpl<bool>(has_rail_interface, "hid", "has_rail_interface");
+    m_set_sys->GetSettingsItemValueImpl<bool>(has_sio_mcu, "hid", "has_sio_mcu");
     platform_config.has_rail_interface.Assign(has_rail_interface);
     platform_config.has_sio_mcu.Assign(has_sio_mcu);
 

src/hid_core/resources/npad/npad_vibration.cpp

@@ -15,7 +15,7 @@ Result NpadVibration::Activate() {
     std::scoped_lock lock{mutex};
 
     f32 master_volume = 1.0f;
-    m_set_sys->GetVibrationMasterVolume(master_volume);
+    m_set_sys->GetVibrationMasterVolume(&master_volume);
     if (master_volume < 0.0f || master_volume > 1.0f) {
         return ResultVibrationStrengthOutOfRange;
     }
@@ -57,7 +57,7 @@ Result NpadVibration::GetVibrationMasterVolume(f32& out_volume) const {
     std::scoped_lock lock{mutex};
 
     f32 master_volume = 1.0f;
-    m_set_sys->GetVibrationMasterVolume(master_volume);
+    m_set_sys->GetVibrationMasterVolume(&master_volume);
     if (master_volume < 0.0f || master_volume > 1.0f) {
         return ResultVibrationStrengthOutOfRange;
     }
@@ -77,7 +77,7 @@ Result NpadVibration::EndPermitVibrationSession() {
     std::scoped_lock lock{mutex};
 
     f32 master_volume = 1.0f;
-    m_set_sys->GetVibrationMasterVolume(master_volume);
+    m_set_sys->GetVibrationMasterVolume(&master_volume);
     if (master_volume < 0.0f || master_volume > 1.0f) {
         return ResultVibrationStrengthOutOfRange;
     }

src/hid_core/resources/touch_screen/touch_screen_resource.cpp

@@ -48,7 +48,7 @@ Result TouchResource::ActivateTouch() {
     }
 
     Set::TouchScreenMode touch_mode{Set::TouchScreenMode::Standard};
-    m_set_sys->GetTouchScreenMode(touch_mode);
+    m_set_sys->GetTouchScreenMode(&touch_mode);
     default_touch_screen_mode = static_cast<Core::HID::TouchScreenModeForNx>(touch_mode);
 
     global_ref_counter++;

src/video_core/CMakeLists.txt

@@ -60,8 +60,8 @@ add_library(video_core STATIC
     framebuffer_config.h
     fsr.cpp
     fsr.h
-    host1x/codecs/codec.cpp
-    host1x/codecs/codec.h
+    host1x/codecs/decoder.cpp
+    host1x/codecs/decoder.h
     host1x/codecs/h264.cpp
     host1x/codecs/h264.h
     host1x/codecs/vp8.cpp
@@ -80,8 +80,6 @@ add_library(video_core STATIC
     host1x/nvdec.cpp
     host1x/nvdec.h
     host1x/nvdec_common.h
-    host1x/sync_manager.cpp
-    host1x/sync_manager.h
     host1x/syncpoint_manager.cpp
     host1x/syncpoint_manager.h
     host1x/vic.cpp
@@ -392,4 +390,8 @@ if (ANDROID AND ARCHITECTURE_arm64)
     target_link_libraries(video_core PRIVATE adrenotools)
 endif()
 
+if (ARCHITECTURE_arm64)
+    target_link_libraries(video_core PRIVATE sse2neon)
+endif()
+
 create_target_directory_groups(video_core)

src/video_core/buffer_cache/buffer_cache.h

@@ -35,7 +35,7 @@ BufferCache<P>::BufferCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, R
     const s64 min_spacing_critical = device_local_memory - 512_MiB;
     const s64 mem_threshold = std::min(device_local_memory, TARGET_THRESHOLD);
     const s64 min_vacancy_expected = (6 * mem_threshold) / 10;
-    const s64 min_vacancy_critical = (3 * mem_threshold) / 10;
+    const s64 min_vacancy_critical = (2 * mem_threshold) / 10;
     minimum_memory = static_cast<u64>(
         std::max(std::min(device_local_memory - min_vacancy_expected, min_spacing_expected),
                  DEFAULT_EXPECTED_MEMORY));
@@ -1488,7 +1488,10 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
             std::span<const u8> upload_span;
             const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
             if (IsRangeGranular(device_addr, copy.size)) {
-                upload_span = std::span(device_memory.GetPointer<u8>(device_addr), copy.size);
+                auto* const ptr = device_memory.GetPointer<u8>(device_addr);
+                if (ptr != nullptr) {
+                    upload_span = std::span(ptr, copy.size);
+                }
             } else {
                 if (immediate_buffer.empty()) {
                     immediate_buffer = ImmediateBuffer(largest_copy);

src/video_core/cdma_pusher.cpp

@@ -2,37 +2,63 @@
 // SPDX-License-Identifier: MIT
 
 #include <bit>
+
+#include "common/thread.h"
+#include "core/core.h"
 #include "video_core/cdma_pusher.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/host1x/control.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/host1x/nvdec.h"
 #include "video_core/host1x/nvdec_common.h"
-#include "video_core/host1x/sync_manager.h"
 #include "video_core/host1x/vic.h"
 #include "video_core/memory_manager.h"
 
 namespace Tegra {
-CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_)
-    : host1x{host1x_}, nvdec_processor(std::make_shared<Host1x::Nvdec>(host1x)),
-      vic_processor(std::make_unique<Host1x::Vic>(host1x, nvdec_processor)),
-      host1x_processor(std::make_unique<Host1x::Control>(host1x)),
-      sync_manager(std::make_unique<Host1x::SyncptIncrManager>(host1x)) {}
+
+CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
+    : host1x{host1x_}, memory_manager{host1x.GMMU()},
+      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
+                                                                      static_cast<ChClassId>(id)} {
+    thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
+}
 
 CDmaPusher::~CDmaPusher() = default;
 
-void CDmaPusher::ProcessEntries(ChCommandHeaderList&& entries) {
-    for (const auto& value : entries) {
+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};
+            Common::CondvarWait(command_cv, 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(offset + lbs, value.raw);
+                ExecuteCommand(method_offset + lbs, value.raw);
                 continue;
             } else if (count != 0) {
                 --count;
-            ExecuteCommand(offset, value.raw);
+                ExecuteCommand(method_offset, value.raw);
                 if (incrementing) {
-                ++offset;
+                    ++method_offset;
                 }
                 continue;
             }
@@ -40,98 +66,66 @@ void CDmaPusher::ProcessEntries(ChCommandHeaderList&& entries) {
             switch (mode) {
             case ChSubmissionMode::SetClass: {
                 mask = value.value & 0x3f;
-            offset = value.method_offset;
+                method_offset = value.method_offset;
                 current_class = static_cast<ChClassId>((value.value >> 6) & 0x3ff);
                 break;
             }
             case ChSubmissionMode::Incrementing:
             case ChSubmissionMode::NonIncrementing:
                 count = value.value;
-            offset = value.method_offset;
+                method_offset = value.method_offset;
                 incrementing = mode == ChSubmissionMode::Incrementing;
                 break;
             case ChSubmissionMode::Mask:
                 mask = value.value;
-            offset = value.method_offset;
+                method_offset = value.method_offset;
                 break;
             case ChSubmissionMode::Immediate: {
                 const u32 data = value.value & 0xfff;
-            offset = value.method_offset;
-            ExecuteCommand(offset, data);
+                method_offset = value.method_offset;
+                ExecuteCommand(method_offset, data);
                 break;
             }
             default:
-            UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!", static_cast<u32>(mode));
+                LOG_ERROR(HW_GPU, "Bad command at index {} (bytes 0x{: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 state_offset, u32 data) {
+void CDmaPusher::ExecuteCommand(u32 method, u32 arg) {
     switch (current_class) {
-    case ChClassId::NvDec:
-        ThiStateWrite(nvdec_thi_state, offset, data);
-        switch (static_cast<ThiMethod>(offset)) {
-        case ThiMethod::IncSyncpt: {
-            LOG_DEBUG(Service_NVDRV, "NVDEC Class IncSyncpt Method");
-            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
-            const auto cond = static_cast<u32>((data >> 8) & 0xFF);
-            if (cond == 0) {
-                sync_manager->Increment(syncpoint_id);
-            } else {
-                sync_manager->SignalDone(
-                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
-            }
-            break;
-        }
-        case ThiMethod::SetMethod1:
-            LOG_DEBUG(Service_NVDRV, "NVDEC method 0x{:X}",
-                      static_cast<u32>(nvdec_thi_state.method_0));
-            nvdec_processor->ProcessMethod(nvdec_thi_state.method_0, data);
-            break;
-        default:
-            break;
-        }
-        break;
-    case ChClassId::GraphicsVic:
-        ThiStateWrite(vic_thi_state, static_cast<u32>(state_offset), {data});
-        switch (static_cast<ThiMethod>(state_offset)) {
-        case ThiMethod::IncSyncpt: {
-            LOG_DEBUG(Service_NVDRV, "VIC Class IncSyncpt Method");
-            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
-            const auto cond = static_cast<u32>((data >> 8) & 0xFF);
-            if (cond == 0) {
-                sync_manager->Increment(syncpoint_id);
-            } else {
-                sync_manager->SignalDone(
-                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
-            }
-            break;
-        }
-        case ThiMethod::SetMethod1:
-            LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
-                      static_cast<u32>(vic_thi_state.method_0), data);
-            vic_processor->ProcessMethod(static_cast<Host1x::Vic::Method>(vic_thi_state.method_0),
-                                         data);
-            break;
-        default:
-            break;
-        }
-        break;
     case ChClassId::Control:
-        // This device is mainly for syncpoint synchronization
-        LOG_DEBUG(Service_NVDRV, "Host1X Class Method");
-        host1x_processor->ProcessMethod(static_cast<Host1x::Control::Method>(offset), data);
+        LOG_TRACE(Service_NVDRV, "Class {} method 0x{:X} arg 0x{:X}",
+                  static_cast<u32>(current_class), method, arg);
+        host_processor->ProcessMethod(static_cast<Host1x::Control::Method>(method), arg);
         break;
     default:
-        UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class));
+        thi_regs.reg_array[method] = arg;
+        switch (static_cast<ThiMethod>(method)) {
+        case ThiMethod::IncSyncpt: {
+            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;
         }
-}
-
-void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 state_offset, u32 argument) {
-    u8* const offset_ptr = reinterpret_cast<u8*>(&state) + sizeof(u32) * state_offset;
-    std::memcpy(offset_ptr, &argument, sizeof(u32));
+        case ThiMethod::SetMethod1:
+            LOG_TRACE(Service_NVDRV, "Class {} method 0x{: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:
+            break;
+        }
+    }
 }
 
 } // namespace Tegra

src/video_core/cdma_pusher.h

@@ -3,12 +3,18 @@
 
 #pragma once
 
+#include <condition_variable>
+#include <deque>
 #include <memory>
+#include <mutex>
+#include <thread>
 #include <vector>
 
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/polyfill_thread.h"
+#include "core/memory.h"
 
 namespace Tegra {
 
@@ -62,23 +68,31 @@ struct ChCommand {
     std::vector<u32> arguments;
 };
 
-using ChCommandHeaderList = std::vector<ChCommandHeader>;
+using ChCommandHeaderList =
+    Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader, Core::Memory::GuestMemoryFlags::SafeRead>;
 
 struct ThiRegisters {
-    u32_le increment_syncpt{};
-    INSERT_PADDING_WORDS(1);
-    u32_le increment_syncpt_error{};
-    u32_le ctx_switch_incremement_syncpt{};
-    INSERT_PADDING_WORDS(4);
-    u32_le ctx_switch{};
-    INSERT_PADDING_WORDS(1);
-    u32_le ctx_syncpt_eof{};
-    INSERT_PADDING_WORDS(5);
-    u32_le method_0{};
-    u32_le method_1{};
-    INSERT_PADDING_WORDS(12);
-    u32_le int_status{};
-    u32_le int_mask{};
+    static constexpr std::size_t NUM_REGS = 0x20;
+
+    union {
+        struct {
+            u32_le increment_syncpt;
+            INSERT_PADDING_WORDS_NOINIT(1);
+            u32_le increment_syncpt_error;
+            u32_le ctx_switch_incremement_syncpt;
+            INSERT_PADDING_WORDS_NOINIT(4);
+            u32_le ctx_switch;
+            INSERT_PADDING_WORDS_NOINIT(1);
+            u32_le ctx_syncpt_eof;
+            INSERT_PADDING_WORDS_NOINIT(5);
+            u32_le method_0;
+            u32_le method_1;
+            INSERT_PADDING_WORDS_NOINIT(12);
+            u32_le int_status;
+            u32_le int_mask;
+        };
+        std::array<u32, NUM_REGS> reg_array;
+    };
 };
 
 enum class ThiMethod : u32 {
@@ -89,32 +103,39 @@ enum class ThiMethod : u32 {
 
 class CDmaPusher {
 public:
-    explicit CDmaPusher(Host1x::Host1x& host1x);
-    ~CDmaPusher();
+    CDmaPusher() = delete;
+    virtual ~CDmaPusher();
 
-    /// Process the command entry
-    void ProcessEntries(ChCommandHeaderList&& entries);
+    void PushEntries(ChCommandHeaderList&& entries) {
+        std::scoped_lock l{command_mutex};
+        command_lists.push_back(std::move(entries));
+        command_cv.notify_one();
+    }
+
+protected:
+    explicit CDmaPusher(Host1x::Host1x& host1x, s32 id);
+
+    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);
 
-    /// Write arguments value to the ThiRegisters member at the specified offset
-    void ThiStateWrite(ThiRegisters& state, u32 offset, u32 argument);
+    std::unique_ptr<Host1x::Control> host_processor;
 
-    Host1x::Host1x& host1x;
-    std::shared_ptr<Tegra::Host1x::Nvdec> nvdec_processor;
-    std::unique_ptr<Tegra::Host1x::Vic> vic_processor;
-    std::unique_ptr<Tegra::Host1x::Control> host1x_processor;
-    std::unique_ptr<Host1x::SyncptIncrManager> sync_manager;
-    ChClassId current_class{};
-    ThiRegisters vic_thi_state{};
-    ThiRegisters nvdec_thi_state{};
+    std::mutex command_mutex;
+    std::condition_variable_any command_cv;
+    std::deque<ChCommandHeaderList> command_lists;
+    std::jthread thread;
 
-    u32 count{};
-    u32 offset{};
-    u32 mask{};
-    bool incrementing{};
+    ThiRegisters thi_regs{};
+    ChClassId current_class;
 };
 
 } // namespace Tegra

src/video_core/gpu.cpp

@@ -250,30 +250,6 @@ struct GPU::Impl {
         gpu_thread.SubmitList(channel, std::move(entries));
     }
 
-    /// Push GPU command buffer entries to be processed
-    void PushCommandBuffer(u32 id, Tegra::ChCommandHeaderList& entries) {
-        if (!use_nvdec) {
-            return;
-        }
-
-        if (!cdma_pushers.contains(id)) {
-            cdma_pushers.insert_or_assign(id, std::make_unique<Tegra::CDmaPusher>(host1x));
-        }
-
-        // SubmitCommandBuffer would make the nvdec operations async, this is not currently working
-        // TODO(ameerj): RE proper async nvdec operation
-        // gpu_thread.SubmitCommandBuffer(std::move(entries));
-        cdma_pushers[id]->ProcessEntries(std::move(entries));
-    }
-
-    /// Frees the CDMAPusher instance to free up resources
-    void ClearCdmaInstance(u32 id) {
-        const auto iter = cdma_pushers.find(id);
-        if (iter != cdma_pushers.end()) {
-            cdma_pushers.erase(iter);
-        }
-    }
-
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     void FlushRegion(DAddr addr, u64 size) {
         gpu_thread.FlushRegion(addr, size);
@@ -362,7 +338,6 @@ struct GPU::Impl {
     Core::System& system;
     Host1x::Host1x& host1x;
 
-    std::map<u32, std::unique_ptr<Tegra::CDmaPusher>> cdma_pushers;
     std::unique_ptr<VideoCore::RendererBase> renderer;
     VideoCore::RasterizerInterface* rasterizer = nullptr;
     const bool use_nvdec;
@@ -556,14 +531,6 @@ void GPU::PushGPUEntries(s32 channel, Tegra::CommandList&& entries) {
     impl->PushGPUEntries(channel, std::move(entries));
 }
 
-void GPU::PushCommandBuffer(u32 id, Tegra::ChCommandHeaderList& entries) {
-    impl->PushCommandBuffer(id, entries);
-}
-
-void GPU::ClearCdmaInstance(u32 id) {
-    impl->ClearCdmaInstance(id);
-}
-
 VideoCore::RasterizerDownloadArea GPU::OnCPURead(PAddr addr, u64 size) {
     return impl->OnCPURead(addr, size);
 }

src/video_core/gpu.h

@@ -234,15 +234,6 @@ public:
     /// Push GPU command entries to be processed
     void PushGPUEntries(s32 channel, Tegra::CommandList&& entries);
 
-    /// Push GPU command buffer entries to be processed
-    void PushCommandBuffer(u32 id, Tegra::ChCommandHeaderList& entries);
-
-    /// Frees the CDMAPusher instance to free up resources
-    void ClearCdmaInstance(u32 id);
-
-    /// Swap buffers (render frame)
-    void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);
-
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     [[nodiscard]] VideoCore::RasterizerDownloadArea OnCPURead(DAddr addr, u64 size);
 

src/video_core/gpu_thread.cpp

@@ -12,6 +12,7 @@
 #include "video_core/dma_pusher.h"
 #include "video_core/gpu.h"
 #include "video_core/gpu_thread.h"
+#include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
 
 namespace VideoCommon::GPUThread {

src/video_core/host1x/codecs/codec.cpp

@@ -1,113 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/assert.h"
-#include "common/settings.h"
-#include "video_core/host1x/codecs/codec.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/host1x.h"
-#include "video_core/memory_manager.h"
-
-namespace Tegra {
-
-Codec::Codec(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs)
-    : host1x(host1x_), state{regs}, h264_decoder(std::make_unique<Decoder::H264>(host1x)),
-      vp8_decoder(std::make_unique<Decoder::VP8>(host1x)),
-      vp9_decoder(std::make_unique<Decoder::VP9>(host1x)) {}
-
-Codec::~Codec() = default;
-
-void Codec::Initialize() {
-    initialized = decode_api.Initialize(current_codec);
-}
-
-void Codec::SetTargetCodec(Host1x::NvdecCommon::VideoCodec codec) {
-    if (current_codec != codec) {
-        current_codec = codec;
-        LOG_INFO(Service_NVDRV, "NVDEC video codec initialized to {}", GetCurrentCodecName());
-    }
-}
-
-void Codec::Decode() {
-    const bool is_first_frame = !initialized;
-    if (is_first_frame) {
-        Initialize();
-    }
-
-    if (!initialized) {
-        return;
-    }
-
-    // Assemble bitstream.
-    bool vp9_hidden_frame = false;
-    size_t configuration_size = 0;
-    const auto packet_data = [&]() {
-        switch (current_codec) {
-        case Tegra::Host1x::NvdecCommon::VideoCodec::H264:
-            return h264_decoder->ComposeFrame(state, &configuration_size, is_first_frame);
-        case Tegra::Host1x::NvdecCommon::VideoCodec::VP8:
-            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();
-        default:
-            ASSERT(false);
-            return std::span<const u8>{};
-        }
-    }();
-
-    // Send assembled bitstream to decoder.
-    if (!decode_api.SendPacket(packet_data, configuration_size)) {
-        return;
-    }
-
-    // Only receive/store visible frames.
-    if (vp9_hidden_frame) {
-        return;
-    }
-
-    // Receive output frames from decoder.
-    decode_api.ReceiveFrames(frames);
-
-    while (frames.size() > 10) {
-        LOG_DEBUG(HW_GPU, "ReceiveFrames overflow, dropped frame");
-        frames.pop();
-    }
-}
-
-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()) {
-        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:
-        return "None";
-    case Host1x::NvdecCommon::VideoCodec::H264:
-        return "H264";
-    case Host1x::NvdecCommon::VideoCodec::VP8:
-        return "VP8";
-    case Host1x::NvdecCommon::VideoCodec::H265:
-        return "H265";
-    case Host1x::NvdecCommon::VideoCodec::VP9:
-        return "VP9";
-    default:
-        return "Unknown";
-    }
-}
-} // namespace Tegra

src/video_core/host1x/codecs/codec.h

@@ -1,63 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string_view>
-#include <queue>
-#include "common/common_types.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
-
-class Codec {
-public:
-    explicit Codec(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs);
-    ~Codec();
-
-    /// Initialize the codec, returning success or failure
-    void Initialize();
-
-    /// Sets NVDEC video stream codec
-    void SetTargetCodec(Host1x::NvdecCommon::VideoCodec codec);
-
-    /// Call decoders to construct headers, decode AVFrame with ffmpeg
-    void Decode();
-
-    /// 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;
-
-private:
-    bool initialized{};
-    Host1x::NvdecCommon::VideoCodec current_codec{Host1x::NvdecCommon::VideoCodec::None};
-    FFmpeg::DecodeApi decode_api;
-
-    Host1x::Host1x& host1x;
-    const Host1x::NvdecCommon::NvdecRegisters& state;
-    std::unique_ptr<Decoder::H264> h264_decoder;
-    std::unique_ptr<Decoder::VP8> vp8_decoder;
-    std::unique_ptr<Decoder::VP9> vp9_decoder;
-
-    std::queue<std::unique_ptr<FFmpeg::Frame>> frames{};
-};
-
-} // namespace Tegra

src/video_core/host1x/codecs/decoder.cpp

@@ -0,0 +1,71 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/assert.h"
+#include "common/settings.h"
+#include "video_core/host1x/codecs/decoder.h"
+#include "video_core/host1x/host1x.h"
+#include "video_core/memory_manager.h"
+
+namespace Tegra {
+
+Decoder::Decoder(Host1x::Host1x& host1x_, s32 id_, const Host1x::NvdecCommon::NvdecRegisters& regs_,
+                 Host1x::FrameQueue& frame_queue_)
+    : host1x(host1x_), memory_manager{host1x.GMMU()}, regs{regs_}, id{id_}, frame_queue{
+                                                                                frame_queue_} {}
+
+Decoder::~Decoder() = default;
+
+void Decoder::Decode() {
+    if (!initialized) {
+        return;
+    }
+
+    const auto packet_data = ComposeFrame();
+    // Send assembled bitstream to decoder.
+    if (!decode_api.SendPacket(packet_data)) {
+        return;
+    }
+
+    // Only receive/store visible frames.
+    if (vp9_hidden_frame) {
+        return;
+    }
+
+    // Receive output frames from decoder.
+    auto frame = decode_api.ReceiveFrame();
+
+    if (IsInterlaced()) {
+        auto [luma_top, luma_bottom, chroma_top, chroma_bottom] = GetInterlacedOffsets();
+        auto frame_copy = frame;
+
+        if (!frame.get()) {
+            LOG_ERROR(HW_GPU,
+                      "Nvdec {} dailed to decode interlaced frame for top 0x{:X} bottom 0x{:X}", id,
+                      luma_top, luma_bottom);
+        }
+
+        if (UsingDecodeOrder()) {
+            frame_queue.PushDecodeOrder(id, luma_top, std::move(frame));
+            frame_queue.PushDecodeOrder(id, luma_bottom, std::move(frame_copy));
+        } else {
+            frame_queue.PushPresentOrder(id, luma_top, std::move(frame));
+            frame_queue.PushPresentOrder(id, luma_bottom, std::move(frame_copy));
+        }
+    } else {
+        auto [luma_offset, chroma_offset] = GetProgressiveOffsets();
+
+        if (!frame.get()) {
+            LOG_ERROR(HW_GPU, "Nvdec {} failed to decode progressive frame for luma 0x{:X}", id,
+                      luma_offset);
+        }
+
+        if (UsingDecodeOrder()) {
+            frame_queue.PushDecodeOrder(id, luma_offset, std::move(frame));
+        } else {
+            frame_queue.PushPresentOrder(id, luma_offset, std::move(frame));
+        }
+    }
+}
+
+} // namespace Tegra

src/video_core/host1x/codecs/decoder.h

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string_view>
+#include <unordered_map>
+#include <queue>
+
+#include "common/common_types.h"
+#include "video_core/host1x/ffmpeg/ffmpeg.h"
+#include "video_core/host1x/nvdec_common.h"
+
+namespace Tegra {
+
+namespace Host1x {
+class Host1x;
+class FrameQueue;
+} // namespace Host1x
+
+class Decoder {
+public:
+    virtual ~Decoder();
+
+    /// Call decoders to construct headers, decode AVFrame with ffmpeg
+    void Decode();
+
+    bool UsingDecodeOrder() const {
+        return decode_api.UsingDecodeOrder();
+    }
+
+    /// Returns the value of current_codec
+    [[nodiscard]] Host1x::NvdecCommon::VideoCodec GetCurrentCodec() const {
+        return codec;
+    }
+
+    /// Return name of the current codec
+    [[nodiscard]] virtual std::string_view GetCurrentCodecName() const = 0;
+
+protected:
+    explicit Decoder(Host1x::Host1x& host1x, s32 id,
+                     const Host1x::NvdecCommon::NvdecRegisters& regs,
+                     Host1x::FrameQueue& frame_queue);
+
+    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;
+
+    Host1x::Host1x& host1x;
+    Tegra::MemoryManager& memory_manager;
+    const Host1x::NvdecCommon::NvdecRegisters& regs;
+    s32 id;
+    Host1x::FrameQueue& frame_queue;
+    Host1x::NvdecCommon::VideoCodec codec;
+    FFmpeg::DecodeApi decode_api;
+    bool initialized{};
+    bool vp9_hidden_frame{};
+};
+
+} // namespace Tegra

src/video_core/host1x/codecs/h264.cpp

@@ -1,5 +1,5 @@
-// SPDX-FileCopyrightText: Ryujinx Team and Contributors
-// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <array>
 #include <bit>
@@ -10,7 +10,7 @@
 #include "video_core/host1x/host1x.h"
 #include "video_core/memory_manager.h"
 
-namespace Tegra::Decoder {
+namespace Tegra::Decoders {
 namespace {
 // ZigZag LUTs from libavcodec.
 constexpr std::array<u8, 64> zig_zag_direct{
@@ -25,23 +25,56 @@ constexpr std::array<u8, 16> zig_zag_scan{
 };
 } // Anonymous namespace
 
-H264::H264(Host1x::Host1x& host1x_) : host1x{host1x_} {}
+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;
 
-std::span<const u8> H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters& state,
-                                       size_t* out_configuration_size, bool is_first_frame) {
-    H264DecoderContext context;
-    host1x.GMMU().ReadBlock(state.picture_info_offset, &context, sizeof(H264DecoderContext));
+std::tuple<u64, u64> H264::GetProgressiveOffsets() {
+    auto pic_idx{current_context.h264_parameter_set.curr_pic_idx};
+    auto luma{regs.surface_luma_offsets[pic_idx].Address() +
+              current_context.h264_parameter_set.luma_frame_offset.Address()};
+    auto chroma{regs.surface_chroma_offsets[pic_idx].Address() +
+                current_context.h264_parameter_set.chroma_frame_offset.Address()};
+    return {luma, chroma};
+}
 
-    const s64 frame_number = context.h264_parameter_set.frame_number.Value();
+std::tuple<u64, u64, u64, u64> H264::GetInterlacedOffsets() {
+    auto pic_idx{current_context.h264_parameter_set.curr_pic_idx};
+    auto luma_top{regs.surface_luma_offsets[pic_idx].Address() +
+                  current_context.h264_parameter_set.luma_top_offset.Address()};
+    auto luma_bottom{regs.surface_luma_offsets[pic_idx].Address() +
+                     current_context.h264_parameter_set.luma_bot_offset.Address()};
+    auto chroma_top{regs.surface_chroma_offsets[pic_idx].Address() +
+                    current_context.h264_parameter_set.chroma_top_offset.Address()};
+    auto chroma_bottom{regs.surface_chroma_offsets[pic_idx].Address() +
+                       current_context.h264_parameter_set.chroma_bot_offset.Address()};
+    return {luma_top, luma_bottom, chroma_top, chroma_bottom};
+}
+
+bool H264::IsInterlaced() {
+    return current_context.h264_parameter_set.luma_top_offset.Address() != 0 ||
+           current_context.h264_parameter_set.luma_bot_offset.Address() != 0;
+}
+
+std::span<const u8> H264::ComposeFrame() {
+    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.resize_destructive(context.stream_len);
-        host1x.GMMU().ReadBlock(state.frame_bitstream_offset, frame.data(), frame.size());
-        *out_configuration_size = 0;
-        return frame;
+        frame_scratch.resize_destructive(current_context.stream_len);
+        memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(), frame_scratch.data(),
+                                 frame_scratch.size());
+        return frame_scratch;
     }
 
+    is_first_frame = false;
+
     // Encode header
     H264BitWriter writer{};
     writer.WriteU(1, 24);
@@ -53,7 +86,7 @@ std::span<const u8> H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters
     writer.WriteU(31, 8);
     writer.WriteUe(0);
     const u32 chroma_format_idc =
-        static_cast<u32>(context.h264_parameter_set.chroma_format_idc.Value());
+        static_cast<u32>(current_context.h264_parameter_set.chroma_format_idc.Value());
     writer.WriteUe(chroma_format_idc);
     if (chroma_format_idc == 3) {
         writer.WriteBit(false);
@@ -61,42 +94,44 @@ std::span<const u8> H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters
 
     writer.WriteUe(0);
     writer.WriteUe(0);
-    writer.WriteBit(false); // QpprimeYZeroTransformBypassFlag
+    writer.WriteBit(current_context.qpprime_y_zero_transform_bypass_flag.Value() != 0);
     writer.WriteBit(false); // Scaling matrix present flag
 
-    writer.WriteUe(static_cast<u32>(context.h264_parameter_set.log2_max_frame_num_minus4.Value()));
+    writer.WriteUe(
+        static_cast<u32>(current_context.h264_parameter_set.log2_max_frame_num_minus4.Value()));
 
     const auto order_cnt_type =
-        static_cast<u32>(context.h264_parameter_set.pic_order_cnt_type.Value());
+        static_cast<u32>(current_context.h264_parameter_set.pic_order_cnt_type.Value());
     writer.WriteUe(order_cnt_type);
     if (order_cnt_type == 0) {
-        writer.WriteUe(context.h264_parameter_set.log2_max_pic_order_cnt_lsb_minus4);
+        writer.WriteUe(current_context.h264_parameter_set.log2_max_pic_order_cnt_lsb_minus4);
     } else if (order_cnt_type == 1) {
-        writer.WriteBit(context.h264_parameter_set.delta_pic_order_always_zero_flag != 0);
+        writer.WriteBit(current_context.h264_parameter_set.delta_pic_order_always_zero_flag != 0);
 
         writer.WriteSe(0);
         writer.WriteSe(0);
         writer.WriteUe(0);
     }
 
-    const s32 pic_height = context.h264_parameter_set.frame_height_in_map_units /
-                           (context.h264_parameter_set.frame_mbs_only_flag ? 1 : 2);
+    const s32 pic_height = current_context.h264_parameter_set.frame_height_in_mbs /
+                           (current_context.h264_parameter_set.frame_mbs_only_flag ? 1 : 2);
 
-    // TODO (ameerj): Where do we get this number, it seems to be particular for each stream
-    const auto nvdec_decoding = Settings::values.nvdec_emulation.GetValue();
-    const bool uses_gpu_decoding = nvdec_decoding == Settings::NvdecEmulation::Gpu;
-    const u32 max_num_ref_frames = uses_gpu_decoding ? 6u : 16u;
+    u32 max_num_ref_frames =
+        std::max(std::max(current_context.h264_parameter_set.num_refidx_l0_default_active,
+                          current_context.h264_parameter_set.num_refidx_l1_default_active) +
+                     1,
+                 4);
     writer.WriteUe(max_num_ref_frames);
     writer.WriteBit(false);
-    writer.WriteUe(context.h264_parameter_set.pic_width_in_mbs - 1);
+    writer.WriteUe(current_context.h264_parameter_set.pic_width_in_mbs - 1);
     writer.WriteUe(pic_height - 1);
-    writer.WriteBit(context.h264_parameter_set.frame_mbs_only_flag != 0);
+    writer.WriteBit(current_context.h264_parameter_set.frame_mbs_only_flag != 0);
 
-    if (!context.h264_parameter_set.frame_mbs_only_flag) {
-        writer.WriteBit(context.h264_parameter_set.flags.mbaff_frame.Value() != 0);
+    if (!current_context.h264_parameter_set.frame_mbs_only_flag) {
+        writer.WriteBit(current_context.h264_parameter_set.flags.mbaff_frame.Value() != 0);
     }
 
-    writer.WriteBit(context.h264_parameter_set.flags.direct_8x8_inference.Value() != 0);
+    writer.WriteBit(current_context.h264_parameter_set.flags.direct_8x8_inference.Value() != 0);
     writer.WriteBit(false); // Frame cropping flag
     writer.WriteBit(false); // VUI parameter present flag
 
@@ -111,57 +146,59 @@ std::span<const u8> H264::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters
     writer.WriteUe(0);
     writer.WriteUe(0);
 
-    writer.WriteBit(context.h264_parameter_set.entropy_coding_mode_flag != 0);
-    writer.WriteBit(context.h264_parameter_set.pic_order_present_flag != 0);
+    writer.WriteBit(current_context.h264_parameter_set.entropy_coding_mode_flag != 0);
+    writer.WriteBit(current_context.h264_parameter_set.pic_order_present_flag != 0);
     writer.WriteUe(0);
-    writer.WriteUe(context.h264_parameter_set.num_refidx_l0_default_active);
-    writer.WriteUe(context.h264_parameter_set.num_refidx_l1_default_active);
-    writer.WriteBit(context.h264_parameter_set.flags.weighted_pred.Value() != 0);
-    writer.WriteU(static_cast<s32>(context.h264_parameter_set.weighted_bipred_idc.Value()), 2);
-    s32 pic_init_qp = static_cast<s32>(context.h264_parameter_set.pic_init_qp_minus26.Value());
+    writer.WriteUe(current_context.h264_parameter_set.num_refidx_l0_default_active);
+    writer.WriteUe(current_context.h264_parameter_set.num_refidx_l1_default_active);
+    writer.WriteBit(current_context.h264_parameter_set.flags.weighted_pred.Value() != 0);
+    writer.WriteU(static_cast<s32>(current_context.h264_parameter_set.weighted_bipred_idc.Value()),
+                  2);
+    s32 pic_init_qp =
+        static_cast<s32>(current_context.h264_parameter_set.pic_init_qp_minus26.Value());
     writer.WriteSe(pic_init_qp);
     writer.WriteSe(0);
     s32 chroma_qp_index_offset =
-        static_cast<s32>(context.h264_parameter_set.chroma_qp_index_offset.Value());
+        static_cast<s32>(current_context.h264_parameter_set.chroma_qp_index_offset.Value());
 
     writer.WriteSe(chroma_qp_index_offset);
-    writer.WriteBit(context.h264_parameter_set.deblocking_filter_control_present_flag != 0);
-    writer.WriteBit(context.h264_parameter_set.flags.constrained_intra_pred.Value() != 0);
-    writer.WriteBit(context.h264_parameter_set.redundant_pic_cnt_present_flag != 0);
-    writer.WriteBit(context.h264_parameter_set.transform_8x8_mode_flag != 0);
+    writer.WriteBit(current_context.h264_parameter_set.deblocking_filter_control_present_flag != 0);
+    writer.WriteBit(current_context.h264_parameter_set.flags.constrained_intra_pred.Value() != 0);
+    writer.WriteBit(current_context.h264_parameter_set.redundant_pic_cnt_present_flag != 0);
+    writer.WriteBit(current_context.h264_parameter_set.transform_8x8_mode_flag != 0);
 
     writer.WriteBit(true); // pic_scaling_matrix_present_flag
 
     for (s32 index = 0; index < 6; index++) {
         writer.WriteBit(true);
-        std::span<const u8> matrix{context.weight_scale};
-        writer.WriteScalingList(scan, matrix, index * 16, 16);
+        std::span<const u8> matrix{current_context.weight_scale_4x4};
+        writer.WriteScalingList(scan_scratch, matrix, index * 16, 16);
     }
 
-    if (context.h264_parameter_set.transform_8x8_mode_flag) {
+    if (current_context.h264_parameter_set.transform_8x8_mode_flag) {
         for (s32 index = 0; index < 2; index++) {
             writer.WriteBit(true);
-            std::span<const u8> matrix{context.weight_scale_8x8};
-            writer.WriteScalingList(scan, matrix, index * 64, 64);
+            std::span<const u8> matrix{current_context.weight_scale_8x8};
+            writer.WriteScalingList(scan_scratch, matrix, index * 64, 64);
         }
     }
 
     s32 chroma_qp_index_offset2 =
-        static_cast<s32>(context.h264_parameter_set.second_chroma_qp_index_offset.Value());
+        static_cast<s32>(current_context.h264_parameter_set.second_chroma_qp_index_offset.Value());
 
     writer.WriteSe(chroma_qp_index_offset2);
 
     writer.End();
 
     const auto& encoded_header = writer.GetByteArray();
-    frame.resize(encoded_header.size() + context.stream_len);
-    std::memcpy(frame.data(), encoded_header.data(), encoded_header.size());
+    frame_scratch.resize(encoded_header.size() + current_context.stream_len);
+    std::memcpy(frame_scratch.data(), encoded_header.data(), encoded_header.size());
 
-    *out_configuration_size = encoded_header.size();
-    host1x.GMMU().ReadBlock(state.frame_bitstream_offset, frame.data() + encoded_header.size(),
-                            context.stream_len);
+    memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(),
+                             frame_scratch.data() + encoded_header.size(),
+                             current_context.stream_len);
 
-    return frame;
+    return frame_scratch;
 }
 
 H264BitWriter::H264BitWriter() = default;
@@ -278,4 +315,4 @@ void H264BitWriter::Flush() {
     buffer = 0;
     buffer_pos = 0;
 }
-} // namespace Tegra::Decoder
+} // namespace Tegra::Decoders

src/video_core/host1x/codecs/h264.h

@@ -1,5 +1,5 @@
-// SPDX-FileCopyrightText: Ryujinx Team and Contributors
-// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
@@ -10,6 +10,7 @@
 #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/nvdec_common.h"
 
 namespace Tegra {
@@ -18,7 +19,7 @@ namespace Host1x {
 class Host1x;
 } // namespace Host1x
 
-namespace Decoder {
+namespace Decoders {
 
 class H264BitWriter {
 public:
@@ -60,30 +61,27 @@ private:
     std::vector<u8> byte_array;
 };
 
-class H264 {
-public:
-    explicit H264(Host1x::Host1x& host1x);
-    ~H264();
-
-    /// Compose the H264 frame for FFmpeg decoding
-    [[nodiscard]] std::span<const u8> ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters& state,
-                                                   size_t* out_configuration_size,
-                                                   bool is_first_frame = false);
+struct Offset {
+    constexpr u32 Address() const noexcept {
+        return offset << 8;
+    }
 
 private:
-    Common::ScratchBuffer<u8> frame;
-    Common::ScratchBuffer<u8> scan;
-    Host1x::Host1x& host1x;
+    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 {
+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_map_units;         ///< 0x10
+    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
@@ -94,12 +92,12 @@ private:
     u32 transform_8x8_mode_flag;                ///< 0x30
     u32 pitch_luma;                             ///< 0x34
     u32 pitch_chroma;                           ///< 0x38
-        u32 luma_top_offset;                        ///< 0x3C
-        u32 luma_bot_offset;                        ///< 0x40
-        u32 luma_frame_offset;                      ///< 0x44
-        u32 chroma_top_offset;                      ///< 0x48
-        u32 chroma_bot_offset;                      ///< 0x4C
-        u32 chroma_frame_offset;                    ///< 0x50
+    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 {
@@ -125,58 +123,151 @@ private:
         BitField<62, 1, u64> frame_surfaces;
         BitField<63, 1, u64> output_memory_layout;
     };
-    };
-    static_assert(sizeof(H264ParameterSet) == 0x60, "H264ParameterSet is an invalid size");
-
-    struct H264DecoderContext {
-        INSERT_PADDING_WORDS_NOINIT(18);       ///< 0x0000
-        u32 stream_len;                        ///< 0x0048
-        INSERT_PADDING_WORDS_NOINIT(3);        ///< 0x004C
-        H264ParameterSet h264_parameter_set;   ///< 0x0058
-        INSERT_PADDING_WORDS_NOINIT(66);       ///< 0x00B8
-        std::array<u8, 0x60> weight_scale;     ///< 0x01C0
-        std::array<u8, 0x80> weight_scale_8x8; ///< 0x0220
-    };
-    static_assert(sizeof(H264DecoderContext) == 0x2A0, "H264DecoderContext is an invalid size");
+};
+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_map_units, 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);
+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(weight_scale, 0x1C0);
+ASSERT_POSITION(stream_len, 0x48);
+ASSERT_POSITION(h264_parameter_set, 0x58);
+ASSERT_POSITION(dpb, 0xC0);
+ASSERT_POSITION(weight_scale_4x4, 0x1C0);
 #undef ASSERT_POSITION
+
+class H264 final : public Decoder {
+public:
+    explicit H264(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
+                  Host1x::FrameQueue& frame_queue);
+    ~H264() override;
+
+    H264(const H264&) = delete;
+    H264& operator=(const H264&) = delete;
+
+    H264(H264&&) = delete;
+    H264& operator=(H264&&) = delete;
+
+    /// Compose the H264 frame for FFmpeg decoding
+    [[nodiscard]] std::span<const u8> ComposeFrame() override;
+
+    std::tuple<u64, u64> GetProgressiveOffsets() override;
+    std::tuple<u64, u64, u64, u64> GetInterlacedOffsets() override;
+    bool IsInterlaced() override;
+
+    std::string_view GetCurrentCodecName() const override {
+        return "H264";
+    }
+
+private:
+    bool is_first_frame{true};
+    Common::ScratchBuffer<u8> frame_scratch;
+    Common::ScratchBuffer<u8> scan_scratch;
+    H264DecoderContext current_context{};
 };
 
-} // namespace Decoder
+} // namespace Decoders
 } // namespace Tegra

src/video_core/host1x/codecs/vp8.cpp

@@ -7,47 +7,70 @@
 #include "video_core/host1x/host1x.h"
 #include "video_core/memory_manager.h"
 
-namespace Tegra::Decoder {
-VP8::VP8(Host1x::Host1x& host1x_) : host1x{host1x_} {}
+namespace Tegra::Decoders {
+VP8::VP8(Host1x::Host1x& host1x_, const Host1x::NvdecCommon::NvdecRegisters& regs_, s32 id_,
+         Host1x::FrameQueue& frame_queue_)
+    : Decoder{host1x_, id_, regs_, frame_queue_} {
+    codec = Host1x::NvdecCommon::VideoCodec::VP8;
+    initialized = decode_api.Initialize(codec);
+}
 
 VP8::~VP8() = default;
 
-std::span<const u8> VP8::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters& state) {
-    VP8PictureInfo info;
-    host1x.GMMU().ReadBlock(state.picture_info_offset, &info, sizeof(VP8PictureInfo));
+std::tuple<u64, u64> VP8::GetProgressiveOffsets() {
+    auto luma{regs.surface_luma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    auto chroma{regs.surface_chroma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    return {luma, chroma};
+}
 
-    const bool is_key_frame = info.key_frame == 1u;
-    const auto bitstream_size = static_cast<size_t>(info.vld_buffer_size);
+std::tuple<u64, u64, u64, u64> VP8::GetInterlacedOffsets() {
+    auto luma_top{regs.surface_luma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    auto luma_bottom{
+        regs.surface_luma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    auto chroma_top{
+        regs.surface_chroma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    auto chroma_bottom{
+        regs.surface_chroma_offsets[static_cast<u32>(Vp8SurfaceIndex::Current)].Address()};
+    return {luma_top, luma_bottom, chroma_top, chroma_bottom};
+}
+
+std::span<const u8> VP8::ComposeFrame() {
+    memory_manager.ReadBlock(regs.picture_info_offset.Address(), &current_context,
+                             sizeof(VP8PictureInfo));
+
+    const bool is_key_frame = current_context.key_frame == 1u;
+    const auto bitstream_size = static_cast<size_t>(current_context.vld_buffer_size);
     const size_t header_size = is_key_frame ? 10u : 3u;
-    frame.resize(header_size + bitstream_size);
+    frame_scratch.resize(header_size + bitstream_size);
 
     // Based on page 30 of the VP8 specification.
     // https://datatracker.ietf.org/doc/rfc6386/
-    frame[0] = is_key_frame ? 0u : 1u; // 1-bit frame type (0: keyframe, 1: interframes).
-    frame[0] |= static_cast<u8>((info.version & 7u) << 1u); // 3-bit version number
-    frame[0] |= static_cast<u8>(1u << 4u);                  // 1-bit show_frame flag
+    frame_scratch[0] = is_key_frame ? 0u : 1u; // 1-bit frame type (0: keyframe, 1: interframes).
+    frame_scratch[0] |=
+        static_cast<u8>((current_context.version & 7u) << 1u); // 3-bit version number
+    frame_scratch[0] |= static_cast<u8>(1u << 4u);             // 1-bit show_frame flag
 
     // The next 19-bits are the first partition size
-    frame[0] |= static_cast<u8>((info.first_part_size & 7u) << 5u);
-    frame[1] = static_cast<u8>((info.first_part_size & 0x7f8u) >> 3u);
-    frame[2] = static_cast<u8>((info.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[3] = 0x9du;
-        frame[4] = 0x01u;
-        frame[5] = 0x2au;
+        frame_scratch[3] = 0x9du;
+        frame_scratch[4] = 0x01u;
+        frame_scratch[5] = 0x2au;
         // TODO(ameerj): Horizontal/Vertical Scale
         // 16 bits: (2 bits Horizontal Scale << 14) | Width (14 bits)
-        frame[6] = static_cast<u8>(info.frame_width & 0xff);
-        frame[7] = static_cast<u8>(((info.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[8] = static_cast<u8>(info.frame_height & 0xff);
-        frame[9] = static_cast<u8>(((info.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 = state.frame_bitstream_offset;
-    host1x.GMMU().ReadBlock(bitstream_offset, frame.data() + header_size, bitstream_size);
+    const u64 bitstream_offset = regs.frame_bitstream_offset.Address();
+    memory_manager.ReadBlock(bitstream_offset, frame_scratch.data() + header_size, bitstream_size);
 
-    return frame;
+    return frame_scratch;
 }
 
-} // namespace Tegra::Decoder
+} // namespace Tegra::Decoders

src/video_core/host1x/codecs/vp8.h

@@ -9,6 +9,7 @@
 #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/nvdec_common.h"
 
 namespace Tegra {
@@ -17,20 +18,41 @@ namespace Host1x {
 class Host1x;
 } // namespace Host1x
 
-namespace Decoder {
+namespace Decoders {
+enum class Vp8SurfaceIndex : u32 {
+    Last = 0,
+    Golden = 1,
+    AltRef = 2,
+    Current = 3,
+};
 
-class VP8 {
+class VP8 final : public Decoder {
 public:
-    explicit VP8(Host1x::Host1x& host1x);
-    ~VP8();
+    explicit VP8(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
+                 Host1x::FrameQueue& frame_queue);
+    ~VP8() override;
 
-    /// Compose the VP8 frame for FFmpeg decoding
-    [[nodiscard]] std::span<const u8> ComposeFrame(
-        const Host1x::NvdecCommon::NvdecRegisters& state);
+    VP8(const VP8&) = delete;
+    VP8& operator=(const VP8&) = delete;
+
+    VP8(VP8&&) = delete;
+    VP8& operator=(VP8&&) = delete;
+
+    [[nodiscard]] std::span<const u8> ComposeFrame() override;
+
+    std::tuple<u64, u64> GetProgressiveOffsets() override;
+    std::tuple<u64, u64, u64, u64> GetInterlacedOffsets() override;
+
+    bool IsInterlaced() override {
+        return false;
+    }
+
+    std::string_view GetCurrentCodecName() const override {
+        return "VP8";
+    }
 
 private:
-    Common::ScratchBuffer<u8> frame;
-    Host1x::Host1x& host1x;
+    Common::ScratchBuffer<u8> frame_scratch;
 
     struct VP8PictureInfo {
         INSERT_PADDING_WORDS_NOINIT(14);
@@ -73,7 +95,9 @@ private:
         INSERT_PADDING_WORDS_NOINIT(3);
     };
     static_assert(sizeof(VP8PictureInfo) == 0xc0, "PictureInfo is an invalid size");
+
+    VP8PictureInfo current_context{};
 };
 
-} // namespace Decoder
+} // namespace Decoders
 } // namespace Tegra

src/video_core/host1x/codecs/vp9.cpp

@@ -4,12 +4,13 @@
 #include <algorithm> // for std::copy
 #include <numeric>
 
+#include "common/alignment.h"
 #include "common/assert.h"
 #include "video_core/host1x/codecs/vp9.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/memory_manager.h"
 
-namespace Tegra::Decoder {
+namespace Tegra::Decoders {
 namespace {
 constexpr u32 diff_update_probability = 252;
 constexpr u32 frame_sync_code = 0x498342;
@@ -237,7 +238,12 @@ constexpr std::array<u8, 254> map_lut{
 }
 } // Anonymous namespace
 
-VP9::VP9(Host1x::Host1x& host1x_) : host1x{host1x_} {}
+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;
 
@@ -356,34 +362,112 @@ void VP9::WriteMvProbabilityUpdate(VpxRangeEncoder& writer, u8 new_prob, u8 old_
     }
 }
 
-Vp9PictureInfo VP9::GetVp9PictureInfo(const Host1x::NvdecCommon::NvdecRegisters& state) {
-    PictureInfo picture_info;
-    host1x.GMMU().ReadBlock(state.picture_info_offset, &picture_info, sizeof(PictureInfo));
-    Vp9PictureInfo vp9_info = picture_info.Convert();
+void VP9::WriteSegmentation(VpxBitStreamWriter& writer) {
+    bool enabled = current_picture_info.segmentation.enabled != 0;
+    writer.WriteBit(enabled);
+    if (!enabled) {
+        return;
+    }
 
-    InsertEntropy(state.vp9_entropy_probs_offset, vp9_info.entropy);
+    auto update_map = current_picture_info.segmentation.update_map != 0;
+    writer.WriteBit(update_map);
+
+    if (update_map) {
+        EntropyProbs 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;
+            writer.WriteBit(coded);
+            if (coded) {
+                writer.WriteU(prob, 8);
+            }
+        };
+
+        for (size_t i = 0; i < entropy_probs.mb_segment_tree_probs.size(); i++) {
+            WriteProb(entropy_probs.mb_segment_tree_probs[i]);
+        }
+
+        auto temporal_update = current_picture_info.segmentation.temporal_update != 0;
+        writer.WriteBit(temporal_update);
+
+        if (temporal_update) {
+            for (s32 i = 0; i < 3; i++) {
+                WriteProb(entropy_probs.segment_pred_probs[i]);
+            }
+        }
+    }
+
+    if (last_segmentation == current_picture_info.segmentation) {
+        writer.WriteBit(false);
+        return;
+    }
+
+    last_segmentation = current_picture_info.segmentation;
+    writer.WriteBit(true);
+    writer.WriteBit(current_picture_info.segmentation.abs_delta != 0);
+
+    constexpr s32 MAX_SEGMENTS = 8;
+    constexpr std::array SegmentationFeatureBits = {8, 6, 2, 0};
+
+    for (s32 i = 0; i < MAX_SEGMENTS; i++) {
+        auto q_enabled = current_picture_info.segmentation.feature_enabled[i][0] != 0;
+        writer.WriteBit(q_enabled);
+        if (q_enabled) {
+            writer.WriteS(current_picture_info.segmentation.feature_data[i][0],
+                          SegmentationFeatureBits[0]);
+        }
+
+        auto lf_enabled = current_picture_info.segmentation.feature_enabled[i][1] != 0;
+        writer.WriteBit(lf_enabled);
+        if (lf_enabled) {
+            writer.WriteS(current_picture_info.segmentation.feature_data[i][1],
+                          SegmentationFeatureBits[1]);
+        }
+
+        auto ref_enabled = current_picture_info.segmentation.feature_enabled[i][2] != 0;
+        writer.WriteBit(ref_enabled);
+        if (ref_enabled) {
+            writer.WriteU(current_picture_info.segmentation.feature_data[i][2],
+                          SegmentationFeatureBits[2]);
+        }
+
+        auto skip_enabled = current_picture_info.segmentation.feature_enabled[i][3] != 0;
+        writer.WriteBit(skip_enabled);
+    }
+}
+
+Vp9PictureInfo VP9::GetVp9PictureInfo() {
+    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);
 
     // surface_luma_offset[0:3] contains the address of the reference frame offsets in the following
     // order: last, golden, altref, current.
-    std::copy(state.surface_luma_offset.begin(), state.surface_luma_offset.begin() + 4,
-              vp9_info.frame_offsets.begin());
+    for (size_t i = 0; i < 4; i++) {
+        vp9_info.frame_offsets[i] = regs.surface_luma_offsets[i].Address();
+    }
 
     return vp9_info;
 }
 
 void VP9::InsertEntropy(u64 offset, Vp9EntropyProbs& dst) {
     EntropyProbs entropy;
-    host1x.GMMU().ReadBlock(offset, &entropy, sizeof(EntropyProbs));
+    memory_manager.ReadBlock(offset, &entropy, sizeof(EntropyProbs));
     entropy.Convert(dst);
 }
 
-Vp9FrameContainer VP9::GetCurrentFrame(const Host1x::NvdecCommon::NvdecRegisters& state) {
+Vp9FrameContainer VP9::GetCurrentFrame() {
     Vp9FrameContainer current_frame{};
     {
         // gpu.SyncGuestHost(); epic, why?
-        current_frame.info = GetVp9PictureInfo(state);
+        current_frame.info = GetVp9PictureInfo();
         current_frame.bit_stream.resize(current_frame.info.bitstream_size);
-        host1x.GMMU().ReadBlock(state.frame_bitstream_offset, current_frame.bit_stream.data(),
+        memory_manager.ReadBlock(regs.frame_bitstream_offset.Address(),
+                                 current_frame.bit_stream.data(),
                                  current_frame.info.bitstream_size);
     }
     if (!next_frame.bit_stream.empty()) {
@@ -742,8 +826,7 @@ VpxBitStreamWriter VP9::ComposeUncompressedHeader() {
     uncomp_writer.WriteDeltaQ(current_frame_info.uv_dc_delta_q);
     uncomp_writer.WriteDeltaQ(current_frame_info.uv_ac_delta_q);
 
-    ASSERT(!current_frame_info.segment_enabled);
-    uncomp_writer.WriteBit(false); // Segmentation enabled (TODO).
+    WriteSegmentation(uncomp_writer);
 
     const s32 min_tile_cols_log2 = CalcMinLog2TileCols(current_frame_info.frame_size.width);
     const s32 max_tile_cols_log2 = CalcMaxLog2TileCols(current_frame_info.frame_size.width);
@@ -770,10 +853,29 @@ VpxBitStreamWriter VP9::ComposeUncompressedHeader() {
     return uncomp_writer;
 }
 
-void VP9::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters& state) {
+std::tuple<u64, u64> VP9::GetProgressiveOffsets() {
+    auto luma{regs.surface_luma_offsets[static_cast<u32>(Vp9SurfaceIndex::Current)].Address()};
+    auto chroma{regs.surface_chroma_offsets[static_cast<u32>(Vp9SurfaceIndex::Current)].Address()};
+    return {luma, chroma};
+}
+
+std::tuple<u64, u64, u64, u64> VP9::GetInterlacedOffsets() {
+    auto luma_top{regs.surface_luma_offsets[static_cast<u32>(Vp9SurfaceIndex::Current)].Address()};
+    auto luma_bottom{
+        regs.surface_luma_offsets[static_cast<u32>(Vp9SurfaceIndex::Current)].Address()};
+    auto chroma_top{
+        regs.surface_chroma_offsets[static_cast<u32>(Vp9SurfaceIndex::Current)].Address()};
+    auto chroma_bottom{
+        regs.surface_chroma_offsets[static_cast<u32>(Vp9SurfaceIndex::Current)].Address()};
+    return {luma_top, luma_bottom, chroma_top, chroma_bottom};
+}
+
+std::span<const u8> VP9::ComposeFrame() {
+    vp9_hidden_frame = false;
+
     std::vector<u8> bitstream;
     {
-        Vp9FrameContainer curr_frame = GetCurrentFrame(state);
+        Vp9FrameContainer curr_frame = GetCurrentFrame();
         current_frame_info = curr_frame.info;
         bitstream = std::move(curr_frame.bit_stream);
     }
@@ -786,12 +888,16 @@ void VP9::ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters& state) {
     std::vector<u8> uncompressed_header = uncomp_writer.GetByteArray();
 
     // Write headers and frame to buffer
-    frame.resize(uncompressed_header.size() + compressed_header.size() + bitstream.size());
-    std::copy(uncompressed_header.begin(), uncompressed_header.end(), frame.begin());
+    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.begin() + uncompressed_header.size());
+              frame_scratch.begin() + uncompressed_header.size());
     std::copy(bitstream.begin(), bitstream.end(),
-              frame.begin() + uncompressed_header.size() + compressed_header.size());
+              frame_scratch.begin() + uncompressed_header.size() + compressed_header.size());
+
+    vp9_hidden_frame = WasFrameHidden();
+
+    return GetFrameBytes();
 }
 
 VpxRangeEncoder::VpxRangeEncoder() {
@@ -944,4 +1050,4 @@ const std::vector<u8>& VpxBitStreamWriter::GetByteArray() const {
     return byte_array;
 }
 
-} // namespace Tegra::Decoder
+} // namespace Tegra::Decoders

src/video_core/host1x/codecs/vp9.h

@@ -10,6 +10,7 @@
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
 #include "common/stream.h"
+#include "video_core/host1x/codecs/decoder.h"
 #include "video_core/host1x/codecs/vp9_types.h"
 #include "video_core/host1x/nvdec_common.h"
 
@@ -19,7 +20,7 @@ namespace Host1x {
 class Host1x;
 } // namespace Host1x
 
-namespace Decoder {
+namespace Decoders {
 
 /// The VpxRangeEncoder, and VpxBitStreamWriter classes are used to compose the
 /// VP9 header bitstreams.
@@ -110,21 +111,32 @@ private:
     std::vector<u8> byte_array;
 };
 
-class VP9 {
+class VP9 final : public Decoder {
 public:
-    explicit VP9(Host1x::Host1x& host1x);
-    ~VP9();
+    explicit VP9(Host1x::Host1x& host1x, const Host1x::NvdecCommon::NvdecRegisters& regs, s32 id,
+                 Host1x::FrameQueue& frame_queue);
+    ~VP9() override;
 
     VP9(const VP9&) = delete;
     VP9& operator=(const VP9&) = delete;
 
-    VP9(VP9&&) = default;
+    VP9(VP9&&) = delete;
     VP9& operator=(VP9&&) = delete;
 
-    /// Composes the VP9 frame from the GPU state information.
-    /// Based on the official VP9 spec documentation
-    void ComposeFrame(const Host1x::NvdecCommon::NvdecRegisters& state);
+    [[nodiscard]] std::span<const u8> ComposeFrame() override;
 
+    std::tuple<u64, u64> GetProgressiveOffsets() override;
+    std::tuple<u64, u64, u64, u64> GetInterlacedOffsets() override;
+
+    bool IsInterlaced() override {
+        return false;
+    }
+
+    std::string_view GetCurrentCodecName() const override {
+        return "VP9";
+    }
+
+private:
     /// Returns true if the most recent frame was a hidden frame.
     [[nodiscard]] bool WasFrameHidden() const {
         return !current_frame_info.show_frame;
@@ -132,10 +144,9 @@ public:
 
     /// Returns a const span to the composed frame data.
     [[nodiscard]] std::span<const u8> GetFrameBytes() const {
-        return frame;
+        return frame_scratch;
     }
 
-private:
     /// Generates compressed header probability updates in the bitstream writer
     template <typename T, std::size_t N>
     void WriteProbabilityUpdate(VpxRangeEncoder& writer, const std::array<T, N>& new_prob,
@@ -167,23 +178,22 @@ private:
     /// Write motion vector probability updates. 6.3.17 in the spec
     void WriteMvProbabilityUpdate(VpxRangeEncoder& writer, u8 new_prob, u8 old_prob);
 
+    void WriteSegmentation(VpxBitStreamWriter& writer);
+
     /// Returns VP9 information from NVDEC provided offset and size
-    [[nodiscard]] Vp9PictureInfo GetVp9PictureInfo(
-        const Host1x::NvdecCommon::NvdecRegisters& state);
+    [[nodiscard]] Vp9PictureInfo GetVp9PictureInfo();
 
     /// Read and convert NVDEC provided entropy probs to Vp9EntropyProbs struct
     void InsertEntropy(u64 offset, Vp9EntropyProbs& dst);
 
     /// Returns frame to be decoded after buffering
-    [[nodiscard]] Vp9FrameContainer GetCurrentFrame(
-        const Host1x::NvdecCommon::NvdecRegisters& state);
+    [[nodiscard]] Vp9FrameContainer GetCurrentFrame();
 
     /// Use NVDEC providied information to compose the headers for the current frame
     [[nodiscard]] std::vector<u8> ComposeCompressedHeader();
     [[nodiscard]] VpxBitStreamWriter ComposeUncompressedHeader();
 
-    Host1x::Host1x& host1x;
-    Common::ScratchBuffer<u8> frame;
+    Common::ScratchBuffer<u8> frame_scratch;
 
     std::array<s8, 4> loop_filter_ref_deltas{};
     std::array<s8, 2> loop_filter_mode_deltas{};
@@ -192,9 +202,11 @@ private:
     std::array<Vp9EntropyProbs, 4> frame_ctxs{};
     bool swap_ref_indices{};
 
+    Segmentation last_segmentation{};
+    PictureInfo current_picture_info{};
     Vp9PictureInfo current_frame_info{};
     Vp9EntropyProbs prev_frame_probs{};
 };
 
-} // namespace Decoder
+} // namespace Decoders
 } // namespace Tegra

src/video_core/host1x/codecs/vp9_types.h

@@ -11,7 +11,14 @@
 
 namespace Tegra {
 
-namespace Decoder {
+namespace Decoders {
+enum class Vp9SurfaceIndex : u32 {
+    Last = 0,
+    Golden = 1,
+    AltRef = 2,
+    Current = 3,
+};
+
 struct Vp9FrameDimensions {
     s16 width;
     s16 height;
@@ -48,11 +55,13 @@ enum class TxMode {
 };
 
 struct Segmentation {
+    constexpr bool operator==(const Segmentation& rhs) const = default;
+
     u8 enabled;
     u8 update_map;
     u8 temporal_update;
     u8 abs_delta;
-    std::array<u32, 8> feature_mask;
+    std::array<std::array<u8, 4>, 8> feature_enabled;
     std::array<std::array<s16, 4>, 8> feature_data;
 };
 static_assert(sizeof(Segmentation) == 0x64, "Segmentation is an invalid size");
@@ -190,7 +199,17 @@ struct PictureInfo {
 static_assert(sizeof(PictureInfo) == 0x100, "PictureInfo is an invalid size");
 
 struct EntropyProbs {
-    INSERT_PADDING_BYTES_NOINIT(1024);                 ///< 0x0000
+    std::array<u8, 10 * 10 * 8> kf_bmode_prob;         ///< 0x0000
+    std::array<u8, 10 * 10 * 1> kf_bmode_probB;        ///< 0x0320
+    std::array<u8, 3> ref_pred_probs;                  ///< 0x0384
+    std::array<u8, 7> mb_segment_tree_probs;           ///< 0x0387
+    std::array<u8, 3> segment_pred_probs;              ///< 0x038E
+    std::array<u8, 4> ref_scores;                      ///< 0x0391
+    std::array<u8, 2> prob_comppred;                   ///< 0x0395
+    INSERT_PADDING_BYTES_NOINIT(9);                    ///< 0x0397
+    std::array<u8, 10 * 8> kf_uv_mode_prob;            ///< 0x03A0
+    std::array<u8, 10 * 1> kf_uv_mode_probB;           ///< 0x03F0
+    INSERT_PADDING_BYTES_NOINIT(6);                    ///< 0x03FA
     std::array<u8, 28> inter_mode_prob;                ///< 0x0400
     std::array<u8, 4> intra_inter_prob;                ///< 0x041C
     INSERT_PADDING_BYTES_NOINIT(80);                   ///< 0x0420
@@ -302,5 +321,5 @@ ASSERT_POSITION(class_0_fr, 0x560);
 ASSERT_POSITION(coef_probs, 0x5A0);
 #undef ASSERT_POSITION
 
-}; // namespace Decoder
+}; // namespace Decoders
 }; // namespace Tegra

src/video_core/host1x/control.cpp

@@ -27,6 +27,7 @@ void Control::ProcessMethod(Method method, u32 argument) {
 }
 
 void Control::Execute(u32 data) {
+    LOG_TRACE(Service_NVDRV, "Control wait syncpt {} value {}", data, syncpoint_value);
     host1x.GetSyncpointManager().WaitHost(data, syncpoint_value);
 }
 

src/video_core/host1x/control.h

@@ -6,9 +6,7 @@
 
 #include "common/common_types.h"
 
-namespace Tegra {
-
-namespace Host1x {
+namespace Tegra::Host1x {
 
 class Host1x;
 class Nvdec;
@@ -31,10 +29,8 @@ private:
     /// For Host1x, execute is waiting on a syncpoint previously written into the state
     void Execute(u32 data);
 
-    u32 syncpoint_value{};
     Host1x& host1x;
+    u32 syncpoint_value{};
 };
 
-} // namespace Host1x
-
-} // namespace Tegra
+} // namespace Tegra::Host1x

src/video_core/host1x/ffmpeg/ffmpeg.cpp

@@ -5,7 +5,9 @@
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
+#include "core/memory.h"
 #include "video_core/host1x/ffmpeg/ffmpeg.h"
+#include "video_core/memory_manager.h"
 
 extern "C" {
 #ifdef LIBVA_FOUND
@@ -149,6 +151,7 @@ bool HardwareContext::InitializeForDecoder(DecoderContext& decoder_context,
         }
     }
 
+    LOG_INFO(HW_GPU, "Hardware decoding is disabled due to implementation issues, using CPU.");
     return false;
 }
 
@@ -183,8 +186,8 @@ bool HardwareContext::InitializeWithType(AVHWDeviceType type) {
     return true;
 }
 
-DecoderContext::DecoderContext(const Decoder& decoder) {
-    m_codec_context = avcodec_alloc_context3(decoder.GetCodec());
+DecoderContext::DecoderContext(const Decoder& decoder) : m_decoder{decoder} {
+    m_codec_context = avcodec_alloc_context3(m_decoder.GetCodec());
     av_opt_set(m_codec_context->priv_data, "tune", "zerolatency", 0);
     m_codec_context->thread_count = 0;
     m_codec_context->thread_type &= ~FF_THREAD_FRAME;
@@ -216,6 +219,25 @@ bool DecoderContext::OpenContext(const Decoder& decoder) {
 }
 
 bool DecoderContext::SendPacket(const Packet& packet) {
+    m_temp_frame = std::make_shared<Frame>();
+    m_got_frame = 0;
+
+// Android can randomly crash when calling decode directly, so skip.
+// TODO update ffmpeg and hope that fixes it.
+#ifndef ANDROID
+    if (!m_codec_context->hw_device_ctx && m_codec_context->codec_id == AV_CODEC_ID_H264) {
+        m_decode_order = true;
+        auto* codec{ffcodec(m_decoder.GetCodec())};
+        if (const int ret = codec->cb.decode(m_codec_context, m_temp_frame->GetFrame(),
+                                             &m_got_frame, packet.GetPacket());
+            ret < 0) {
+            LOG_DEBUG(Service_NVDRV, "avcodec_send_packet error {}", AVError(ret));
+            return false;
+        }
+        return true;
+    }
+#endif
+
     if (const int ret = avcodec_send_packet(m_codec_context, packet.GetPacket()); ret < 0) {
         LOG_ERROR(HW_GPU, "avcodec_send_packet error: {}", AVError(ret));
         return false;
@@ -224,8 +246,31 @@ bool DecoderContext::SendPacket(const Packet& packet) {
     return true;
 }
 
-std::unique_ptr<Frame> DecoderContext::ReceiveFrame(bool* out_is_interlaced) {
-    auto dst_frame = std::make_unique<Frame>();
+std::shared_ptr<Frame> DecoderContext::ReceiveFrame() {
+    // Android can randomly crash when calling decode directly, so skip.
+    // TODO update ffmpeg and hope that fixes it.
+#ifndef ANDROID
+    if (!m_codec_context->hw_device_ctx && m_codec_context->codec_id == AV_CODEC_ID_H264) {
+        m_decode_order = true;
+        auto* codec{ffcodec(m_decoder.GetCodec())};
+        int ret{0};
+
+        if (m_got_frame == 0) {
+            Packet packet{{}};
+            auto* pkt = packet.GetPacket();
+            pkt->data = nullptr;
+            pkt->size = 0;
+            ret = codec->cb.decode(m_codec_context, m_temp_frame->GetFrame(), &m_got_frame, pkt);
+            m_codec_context->has_b_frames = 0;
+        }
+
+        if (m_got_frame == 0 || ret < 0) {
+            LOG_ERROR(Service_NVDRV, "Failed to receive a frame! error {}", ret);
+            return {};
+        }
+    } else
+#endif
+    {
 
         const auto ReceiveImpl = [&](AVFrame* frame) {
             if (const int ret = avcodec_receive_frame(m_codec_context, frame); ret < 0) {
@@ -233,12 +278,6 @@ std::unique_ptr<Frame> DecoderContext::ReceiveFrame(bool* out_is_interlaced) {
                 return false;
             }
 
-        *out_is_interlaced =
-#if defined(FF_API_INTERLACED_FRAME) || LIBAVUTIL_VERSION_MAJOR >= 59
-            (frame->flags & AV_FRAME_FLAG_INTERLACED) != 0;
-#else
-            frame->interlaced_frame != 0;
-#endif
             return true;
         };
 
@@ -251,112 +290,29 @@ std::unique_ptr<Frame> DecoderContext::ReceiveFrame(bool* out_is_interlaced) {
                 return {};
             }
 
-        dst_frame->SetFormat(PreferredGpuFormat);
-        if (const int ret =
-                av_hwframe_transfer_data(dst_frame->GetFrame(), intermediate_frame.GetFrame(), 0);
+            m_temp_frame->SetFormat(PreferredGpuFormat);
+            if (const int ret = av_hwframe_transfer_data(m_temp_frame->GetFrame(),
+                                                         intermediate_frame.GetFrame(), 0);
                 ret < 0) {
                 LOG_ERROR(HW_GPU, "av_hwframe_transfer_data error: {}", AVError(ret));
                 return {};
             }
         } else {
             // Otherwise, decode the frame as normal.
-        if (!ReceiveImpl(dst_frame->GetFrame())) {
+            if (!ReceiveImpl(m_temp_frame->GetFrame())) {
                 return {};
             }
         }
-
-    return dst_frame;
-}
-
-DeinterlaceFilter::DeinterlaceFilter(const Frame& frame) {
-    const AVFilter* buffer_src = avfilter_get_by_name("buffer");
-    const AVFilter* buffer_sink = avfilter_get_by_name("buffersink");
-    AVFilterInOut* inputs = avfilter_inout_alloc();
-    AVFilterInOut* outputs = avfilter_inout_alloc();
-    SCOPE_EXIT({
-        avfilter_inout_free(&inputs);
-        avfilter_inout_free(&outputs);
-    });
-
-    // Don't know how to get the accurate time_base but it doesn't matter for yadif filter
-    // so just use 1/1 to make buffer filter happy
-    std::string args = fmt::format("video_size={}x{}:pix_fmt={}:time_base=1/1", frame.GetWidth(),
-                                   frame.GetHeight(), static_cast<int>(frame.GetPixelFormat()));
-
-    m_filter_graph = avfilter_graph_alloc();
-    int ret = avfilter_graph_create_filter(&m_source_context, buffer_src, "in", args.c_str(),
-                                           nullptr, m_filter_graph);
-    if (ret < 0) {
-        LOG_ERROR(HW_GPU, "avfilter_graph_create_filter source error: {}", AVError(ret));
-        return;
     }
 
-    ret = avfilter_graph_create_filter(&m_sink_context, buffer_sink, "out", nullptr, nullptr,
-                                       m_filter_graph);
-    if (ret < 0) {
-        LOG_ERROR(HW_GPU, "avfilter_graph_create_filter sink error: {}", AVError(ret));
-        return;
-    }
-
-    inputs->name = av_strdup("out");
-    inputs->filter_ctx = m_sink_context;
-    inputs->pad_idx = 0;
-    inputs->next = nullptr;
-
-    outputs->name = av_strdup("in");
-    outputs->filter_ctx = m_source_context;
-    outputs->pad_idx = 0;
-    outputs->next = nullptr;
-
-    const char* description = "yadif=1:-1:0";
-    ret = avfilter_graph_parse_ptr(m_filter_graph, description, &inputs, &outputs, nullptr);
-    if (ret < 0) {
-        LOG_ERROR(HW_GPU, "avfilter_graph_parse_ptr error: {}", AVError(ret));
-        return;
-    }
-
-    ret = avfilter_graph_config(m_filter_graph, nullptr);
-    if (ret < 0) {
-        LOG_ERROR(HW_GPU, "avfilter_graph_config error: {}", AVError(ret));
-        return;
-    }
-
-    m_initialized = true;
-}
-
-bool DeinterlaceFilter::AddSourceFrame(const Frame& frame) {
-    if (const int ret = av_buffersrc_add_frame_flags(m_source_context, frame.GetFrame(),
-                                                     AV_BUFFERSRC_FLAG_KEEP_REF);
-        ret < 0) {
-        LOG_ERROR(HW_GPU, "av_buffersrc_add_frame_flags error: {}", AVError(ret));
-        return false;
-    }
-
-    return true;
-}
-
-std::unique_ptr<Frame> DeinterlaceFilter::DrainSinkFrame() {
-    auto dst_frame = std::make_unique<Frame>();
-    const int ret = av_buffersink_get_frame(m_sink_context, dst_frame->GetFrame());
-
-    if (ret == AVERROR(EAGAIN) || ret == AVERROR(AVERROR_EOF)) {
-        return {};
-    }
-
-    if (ret < 0) {
-        LOG_ERROR(HW_GPU, "av_buffersink_get_frame error: {}", AVError(ret));
-        return {};
-    }
-
-    return dst_frame;
-}
-
-DeinterlaceFilter::~DeinterlaceFilter() {
-    avfilter_graph_free(&m_filter_graph);
+#if defined(FF_API_INTERLACED_FRAME) || LIBAVUTIL_VERSION_MAJOR >= 59
+    m_temp_frame->GetFrame()->interlaced_frame =
+        (m_temp_frame->GetFrame()->flags & AV_FRAME_FLAG_INTERLACED) != 0;
+#endif
+    return std::move(m_temp_frame);
 }
 
 void DecodeApi::Reset() {
-    m_deinterlace_filter.reset();
     m_hardware_context.reset();
     m_decoder_context.reset();
     m_decoder.reset();
@@ -382,43 +338,14 @@ bool DecodeApi::Initialize(Tegra::Host1x::NvdecCommon::VideoCodec codec) {
     return true;
 }
 
-bool DecodeApi::SendPacket(std::span<const u8> packet_data, size_t configuration_size) {
+bool DecodeApi::SendPacket(std::span<const u8> packet_data) {
     FFmpeg::Packet packet(packet_data);
     return m_decoder_context->SendPacket(packet);
 }
 
-void DecodeApi::ReceiveFrames(std::queue<std::unique_ptr<Frame>>& frame_queue) {
+std::shared_ptr<Frame> DecodeApi::ReceiveFrame() {
     // Receive raw frame from decoder.
-    bool is_interlaced;
-    auto frame = m_decoder_context->ReceiveFrame(&is_interlaced);
-    if (!frame) {
-        return;
-    }
-
-    if (!is_interlaced) {
-        // If the frame is not interlaced, we can pend it now.
-        frame_queue.push(std::move(frame));
-    } else {
-        // Create the deinterlacer if needed.
-        if (!m_deinterlace_filter) {
-            m_deinterlace_filter.emplace(*frame);
-        }
-
-        // Add the frame we just received.
-        if (!m_deinterlace_filter->AddSourceFrame(*frame)) {
-            return;
-        }
-
-        // Pend output fields.
-        while (true) {
-            auto filter_frame = m_deinterlace_filter->DrainSinkFrame();
-            if (!filter_frame) {
-                break;
-            }
-
-            frame_queue.push(std::move(filter_frame));
-        }
-    }
+    return m_decoder_context->ReceiveFrame();
 }
 
 } // namespace FFmpeg

src/video_core/host1x/ffmpeg/ffmpeg.h

@@ -20,17 +20,20 @@ extern "C" {
 #endif
 
 #include <libavcodec/avcodec.h>
-#include <libavfilter/avfilter.h>
-#include <libavfilter/buffersink.h>
-#include <libavfilter/buffersrc.h>
-#include <libavutil/avutil.h>
 #include <libavutil/opt.h>
+#ifndef ANDROID
+#include <libavcodec/codec_internal.h>
+#endif
 
 #if defined(__GNUC__) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
 }
 
+namespace Tegra {
+class MemoryManager;
+}
+
 namespace FFmpeg {
 
 class Packet;
@@ -90,6 +93,10 @@ public:
         return m_frame->data[plane];
     }
 
+    const u8* GetPlane(int plane) const {
+        return m_frame->data[plane];
+    }
+
     u8** GetPlanes() const {
         return m_frame->data;
     }
@@ -98,6 +105,14 @@ public:
         m_frame->format = format;
     }
 
+    bool IsInterlaced() const {
+        return m_frame->interlaced_frame != 0;
+    }
+
+    bool IsHardwareDecoded() const {
+        return m_frame->hw_frames_ctx != nullptr;
+    }
+
     AVFrame* GetFrame() const {
         return m_frame;
     }
@@ -160,33 +175,22 @@ public:
     void InitializeHardwareDecoder(const HardwareContext& context, AVPixelFormat hw_pix_fmt);
     bool OpenContext(const Decoder& decoder);
     bool SendPacket(const Packet& packet);
-    std::unique_ptr<Frame> ReceiveFrame(bool* out_is_interlaced);
+    std::shared_ptr<Frame> ReceiveFrame();
 
     AVCodecContext* GetCodecContext() const {
         return m_codec_context;
     }
 
+    bool UsingDecodeOrder() const {
+        return m_decode_order;
+    }
+
 private:
+    const Decoder& m_decoder;
     AVCodecContext* m_codec_context{};
-};
-
-// Wraps an AVFilterGraph.
-class DeinterlaceFilter {
-public:
-    YUZU_NON_COPYABLE(DeinterlaceFilter);
-    YUZU_NON_MOVEABLE(DeinterlaceFilter);
-
-    explicit DeinterlaceFilter(const Frame& frame);
-    ~DeinterlaceFilter();
-
-    bool AddSourceFrame(const Frame& frame);
-    std::unique_ptr<Frame> DrainSinkFrame();
-
-private:
-    AVFilterGraph* m_filter_graph{};
-    AVFilterContext* m_source_context{};
-    AVFilterContext* m_sink_context{};
-    bool m_initialized{};
+    s32 m_got_frame{};
+    std::shared_ptr<Frame> m_temp_frame{};
+    bool m_decode_order{};
 };
 
 class DecodeApi {
@@ -200,14 +204,17 @@ public:
     bool Initialize(Tegra::Host1x::NvdecCommon::VideoCodec codec);
     void Reset();
 
-    bool SendPacket(std::span<const u8> packet_data, size_t configuration_size);
-    void ReceiveFrames(std::queue<std::unique_ptr<Frame>>& frame_queue);
+    bool UsingDecodeOrder() const {
+        return m_decoder_context->UsingDecodeOrder();
+    }
+
+    bool SendPacket(std::span<const u8> packet_data);
+    std::shared_ptr<Frame> ReceiveFrame();
 
 private:
     std::optional<FFmpeg::Decoder> m_decoder;
     std::optional<FFmpeg::DecoderContext> m_decoder_context;
     std::optional<FFmpeg::HardwareContext> m_hardware_context;
-    std::optional<FFmpeg::DeinterlaceFilter> m_deinterlace_filter;
 };
 
 } // namespace FFmpeg

src/video_core/host1x/host1x.cpp

@@ -3,10 +3,10 @@
 
 #include "core/core.h"
 #include "video_core/host1x/host1x.h"
+#include "video_core/host1x/nvdec.h"
+#include "video_core/host1x/vic.h"
 
-namespace Tegra {
-
-namespace Host1x {
+namespace Tegra::Host1x {
 
 Host1x::Host1x(Core::System& system_)
     : system{system_}, syncpoint_manager{},
@@ -15,6 +15,22 @@ Host1x::Host1x(Core::System& system_)
 
 Host1x::~Host1x() = default;
 
-} // namespace Host1x
+void Host1x::StartDevice(s32 fd, ChannelType type, u32 syncpt) {
+    switch (type) {
+    case ChannelType::NvDec:
+        devices[fd] = std::make_unique<Tegra::Host1x::Nvdec>(*this, fd, syncpt, frame_queue);
+        break;
+    case ChannelType::VIC:
+        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));
+        break;
+    }
+}
 
-} // namespace Tegra
+void Host1x::StopDevice(s32 fd, ChannelType type) {
+    devices.erase(fd);
+}
+
+} // namespace Tegra::Host1x

src/video_core/host1x/host1x.h

@@ -3,9 +3,14 @@
 
 #pragma once
 
+#include <unordered_map>
+#include <unordered_set>
+#include <queue>
+
 #include "common/common_types.h"
 
 #include "common/address_space.h"
+#include "video_core/cdma_pusher.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/host1x/syncpoint_manager.h"
 #include "video_core/memory_manager.h"
@@ -14,15 +19,137 @@ namespace Core {
 class System;
 } // namespace Core
 
-namespace Tegra {
+namespace FFmpeg {
+class Frame;
+} // namespace FFmpeg
 
-namespace Host1x {
+namespace Tegra::Host1x {
+class Nvdec;
+
+class FrameQueue {
+public:
+    void Open(s32 fd) {
+        std::scoped_lock l{m_mutex};
+        m_presentation_order.insert({fd, {}});
+        m_decode_order.insert({fd, {}});
+    }
+
+    void Close(s32 fd) {
+        std::scoped_lock l{m_mutex};
+        m_presentation_order.erase(fd);
+        m_decode_order.erase(fd);
+    }
+
+    s32 VicFindNvdecFdFromOffset(u64 search_offset) {
+        std::scoped_lock l{m_mutex};
+        // Vic does not know which nvdec is producing frames for it, so search all the fds here for
+        // the given offset.
+        for (auto& map : m_presentation_order) {
+            for (auto& [offset, frame] : map.second) {
+                if (offset == search_offset) {
+                    return map.first;
+                }
+            }
+        }
+
+        for (auto& map : m_decode_order) {
+            for (auto& [offset, frame] : map.second) {
+                if (offset == search_offset) {
+                    return map.first;
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    void PushPresentOrder(s32 fd, u64 offset, std::shared_ptr<FFmpeg::Frame>&& frame) {
+        std::scoped_lock l{m_mutex};
+        auto map = m_presentation_order.find(fd);
+        if (map == m_presentation_order.end()) {
+            return;
+        }
+        map->second.emplace_back(offset, std::move(frame));
+    }
+
+    void PushDecodeOrder(s32 fd, u64 offset, std::shared_ptr<FFmpeg::Frame>&& frame) {
+        std::scoped_lock l{m_mutex};
+        auto map = m_decode_order.find(fd);
+        if (map == m_decode_order.end()) {
+            return;
+        }
+        map->second.insert_or_assign(offset, std::move(frame));
+    }
+
+    std::shared_ptr<FFmpeg::Frame> GetFrame(s32 fd, u64 offset) {
+        if (fd == -1) {
+            return {};
+        }
+
+        std::scoped_lock l{m_mutex};
+        auto present_map = m_presentation_order.find(fd);
+        if (present_map != m_presentation_order.end() && present_map->second.size() > 0) {
+            return GetPresentOrderLocked(fd);
+        }
+
+        auto decode_map = m_decode_order.find(fd);
+        if (decode_map != m_decode_order.end() && decode_map->second.size() > 0) {
+            return GetDecodeOrderLocked(fd, offset);
+        }
+
+        return {};
+    }
+
+private:
+    std::shared_ptr<FFmpeg::Frame> GetPresentOrderLocked(s32 fd) {
+        auto map = m_presentation_order.find(fd);
+        if (map == m_presentation_order.end() || map->second.size() == 0) {
+            return {};
+        }
+        auto frame = std::move(map->second.front().second);
+        map->second.pop_front();
+        return frame;
+    }
+
+    std::shared_ptr<FFmpeg::Frame> GetDecodeOrderLocked(s32 fd, u64 offset) {
+        auto map = m_decode_order.find(fd);
+        if (map == m_decode_order.end() || map->second.size() == 0) {
+            return {};
+        }
+        auto it = map->second.find(offset);
+        if (it == map->second.end()) {
+            return {};
+        }
+        return std::move(map->second.extract(it).mapped());
+    }
+
+    using FramePtr = std::shared_ptr<FFmpeg::Frame>;
+
+    std::mutex m_mutex{};
+    std::unordered_map<s32, std::deque<std::pair<u64, FramePtr>>> m_presentation_order;
+    std::unordered_map<s32, std::unordered_map<u64, FramePtr>> m_decode_order;
+};
+
+enum class ChannelType : u32 {
+    MsEnc = 0,
+    VIC = 1,
+    GPU = 2,
+    NvDec = 3,
+    Display = 4,
+    NvJpg = 5,
+    TSec = 6,
+    Max = 7,
+};
 
 class Host1x {
 public:
     explicit Host1x(Core::System& system);
     ~Host1x();
 
+    Core::System& System() {
+        return system;
+    }
+
     SyncpointManager& GetSyncpointManager() {
         return syncpoint_manager;
     }
@@ -55,14 +182,25 @@ public:
         return *allocator;
     }
 
+    void StartDevice(s32 fd, ChannelType type, u32 syncpt);
+    void StopDevice(s32 fd, ChannelType type);
+
+    void PushEntries(s32 fd, ChCommandHeaderList&& entries) {
+        auto it = devices.find(fd);
+        if (it == devices.end()) {
+            return;
+        }
+        it->second->PushEntries(std::move(entries));
+    }
+
 private:
     Core::System& system;
     SyncpointManager syncpoint_manager;
     Tegra::MaxwellDeviceMemoryManager memory_manager;
     Tegra::MemoryManager gmmu_manager;
     std::unique_ptr<Common::FlatAllocator<u32, 0, 32>> allocator;
+    FrameQueue frame_queue;
+    std::unordered_map<s32, std::unique_ptr<CDmaPusher>> devices;
 };
 
-} // namespace Host1x
-
-} // namespace Tegra
+} // namespace Tegra::Host1x

src/video_core/host1x/nvdec.cpp

@@ -2,6 +2,12 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
+
+#include "common/polyfill_thread.h"
+#include "common/settings.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/host1x.h"
 #include "video_core/host1x/nvdec.h"
 
@@ -10,37 +16,69 @@ namespace Tegra::Host1x {
 #define NVDEC_REG_INDEX(field_name)                                                                \
     (offsetof(NvdecCommon::NvdecRegisters, field_name) / sizeof(u64))
 
-Nvdec::Nvdec(Host1x& host1x_)
-    : host1x(host1x_), state{}, codec(std::make_unique<Codec>(host1x, state)) {}
+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);
+    frame_queue.Open(id);
+}
 
-Nvdec::~Nvdec() = default;
+Nvdec::~Nvdec() {
+    LOG_INFO(HW_GPU, "Destroying nvdec {}", id);
+}
 
 void Nvdec::ProcessMethod(u32 method, u32 argument) {
-    state.reg_array[method] = static_cast<u64>(argument) << 8;
+    regs.reg_array[method] = argument;
 
     switch (method) {
     case NVDEC_REG_INDEX(set_codec_id):
-        codec->SetTargetCodec(static_cast<NvdecCommon::VideoCodec>(argument));
+        CreateDecoder(static_cast<NvdecCommon::VideoCodec>(argument));
         break;
-    case NVDEC_REG_INDEX(execute):
+    case NVDEC_REG_INDEX(execute): {
+        if (wait_needed) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(32));
+            wait_needed = false;
+        }
         Execute();
-        break;
+    } break;
     }
 }
 
-std::unique_ptr<FFmpeg::Frame> Nvdec::GetFrame() {
-    return codec->GetCurrentFrame();
+void Nvdec::CreateDecoder(NvdecCommon::VideoCodec codec) {
+    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() {
-    switch (codec->GetCurrentCodec()) {
+    if (Settings::values.nvdec_emulation.GetValue() == Settings::NvdecEmulation::Off) [[unlikely]] {
+        // Signalling syncpts too fast can cause games to get stuck as they don't expect a <1ms
+        // execution time. Sleep for half of a 60 fps frame just in case.
+        std::this_thread::sleep_for(std::chrono::milliseconds(8));
+        return;
+    }
+    switch (decoder->GetCurrentCodec()) {
     case NvdecCommon::VideoCodec::H264:
     case NvdecCommon::VideoCodec::VP8:
     case NvdecCommon::VideoCodec::VP9:
-        codec->Decode();
+        decoder->Decode();
         break;
     default:
-        UNIMPLEMENTED_MSG("Codec {}", codec->GetCurrentCodecName());
+        UNIMPLEMENTED_MSG("Codec {}", decoder->GetCurrentCodecName());
         break;
     }
 }

src/video_core/host1x/nvdec.h

@@ -5,33 +5,47 @@
 
 #include <memory>
 #include <vector>
+
 #include "common/common_types.h"
-#include "video_core/host1x/codecs/codec.h"
+#include "video_core/cdma_pusher.h"
+#include "video_core/host1x/codecs/decoder.h"
 
 namespace Tegra {
 
 namespace Host1x {
-
 class Host1x;
+class FrameQueue;
 
-class Nvdec {
+class Nvdec final : public CDmaPusher {
 public:
-    explicit Nvdec(Host1x& host1x);
+    explicit Nvdec(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue_);
     ~Nvdec();
 
     /// Writes the method into the state, Invoke Execute() if encountered
-    void ProcessMethod(u32 method, u32 argument);
+    void ProcessMethod(u32 method, u32 arg) override;
 
-    /// Return most recently decoded frame
-    [[nodiscard]] std::unique_ptr<FFmpeg::Frame> GetFrame();
+    u32 GetSyncpoint() const {
+        return syncpoint;
+    }
+
+    void SetWait() {
+        wait_needed = true;
+    }
 
 private:
+    /// Create the decoder when the codec id is set
+    void CreateDecoder(NvdecCommon::VideoCodec codec);
+
     /// Invoke codec to decode a frame
     void Execute();
 
-    Host1x& host1x;
-    NvdecCommon::NvdecRegisters state;
-    std::unique_ptr<Codec> codec;
+    s32 id;
+    u32 syncpoint;
+    FrameQueue& frame_queue;
+
+    NvdecCommon::NvdecRegisters regs{};
+    std::unique_ptr<Decoder> decoder;
+    bool wait_needed{false};
 };
 
 } // namespace Host1x

src/video_core/host1x/nvdec_common.h

@@ -17,6 +17,17 @@ enum class VideoCodec : u64 {
     VP9 = 0x9,
 };
 
+struct Offset {
+    constexpr u64 Address() const noexcept {
+        return offset << 8;
+    }
+
+private:
+    u64 offset;
+};
+static_assert(std::is_trivial_v<Offset>, "Offset must be trivial");
+static_assert(sizeof(Offset) == 0x8, "Offset has the wrong size!");
+
 // NVDEC should use a 32-bit address space, but is mapped to 64-bit,
 // doubling the sizes here is compensating for that.
 struct NvdecRegisters {
@@ -38,29 +49,40 @@ struct NvdecRegisters {
                     BitField<17, 1, u64> all_intra_frame;
                 };
             } control_params;
-            u64 picture_info_offset;                   ///< 0x0808
-            u64 frame_bitstream_offset;                ///< 0x0810
+            Offset picture_info_offset;                    ///< 0x0808
+            Offset frame_bitstream_offset;                 ///< 0x0810
             u64 frame_number;                              ///< 0x0818
-            u64 h264_slice_data_offsets;               ///< 0x0820
-            u64 h264_mv_dump_offset;                   ///< 0x0828
+            Offset h264_slice_data_offsets;                ///< 0x0820
+            Offset h264_mv_dump_offset;                    ///< 0x0828
             INSERT_PADDING_WORDS_NOINIT(6);                ///< 0x0830
-            u64 frame_stats_offset;                    ///< 0x0848
-            u64 h264_last_surface_luma_offset;         ///< 0x0850
-            u64 h264_last_surface_chroma_offset;       ///< 0x0858
-            std::array<u64, 17> surface_luma_offset;   ///< 0x0860
-            std::array<u64, 17> surface_chroma_offset; ///< 0x08E8
-            INSERT_PADDING_WORDS_NOINIT(68);           ///< 0x0970
-            u64 vp8_prob_data_offset;                  ///< 0x0A80
-            u64 vp8_header_partition_buf_offset;       ///< 0x0A88
-            INSERT_PADDING_WORDS_NOINIT(60);           ///< 0x0A90
-            u64 vp9_entropy_probs_offset;              ///< 0x0B80
-            u64 vp9_backward_updates_offset;           ///< 0x0B88
-            u64 vp9_last_frame_segmap_offset;          ///< 0x0B90
-            u64 vp9_curr_frame_segmap_offset;          ///< 0x0B98
-            INSERT_PADDING_WORDS_NOINIT(2);            ///< 0x0BA0
-            u64 vp9_last_frame_mvs_offset;             ///< 0x0BA8
-            u64 vp9_curr_frame_mvs_offset;             ///< 0x0BB0
-            INSERT_PADDING_WORDS_NOINIT(2);            ///< 0x0BB8
+            Offset frame_stats_offset;                     ///< 0x0848
+            Offset h264_last_surface_luma_offset;          ///< 0x0850
+            Offset h264_last_surface_chroma_offset;        ///< 0x0858
+            std::array<Offset, 17> surface_luma_offsets;   ///< 0x0860
+            std::array<Offset, 17> surface_chroma_offsets; ///< 0x08E8
+            Offset pic_scratch_buf_offset;                 ///< 0x0970
+            Offset external_mvbuffer_offset;               ///< 0x0978
+            INSERT_PADDING_WORDS_NOINIT(32);               ///< 0x0980
+            Offset h264_mbhist_buffer_offset;              ///< 0x0A00
+            INSERT_PADDING_WORDS_NOINIT(30);               ///< 0x0A08
+            Offset vp8_prob_data_offset;                   ///< 0x0A80
+            Offset vp8_header_partition_buf_offset;        ///< 0x0A88
+            INSERT_PADDING_WORDS_NOINIT(28);               ///< 0x0A90
+            Offset hvec_scalist_list_offset;               ///< 0x0B00
+            Offset hvec_tile_sizes_offset;                 ///< 0x0B08
+            Offset hvec_filter_buffer_offset;              ///< 0x0B10
+            Offset hvec_sao_buffer_offset;                 ///< 0x0B18
+            Offset hvec_slice_info_buffer_offset;          ///< 0x0B20
+            Offset hvec_slice_group_index_offset;          ///< 0x0B28
+            INSERT_PADDING_WORDS_NOINIT(20);               ///< 0x0B30
+            Offset vp9_prob_tab_buffer_offset;             ///< 0x0B80
+            Offset vp9_ctx_counter_buffer_offset;          ///< 0x0B88
+            Offset vp9_segment_read_buffer_offset;         ///< 0x0B90
+            Offset vp9_segment_write_buffer_offset;        ///< 0x0B98
+            Offset vp9_tile_size_buffer_offset;            ///< 0x0BA0
+            Offset vp9_col_mvwrite_buffer_offset;          ///< 0x0BA8
+            Offset vp9_col_mvread_buffer_offset;           ///< 0x0BB0
+            Offset vp9_filter_buffer_offset;               ///< 0x0BB8
         };
         std::array<u64, NUM_REGS> reg_array;
     };
@@ -81,16 +103,16 @@ ASSERT_REG_POSITION(h264_slice_data_offsets, 0x104);
 ASSERT_REG_POSITION(frame_stats_offset, 0x109);
 ASSERT_REG_POSITION(h264_last_surface_luma_offset, 0x10A);
 ASSERT_REG_POSITION(h264_last_surface_chroma_offset, 0x10B);
-ASSERT_REG_POSITION(surface_luma_offset, 0x10C);
-ASSERT_REG_POSITION(surface_chroma_offset, 0x11D);
+ASSERT_REG_POSITION(surface_luma_offsets, 0x10C);
+ASSERT_REG_POSITION(surface_chroma_offsets, 0x11D);
 ASSERT_REG_POSITION(vp8_prob_data_offset, 0x150);
 ASSERT_REG_POSITION(vp8_header_partition_buf_offset, 0x151);
-ASSERT_REG_POSITION(vp9_entropy_probs_offset, 0x170);
-ASSERT_REG_POSITION(vp9_backward_updates_offset, 0x171);
-ASSERT_REG_POSITION(vp9_last_frame_segmap_offset, 0x172);
-ASSERT_REG_POSITION(vp9_curr_frame_segmap_offset, 0x173);
-ASSERT_REG_POSITION(vp9_last_frame_mvs_offset, 0x175);
-ASSERT_REG_POSITION(vp9_curr_frame_mvs_offset, 0x176);
+ASSERT_REG_POSITION(vp9_prob_tab_buffer_offset, 0x170);
+ASSERT_REG_POSITION(vp9_ctx_counter_buffer_offset, 0x171);
+ASSERT_REG_POSITION(vp9_segment_read_buffer_offset, 0x172);
+ASSERT_REG_POSITION(vp9_segment_write_buffer_offset, 0x173);
+ASSERT_REG_POSITION(vp9_col_mvwrite_buffer_offset, 0x175);
+ASSERT_REG_POSITION(vp9_col_mvread_buffer_offset, 0x176);
 
 #undef ASSERT_REG_POSITION
 

src/video_core/host1x/sync_manager.cpp

@@ -1,50 +0,0 @@
-// SPDX-FileCopyrightText: Ryujinx Team and Contributors
-// SPDX-License-Identifier: MIT
-
-#include <algorithm>
-#include "sync_manager.h"
-#include "video_core/host1x/host1x.h"
-#include "video_core/host1x/syncpoint_manager.h"
-
-namespace Tegra {
-namespace Host1x {
-
-SyncptIncrManager::SyncptIncrManager(Host1x& host1x_) : host1x(host1x_) {}
-SyncptIncrManager::~SyncptIncrManager() = default;
-
-void SyncptIncrManager::Increment(u32 id) {
-    increments.emplace_back(0, 0, id, true);
-    IncrementAllDone();
-}
-
-u32 SyncptIncrManager::IncrementWhenDone(u32 class_id, u32 id) {
-    const u32 handle = current_id++;
-    increments.emplace_back(handle, class_id, id);
-    return handle;
-}
-
-void SyncptIncrManager::SignalDone(u32 handle) {
-    const auto done_incr =
-        std::find_if(increments.begin(), increments.end(),
-                     [handle](const SyncptIncr& incr) { return incr.id == handle; });
-    if (done_incr != increments.cend()) {
-        done_incr->complete = true;
-    }
-    IncrementAllDone();
-}
-
-void SyncptIncrManager::IncrementAllDone() {
-    std::size_t done_count = 0;
-    for (; done_count < increments.size(); ++done_count) {
-        if (!increments[done_count].complete) {
-            break;
-        }
-        auto& syncpoint_manager = host1x.GetSyncpointManager();
-        syncpoint_manager.IncrementGuest(increments[done_count].syncpt_id);
-        syncpoint_manager.IncrementHost(increments[done_count].syncpt_id);
-    }
-    increments.erase(increments.begin(), increments.begin() + done_count);
-}
-
-} // namespace Host1x
-} // namespace Tegra

src/video_core/host1x/sync_manager.h

@@ -1,53 +0,0 @@
-// SPDX-FileCopyrightText: Ryujinx Team and Contributors
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <mutex>
-#include <vector>
-#include "common/common_types.h"
-
-namespace Tegra {
-
-namespace Host1x {
-
-class Host1x;
-
-struct SyncptIncr {
-    u32 id;
-    u32 class_id;
-    u32 syncpt_id;
-    bool complete;
-
-    SyncptIncr(u32 id_, u32 class_id_, u32 syncpt_id_, bool done = false)
-        : id(id_), class_id(class_id_), syncpt_id(syncpt_id_), complete(done) {}
-};
-
-class SyncptIncrManager {
-public:
-    explicit SyncptIncrManager(Host1x& host1x);
-    ~SyncptIncrManager();
-
-    /// Add syncpoint id and increment all
-    void Increment(u32 id);
-
-    /// Returns a handle to increment later
-    u32 IncrementWhenDone(u32 class_id, u32 id);
-
-    /// IncrememntAllDone, including handle
-    void SignalDone(u32 handle);
-
-    /// Increment all sequential pending increments that are already done.
-    void IncrementAllDone();
-
-private:
-    std::vector<SyncptIncr> increments;
-    std::mutex increment_lock;
-    u32 current_id{};
-
-    Host1x& host1x;
-};
-
-} // namespace Host1x
-
-} // namespace Tegra

src/video_core/host1x/syncpoint_manager.cpp

@@ -18,7 +18,7 @@ SyncpointManager::ActionHandle SyncpointManager::RegisterAction(
         return {};
     }
 
-    std::unique_lock lk(guard);
+    std::scoped_lock lk(guard);
     if (syncpoint.load(std::memory_order_relaxed) >= expected_value) {
         action();
         return {};
@@ -35,7 +35,7 @@ SyncpointManager::ActionHandle SyncpointManager::RegisterAction(
 
 void SyncpointManager::DeregisterAction(std::list<RegisteredAction>& action_storage,
                                         const ActionHandle& handle) {
-    std::unique_lock lk(guard);
+    std::scoped_lock lk(guard);
 
     // We want to ensure the iterator still exists prior to erasing it
     // Otherwise, if an invalid iterator was passed in then it could lead to UB
@@ -78,7 +78,7 @@ void SyncpointManager::Increment(std::atomic<u32>& syncpoint, std::condition_var
                                  std::list<RegisteredAction>& action_storage) {
     auto new_value{syncpoint.fetch_add(1, std::memory_order_acq_rel) + 1};
 
-    std::unique_lock lk(guard);
+    std::scoped_lock lk(guard);
     auto it = action_storage.begin();
     while (it != action_storage.end()) {
         if (it->expected_value > new_value) {

src/video_core/host1x/vic.h

@@ -3,65 +3,646 @@
 
 #pragma once
 
+#include <condition_variable>
+#include <functional>
 #include <memory>
+#include <mutex>
+#include <thread>
 
 #include "common/common_types.h"
 #include "common/scratch_buffer.h"
+#include "video_core/cdma_pusher.h"
 
-struct SwsContext;
-
-namespace Tegra {
-
-namespace Host1x {
-
+namespace Tegra::Host1x {
 class Host1x;
 class Nvdec;
-union VicConfig;
 
-class Vic {
+struct Pixel {
+    u16 r;
+    u16 g;
+    u16 b;
+    u16 a;
+};
+
+// One underscore represents separate pixels.
+// Double underscore represents separate planes.
+// _N represents chroma subsampling, not a separate pixel.
+enum class VideoPixelFormat : u32 {
+    A8 = 0,
+    L8 = 1,
+    A4L4 = 2,
+    L4A4 = 3,
+    R8 = 4,
+    A8L8 = 5,
+    L8A8 = 6,
+    R8G8 = 7,
+    G8R8 = 8,
+    B5G6R5 = 9,
+    R5G6B5 = 10,
+    B6G5R5 = 11,
+    R5G5B6 = 12,
+    A1B5G5R5 = 13,
+    A1R5G5B5 = 14,
+    B5G5R5A1 = 15,
+    R5G5B5A1 = 16,
+    A5B5G5R1 = 17,
+    A5R1G5B5 = 18,
+    B5G5R1A5 = 19,
+    R1G5B5A5 = 20,
+    X1B5G5R5 = 21,
+    X1R5G5B5 = 22,
+    B5G5R5X1 = 23,
+    R5G5B5X1 = 24,
+    A4B4G5R4 = 25,
+    A4R4G4B4 = 26,
+    B4G4R4A4 = 27,
+    R4G4B4A4 = 28,
+    B8G8R8 = 29,
+    R8G8B8 = 30,
+    A8B8G8R8 = 31,
+    A8R8G8B8 = 32,
+    B8G8R8A8 = 33,
+    R8G8B8A8 = 34,
+    X8B8G8R8 = 35,
+    X8R8G8B8 = 36,
+    B8G8R8X8 = 37,
+    R8G8B8X8 = 38,
+    A8B10G10R10 = 39,
+    A2R10G10B10 = 40,
+    B10G10R10A2 = 41,
+    R10G10B10A2 = 42,
+    A4P4 = 43,
+    P4A4 = 44,
+    P8A8 = 45,
+    A8P8 = 46,
+    P8 = 47,
+    P1 = 48,
+    U8V8 = 49,
+    V8U8 = 50,
+    A8Y8U8V8 = 51,
+    V8U8Y8A8 = 52,
+    Y8U8V8 = 53,
+    Y8V8U8 = 54,
+    U8V8Y8 = 55,
+    V8U8Y8 = 56,
+    Y8U8_Y8V8 = 57,
+    Y8V8_Y8U8 = 58,
+    U8Y8_V8Y8 = 59,
+    V8Y8_U8Y8 = 60,
+    Y8__U8V8_N444 = 61,
+    Y8__V8U8_N444 = 62,
+    Y8__U8V8_N422 = 63,
+    Y8__V8U8_N422 = 64,
+    Y8__U8V8_N422R = 65,
+    Y8__V8U8_N422R = 66,
+    Y8__U8V8_N420 = 67,
+    Y8__V8U8_N420 = 68,
+    Y8__U8__V8_N444 = 69,
+    Y8__U8__V8_N422 = 70,
+    Y8__U8__V8_N422R = 71,
+    Y8__U8__V8_N420 = 72,
+    U8 = 73,
+    V8 = 74,
+};
+
+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 PlaneOffsets {
+    Offset luma;
+    Offset chroma_u;
+    Offset chroma_v;
+};
+static_assert(sizeof(PlaneOffsets) == 0xC, "PlaneOffsets has the wrong size!");
+
+enum SurfaceIndex : u32 {
+    Current = 0,
+    Previous = 1,
+    Next = 2,
+    NextNoiseReduced = 3,
+    CurrentMotion = 4,
+    PreviousMotion = 5,
+    PreviousPreviousMotion = 6,
+    CombinedMotion = 7,
+};
+
+enum class DXVAHD_ALPHA_FILL_MODE : u32 {
+    OPAQUE = 0,
+    BACKGROUND = 1,
+    DESTINATION = 2,
+    SOURCE_STREAM = 3,
+    COMPOSITED = 4,
+    SOURCE_ALPHA = 5,
+};
+
+enum class DXVAHD_FRAME_FORMAT : u64 {
+    PROGRESSIVE = 0,
+    INTERLACED_TOP_FIELD_FIRST = 1,
+    INTERLACED_BOTTOM_FIELD_FIRST = 2,
+    TOP_FIELD = 3,
+    BOTTOM_FIELD = 4,
+    SUBPIC_PROGRESSIVE = 5,
+    SUBPIC_INTERLACED_TOP_FIELD_FIRST = 6,
+    SUBPIC_INTERLACED_BOTTOM_FIELD_FIRST = 7,
+    SUBPIC_TOP_FIELD = 8,
+    SUBPIC_BOTTOM_FIELD = 9,
+    TOP_FIELD_CHROMA_BOTTOM = 10,
+    BOTTOM_FIELD_CHROMA_TOP = 11,
+    SUBPIC_TOP_FIELD_CHROMA_BOTTOM = 12,
+    SUBPIC_BOTTOM_FIELD_CHROMA_TOP = 13,
+};
+
+enum class DXVAHD_DEINTERLACE_MODE_PRIVATE : u64 {
+    WEAVE = 0,
+    BOB_FIELD = 1,
+    BOB = 2,
+    NEWBOB = 3,
+    DISI1 = 4,
+    WEAVE_LUMA_BOB_FIELD_CHROMA = 5,
+    MAX = 0xF,
+};
+
+enum class BLK_KIND {
+    PITCH = 0,
+    GENERIC_16Bx2 = 1,
+    // These are unsupported in the vic
+    BL_NAIVE = 2,
+    BL_KEPLER_XBAR_RAW = 3,
+    VP2_TILED = 15,
+};
+
+enum class BLEND_SRCFACTC : u32 {
+    K1 = 0,
+    K1_TIMES_DST = 1,
+    NEG_K1_TIMES_DST = 2,
+    K1_TIMES_SRC = 3,
+    ZERO = 4,
+};
+
+enum class BLEND_DSTFACTC : u32 {
+    K1 = 0,
+    K2 = 1,
+    K1_TIMES_DST = 2,
+    NEG_K1_TIMES_DST = 3,
+    NEG_K1_TIMES_SRC = 4,
+    ZERO = 5,
+    ONE = 6,
+};
+
+enum class BLEND_SRCFACTA : u32 {
+    K1 = 0,
+    K2 = 1,
+    NEG_K1_TIMES_DST = 2,
+    ZERO = 3,
+    MAX = 7,
+};
+
+enum class BLEND_DSTFACTA : u32 {
+    K2 = 0,
+    NEG_K1_TIMES_SRC = 1,
+    ZERO = 2,
+    ONE = 3,
+    MAX = 7,
+};
+
+struct PipeConfig {
+    union {
+        BitField<0, 11, u32> downsample_horiz;
+        BitField<11, 5, u32> reserved0;
+        BitField<16, 11, u32> downsample_vert;
+        BitField<27, 5, u32> reserved1;
+    };
+    u32 reserved2;
+    u32 reserved3;
+    u32 reserved4;
+};
+static_assert(sizeof(PipeConfig) == 0x10, "PipeConfig has the wrong size!");
+
+struct OutputConfig {
+    union {
+        BitField<0, 3, DXVAHD_ALPHA_FILL_MODE> alpha_fill_mode;
+        BitField<3, 3, u64> alpha_fill_slot;
+        BitField<6, 10, u64> background_a;
+        BitField<16, 10, u64> background_r;
+        BitField<26, 10, u64> background_g;
+        BitField<36, 10, u64> background_b;
+        BitField<46, 2, u64> regamma_mode;
+        BitField<48, 1, u64> output_flip_x;
+        BitField<49, 1, u64> output_flip_y;
+        BitField<50, 1, u64> output_transpose;
+        BitField<51, 1, u64> reserved1;
+        BitField<52, 12, u64> reserved2;
+    };
+    union {
+        BitField<0, 14, u32> target_rect_left;
+        BitField<14, 2, u32> reserved3;
+        BitField<16, 14, u32> target_rect_right;
+        BitField<30, 2, u32> reserved4;
+    };
+    union {
+        BitField<0, 14, u32> target_rect_top;
+        BitField<14, 2, u32> reserved5;
+        BitField<16, 14, u32> target_rect_bottom;
+        BitField<30, 2, u32> reserved6;
+    };
+};
+static_assert(sizeof(OutputConfig) == 0x10, "OutputConfig has the wrong size!");
+
+struct OutputSurfaceConfig {
+    union {
+        BitField<0, 7, VideoPixelFormat> out_pixel_format;
+        BitField<7, 2, u32> out_chroma_loc_horiz;
+        BitField<9, 2, u32> out_chroma_loc_vert;
+        BitField<11, 4, BLK_KIND> out_block_kind;
+        BitField<15, 4, u32> out_block_height; // in gobs, log2
+        BitField<19, 3, u32> reserved0;
+        BitField<22, 10, u32> reserved1;
+    };
+    union {
+        BitField<0, 14, u32> out_surface_width;   // - 1
+        BitField<14, 14, u32> out_surface_height; // - 1
+        BitField<28, 4, u32> reserved2;
+    };
+    union {
+        BitField<0, 14, u32> out_luma_width;   // - 1
+        BitField<14, 14, u32> out_luma_height; // - 1
+        BitField<28, 4, u32> reserved3;
+    };
+    union {
+        BitField<0, 14, u32> out_chroma_width;   // - 1
+        BitField<14, 14, u32> out_chroma_height; // - 1
+        BitField<28, 4, u32> reserved4;
+    };
+};
+static_assert(sizeof(OutputSurfaceConfig) == 0x10, "OutputSurfaceConfig has the wrong size!");
+
+struct MatrixStruct {
+    union {
+        BitField<0, 20, s64> matrix_coeff00;  // (0,0) of 4x3 conversion matrix
+        BitField<20, 20, s64> matrix_coeff10; // (1,0) of 4x3 conversion matrix
+        BitField<40, 20, s64> matrix_coeff20; // (2,0) of 4x3 conversion matrix
+        BitField<60, 4, u64> matrix_r_shift;
+    };
+    union {
+        BitField<0, 20, s64> matrix_coeff01;  // (0,1) of 4x3 conversion matrix
+        BitField<20, 20, s64> matrix_coeff11; // (1,1) of 4x3 conversion matrix
+        BitField<40, 20, s64> matrix_coeff21; // (2,1) of 4x3 conversion matrix
+        BitField<60, 3, u64> reserved0;
+        BitField<63, 1, u64> matrix_enable;
+    };
+    union {
+        BitField<0, 20, s64> matrix_coeff02;  // (0,2) of 4x3 conversion matrix
+        BitField<20, 20, s64> matrix_coeff12; // (1,2) of 4x3 conversion matrix
+        BitField<40, 20, s64> matrix_coeff22; // (2,2) of 4x3 conversion matrix
+        BitField<60, 4, u64> reserved1;
+    };
+    union {
+        BitField<0, 20, s64> matrix_coeff03;  // (0,3) of 4x3 conversion matrix
+        BitField<20, 20, s64> matrix_coeff13; // (1,3) of 4x3 conversion matrix
+        BitField<40, 20, s64> matrix_coeff23; // (2,3) of 4x3 conversion matrix
+        BitField<60, 4, u64> reserved2;
+    };
+};
+static_assert(sizeof(MatrixStruct) == 0x20, "MatrixStruct has the wrong size!");
+
+struct ClearRectStruct {
+    union {
+        BitField<0, 14, u32> clear_rect0_left;
+        BitField<14, 2, u32> reserved0;
+        BitField<16, 14, u32> clear_rect0_right;
+        BitField<30, 2, u32> reserved1;
+    };
+    union {
+        BitField<0, 14, u32> clear_rect0_top;
+        BitField<14, 2, u32> reserved2;
+        BitField<16, 14, u32> clear_rect0_bottom;
+        BitField<30, 2, u32> reserved3;
+    };
+    union {
+        BitField<0, 14, u32> clear_rect1_left;
+        BitField<14, 2, u32> reserved4;
+        BitField<16, 14, u32> clear_rect1_right;
+        BitField<30, 2, u32> reserved5;
+    };
+    union {
+        BitField<0, 14, u32> clear_rect1_top;
+        BitField<14, 2, u32> reserved6;
+        BitField<16, 14, u32> clear_rect1_bottom;
+        BitField<30, 2, u32> reserved7;
+    };
+};
+static_assert(sizeof(ClearRectStruct) == 0x10, "ClearRectStruct has the wrong size!");
+
+struct SlotConfig {
+    union {
+        BitField<0, 1, u64> slot_enable;
+        BitField<1, 1, u64> denoise;
+        BitField<2, 1, u64> advanced_denoise;
+        BitField<3, 1, u64> cadence_detect;
+        BitField<4, 1, u64> motion_map;
+        BitField<5, 1, u64> motion_map_capture;
+        BitField<6, 1, u64> is_even;
+        BitField<7, 1, u64> chroma_even;
+        // fetch control struct
+        BitField<8, 1, u64> current_field_enable;
+        BitField<9, 1, u64> prev_field_enable;
+        BitField<10, 1, u64> next_field_enable;
+        BitField<11, 1, u64> next_nr_field_enable; // noise reduction
+        BitField<12, 1, u64> current_motion_field_enable;
+        BitField<13, 1, u64> prev_motion_field_enable;
+        BitField<14, 1, u64> prev_prev_motion_field_enable;
+        BitField<15, 1, u64> combined_motion_field_enable;
+
+        BitField<16, 4, DXVAHD_FRAME_FORMAT> frame_format;
+        BitField<20, 2, u64> filter_length_y; // 0: 1-tap, 1: 2-tap, 2: 5-tap, 3: 10-tap
+        BitField<22, 2, u64> filter_length_x;
+        BitField<24, 12, u64> panoramic;
+        BitField<36, 22, u64> reserved1;
+        BitField<58, 6, u64> detail_filter_clamp;
+    };
+    union {
+        BitField<0, 10, u64> filter_noise;
+        BitField<10, 10, u64> filter_detail;
+        BitField<20, 10, u64> chroma_noise;
+        BitField<30, 10, u64> chroma_detail;
+        BitField<40, 4, DXVAHD_DEINTERLACE_MODE_PRIVATE> deinterlace_mode;
+        BitField<44, 3, u64> motion_accumulation_weight;
+        BitField<47, 11, u64> noise_iir;
+        BitField<58, 4, u64> light_level;
+        BitField<62, 2, u64> reserved4;
+    };
+    union {
+        BitField<0, 10, u64> soft_clamp_low;
+        BitField<10, 10, u64> soft_clamp_high;
+        BitField<20, 3, u64> reserved5;
+        BitField<23, 9, u64> reserved6;
+        BitField<32, 10, u64> planar_alpha;
+        BitField<42, 1, u64> constant_alpha;
+        BitField<43, 3, u64> stereo_interleave;
+        BitField<46, 1, u64> clip_enabled;
+        BitField<47, 8, u64> clear_rect_mask;
+        BitField<55, 2, u64> degamma_mode;
+        BitField<57, 1, u64> reserved7;
+        BitField<58, 1, u64> decompress_enable;
+        BitField<59, 5, u64> reserved9;
+    };
+    union {
+        BitField<0, 8, u64> decompress_ctb_count;
+        BitField<8, 32, u64> decompress_zbc_count;
+        BitField<40, 24, u64> reserved12;
+    };
+    union {
+        BitField<0, 30, u64> source_rect_left;
+        BitField<30, 2, u64> reserved14;
+        BitField<32, 30, u64> source_rect_right;
+        BitField<62, 2, u64> reserved15;
+    };
+    union {
+        BitField<0, 30, u64> source_rect_top;
+        BitField<30, 2, u64> reserved16;
+        BitField<32, 30, u64> source_rect_bottom;
+        BitField<62, 2, u64> reserved17;
+    };
+    union {
+        BitField<0, 14, u64> dest_rect_left;
+        BitField<14, 2, u64> reserved18;
+        BitField<16, 14, u64> dest_rect_right;
+        BitField<30, 2, u64> reserved19;
+        BitField<32, 14, u64> dest_rect_top;
+        BitField<46, 2, u64> reserved20;
+        BitField<48, 14, u64> dest_rect_bottom;
+        BitField<62, 2, u64> reserved21;
+    };
+    u32 reserved22;
+    u32 reserved23;
+};
+static_assert(sizeof(SlotConfig) == 0x40, "SlotConfig has the wrong size!");
+
+struct SlotSurfaceConfig {
+    union {
+        BitField<0, 7, VideoPixelFormat> slot_pixel_format;
+        BitField<7, 2, u32> slot_chroma_loc_horiz;
+        BitField<9, 2, u32> slot_chroma_loc_vert;
+        BitField<11, 4, u32> slot_block_kind;
+        BitField<15, 4, u32> slot_block_height;
+        BitField<19, 3, u32> slot_cache_width;
+        BitField<22, 10, u32> reserved0;
+    };
+    union {
+        BitField<0, 14, u32> slot_surface_width;   //  - 1
+        BitField<14, 14, u32> slot_surface_height; //  - 1
+        BitField<28, 4, u32> reserved1;
+    };
+    union {
+        BitField<0, 14, u32> slot_luma_width;   // padded, - 1
+        BitField<14, 14, u32> slot_luma_height; // padded, - 1
+        BitField<28, 4, u32> reserved2;
+    };
+    union {
+        BitField<0, 14, u32> slot_chroma_width;   // padded, - 1
+        BitField<14, 14, u32> slot_chroma_height; // padded, - 1
+        BitField<28, 4, u32> reserved3;
+    };
+};
+static_assert(sizeof(SlotSurfaceConfig) == 0x10, "SlotSurfaceConfig has the wrong size!");
+
+struct LumaKeyStruct {
+    union {
+        BitField<0, 20, u64> luma_coeff0;  // (0) of 4x1 conversion matrix, S12.8 format
+        BitField<20, 20, u64> luma_coeff1; // (1) of 4x1 conversion matrix, S12.8 format
+        BitField<40, 20, u64> luma_coeff2; // (2) of 4x1 conversion matrix, S12.8 format
+        BitField<60, 4, u64> luma_r_shift;
+    };
+    union {
+        BitField<0, 20, u64> luma_coeff3; // (3) of 4x1 conversion matrix, S12.8 format
+        BitField<20, 10, u64> luma_key_lower;
+        BitField<30, 10, u64> luma_key_upper;
+        BitField<40, 1, u64> luma_key_enabled;
+        BitField<41, 2, u64> reserved0;
+        BitField<43, 21, u64> reserved1;
+    };
+};
+static_assert(sizeof(LumaKeyStruct) == 0x10, "LumaKeyStruct has the wrong size!");
+
+struct BlendingSlotStruct {
+    union {
+        BitField<0, 10, u32> alpha_k1;
+        BitField<10, 6, u32> reserved0;
+        BitField<16, 10, u32> alpha_k2;
+        BitField<26, 6, u32> reserved1;
+    };
+    union {
+        BitField<0, 3, BLEND_SRCFACTC> src_factor_color_match_select;
+        BitField<3, 1, u32> reserved2;
+        BitField<4, 3, BLEND_DSTFACTC> dst_factor_color_match_select;
+        BitField<7, 1, u32> reserved3;
+        BitField<8, 3, BLEND_SRCFACTA> src_factor_a_match_select;
+        BitField<11, 1, u32> reserved4;
+        BitField<12, 3, BLEND_DSTFACTA> dst_factor_a_match_select;
+        BitField<15, 1, u32> reserved5;
+        BitField<16, 4, u32> reserved6;
+        BitField<20, 4, u32> reserved7;
+        BitField<24, 4, u32> reserved8;
+        BitField<28, 4, u32> reserved9;
+    };
+    union {
+        BitField<0, 2, u32> reserved10;
+        BitField<2, 10, u32> override_r;
+        BitField<12, 10, u32> override_g;
+        BitField<22, 10, u32> override_b;
+    };
+    union {
+        BitField<0, 10, u32> override_a;
+        BitField<10, 2, u32> reserved11;
+        BitField<12, 1, u32> use_override_r;
+        BitField<13, 1, u32> use_override_g;
+        BitField<14, 1, u32> use_override_b;
+        BitField<15, 1, u32> use_override_a;
+        BitField<16, 1, u32> mask_r;
+        BitField<17, 1, u32> mask_g;
+        BitField<18, 1, u32> mask_b;
+        BitField<19, 1, u32> mask_a;
+        BitField<20, 12, u32> reserved12;
+    };
+};
+static_assert(sizeof(BlendingSlotStruct) == 0x10, "BlendingSlotStruct has the wrong size!");
+
+struct SlotStruct {
+    SlotConfig config;
+    SlotSurfaceConfig surface_config;
+    LumaKeyStruct luma_key;
+    MatrixStruct color_matrix;
+    MatrixStruct gamut_matrix;
+    BlendingSlotStruct blending;
+};
+static_assert(sizeof(SlotStruct) == 0xB0, "SlotStruct has the wrong size!");
+
+struct ConfigStruct {
+    PipeConfig pipe_config;
+    OutputConfig output_config;
+    OutputSurfaceConfig output_surface_config;
+    MatrixStruct out_color_matrix;
+    std::array<ClearRectStruct, 4> clear_rects;
+    std::array<SlotStruct, 8> slot_structs;
+};
+static_assert(offsetof(ConfigStruct, pipe_config) == 0x0, "pipe_config is in the wrong place!");
+static_assert(offsetof(ConfigStruct, output_config) == 0x10,
+              "output_config is in the wrong place!");
+static_assert(offsetof(ConfigStruct, output_surface_config) == 0x20,
+              "output_surface_config is in the wrong place!");
+static_assert(offsetof(ConfigStruct, out_color_matrix) == 0x30,
+              "out_color_matrix is in the wrong place!");
+static_assert(offsetof(ConfigStruct, clear_rects) == 0x50, "clear_rects is in the wrong place!");
+static_assert(offsetof(ConfigStruct, slot_structs) == 0x90, "slot_structs is in the wrong place!");
+static_assert(sizeof(ConfigStruct) == 0x610, "ConfigStruct has the wrong size!");
+
+struct VicRegisters {
+    static constexpr std::size_t NUM_REGS = 0x446;
+
+    union {
+        struct {
+            INSERT_PADDING_WORDS_NOINIT(0xC0);
+            u32 execute;
+            INSERT_PADDING_WORDS_NOINIT(0x3F);
+            std::array<std::array<PlaneOffsets, 8>, 8> surfaces;
+            u32 picture_index;
+            u32 control_params;
+            Offset config_struct_offset;
+            Offset filter_struct_offset;
+            Offset palette_offset;
+            Offset hist_offset;
+            u32 context_id;
+            u32 fce_ucode_size;
+            PlaneOffsets output_surface;
+            Offset fce_ucode_offset;
+            INSERT_PADDING_WORDS_NOINIT(0x4);
+            std::array<u32, 8> slot_context_ids;
+            std::array<Offset, 8> comp_tag_buffer_offsets;
+            std::array<Offset, 8> history_buffer_offset;
+            INSERT_PADDING_WORDS_NOINIT(0x25D);
+            u32 pm_trigger_end;
+        };
+        std::array<u32, NUM_REGS> reg_array;
+    };
+};
+static_assert(offsetof(VicRegisters, execute) == 0x300, "execute is in the wrong place!");
+static_assert(offsetof(VicRegisters, surfaces) == 0x400, "surfaces is in the wrong place!");
+static_assert(offsetof(VicRegisters, picture_index) == 0x700,
+              "picture_index is in the wrong place!");
+static_assert(offsetof(VicRegisters, control_params) == 0x704,
+              "control_params is in the wrong place!");
+static_assert(offsetof(VicRegisters, config_struct_offset) == 0x708,
+              "config_struct_offset is in the wrong place!");
+static_assert(offsetof(VicRegisters, output_surface) == 0x720,
+              "output_surface is in the wrong place!");
+static_assert(offsetof(VicRegisters, slot_context_ids) == 0x740,
+              "slot_context_ids is in the wrong place!");
+static_assert(offsetof(VicRegisters, history_buffer_offset) == 0x780,
+              "history_buffer_offset is in the wrong place!");
+static_assert(offsetof(VicRegisters, pm_trigger_end) == 0x1114,
+              "pm_trigger_end is in the wrong place!");
+static_assert(sizeof(VicRegisters) == 0x1118, "VicRegisters has the wrong size!");
+
+class Vic final : public CDmaPusher {
 public:
     enum class Method : u32 {
-        Execute = 0xc0,
-        SetControlParams = 0x1c1,
-        SetConfigStructOffset = 0x1c2,
-        SetOutputSurfaceLumaOffset = 0x1c8,
-        SetOutputSurfaceChromaOffset = 0x1c9,
-        SetOutputSurfaceChromaUnusedOffset = 0x1ca
+        Execute = offsetof(VicRegisters, execute),
+        SetControlParams = offsetof(VicRegisters, control_params),
+        SetConfigStructOffset = offsetof(VicRegisters, config_struct_offset),
+        SetOutputSurfaceLumaOffset = offsetof(VicRegisters, output_surface.luma),
+        SetOutputSurfaceChromaOffset = offsetof(VicRegisters, output_surface.chroma_u),
+        SetOutputSurfaceChromaUnusedOffset = offsetof(VicRegisters, output_surface.chroma_v)
     };
 
-    explicit Vic(Host1x& host1x, std::shared_ptr<Nvdec> nvdec_processor);
-
+    explicit Vic(Host1x& host1x, s32 id, u32 syncpt, FrameQueue& frame_queue);
     ~Vic();
 
     /// Write to the device state.
-    void ProcessMethod(Method method, u32 argument);
+    void ProcessMethod(u32 method, u32 arg) override;
 
 private:
     void Execute();
 
-    void WriteRGBFrame(std::unique_ptr<FFmpeg::Frame> frame, const VicConfig& config);
+    void Blend(const ConfigStruct& config, const SlotStruct& slot);
 
-    void WriteYUVFrame(std::unique_ptr<FFmpeg::Frame> frame, const VicConfig& config);
+    template <bool Planar, bool Interlaced = false>
+    void ReadProgressiveY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets,
+                                      std::shared_ptr<const FFmpeg::Frame> frame);
+    template <bool Planar, bool TopField>
+    void ReadInterlacedY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets,
+                                     std::shared_ptr<const FFmpeg::Frame> frame);
 
-    Host1x& host1x;
-    std::shared_ptr<Tegra::Host1x::Nvdec> nvdec_processor;
+    template <bool Planar>
+    void ReadY8__V8U8_N420(const SlotStruct& slot, std::span<const PlaneOffsets> offsets,
+                           std::shared_ptr<const FFmpeg::Frame> frame);
 
-    /// Avoid reallocation of the following buffers every frame, as their
-    /// size does not change during a stream
-    using AVMallocPtr = std::unique_ptr<u8, decltype(&av_free)>;
-    AVMallocPtr converted_frame_buffer;
-    Common::ScratchBuffer<u8> luma_buffer;
-    Common::ScratchBuffer<u8> chroma_buffer;
+    void WriteY8__V8U8_N420(const OutputSurfaceConfig& output_surface_config);
 
-    GPUVAddr config_struct_address{};
-    GPUVAddr output_surface_luma_address{};
-    GPUVAddr output_surface_chroma_address{};
+    template <VideoPixelFormat Format>
+    void WriteABGR(const OutputSurfaceConfig& output_surface_config);
 
-    SwsContext* scaler_ctx{};
-    s32 scaler_width{};
-    s32 scaler_height{};
+    s32 id;
+    s32 nvdec_id{-1};
+    u32 syncpoint;
+
+    VicRegisters regs{};
+    FrameQueue& frame_queue;
+
+    const bool has_sse41{false};
+
+    Common::ScratchBuffer<Pixel> output_surface;
+    Common::ScratchBuffer<Pixel> slot_surface;
+    Common::ScratchBuffer<u8> luma_scratch;
+    Common::ScratchBuffer<u8> chroma_scratch;
+    Common::ScratchBuffer<u8> swizzle_scratch;
 };
 
-} // namespace Host1x
-
-} // namespace Tegra
+} // namespace Tegra::Host1x

src/video_core/memory_manager.h

@@ -43,6 +43,8 @@ public:
                            u64 big_page_bits_ = 16, u64 page_bits_ = 12);
     ~MemoryManager();
 
+    static constexpr bool HAS_FLUSH_INVALIDATION = true;
+
     size_t GetID() const {
         return unique_identifier;
     }

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1064,8 +1064,6 @@ public:
                 }
             });
         }
-        auto* ptr = device_memory.GetPointer<u8>(new_query->dependant_address);
-        ASSERT(ptr != nullptr);
 
         new_query->dependant_manage = must_manage_dependance;
         pending_flush_queries.push_back(index);
@@ -1104,10 +1102,12 @@ public:
                 tfb_streamer.Free(query->dependant_index);
             } else {
                 u8* pointer = device_memory.GetPointer<u8>(query->dependant_address);
+                if (pointer != nullptr) {
                     u32 result;
                     std::memcpy(&result, pointer, sizeof(u32));
                     num_vertices = static_cast<u64>(result) / query->stride;
                 }
+            }
             query->value = [&]() -> u64 {
                 switch (query->topology) {
                 case Maxwell3D::Regs::PrimitiveTopology::Points:
@@ -1360,7 +1360,9 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
     const auto check_value = [&](DAddr address) {
         u8* ptr = impl->device_memory.GetPointer<u8>(address);
         u64 value{};
+        if (ptr != nullptr) {
             std::memcpy(&value, ptr, sizeof(value));
+        }
         return value == 0;
     };
     std::array<VideoCommon::LookupData*, 2> objects{&object_1, &object_2};

src/video_core/surface.cpp

@@ -3,6 +3,7 @@
 
 #include "common/common_types.h"
 #include "common/math_util.h"
+#include "common/settings.h"
 #include "video_core/surface.h"
 
 namespace VideoCore::Surface {
@@ -400,11 +401,20 @@ std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) {
     return {DefaultBlockWidth(format), DefaultBlockHeight(format)};
 }
 
-u64 EstimatedDecompressedSize(u64 base_size, PixelFormat format) {
+u64 TranscodedAstcSize(u64 base_size, PixelFormat format) {
     constexpr u64 RGBA8_PIXEL_SIZE = 4;
     const u64 base_block_size = static_cast<u64>(DefaultBlockWidth(format)) *
                                 static_cast<u64>(DefaultBlockHeight(format)) * RGBA8_PIXEL_SIZE;
-    return (base_size * base_block_size) / BytesPerBlock(format);
+    const u64 uncompressed_size = (base_size * base_block_size) / BytesPerBlock(format);
+
+    switch (Settings::values.astc_recompression.GetValue()) {
+    case Settings::AstcRecompression::Bc1:
+        return uncompressed_size / 8;
+    case Settings::AstcRecompression::Bc3:
+        return uncompressed_size / 4;
+    default:
+        return uncompressed_size;
+    }
 }
 
 } // namespace VideoCore::Surface

src/video_core/surface.h

@@ -517,6 +517,6 @@ size_t PixelComponentSizeBitsInteger(PixelFormat format);
 
 std::pair<u32, u32> GetASTCBlockSize(PixelFormat format);
 
-u64 EstimatedDecompressedSize(u64 base_size, PixelFormat format);
+u64 TranscodedAstcSize(u64 base_size, PixelFormat format);
 
 } // namespace VideoCore::Surface

src/video_core/texture_cache/texture_cache.h

@@ -55,7 +55,7 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
         const s64 min_spacing_critical = device_local_memory - 512_MiB;
         const s64 mem_threshold = std::min(device_local_memory, TARGET_THRESHOLD);
         const s64 min_vacancy_expected = (6 * mem_threshold) / 10;
-        const s64 min_vacancy_critical = (3 * mem_threshold) / 10;
+        const s64 min_vacancy_critical = (2 * mem_threshold) / 10;
         expected_memory = static_cast<u64>(
             std::max(std::min(device_local_memory - min_vacancy_expected, min_spacing_expected),
                      DEFAULT_EXPECTED_MEMORY));
@@ -1979,7 +1979,7 @@ void TextureCache<P>::RegisterImage(ImageId image_id) {
     if ((IsPixelFormatASTC(image.info.format) &&
          True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
         True(image.flags & ImageFlagBits::Converted)) {
-        tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
+        tentative_size = TranscodedAstcSize(tentative_size, image.info.format);
     }
     total_used_memory += Common::AlignUp(tentative_size, 1024);
     image.lru_index = lru_cache.Insert(image_id, frame_tick);
@@ -2149,7 +2149,7 @@ void TextureCache<P>::DeleteImage(ImageId image_id, bool immediate_delete) {
     if ((IsPixelFormatASTC(image.info.format) &&
          True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
         True(image.flags & ImageFlagBits::Converted)) {
-        tentative_size = EstimatedDecompressedSize(tentative_size, image.info.format);
+        tentative_size = TranscodedAstcSize(tentative_size, image.info.format);
     }
     total_used_memory -= Common::AlignUp(tentative_size, 1024);
     const GPUVAddr gpu_addr = image.gpu_addr;