vk_memory_manager,vk_stream_buffer: Use persistent memory maps

yuzu originally mapped and unmapped when memory had to be used from the
host. This was originally used to reduce overhead on debugging tools
(renderdoc and Nsight), but at the same time it broke compatibility with
Nsight because this is not handled properly.

After measuring recently, there isn't much of a difference in capture
and replay performance on renderdoc by avoiding persistent memory maps.

This commit replaces previous memory maps with a persistent memory map,
but the API is kept intact to be able to rollback in case it's needed.

CMakeLists.txt

@@ -263,7 +263,6 @@ if (CONAN_REQUIRED_LIBS)
         libzip:with_openssl=False
         libzip:enable_windows_crypto=False
     )
-
     conan_check(VERSION 1.24.0 REQUIRED)
     # Add the bincrafters remote
     conan_add_remote(NAME bincrafters
@@ -355,19 +354,6 @@ if (NOT LIBUSB_FOUND)
     set(LIBUSB_LIBRARIES usb)
 endif()
 
-# Use system installed ffmpeg.
-if (NOT MSVC)
-    find_package(FFmpeg REQUIRED)
-else()
-    set(FFMPEG_EXT_NAME "ffmpeg-4.2.1")
-    set(FFMPEG_PATH "${CMAKE_BINARY_DIR}/externals/${FFMPEG_EXT_NAME}")
-    download_bundled_external("ffmpeg/" ${FFMPEG_EXT_NAME} "")
-    set(FFMPEG_FOUND YES)
-    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
-    set(FFMPEG_LIBRARY_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg library" FORCE)
-    set(FFMPEG_DLL_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
-endif()
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -1,10 +0,0 @@
-function(copy_yuzu_FFmpeg_deps target_dir)
-    include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    windows_copy_files(${target_dir} ${FFMPEG_DLL_DIR} ${DLL_DEST}
-        avcodec-58.dll
-        avutil-56.dll
-        swresample-3.dll
-        swscale-5.dll
-    )
-endfunction(copy_yuzu_FFmpeg_deps)

externals/find-modules/FindFFmpeg.cmake

@@ -1,100 +0,0 @@
-# - Try to find ffmpeg libraries (libavcodec, libavformat and libavutil)
-# Once done this will define
-#
-# FFMPEG_FOUND - system has ffmpeg or libav
-# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
-# FFMPEG_LIBRARIES - Link these to use ffmpeg
-# FFMPEG_LIBAVCODEC
-# FFMPEG_LIBAVFORMAT
-# FFMPEG_LIBAVUTIL
-#
-# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
-# Modified for other libraries by Lasse Kärkkäinen <tronic>
-# Modified for Hedgewars by Stepik777
-# Modified for FFmpeg-example Tuukka Pasanen 2018
-# Modified for yuzu toastUnlimted 2020
-#
-# Redistribution and use is allowed according to the terms of the New
-# BSD license.
-#
-
-include(FindPackageHandleStandardArgs)
-
-find_package_handle_standard_args(FFMPEG
-  FOUND_VAR FFMPEG_FOUND
-  REQUIRED_VARS
-      FFMPEG_LIBRARY
-      FFMPEG_INCLUDE_DIR
-  VERSION_VAR FFMPEG_VERSION
-)
-
-if(FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
-  # in cache already
-  set(FFMPEG_FOUND TRUE)
-else()
-  # use pkg-config to get the directories and then use these values
-  # in the FIND_PATH() and FIND_LIBRARY() calls
-  find_package(PkgConfig)
-  if(PKG_CONFIG_FOUND)
-    pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
-    pkg_check_modules(_FFMPEG_AVUTIL libavutil)
-    pkg_check_modules(_FFMPEG_SWSCALE libswscale)
-  endif()
-
-  find_path(FFMPEG_AVCODEC_INCLUDE_DIR
-    NAMES libavcodec/avcodec.h
-    PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS}
-      /usr/include
-      /usr/local/include
-      /opt/local/include
-      /sw/include
-    PATH_SUFFIXES ffmpeg libav)
-
-  find_library(FFMPEG_LIBAVCODEC
-    NAMES avcodec
-    PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  find_library(FFMPEG_LIBAVUTIL
-    NAMES avutil
-    PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  find_library(FFMPEG_LIBSWSCALE
-    NAMES swscale
-    PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  if(FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE)
-    set(FFMPEG_FOUND TRUE)
-  endif()
-
-  if(FFMPEG_FOUND)
-    set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
-    set(FFMPEG_LIBRARIES
-      ${FFMPEG_LIBAVCODEC}
-      ${FFMPEG_LIBAVUTIL}
-      ${FFMPEG_LIBSWSCALE})
-  endif()
-
-  if(FFMPEG_FOUND)
-    if(NOT FFMPEG_FIND_QUIETLY)
-      message(STATUS
-      "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
-    endif()
-  else()
-    if(FFMPEG_FIND_REQUIRED)
-      message(FATAL_ERROR
-      "Could not find libavcodec or libavutil or libswscale")
-    endif()
-  endif()
-endif()

src/audio_core/CMakeLists.txt

@@ -51,12 +51,9 @@ if (NOT MSVC)
         -Werror=implicit-fallthrough
         -Werror=reorder
         -Werror=sign-compare
+        -Werror=unused-but-set-parameter
+        -Werror=unused-but-set-variable
         -Werror=unused-variable
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-
-        -Wno-sign-conversion
     )
 endif()
 

src/common/CMakeLists.txt

@@ -150,8 +150,6 @@ add_library(common STATIC
     scope_exit.h
     spin_lock.cpp
     spin_lock.h
-    stream.cpp
-    stream.h
     string_util.cpp
     string_util.h
     swap.h

src/common/math_util.h

@@ -20,14 +20,14 @@ struct Rectangle {
 
     constexpr Rectangle() = default;
 
-    constexpr Rectangle(T left_, T top_, T right_, T bottom_)
-        : left(left_), top(top_), right(right_), bottom(bottom_) {}
+    constexpr Rectangle(T left, T top, T right, T bottom)
+        : left(left), top(top), right(right), bottom(bottom) {}
 
     [[nodiscard]] T GetWidth() const {
         if constexpr (std::is_floating_point_v<T>) {
             return std::abs(right - left);
         } else {
-            return static_cast<T>(std::abs(static_cast<std::make_signed_t<T>>(right - left)));
+            return std::abs(static_cast<std::make_signed_t<T>>(right - left));
         }
     }
 
@@ -35,7 +35,7 @@ struct Rectangle {
         if constexpr (std::is_floating_point_v<T>) {
             return std::abs(bottom - top);
         } else {
-            return static_cast<T>(std::abs(static_cast<std::make_signed_t<T>>(bottom - top)));
+            return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
         }
     }
 

src/common/stream.cpp

@@ -1,47 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <stdexcept>
-#include "common/common_types.h"
-#include "common/stream.h"
-
-namespace Common {
-
-Stream::Stream() = default;
-Stream::~Stream() = default;
-
-void Stream::Seek(s32 offset, SeekOrigin origin) {
-    if (origin == SeekOrigin::SetOrigin) {
-        if (offset < 0) {
-            position = 0;
-        } else if (position >= buffer.size()) {
-            position = buffer.size();
-        } else {
-            position = offset;
-        }
-    } else if (origin == SeekOrigin::FromCurrentPos) {
-        Seek(static_cast<s32>(position) + offset, SeekOrigin::SetOrigin);
-    } else if (origin == SeekOrigin::FromEnd) {
-        Seek(static_cast<s32>(buffer.size()) - offset, SeekOrigin::SetOrigin);
-    }
-}
-
-u8 Stream::ReadByte() {
-    if (position < buffer.size()) {
-        return buffer[position++];
-    } else {
-        throw std::out_of_range("Attempting to read a byte not within the buffer range");
-    }
-}
-
-void Stream::WriteByte(u8 byte) {
-    if (position == buffer.size()) {
-        buffer.push_back(byte);
-        position++;
-    } else {
-        buffer.insert(buffer.begin() + position, byte);
-    }
-}
-
-} // namespace Common

src/common/stream.h

@@ -1,50 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-
-namespace Common {
-
-enum class SeekOrigin {
-    SetOrigin,
-    FromCurrentPos,
-    FromEnd,
-};
-
-class Stream {
-public:
-    /// Stream creates a bitstream and provides common functionality on the stream.
-    explicit Stream();
-    ~Stream();
-
-    /// Reposition bitstream "cursor" to the specified offset from origin
-    void Seek(s32 offset, SeekOrigin origin);
-
-    /// Reads next byte in the stream buffer and increments position
-    u8 ReadByte();
-
-    /// Writes byte at current position
-    void WriteByte(u8 byte);
-
-    std::size_t GetPosition() const {
-        return position;
-    }
-
-    std::vector<u8>& GetBuffer() {
-        return buffer;
-    }
-
-    const std::vector<u8>& GetBuffer() const {
-        return buffer;
-    }
-
-private:
-    std::vector<u8> buffer;
-    std::size_t position{0};
-};
-
-} // namespace Common

src/common/vector_math.h

@@ -87,13 +87,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec2<decltype(T{} * V{})> operator*(const V& f) const {
-        using TV = decltype(T{} * V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
-        };
+        return {x * f, y * f};
     }
 
     template <typename V>
@@ -104,13 +98,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec2<decltype(T{} / V{})> operator/(const V& f) const {
-        using TV = decltype(T{} / V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
-        };
+        return {x / f, y / f};
     }
 
     template <typename V>
@@ -180,10 +168,7 @@ public:
 
 template <typename T, typename V>
 [[nodiscard]] constexpr Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
-    using C = std::common_type_t<T, V>;
-
-    return Vec2<T>(static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.x)),
-                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.y)));
+    return Vec2<T>(f * vec.x, f * vec.y);
 }
 
 using Vec2f = Vec2<float>;
@@ -252,14 +237,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec3<decltype(T{} * V{})> operator*(const V& f) const {
-        using TV = decltype(T{} * V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) * static_cast<C>(f)),
-        };
+        return {x * f, y * f, z * f};
     }
 
     template <typename V>
@@ -269,14 +247,7 @@ public:
     }
     template <typename V>
     [[nodiscard]] constexpr Vec3<decltype(T{} / V{})> operator/(const V& f) const {
-        using TV = decltype(T{} / V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) / static_cast<C>(f)),
-        };
+        return {x / f, y / f, z / f};
     }
 
     template <typename V>
@@ -396,11 +367,7 @@ public:
 
 template <typename T, typename V>
 [[nodiscard]] constexpr Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
-    using C = std::common_type_t<T, V>;
-
-    return Vec3<T>(static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.x)),
-                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.y)),
-                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.z)));
+    return Vec3<T>(f * vec.x, f * vec.y, f * vec.z);
 }
 
 template <>
@@ -479,15 +446,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec4<decltype(T{} * V{})> operator*(const V& f) const {
-        using TV = decltype(T{} * V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(w) * static_cast<C>(f)),
-        };
+        return {x * f, y * f, z * f, w * f};
     }
 
     template <typename V>
@@ -498,15 +457,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec4<decltype(T{} / V{})> operator/(const V& f) const {
-        using TV = decltype(T{} / V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(w) / static_cast<C>(f)),
-        };
+        return {x / f, y / f, z / f, w / f};
     }
 
     template <typename V>
@@ -631,15 +582,7 @@ public:
 
 template <typename T, typename V>
 [[nodiscard]] constexpr Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
-    using TV = decltype(V{} * T{});
-    using C = std::common_type_t<T, V>;
-
-    return {
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.x)),
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.y)),
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.z)),
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.w)),
-    };
+    return {f * vec.x, f * vec.y, f * vec.z, f * vec.w};
 }
 
 using Vec4f = Vec4<float>;

src/core/CMakeLists.txt

@@ -1,3 +1,9 @@
+if (YUZU_ENABLE_BOXCAT)
+    set(BCAT_BOXCAT_ADDITIONAL_SOURCES hle/service/bcat/backend/boxcat.cpp hle/service/bcat/backend/boxcat.h)
+else()
+    set(BCAT_BOXCAT_ADDITIONAL_SOURCES)
+endif()
+
 add_library(core STATIC
     arm/arm_interface.h
     arm/arm_interface.cpp
@@ -297,6 +303,7 @@ add_library(core STATIC
     hle/service/audio/hwopus.h
     hle/service/bcat/backend/backend.cpp
     hle/service/bcat/backend/backend.h
+    ${BCAT_BOXCAT_ADDITIONAL_SOURCES}
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
     hle/service/bcat/module.cpp
@@ -439,8 +446,6 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvhost_nvdec.cpp
     hle/service/nvdrv/devices/nvhost_nvdec.h
-    hle/service/nvdrv/devices/nvhost_nvdec_common.cpp
-    hle/service/nvdrv/devices/nvhost_nvdec_common.h
     hle/service/nvdrv/devices/nvhost_nvjpg.cpp
     hle/service/nvdrv/devices/nvhost_nvjpg.h
     hle/service/nvdrv/devices/nvhost_vic.cpp
@@ -603,13 +608,6 @@ add_library(core STATIC
     tools/freezer.h
 )
 
-if (YUZU_ENABLE_BOXCAT)
-    target_sources(core PRIVATE
-        hle/service/bcat/backend/boxcat.cpp
-        hle/service/bcat/backend/boxcat.h
-    )
-endif()
-
 if (MSVC)
     target_compile_options(core PRIVATE
         # 'expression' : signed/unsigned mismatch
@@ -632,12 +630,9 @@ else()
         -Werror=implicit-fallthrough
         -Werror=reorder
         -Werror=sign-compare
+        -Werror=unused-but-set-parameter
+        -Werror=unused-but-set-variable
         -Werror=unused-variable
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-
-        -Wno-sign-conversion
     )
 endif()
 

src/core/core.cpp

@@ -40,7 +40,6 @@
 #include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/hle/service/time/time_manager.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/memory/cheat_engine.h"
@@ -122,7 +121,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 struct System::Impl {
     explicit Impl(System& system)
         : kernel{system}, fs_controller{system}, memory{system},
-          cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
+          cpu_manager{system}, reporter{system}, applet_manager{system} {}
 
     ResultStatus Run() {
         status = ResultStatus::Success;
@@ -190,9 +189,6 @@ struct System::Impl {
             return ResultStatus::ErrorVideoCore;
         }
 
-        // Initialize time manager, which must happen after kernel is created
-        time_manager.Initialize();
-
         is_powered_on = true;
         exit_lock = false;
 
@@ -391,7 +387,6 @@ struct System::Impl {
     /// Service State
     Service::Glue::ARPManager arp_manager;
     Service::LM::Manager lm_manager{reporter};
-    Service::Time::TimeManager time_manager;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -722,14 +717,6 @@ const Service::LM::Manager& System::GetLogManager() const {
     return impl->lm_manager;
 }
 
-Service::Time::TimeManager& System::GetTimeManager() {
-    return impl->time_manager;
-}
-
-const Service::Time::TimeManager& System::GetTimeManager() const {
-    return impl->time_manager;
-}
-
 void System::SetExitLock(bool locked) {
     impl->exit_lock = locked;
 }

src/core/core.h

@@ -69,10 +69,6 @@ namespace SM {
 class ServiceManager;
 } // namespace SM
 
-namespace Time {
-class TimeManager;
-} // namespace Time
-
 } // namespace Service
 
 namespace Tegra {
@@ -365,10 +361,6 @@ public:
 
     const Service::LM::Manager& GetLogManager() const;
 
-    Service::Time::TimeManager& GetTimeManager();
-
-    const Service::Time::TimeManager& GetTimeManager() const;
-
     void SetExitLock(bool locked);
 
     bool GetExitLock() const;

src/core/cpu_manager.cpp

@@ -365,8 +365,6 @@ void CpuManager::RunThread(std::size_t core) {
     data.enter_barrier.reset();
     data.exit_barrier.reset();
     data.initialized = false;
-
-    MicroProfileOnThreadExit();
 }
 
 } // namespace Core

src/core/frontend/applets/controller.cpp

@@ -19,7 +19,7 @@ DefaultControllerApplet::DefaultControllerApplet(Service::SM::ServiceManager& se
 DefaultControllerApplet::~DefaultControllerApplet() = default;
 
 void DefaultControllerApplet::ReconfigureControllers(std::function<void()> callback,
-                                                     const ControllerParameters& parameters) const {
+                                                     ControllerParameters parameters) const {
     LOG_INFO(Service_HID, "called, deducing the best configuration based on the given parameters!");
 
     auto& npad =

src/core/frontend/applets/controller.h

@@ -38,7 +38,7 @@ public:
     virtual ~ControllerApplet();
 
     virtual void ReconfigureControllers(std::function<void()> callback,
-                                        const ControllerParameters& parameters) const = 0;
+                                        ControllerParameters parameters) const = 0;
 };
 
 class DefaultControllerApplet final : public ControllerApplet {
@@ -47,7 +47,7 @@ public:
     ~DefaultControllerApplet() override;
 
     void ReconfigureControllers(std::function<void()> callback,
-                                const ControllerParameters& parameters) const override;
+                                ControllerParameters parameters) const override;
 
 private:
     Service::SM::ServiceManager& service_manager;

src/core/hle/kernel/kernel.cpp

@@ -7,6 +7,7 @@
 #include <bitset>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <thread>
 #include <unordered_map>
 #include <utility>
@@ -86,6 +87,8 @@ struct KernelCore::Impl {
         }
         cores.clear();
 
+        registered_core_threads.reset();
+
         process_list.clear();
         current_process = nullptr;
 
@@ -104,11 +107,7 @@ struct KernelCore::Impl {
         cores.clear();
 
         exclusive_monitor.reset();
-
-        num_host_threads = 0;
-        std::fill(register_host_thread_keys.begin(), register_host_thread_keys.end(),
-                  std::thread::id{});
-        std::fill(register_host_thread_values.begin(), register_host_thread_values.end(), 0);
+        host_thread_ids.clear();
     }
 
     void InitializePhysicalCores() {
@@ -178,58 +177,54 @@ struct KernelCore::Impl {
 
     void MakeCurrentProcess(Process* process) {
         current_process = process;
+
         if (process == nullptr) {
             return;
         }
-        const u32 core_id = GetCurrentHostThreadID();
+
+        u32 core_id = GetCurrentHostThreadID();
         if (core_id < Core::Hardware::NUM_CPU_CORES) {
             system.Memory().SetCurrentPageTable(*process, core_id);
         }
     }
 
     void RegisterCoreThread(std::size_t core_id) {
-        const std::thread::id this_id = std::this_thread::get_id();
+        std::unique_lock lock{register_thread_mutex};
         if (!is_multicore) {
-            single_core_thread_id = this_id;
+            single_core_thread_id = std::this_thread::get_id();
         }
-        const auto end =
-            register_host_thread_keys.begin() + static_cast<ptrdiff_t>(num_host_threads);
-        const auto it = std::find(register_host_thread_keys.begin(), end, this_id);
+        const std::thread::id this_id = std::this_thread::get_id();
+        const auto it = host_thread_ids.find(this_id);
         ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
-        ASSERT(it == end);
-        InsertHostThread(static_cast<u32>(core_id));
+        ASSERT(it == host_thread_ids.end());
+        ASSERT(!registered_core_threads[core_id]);
+        host_thread_ids[this_id] = static_cast<u32>(core_id);
+        registered_core_threads.set(core_id);
     }
 
     void RegisterHostThread() {
+        std::unique_lock lock{register_thread_mutex};
         const std::thread::id this_id = std::this_thread::get_id();
-        const auto end =
-            register_host_thread_keys.begin() + static_cast<ptrdiff_t>(num_host_threads);
-        const auto it = std::find(register_host_thread_keys.begin(), end, this_id);
-        if (it == end) {
-            InsertHostThread(registered_thread_ids++);
+        const auto it = host_thread_ids.find(this_id);
+        if (it != host_thread_ids.end()) {
+            return;
         }
+        host_thread_ids[this_id] = registered_thread_ids++;
     }
 
-    void InsertHostThread(u32 value) {
-        const size_t index = num_host_threads++;
-        ASSERT_MSG(index < NUM_REGISTRABLE_HOST_THREADS, "Too many host threads");
-        register_host_thread_values[index] = value;
-        register_host_thread_keys[index] = std::this_thread::get_id();
-    }
-
-    [[nodiscard]] u32 GetCurrentHostThreadID() const {
+    u32 GetCurrentHostThreadID() const {
         const std::thread::id this_id = std::this_thread::get_id();
-        if (!is_multicore && single_core_thread_id == this_id) {
-            return static_cast<u32>(system.GetCpuManager().CurrentCore());
+        if (!is_multicore) {
+            if (single_core_thread_id == this_id) {
+                return static_cast<u32>(system.GetCpuManager().CurrentCore());
+            }
         }
-        const auto end =
-            register_host_thread_keys.begin() + static_cast<ptrdiff_t>(num_host_threads);
-        const auto it = std::find(register_host_thread_keys.begin(), end, this_id);
-        if (it == end) {
+        std::unique_lock lock{register_thread_mutex};
+        const auto it = host_thread_ids.find(this_id);
+        if (it == host_thread_ids.end()) {
             return Core::INVALID_HOST_THREAD_ID;
         }
-        return register_host_thread_values[static_cast<size_t>(
-            std::distance(register_host_thread_keys.begin(), it))];
+        return it->second;
     }
 
     Core::EmuThreadHandle GetCurrentEmuThreadID() const {
@@ -327,14 +322,10 @@ struct KernelCore::Impl {
     std::vector<Kernel::PhysicalCore> cores;
 
     // 0-3 IDs represent core threads, >3 represent others
-    std::atomic<u32> registered_thread_ids{Core::Hardware::NUM_CPU_CORES};
-
-    // Number of host threads is a relatively high number to avoid overflowing
-    static constexpr size_t NUM_REGISTRABLE_HOST_THREADS = 64;
-    std::atomic<size_t> num_host_threads{0};
-    std::array<std::atomic<std::thread::id>, NUM_REGISTRABLE_HOST_THREADS>
-        register_host_thread_keys{};
-    std::array<std::atomic<u32>, NUM_REGISTRABLE_HOST_THREADS> register_host_thread_values{};
+    std::unordered_map<std::thread::id, u32> host_thread_ids;
+    u32 registered_thread_ids{Core::Hardware::NUM_CPU_CORES};
+    std::bitset<Core::Hardware::NUM_CPU_CORES> registered_core_threads;
+    mutable std::mutex register_thread_mutex;
 
     // Kernel memory management
     std::unique_ptr<Memory::MemoryManager> memory_manager;

src/core/hle/service/bcat/backend/backend.cpp

@@ -84,7 +84,7 @@ void ProgressServiceBackend::FinishDownload(ResultCode result) {
 
 void ProgressServiceBackend::SignalUpdate() const {
     if (need_hle_lock) {
-        std::lock_guard lock(HLE::g_hle_lock);
+        std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
         event.writable->Signal();
     } else {
         event.writable->Signal();

src/core/hle/service/bcat/backend/boxcat.cpp

@@ -454,16 +454,6 @@ Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
         {std::string("Boxcat-Client-Type"), std::string(BOXCAT_CLIENT_TYPE)},
     };
 
-    if (!client.is_valid()) {
-        LOG_ERROR(Service_BCAT, "Client is invalid, going offline!");
-        return StatusResult::Offline;
-    }
-
-    if (!client.is_socket_open()) {
-        LOG_ERROR(Service_BCAT, "Failed to open socket, going offline!");
-        return StatusResult::Offline;
-    }
-
     const auto response = client.Get(BOXCAT_PATHNAME_EVENTS, headers);
     if (response == nullptr)
         return StatusResult::Offline;

src/core/hle/service/filesystem/filesystem.cpp

@@ -79,7 +79,7 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
     }
 
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
-    if (dir == nullptr || dir->GetFile(Common::FS::GetFilename(path)) == nullptr) {
+    if (dir->GetFile(Common::FS::GetFilename(path)) == nullptr) {
         return FileSys::ERROR_PATH_NOT_FOUND;
     }
     if (!dir->DeleteFile(Common::FS::GetFilename(path))) {
@@ -93,9 +93,8 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
 ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
-    if (dir == nullptr || Common::FS::GetFilename(Common::FS::GetParentPath(path)).empty()) {
+    if (dir == nullptr && Common::FS::GetFilename(Common::FS::GetParentPath(path)).empty())
         dir = backing;
-    }
     auto new_dir = dir->CreateSubdirectory(Common::FS::GetFilename(path));
     if (new_dir == nullptr) {
         // TODO(DarkLordZach): Find a better error code for this

src/core/hle/service/ldr/ldr.cpp

@@ -23,7 +23,7 @@ namespace Service::LDR {
 
 constexpr ResultCode ERROR_INSUFFICIENT_ADDRESS_SPACE{ErrorModule::RO, 2};
 
-[[maybe_unused]] constexpr ResultCode ERROR_INVALID_MEMORY_STATE{ErrorModule::Loader, 51};
+constexpr ResultCode ERROR_INVALID_MEMORY_STATE{ErrorModule::Loader, 51};
 constexpr ResultCode ERROR_INVALID_NRO{ErrorModule::Loader, 52};
 constexpr ResultCode ERROR_INVALID_NRR{ErrorModule::Loader, 53};
 constexpr ResultCode ERROR_MISSING_NRR_HASH{ErrorModule::Loader, 54};
@@ -33,7 +33,7 @@ constexpr ResultCode ERROR_ALREADY_LOADED{ErrorModule::Loader, 57};
 constexpr ResultCode ERROR_INVALID_ALIGNMENT{ErrorModule::Loader, 81};
 constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::Loader, 82};
 constexpr ResultCode ERROR_INVALID_NRO_ADDRESS{ErrorModule::Loader, 84};
-[[maybe_unused]] constexpr ResultCode ERROR_INVALID_NRR_ADDRESS{ErrorModule::Loader, 85};
+constexpr ResultCode ERROR_INVALID_NRR_ADDRESS{ErrorModule::Loader, 85};
 constexpr ResultCode ERROR_NOT_INITIALIZED{ErrorModule::Loader, 87};
 
 constexpr std::size_t MAXIMUM_LOADED_RO{0x40};

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

@@ -131,7 +131,7 @@ template <typename T>
 T GetRandomValue(T min, T max) {
     std::random_device device;
     std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(static_cast<u64>(min), static_cast<u64>(max));
+    std::uniform_int_distribution<u64> distribution(0, static_cast<u64>(max));
     return static_cast<T>(distribution(gen));
 }
 

src/core/hle/service/nifm/nifm.cpp

@@ -62,7 +62,7 @@ public:
             {18, nullptr, "SetRequirementByRevision"},
             {19, nullptr, "GetRequirement"},
             {20, nullptr, "GetRevision"},
-            {21, &IRequest::GetAppletInfo, "GetAppletInfo"},
+            {21, nullptr, "GetAppletInfo"},
             {22, nullptr, "GetAdditionalInfo"},
             {23, nullptr, "SetKeptInSleep"},
             {24, nullptr, "RegisterSocketDescriptor"},
@@ -125,16 +125,6 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    void GetAppletInfo(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 8};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0);
-        rb.Push<u32>(0);
-        rb.Push<u32>(0);
-    }
-
     Kernel::EventPair event1, event2;
 };
 

src/core/hle/service/ns/pl_u.cpp

@@ -50,9 +50,19 @@ constexpr std::array<std::pair<FontArchives, const char*>, 7> SHARED_FONTS{
     std::make_pair(FontArchives::Extension, "nintendo_ext2_003.bfttf"),
 };
 
+constexpr std::array<const char*, 7> SHARED_FONTS_TTF{
+    "FontStandard.ttf",
+    "FontChineseSimplified.ttf",
+    "FontExtendedChineseSimplified.ttf",
+    "FontChineseTraditional.ttf",
+    "FontKorean.ttf",
+    "FontNintendoExtended.ttf",
+    "FontNintendoExtended2.ttf",
+};
+
 // The below data is specific to shared font data dumped from Switch on f/w 2.2
 // Virtual address and offsets/sizes likely will vary by dump
-[[maybe_unused]] constexpr VAddr SHARED_FONT_MEM_VADDR{0x00000009d3016000ULL};
+constexpr VAddr SHARED_FONT_MEM_VADDR{0x00000009d3016000ULL};
 constexpr u32 EXPECTED_RESULT{0x7f9a0218}; // What we expect the decrypted bfttf first 4 bytes to be
 constexpr u32 EXPECTED_MAGIC{0x36f81a1e};  // What we expect the encrypted bfttf first 4 bytes to be
 constexpr u64 SHARED_FONT_MEM_SIZE{0x1100000};

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

@@ -46,8 +46,6 @@ u32 nvhost_as_gpu::ioctl(Ioctl command, const std::vector<u8>& input, const std:
         return GetVARegions(input, output);
     case IoctlCommand::IocUnmapBufferCommand:
         return UnmapBuffer(input, output);
-    case IoctlCommand::IocFreeSpaceCommand:
-        return FreeSpace(input, output);
     default:
         break;
     }
@@ -93,20 +91,6 @@ u32 nvhost_as_gpu::AllocateSpace(const std::vector<u8>& input, std::vector<u8>&
     return result;
 }
 
-u32 nvhost_as_gpu::FreeSpace(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlFreeSpace params{};
-    std::memcpy(&params, input.data(), input.size());
-
-    LOG_DEBUG(Service_NVDRV, "called, offset={:X}, pages={:X}, page_size={:X}", params.offset,
-              params.pages, params.page_size);
-
-    system.GPU().MemoryManager().Unmap(params.offset,
-                                       static_cast<std::size_t>(params.pages) * params.page_size);
-
-    std::memcpy(output.data(), &params, output.size());
-    return NvErrCodes::Success;
-}
-
 u32 nvhost_as_gpu::Remap(const std::vector<u8>& input, std::vector<u8>& output) {
     const auto num_entries = input.size() / sizeof(IoctlRemapEntry);
 

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

@@ -82,7 +82,6 @@ private:
         IocBindChannelCommand = 0x40044101,
         IocGetVaRegionsCommand = 0xC0404108,
         IocUnmapBufferCommand = 0xC0084105,
-        IocFreeSpaceCommand = 0xC0104103,
     };
 
     struct IoctlInitalizeEx {
@@ -108,13 +107,6 @@ private:
     };
     static_assert(sizeof(IoctlAllocSpace) == 24, "IoctlInitalizeEx is incorrect size");
 
-    struct IoctlFreeSpace {
-        u64_le offset;
-        u32_le pages;
-        u32_le page_size;
-    };
-    static_assert(sizeof(IoctlFreeSpace) == 16, "IoctlFreeSpace is incorrect size");
-
     struct IoctlRemapEntry {
         u16_le flags;
         u16_le kind;
@@ -170,7 +162,6 @@ private:
     u32 Remap(const std::vector<u8>& input, std::vector<u8>& output);
     u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
     u32 UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 FreeSpace(const std::vector<u8>& input, std::vector<u8>& output);
     u32 BindChannel(const std::vector<u8>& input, std::vector<u8>& output);
     u32 GetVARegions(const std::vector<u8>& input, std::vector<u8>& output);
 

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

@@ -2,17 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cstring>
+
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec.h"
-#include "video_core/memory_manager.h"
-#include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
 
-nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
-    : nvhost_nvdec_common(system, std::move(nvmap_dev)) {}
+nvhost_nvdec::nvhost_nvdec(Core::System& system) : nvdevice(system) {}
 nvhost_nvdec::~nvhost_nvdec() = default;
 
 u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
@@ -23,7 +21,7 @@ u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, const std::
 
     switch (static_cast<IoctlCommand>(command.raw)) {
     case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input);
+        return SetNVMAPfd(input, output);
     case IoctlCommand::IocSubmit:
         return Submit(input, output);
     case IoctlCommand::IocGetSyncpoint:
@@ -31,29 +29,79 @@ u32 nvhost_nvdec::ioctl(Ioctl command, const std::vector<u8>& input, const std::
     case IoctlCommand::IocGetWaitbase:
         return GetWaitbase(input, output);
     case IoctlCommand::IocMapBuffer:
-    case IoctlCommand::IocMapBuffer2:
-    case IoctlCommand::IocMapBuffer3:
-    case IoctlCommand::IocMapBufferEx:
         return MapBuffer(input, output);
-    case IoctlCommand::IocUnmapBufferEx: {
-        // This command is sent when the video stream has ended, flush all video contexts
-        // This is usually sent in the folowing order: vic, nvdec, vic.
-        // Inform the GPU to clear any remaining nvdec buffers when this is detected.
-        LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
-        Tegra::ChCommandHeaderList cmdlist(1);
-        cmdlist[0] = Tegra::ChCommandHeader{0xDEADB33F};
-        system.GPU().PushCommandBuffer(cmdlist);
-        [[fallthrough]]; // fallthrough to unmap buffers
-    };
-    case IoctlCommand::IocUnmapBuffer:
-    case IoctlCommand::IocUnmapBuffer2:
-    case IoctlCommand::IocUnmapBuffer3:
-        return UnmapBuffer(input, output);
-    case IoctlCommand::IocSetSubmitTimeout:
-        return SetSubmitTimeout(input, output);
+    case IoctlCommand::IocMapBufferEx:
+        return MapBufferEx(input, output);
+    case IoctlCommand::IocUnmapBufferEx:
+        return UnmapBufferEx(input, output);
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented ioctl 0x{:X}", command.raw);
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
+}
+
+u32 nvhost_nvdec::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSetNvmapFD));
+    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
+
+    nvmap_fd = params.nvmap_fd;
+    return 0;
+}
+
+u32 nvhost_nvdec::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlSubmit params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSubmit));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
+    return 0;
+}
+
+u32 nvhost_nvdec::GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlGetSyncpoint params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
+    LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
+    params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));
+    return 0;
+}
+
+u32 nvhost_nvdec::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlGetWaitbase params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
+    LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
+    params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, sizeof(IoctlGetWaitbase));
+    return 0;
+}
+
+u32 nvhost_nvdec::MapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlMapBuffer params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called with address={:08X}{:08X}", params.address_2,
+                params.address_1);
+    params.address_1 = 0;
+    params.address_2 = 0;
+    std::memcpy(output.data(), &params, sizeof(IoctlMapBuffer));
+    return 0;
+}
+
+u32 nvhost_nvdec::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlMapBufferEx params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBufferEx));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called with address={:08X}{:08X}", params.address_2,
+                params.address_1);
+    params.address_1 = 0;
+    params.address_2 = 0;
+    std::memcpy(output.data(), &params, sizeof(IoctlMapBufferEx));
+    return 0;
+}
+
+u32 nvhost_nvdec::UnmapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlUnmapBufferEx params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlUnmapBufferEx));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    std::memcpy(output.data(), &params, sizeof(IoctlUnmapBufferEx));
     return 0;
 }
 

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

@@ -4,14 +4,16 @@
 
 #pragma once
 
-#include <memory>
-#include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"
+#include <vector>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/nvdrv/devices/nvdevice.h"
 
 namespace Service::Nvidia::Devices {
 
-class nvhost_nvdec final : public nvhost_nvdec_common {
+class nvhost_nvdec final : public nvdevice {
 public:
-    explicit nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
+    explicit nvhost_nvdec(Core::System& system);
     ~nvhost_nvdec() override;
 
     u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
@@ -25,15 +27,62 @@ private:
         IocGetSyncpoint = 0xC0080002,
         IocGetWaitbase = 0xC0080003,
         IocMapBuffer = 0xC01C0009,
-        IocMapBuffer2 = 0xC16C0009,
-        IocMapBuffer3 = 0xC15C0009,
         IocMapBufferEx = 0xC0A40009,
-        IocUnmapBuffer = 0xC0A4000A,
-        IocUnmapBuffer2 = 0xC16C000A,
-        IocUnmapBufferEx = 0xC01C000A,
-        IocUnmapBuffer3 = 0xC15C000A,
-        IocSetSubmitTimeout = 0x40040007,
+        IocUnmapBufferEx = 0xC0A4000A,
     };
+
+    struct IoctlSetNvmapFD {
+        u32_le nvmap_fd;
+    };
+    static_assert(sizeof(IoctlSetNvmapFD) == 0x4, "IoctlSetNvmapFD is incorrect size");
+
+    struct IoctlSubmit {
+        INSERT_PADDING_BYTES(0x40); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlSubmit) == 0x40, "IoctlSubmit has incorrect size");
+
+    struct IoctlGetSyncpoint {
+        u32 unknown; // seems to be ignored? Nintendo added this
+        u32 value;
+    };
+    static_assert(sizeof(IoctlGetSyncpoint) == 0x08, "IoctlGetSyncpoint has incorrect size");
+
+    struct IoctlGetWaitbase {
+        u32 unknown; // seems to be ignored? Nintendo added this
+        u32 value;
+    };
+    static_assert(sizeof(IoctlGetWaitbase) == 0x08, "IoctlGetWaitbase has incorrect size");
+
+    struct IoctlMapBuffer {
+        u32 unknown;
+        u32 address_1;
+        u32 address_2;
+        INSERT_PADDING_BYTES(0x10); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlMapBuffer) == 0x1C, "IoctlMapBuffer is incorrect size");
+
+    struct IoctlMapBufferEx {
+        u32 unknown;
+        u32 address_1;
+        u32 address_2;
+        INSERT_PADDING_BYTES(0x98); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlMapBufferEx) == 0xA4, "IoctlMapBufferEx has incorrect size");
+
+    struct IoctlUnmapBufferEx {
+        INSERT_PADDING_BYTES(0xA4); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlUnmapBufferEx) == 0xA4, "IoctlUnmapBufferEx has incorrect size");
+
+    u32_le nvmap_fd{};
+
+    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 Submit(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 MapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 UnmapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
 };
 
 } // namespace Service::Nvidia::Devices

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

@@ -1,234 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "core/core.h"
-#include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"
-#include "core/hle/service/nvdrv/devices/nvmap.h"
-#include "core/memory.h"
-#include "video_core/memory_manager.h"
-#include "video_core/renderer_base.h"
-
-namespace Service::Nvidia::Devices {
-
-namespace {
-// Splice vectors will copy count amount of type T from the input vector into the dst vector.
-template <typename T>
-std::size_t SpliceVectors(const std::vector<u8>& input, std::vector<T>& dst, std::size_t count,
-                          std::size_t offset) {
-    std::memcpy(dst.data(), input.data() + offset, count * sizeof(T));
-    offset += count * sizeof(T);
-    return offset;
-}
-
-// Write vectors will write data to the output buffer
-template <typename T>
-std::size_t WriteVectors(std::vector<u8>& dst, const std::vector<T>& src, std::size_t offset) {
-    std::memcpy(dst.data() + offset, src.data(), src.size() * sizeof(T));
-    offset += src.size() * sizeof(T);
-    return offset;
-}
-} // Anonymous namespace
-
-namespace NvErrCodes {
-constexpr u32 Success{};
-constexpr u32 OutOfMemory{static_cast<u32>(-12)};
-constexpr u32 InvalidInput{static_cast<u32>(-22)};
-} // namespace NvErrCodes
-
-nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
-    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
-nvhost_nvdec_common::~nvhost_nvdec_common() = default;
-
-u32 nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
-    IoctlSetNvmapFD params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlSetNvmapFD));
-    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
-
-    nvmap_fd = params.nvmap_fd;
-    return 0;
-}
-
-u32 nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlSubmit params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlSubmit));
-    LOG_DEBUG(Service_NVDRV, "called NVDEC Submit, cmd_buffer_count={}", params.cmd_buffer_count);
-
-    // Instantiate param buffers
-    std::size_t offset = sizeof(IoctlSubmit);
-    std::vector<CommandBuffer> command_buffers(params.cmd_buffer_count);
-    std::vector<Reloc> relocs(params.relocation_count);
-    std::vector<u32> reloc_shifts(params.relocation_count);
-    std::vector<SyncptIncr> syncpt_increments(params.syncpoint_count);
-    std::vector<SyncptIncr> wait_checks(params.syncpoint_count);
-    std::vector<Fence> fences(params.fence_count);
-
-    // Splice input into their respective buffers
-    offset = SpliceVectors(input, command_buffers, params.cmd_buffer_count, offset);
-    offset = SpliceVectors(input, relocs, params.relocation_count, offset);
-    offset = SpliceVectors(input, reloc_shifts, params.relocation_count, offset);
-    offset = SpliceVectors(input, syncpt_increments, params.syncpoint_count, offset);
-    offset = SpliceVectors(input, wait_checks, params.syncpoint_count, offset);
-    offset = SpliceVectors(input, fences, params.fence_count, offset);
-
-    // TODO(ameerj): For async gpu, utilize fences for syncpoint 'max' increment
-
-    auto& gpu = system.GPU();
-
-    for (const auto& cmd_buffer : command_buffers) {
-        auto object = nvmap_dev->GetObject(cmd_buffer.memory_id);
-        ASSERT_OR_EXECUTE(object, return NvErrCodes::InvalidInput;);
-        const auto map = FindBufferMap(object->dma_map_addr);
-        if (!map) {
-            LOG_ERROR(Service_NVDRV, "Tried to submit an invalid offset 0x{:X} dma 0x{:X}",
-                      object->addr, object->dma_map_addr);
-            return 0;
-        }
-        Tegra::ChCommandHeaderList cmdlist(cmd_buffer.word_count);
-        gpu.MemoryManager().ReadBlock(map->StartAddr() + cmd_buffer.offset, cmdlist.data(),
-                                      cmdlist.size() * sizeof(u32));
-        gpu.PushCommandBuffer(cmdlist);
-    }
-
-    std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
-    // Some games expect command_buffers to be written back
-    offset = sizeof(IoctlSubmit);
-    offset = WriteVectors(output, command_buffers, offset);
-    offset = WriteVectors(output, relocs, offset);
-    offset = WriteVectors(output, reloc_shifts, offset);
-    offset = WriteVectors(output, syncpt_increments, offset);
-    offset = WriteVectors(output, wait_checks, offset);
-
-    return NvErrCodes::Success;
-}
-
-u32 nvhost_nvdec_common::GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlGetSyncpoint params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
-    LOG_DEBUG(Service_NVDRV, "called GetSyncpoint, id={}", params.param);
-
-    // We found that implementing this causes deadlocks with async gpu, along with degraded
-    // performance. TODO: RE the nvdec async implementation
-    params.value = 0;
-    std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));
-
-    return NvErrCodes::Success;
-}
-
-u32 nvhost_nvdec_common::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlGetWaitbase params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
-    params.value = 0; // Seems to be hard coded at 0
-    std::memcpy(output.data(), &params, sizeof(IoctlGetWaitbase));
-    return 0;
-}
-
-u32 nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlMapBuffer params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
-    std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
-
-    SpliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));
-
-    auto& gpu = system.GPU();
-
-    for (auto& cmf_buff : cmd_buffer_handles) {
-        auto object{nvmap_dev->GetObject(cmf_buff.map_handle)};
-        if (!object) {
-            LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmf_buff.map_handle);
-            std::memcpy(output.data(), &params, output.size());
-            return NvErrCodes::InvalidInput;
-        }
-        if (object->dma_map_addr == 0) {
-            // NVDEC and VIC memory is in the 32-bit address space
-            // MapAllocate32 will attempt to map a lower 32-bit value in the shared gpu memory space
-            const GPUVAddr low_addr = gpu.MemoryManager().MapAllocate32(object->addr, object->size);
-            object->dma_map_addr = static_cast<u32>(low_addr);
-            // Ensure that the dma_map_addr is indeed in the lower 32-bit address space.
-            ASSERT(object->dma_map_addr == low_addr);
-        }
-        if (!object->dma_map_addr) {
-            LOG_ERROR(Service_NVDRV, "failed to map size={}", object->size);
-        } else {
-            cmf_buff.map_address = object->dma_map_addr;
-            AddBufferMap(object->dma_map_addr, object->size, object->addr,
-                         object->status == nvmap::Object::Status::Allocated);
-        }
-    }
-    std::memcpy(output.data(), &params, sizeof(IoctlMapBuffer));
-    std::memcpy(output.data() + sizeof(IoctlMapBuffer), cmd_buffer_handles.data(),
-                cmd_buffer_handles.size() * sizeof(MapBufferEntry));
-
-    return NvErrCodes::Success;
-}
-
-u32 nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
-    IoctlMapBuffer params{};
-    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
-    std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
-    SpliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));
-
-    auto& gpu = system.GPU();
-
-    for (auto& cmf_buff : cmd_buffer_handles) {
-        const auto object{nvmap_dev->GetObject(cmf_buff.map_handle)};
-        if (!object) {
-            LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmf_buff.map_handle);
-            std::memcpy(output.data(), &params, output.size());
-            return NvErrCodes::InvalidInput;
-        }
-        if (const auto size{RemoveBufferMap(object->dma_map_addr)}; size) {
-            gpu.MemoryManager().Unmap(object->dma_map_addr, *size);
-        } else {
-            // This occurs quite frequently, however does not seem to impact functionality
-            LOG_DEBUG(Service_NVDRV, "invalid offset=0x{:X} dma=0x{:X}", object->addr,
-                      object->dma_map_addr);
-        }
-        object->dma_map_addr = 0;
-    }
-    std::memset(output.data(), 0, output.size());
-    return NvErrCodes::Success;
-}
-
-u32 nvhost_nvdec_common::SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output) {
-    std::memcpy(&submit_timeout, input.data(), input.size());
-    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
-    return NvErrCodes::Success;
-}
-
-std::optional<nvhost_nvdec_common::BufferMap> nvhost_nvdec_common::FindBufferMap(
-    GPUVAddr gpu_addr) const {
-    const auto it = std::find_if(
-        buffer_mappings.begin(), buffer_mappings.upper_bound(gpu_addr), [&](const auto& entry) {
-            return (gpu_addr >= entry.second.StartAddr() && gpu_addr < entry.second.EndAddr());
-        });
-
-    ASSERT(it != buffer_mappings.end());
-    return it->second;
-}
-
-void nvhost_nvdec_common::AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr,
-                                       bool is_allocated) {
-    buffer_mappings.insert_or_assign(gpu_addr, BufferMap{gpu_addr, size, cpu_addr, is_allocated});
-}
-
-std::optional<std::size_t> nvhost_nvdec_common::RemoveBufferMap(GPUVAddr gpu_addr) {
-    const auto iter{buffer_mappings.find(gpu_addr)};
-    if (iter == buffer_mappings.end()) {
-        return std::nullopt;
-    }
-    std::size_t size = 0;
-    if (iter->second.IsAllocated()) {
-        size = iter->second.Size();
-    }
-    buffer_mappings.erase(iter);
-    return size;
-}
-
-} // namespace Service::Nvidia::Devices

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

@@ -1,168 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include <vector>
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/service/nvdrv/devices/nvdevice.h"
-
-namespace Service::Nvidia::Devices {
-class nvmap;
-
-class nvhost_nvdec_common : public nvdevice {
-public:
-    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
-    ~nvhost_nvdec_common() override;
-
-    virtual u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
-                      std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
-                      IoctlVersion version) = 0;
-
-protected:
-    class BufferMap final {
-    public:
-        constexpr BufferMap() = default;
-
-        constexpr BufferMap(GPUVAddr start_addr, std::size_t size)
-            : start_addr{start_addr}, end_addr{start_addr + size} {}
-
-        constexpr BufferMap(GPUVAddr start_addr, std::size_t size, VAddr cpu_addr,
-                            bool is_allocated)
-            : start_addr{start_addr}, end_addr{start_addr + size}, cpu_addr{cpu_addr},
-              is_allocated{is_allocated} {}
-
-        constexpr VAddr StartAddr() const {
-            return start_addr;
-        }
-
-        constexpr VAddr EndAddr() const {
-            return end_addr;
-        }
-
-        constexpr std::size_t Size() const {
-            return end_addr - start_addr;
-        }
-
-        constexpr VAddr CpuAddr() const {
-            return cpu_addr;
-        }
-
-        constexpr bool IsAllocated() const {
-            return is_allocated;
-        }
-
-    private:
-        GPUVAddr start_addr{};
-        GPUVAddr end_addr{};
-        VAddr cpu_addr{};
-        bool is_allocated{};
-    };
-
-    struct IoctlSetNvmapFD {
-        u32_le nvmap_fd;
-    };
-    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
-
-    struct IoctlSubmitCommandBuffer {
-        u32_le id;
-        u32_le offset;
-        u32_le count;
-    };
-    static_assert(sizeof(IoctlSubmitCommandBuffer) == 0xC,
-                  "IoctlSubmitCommandBuffer is incorrect size");
-    struct IoctlSubmit {
-        u32_le cmd_buffer_count;
-        u32_le relocation_count;
-        u32_le syncpoint_count;
-        u32_le fence_count;
-    };
-    static_assert(sizeof(IoctlSubmit) == 0x10, "IoctlSubmit has incorrect size");
-
-    struct CommandBuffer {
-        s32 memory_id;
-        u32 offset;
-        s32 word_count;
-    };
-    static_assert(sizeof(CommandBuffer) == 0xC, "CommandBuffer has incorrect size");
-
-    struct Reloc {
-        s32 cmdbuffer_memory;
-        s32 cmdbuffer_offset;
-        s32 target;
-        s32 target_offset;
-    };
-    static_assert(sizeof(Reloc) == 0x10, "CommandBuffer has incorrect size");
-
-    struct SyncptIncr {
-        u32 id;
-        u32 increments;
-    };
-    static_assert(sizeof(SyncptIncr) == 0x8, "CommandBuffer has incorrect size");
-
-    struct Fence {
-        u32 id;
-        u32 value;
-    };
-    static_assert(sizeof(Fence) == 0x8, "CommandBuffer has incorrect size");
-
-    struct IoctlGetSyncpoint {
-        // Input
-        u32_le param;
-        // Output
-        u32_le value;
-    };
-    static_assert(sizeof(IoctlGetSyncpoint) == 8, "IocGetIdParams has wrong size");
-
-    struct IoctlGetWaitbase {
-        u32_le unknown; // seems to be ignored? Nintendo added this
-        u32_le value;
-    };
-    static_assert(sizeof(IoctlGetWaitbase) == 0x8, "IoctlGetWaitbase is incorrect size");
-
-    struct IoctlMapBuffer {
-        u32_le num_entries;
-        u32_le data_address; // Ignored by the driver.
-        u32_le attach_host_ch_das;
-    };
-    static_assert(sizeof(IoctlMapBuffer) == 0x0C, "IoctlMapBuffer is incorrect size");
-
-    struct IocGetIdParams {
-        // Input
-        u32_le param;
-        // Output
-        u32_le value;
-    };
-    static_assert(sizeof(IocGetIdParams) == 8, "IocGetIdParams has wrong size");
-
-    // Used for mapping and unmapping command buffers
-    struct MapBufferEntry {
-        u32_le map_handle;
-        u32_le map_address;
-    };
-    static_assert(sizeof(IoctlMapBuffer) == 0x0C, "IoctlMapBuffer is incorrect size");
-
-    /// Ioctl command implementations
-    u32 SetNVMAPfd(const std::vector<u8>& input);
-    u32 Submit(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 MapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
-    u32 SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output);
-
-    std::optional<BufferMap> FindBufferMap(GPUVAddr gpu_addr) const;
-    void AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr, bool is_allocated);
-    std::optional<std::size_t> RemoveBufferMap(GPUVAddr gpu_addr);
-
-    u32_le nvmap_fd{};
-    u32_le submit_timeout{};
-    std::shared_ptr<nvmap> nvmap_dev;
-
-    // This is expected to be ordered, therefore we must use a map, not unordered_map
-    std::map<GPUVAddr, BufferMap> buffer_mappings;
-};
-}; // namespace Service::Nvidia::Devices

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

@@ -2,17 +2,15 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cstring>
+
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_vic.h"
-#include "video_core/memory_manager.h"
-#include "video_core/renderer_base.h"
 
 namespace Service::Nvidia::Devices {
-nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
-    : nvhost_nvdec_common(system, std::move(nvmap_dev)) {}
 
+nvhost_vic::nvhost_vic(Core::System& system) : nvdevice(system) {}
 nvhost_vic::~nvhost_vic() = default;
 
 u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
@@ -23,7 +21,7 @@ u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, const std::ve
 
     switch (static_cast<IoctlCommand>(command.raw)) {
     case IoctlCommand::IocSetNVMAPfdCommand:
-        return SetNVMAPfd(input);
+        return SetNVMAPfd(input, output);
     case IoctlCommand::IocSubmit:
         return Submit(input, output);
     case IoctlCommand::IocGetSyncpoint:
@@ -31,19 +29,83 @@ u32 nvhost_vic::ioctl(Ioctl command, const std::vector<u8>& input, const std::ve
     case IoctlCommand::IocGetWaitbase:
         return GetWaitbase(input, output);
     case IoctlCommand::IocMapBuffer:
-    case IoctlCommand::IocMapBuffer2:
-    case IoctlCommand::IocMapBuffer3:
-    case IoctlCommand::IocMapBuffer4:
+        return MapBuffer(input, output);
     case IoctlCommand::IocMapBufferEx:
         return MapBuffer(input, output);
-    case IoctlCommand::IocUnmapBuffer:
-    case IoctlCommand::IocUnmapBuffer2:
-    case IoctlCommand::IocUnmapBuffer3:
     case IoctlCommand::IocUnmapBufferEx:
-        return UnmapBuffer(input, output);
+        return UnmapBufferEx(input, output);
     }
 
-    UNIMPLEMENTED_MSG("Unimplemented ioctl 0x{:X}", command.raw);
+    UNIMPLEMENTED_MSG("Unimplemented ioctl");
+    return 0;
+}
+
+u32 nvhost_vic::SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlSetNvmapFD params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSetNvmapFD));
+    LOG_DEBUG(Service_NVDRV, "called, fd={}", params.nvmap_fd);
+
+    nvmap_fd = params.nvmap_fd;
+    return 0;
+}
+
+u32 nvhost_vic::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlSubmit params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlSubmit));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+
+    // Workaround for Luigi's Mansion 3, as nvhost_vic is not implemented for asynch GPU
+    params.command_buffer = {};
+
+    std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
+    return 0;
+}
+
+u32 nvhost_vic::GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlGetSyncpoint params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
+    LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
+    params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));
+    return 0;
+}
+
+u32 nvhost_vic::GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlGetWaitbase params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlGetWaitbase));
+    LOG_INFO(Service_NVDRV, "called, unknown=0x{:X}", params.unknown);
+    params.value = 0; // Seems to be hard coded at 0
+    std::memcpy(output.data(), &params, sizeof(IoctlGetWaitbase));
+    return 0;
+}
+
+u32 nvhost_vic::MapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlMapBuffer params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called with address={:08X}{:08X}", params.address_2,
+                params.address_1);
+    params.address_1 = 0;
+    params.address_2 = 0;
+    std::memcpy(output.data(), &params, sizeof(IoctlMapBuffer));
+    return 0;
+}
+
+u32 nvhost_vic::MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlMapBufferEx params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBufferEx));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called with address={:08X}{:08X}", params.address_2,
+                params.address_1);
+    params.address_1 = 0;
+    params.address_2 = 0;
+    std::memcpy(output.data(), &params, sizeof(IoctlMapBufferEx));
+    return 0;
+}
+
+u32 nvhost_vic::UnmapBufferEx(const std::vector<u8>& input, std::vector<u8>& output) {
+    IoctlUnmapBufferEx params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlUnmapBufferEx));
+    LOG_WARNING(Service_NVDRV, "(STUBBED) called");
+    std::memcpy(output.data(), &params, sizeof(IoctlUnmapBufferEx));
     return 0;
 }
 

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

@@ -4,15 +4,19 @@
 
 #pragma once
 
-#include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"
+#include <array>
+#include <vector>
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/service/nvdrv/devices/nvdevice.h"
 
 namespace Service::Nvidia::Devices {
-class nvmap;
 
-class nvhost_vic final : public nvhost_nvdec_common {
+class nvhost_vic final : public nvdevice {
 public:
-    explicit nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
-    ~nvhost_vic();
+    explicit nvhost_vic(Core::System& system);
+    ~nvhost_vic() override;
+
     u32 ioctl(Ioctl command, const std::vector<u8>& input, const std::vector<u8>& input2,
               std::vector<u8>& output, std::vector<u8>& output2, IoctlCtrl& ctrl,
               IoctlVersion version) override;
@@ -24,14 +28,74 @@ private:
         IocGetSyncpoint = 0xC0080002,
         IocGetWaitbase = 0xC0080003,
         IocMapBuffer = 0xC01C0009,
-        IocMapBuffer2 = 0xC0340009,
-        IocMapBuffer3 = 0xC0140009,
-        IocMapBuffer4 = 0xC00C0009,
         IocMapBufferEx = 0xC03C0009,
-        IocUnmapBuffer = 0xC03C000A,
-        IocUnmapBuffer2 = 0xC034000A,
-        IocUnmapBuffer3 = 0xC00C000A,
-        IocUnmapBufferEx = 0xC01C000A,
+        IocUnmapBufferEx = 0xC03C000A,
     };
+
+    struct IoctlSetNvmapFD {
+        u32_le nvmap_fd;
+    };
+    static_assert(sizeof(IoctlSetNvmapFD) == 4, "IoctlSetNvmapFD is incorrect size");
+
+    struct IoctlSubmitCommandBuffer {
+        u32 id;
+        u32 offset;
+        u32 count;
+    };
+    static_assert(sizeof(IoctlSubmitCommandBuffer) == 0xC,
+                  "IoctlSubmitCommandBuffer is incorrect size");
+
+    struct IoctlSubmit {
+        u32 command_buffer_count;
+        u32 relocations_count;
+        u32 syncpt_count;
+        u32 wait_count;
+        std::array<IoctlSubmitCommandBuffer, 4> command_buffer;
+    };
+    static_assert(sizeof(IoctlSubmit) == 0x40, "IoctlSubmit is incorrect size");
+
+    struct IoctlGetSyncpoint {
+        u32 unknown; // seems to be ignored? Nintendo added this
+        u32 value;
+    };
+    static_assert(sizeof(IoctlGetSyncpoint) == 0x8, "IoctlGetSyncpoint is incorrect size");
+
+    struct IoctlGetWaitbase {
+        u32 unknown; // seems to be ignored? Nintendo added this
+        u32 value;
+    };
+    static_assert(sizeof(IoctlGetWaitbase) == 0x8, "IoctlGetWaitbase is incorrect size");
+
+    struct IoctlMapBuffer {
+        u32 unknown;
+        u32 address_1;
+        u32 address_2;
+        INSERT_PADDING_BYTES(0x10); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlMapBuffer) == 0x1C, "IoctlMapBuffer is incorrect size");
+
+    struct IoctlMapBufferEx {
+        u32 unknown;
+        u32 address_1;
+        u32 address_2;
+        INSERT_PADDING_BYTES(0x30); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlMapBufferEx) == 0x3C, "IoctlMapBufferEx is incorrect size");
+
+    struct IoctlUnmapBufferEx {
+        INSERT_PADDING_BYTES(0x3C); // TODO(DarkLordZach): RE this structure
+    };
+    static_assert(sizeof(IoctlUnmapBufferEx) == 0x3C, "IoctlUnmapBufferEx is incorrect size");
+
+    u32_le nvmap_fd{};
+
+    u32 SetNVMAPfd(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 Submit(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 MapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 MapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
+    u32 UnmapBufferEx(const std::vector<u8>& input, std::vector<u8>& output);
 };
+
 } // namespace Service::Nvidia::Devices

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

@@ -37,7 +37,6 @@ public:
         VAddr addr;
         Status status;
         u32 refcount;
-        u32 dma_map_addr;
     };
 
     std::shared_ptr<Object> GetObject(u32 handle) const {

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

@@ -51,9 +51,9 @@ Module::Module(Core::System& system) {
     devices["/dev/nvmap"] = nvmap_dev;
     devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(system, nvmap_dev);
     devices["/dev/nvhost-ctrl"] = std::make_shared<Devices::nvhost_ctrl>(system, events_interface);
-    devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>(system, nvmap_dev);
+    devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>(system);
     devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>(system);
-    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>(system, nvmap_dev);
+    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>(system);
 }
 
 Module::~Module() = default;

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -99,20 +99,6 @@ void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
     queue_sequence.push_back(slot);
 }
 
-void BufferQueue::CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& multi_fence) {
-    const auto itr = std::find_if(queue.begin(), queue.end(),
-                                  [slot](const Buffer& buffer) { return buffer.slot == slot; });
-    ASSERT(itr != queue.end());
-    ASSERT(itr->status != Buffer::Status::Free);
-    itr->status = Buffer::Status::Free;
-    itr->multi_fence = multi_fence;
-    itr->swap_interval = 0;
-
-    free_buffers.push_back(slot);
-
-    buffer_wait_event.writable->Signal();
-}
-
 std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
     auto itr = queue.end();
     // Iterate to find a queued buffer matching the requested slot.

src/core/hle/service/nvflinger/buffer_queue.h

@@ -95,7 +95,6 @@ public:
     void QueueBuffer(u32 slot, BufferTransformFlags transform,
                      const Common::Rectangle<int>& crop_rect, u32 swap_interval,
                      Service::Nvidia::MultiFence& multi_fence);
-    void CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& multi_fence);
     std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
     void ReleaseBuffer(u32 slot);
     void Disconnect();

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

@@ -10,7 +10,6 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/service/time/interface.h"
 #include "core/hle/service/time/time.h"
@@ -126,7 +125,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
     Kernel::Thread* thread, Clock::SystemClockContext user_context,
     Clock::SystemClockContext network_context, u8 type, Clock::ClockSnapshot& clock_snapshot) {
 
-    auto& time_manager{system.GetTimeManager()};
+    auto& time_manager{module->GetTimeManager()};
 
     clock_snapshot.is_automatic_correction_enabled =
         time_manager.GetStandardUserSystemClockCore().IsAutomaticCorrectionEnabled();
@@ -183,7 +182,7 @@ void Module::Interface::GetStandardUserSystemClock(Kernel::HLERequestContext& ct
     LOG_DEBUG(Service_Time, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardUserSystemClockCore(),
+    rb.PushIpcInterface<ISystemClock>(module->GetTimeManager().GetStandardUserSystemClockCore(),
                                       system);
 }
 
@@ -191,7 +190,7 @@ void Module::Interface::GetStandardNetworkSystemClock(Kernel::HLERequestContext&
     LOG_DEBUG(Service_Time, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardNetworkSystemClockCore(),
+    rb.PushIpcInterface<ISystemClock>(module->GetTimeManager().GetStandardNetworkSystemClockCore(),
                                       system);
 }
 
@@ -199,28 +198,29 @@ void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISteadyClock>(system.GetTimeManager().GetStandardSteadyClockCore(), system);
+    rb.PushIpcInterface<ISteadyClock>(module->GetTimeManager().GetStandardSteadyClockCore(),
+                                      system);
 }
 
 void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ITimeZoneService>(system.GetTimeManager().GetTimeZoneContentManager());
+    rb.PushIpcInterface<ITimeZoneService>(module->GetTimeManager().GetTimeZoneContentManager());
 }
 
 void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardLocalSystemClockCore(),
+    rb.PushIpcInterface<ISystemClock>(module->GetTimeManager().GetStandardLocalSystemClockCore(),
                                       system);
 }
 
 void Module::Interface::IsStandardNetworkSystemClockAccuracySufficient(
     Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
-    auto& clock_core{system.GetTimeManager().GetStandardNetworkSystemClockCore()};
+    auto& clock_core{module->GetTimeManager().GetStandardNetworkSystemClockCore()};
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(clock_core.IsStandardNetworkSystemClockAccuracySufficient(system));
@@ -229,7 +229,7 @@ void Module::Interface::IsStandardNetworkSystemClockAccuracySufficient(
 void Module::Interface::CalculateMonotonicSystemClockBaseTimePoint(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
 
-    auto& steady_clock_core{system.GetTimeManager().GetStandardSteadyClockCore()};
+    auto& steady_clock_core{module->GetTimeManager().GetStandardSteadyClockCore()};
     if (!steady_clock_core.IsInitialized()) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ERROR_UNINITIALIZED_CLOCK);
@@ -262,8 +262,8 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
 
     Clock::SystemClockContext user_context{};
     if (const ResultCode result{
-            system.GetTimeManager().GetStandardUserSystemClockCore().GetClockContext(system,
-                                                                                     user_context)};
+            module->GetTimeManager().GetStandardUserSystemClockCore().GetClockContext(
+                system, user_context)};
         result.IsError()) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(result);
@@ -271,7 +271,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     }
     Clock::SystemClockContext network_context{};
     if (const ResultCode result{
-            system.GetTimeManager().GetStandardNetworkSystemClockCore().GetClockContext(
+            module->GetTimeManager().GetStandardNetworkSystemClockCore().GetClockContext(
                 system, network_context)};
         result.IsError()) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -372,7 +372,7 @@ void Module::Interface::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& c
     LOG_DEBUG(Service_Time, "called");
     IPC::ResponseBuilder rb{ctx, 2, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(SharedFrom(&system.Kernel().GetTimeSharedMem()));
+    rb.PushCopyObjects(module->GetTimeManager().GetSharedMemory().GetSharedMemoryHolder());
 }
 
 Module::Interface::Interface(std::shared_ptr<Module> module, Core::System& system, const char* name)
@@ -381,7 +381,7 @@ Module::Interface::Interface(std::shared_ptr<Module> module, Core::System& syste
 Module::Interface::~Interface() = default;
 
 void InstallInterfaces(Core::System& system) {
-    auto module{std::make_shared<Module>()};
+    auto module{std::make_shared<Module>(system)};
     std::make_shared<Time>(module, system, "time:a")->InstallAsService(system.ServiceManager());
     std::make_shared<Time>(module, system, "time:s")->InstallAsService(system.ServiceManager());
     std::make_shared<Time>(module, system, "time:u")->InstallAsService(system.ServiceManager());

src/core/hle/service/time/time.h

@@ -16,7 +16,7 @@ namespace Service::Time {
 
 class Module final {
 public:
-    Module() = default;
+    Module(Core::System& system) : time_manager{system} {}
 
     class Interface : public ServiceFramework<Interface> {
     public:
@@ -46,6 +46,13 @@ public:
         std::shared_ptr<Module> module;
         Core::System& system;
     };
+
+    TimeManager& GetTimeManager() {
+        return time_manager;
+    }
+
+private:
+    TimeManager time_manager;
 };
 
 /// Registers all Time services with the specified service manager.

src/core/hle/service/time/time_manager.cpp

@@ -22,277 +22,7 @@ static std::chrono::seconds GetSecondsSinceEpoch() {
            Settings::values.custom_rtc_differential;
 }
 
-static s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch().count() + TimeManager::GetExternalTimeZoneOffset();
-}
-
-struct TimeManager::Impl final {
-    explicit Impl(Core::System& system)
-        : shared_memory{system}, standard_local_system_clock_core{standard_steady_clock_core},
-          standard_network_system_clock_core{standard_steady_clock_core},
-          standard_user_system_clock_core{standard_local_system_clock_core,
-                                          standard_network_system_clock_core, system},
-          ephemeral_network_system_clock_core{tick_based_steady_clock_core},
-          local_system_clock_context_writer{
-              std::make_shared<Clock::LocalSystemClockContextWriter>(shared_memory)},
-          network_system_clock_context_writer{
-              std::make_shared<Clock::NetworkSystemClockContextWriter>(shared_memory)},
-          ephemeral_network_system_clock_context_writer{
-              std::make_shared<Clock::EphemeralNetworkSystemClockContextWriter>()},
-          time_zone_content_manager{system} {
-
-        const auto system_time{Clock::TimeSpanType::FromSeconds(GetExternalRtcValue())};
-        SetupStandardSteadyClock(system, Common::UUID::Generate(), system_time, {}, {});
-        SetupStandardLocalSystemClock(system, {}, system_time.ToSeconds());
-        SetupStandardNetworkSystemClock({}, standard_network_clock_accuracy);
-        SetupStandardUserSystemClock(system, {}, Clock::SteadyClockTimePoint::GetRandom());
-        SetupEphemeralNetworkSystemClock();
-    }
-
-    ~Impl() = default;
-
-    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() {
-        return standard_steady_clock_core;
-    }
-
-    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const {
-        return standard_steady_clock_core;
-    }
-
-    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() {
-        return standard_local_system_clock_core;
-    }
-
-    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const {
-        return standard_local_system_clock_core;
-    }
-
-    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() {
-        return standard_network_system_clock_core;
-    }
-
-    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const {
-        return standard_network_system_clock_core;
-    }
-
-    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() {
-        return standard_user_system_clock_core;
-    }
-
-    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const {
-        return standard_user_system_clock_core;
-    }
-
-    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() {
-        return time_zone_content_manager;
-    }
-
-    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const {
-        return time_zone_content_manager;
-    }
-
-    SharedMemory& GetSharedMemory() {
-        return shared_memory;
-    }
-
-    const SharedMemory& GetSharedMemory() const {
-        return shared_memory;
-    }
-
-    void SetupTimeZoneManager(std::string location_name,
-                              Clock::SteadyClockTimePoint time_zone_updated_time_point,
-                              std::size_t total_location_name_count, u128 time_zone_rule_version,
-                              FileSys::VirtualFile& vfs_file) {
-        if (time_zone_content_manager.GetTimeZoneManager().SetDeviceLocationNameWithTimeZoneRule(
-                location_name, vfs_file) != RESULT_SUCCESS) {
-            UNREACHABLE();
-            return;
-        }
-
-        time_zone_content_manager.GetTimeZoneManager().SetUpdatedTime(time_zone_updated_time_point);
-        time_zone_content_manager.GetTimeZoneManager().SetTotalLocationNameCount(
-            total_location_name_count);
-        time_zone_content_manager.GetTimeZoneManager().SetTimeZoneRuleVersion(
-            time_zone_rule_version);
-        time_zone_content_manager.GetTimeZoneManager().MarkAsInitialized();
-    }
-
-    static s64 GetExternalTimeZoneOffset() {
-        // With "auto" timezone setting, we use the external system's timezone offset
-        if (Settings::GetTimeZoneString() == "auto") {
-            return Common::TimeZone::GetCurrentOffsetSeconds().count();
-        }
-        return 0;
-    }
-
-    void SetupStandardSteadyClock(Core::System& system, Common::UUID clock_source_id,
-                                  Clock::TimeSpanType setup_value,
-                                  Clock::TimeSpanType internal_offset, bool is_rtc_reset_detected) {
-        standard_steady_clock_core.SetClockSourceId(clock_source_id);
-        standard_steady_clock_core.SetSetupValue(setup_value);
-        standard_steady_clock_core.SetInternalOffset(internal_offset);
-        standard_steady_clock_core.MarkAsInitialized();
-
-        const auto current_time_point{standard_steady_clock_core.GetCurrentRawTimePoint(system)};
-        shared_memory.SetupStandardSteadyClock(system, clock_source_id, current_time_point);
-    }
-
-    void SetupStandardLocalSystemClock(Core::System& system,
-                                       Clock::SystemClockContext clock_context, s64 posix_time) {
-        standard_local_system_clock_core.SetUpdateCallbackInstance(
-            local_system_clock_context_writer);
-
-        const auto current_time_point{
-            standard_local_system_clock_core.GetSteadyClockCore().GetCurrentTimePoint(system)};
-        if (current_time_point.clock_source_id == clock_context.steady_time_point.clock_source_id) {
-            standard_local_system_clock_core.SetSystemClockContext(clock_context);
-        } else {
-            if (standard_local_system_clock_core.SetCurrentTime(system, posix_time) !=
-                RESULT_SUCCESS) {
-                UNREACHABLE();
-                return;
-            }
-        }
-
-        standard_local_system_clock_core.MarkAsInitialized();
-    }
-
-    void SetupStandardNetworkSystemClock(Clock::SystemClockContext clock_context,
-                                         Clock::TimeSpanType sufficient_accuracy) {
-        standard_network_system_clock_core.SetUpdateCallbackInstance(
-            network_system_clock_context_writer);
-
-        if (standard_network_system_clock_core.SetSystemClockContext(clock_context) !=
-            RESULT_SUCCESS) {
-            UNREACHABLE();
-            return;
-        }
-
-        standard_network_system_clock_core.SetStandardNetworkClockSufficientAccuracy(
-            sufficient_accuracy);
-        standard_network_system_clock_core.MarkAsInitialized();
-    }
-
-    void SetupStandardUserSystemClock(Core::System& system, bool is_automatic_correction_enabled,
-                                      Clock::SteadyClockTimePoint steady_clock_time_point) {
-        if (standard_user_system_clock_core.SetAutomaticCorrectionEnabled(
-                system, is_automatic_correction_enabled) != RESULT_SUCCESS) {
-            UNREACHABLE();
-            return;
-        }
-
-        standard_user_system_clock_core.SetAutomaticCorrectionUpdatedTime(steady_clock_time_point);
-        standard_user_system_clock_core.MarkAsInitialized();
-        shared_memory.SetAutomaticCorrectionEnabled(is_automatic_correction_enabled);
-    }
-
-    void SetupEphemeralNetworkSystemClock() {
-        ephemeral_network_system_clock_core.SetUpdateCallbackInstance(
-            ephemeral_network_system_clock_context_writer);
-        ephemeral_network_system_clock_core.MarkAsInitialized();
-    }
-
-    void UpdateLocalSystemClockTime(Core::System& system, s64 posix_time) {
-        const auto timespan{Service::Time::Clock::TimeSpanType::FromSeconds(posix_time)};
-        if (GetStandardLocalSystemClockCore()
-                .SetCurrentTime(system, timespan.ToSeconds())
-                .IsError()) {
-            UNREACHABLE();
-            return;
-        }
-    }
-
-    SharedMemory shared_memory;
-
-    Clock::StandardSteadyClockCore standard_steady_clock_core;
-    Clock::TickBasedSteadyClockCore tick_based_steady_clock_core;
-    Clock::StandardLocalSystemClockCore standard_local_system_clock_core;
-    Clock::StandardNetworkSystemClockCore standard_network_system_clock_core;
-    Clock::StandardUserSystemClockCore standard_user_system_clock_core;
-    Clock::EphemeralNetworkSystemClockCore ephemeral_network_system_clock_core;
-
-    std::shared_ptr<Clock::LocalSystemClockContextWriter> local_system_clock_context_writer;
-    std::shared_ptr<Clock::NetworkSystemClockContextWriter> network_system_clock_context_writer;
-    std::shared_ptr<Clock::EphemeralNetworkSystemClockContextWriter>
-        ephemeral_network_system_clock_context_writer;
-
-    TimeZone::TimeZoneContentManager time_zone_content_manager;
-};
-
-TimeManager::TimeManager(Core::System& system) : system{system} {}
-
-TimeManager::~TimeManager() = default;
-
-void TimeManager::Initialize() {
-    impl = std::make_unique<Impl>(system);
-
-    // Time zones can only be initialized after impl is valid
-    impl->time_zone_content_manager.Initialize(*this);
-}
-
-Clock::StandardSteadyClockCore& TimeManager::GetStandardSteadyClockCore() {
-    return impl->standard_steady_clock_core;
-}
-
-const Clock::StandardSteadyClockCore& TimeManager::GetStandardSteadyClockCore() const {
-    return impl->standard_steady_clock_core;
-}
-
-Clock::StandardLocalSystemClockCore& TimeManager::GetStandardLocalSystemClockCore() {
-    return impl->standard_local_system_clock_core;
-}
-
-const Clock::StandardLocalSystemClockCore& TimeManager::GetStandardLocalSystemClockCore() const {
-    return impl->standard_local_system_clock_core;
-}
-
-Clock::StandardNetworkSystemClockCore& TimeManager::GetStandardNetworkSystemClockCore() {
-    return impl->standard_network_system_clock_core;
-}
-
-const Clock::StandardNetworkSystemClockCore& TimeManager::GetStandardNetworkSystemClockCore()
-    const {
-    return impl->standard_network_system_clock_core;
-}
-
-Clock::StandardUserSystemClockCore& TimeManager::GetStandardUserSystemClockCore() {
-    return impl->standard_user_system_clock_core;
-}
-
-const Clock::StandardUserSystemClockCore& TimeManager::GetStandardUserSystemClockCore() const {
-    return impl->standard_user_system_clock_core;
-}
-
-TimeZone::TimeZoneContentManager& TimeManager::GetTimeZoneContentManager() {
-    return impl->time_zone_content_manager;
-}
-
-const TimeZone::TimeZoneContentManager& TimeManager::GetTimeZoneContentManager() const {
-    return impl->time_zone_content_manager;
-}
-
-SharedMemory& TimeManager::GetSharedMemory() {
-    return impl->shared_memory;
-}
-
-const SharedMemory& TimeManager::GetSharedMemory() const {
-    return impl->shared_memory;
-}
-
-void TimeManager::UpdateLocalSystemClockTime(s64 posix_time) {
-    impl->UpdateLocalSystemClockTime(system, posix_time);
-}
-
-void TimeManager::SetupTimeZoneManager(std::string location_name,
-                                       Clock::SteadyClockTimePoint time_zone_updated_time_point,
-                                       std::size_t total_location_name_count,
-                                       u128 time_zone_rule_version,
-                                       FileSys::VirtualFile& vfs_file) {
-    impl->SetupTimeZoneManager(location_name, time_zone_updated_time_point,
-                               total_location_name_count, time_zone_rule_version, vfs_file);
-}
-
-/*static*/ s64 TimeManager::GetExternalTimeZoneOffset() {
+static s64 GetExternalTimeZoneOffset() {
     // With "auto" timezone setting, we use the external system's timezone offset
     if (Settings::GetTimeZoneString() == "auto") {
         return Common::TimeZone::GetCurrentOffsetSeconds().count();
@@ -300,4 +30,117 @@ void TimeManager::SetupTimeZoneManager(std::string location_name,
     return 0;
 }
 
+static s64 GetExternalRtcValue() {
+    return GetSecondsSinceEpoch().count() + GetExternalTimeZoneOffset();
+}
+
+TimeManager::TimeManager(Core::System& system)
+    : shared_memory{system}, standard_local_system_clock_core{standard_steady_clock_core},
+      standard_network_system_clock_core{standard_steady_clock_core},
+      standard_user_system_clock_core{standard_local_system_clock_core,
+                                      standard_network_system_clock_core, system},
+      ephemeral_network_system_clock_core{tick_based_steady_clock_core},
+      local_system_clock_context_writer{
+          std::make_shared<Clock::LocalSystemClockContextWriter>(shared_memory)},
+      network_system_clock_context_writer{
+          std::make_shared<Clock::NetworkSystemClockContextWriter>(shared_memory)},
+      ephemeral_network_system_clock_context_writer{
+          std::make_shared<Clock::EphemeralNetworkSystemClockContextWriter>()},
+      time_zone_content_manager{*this, system} {
+
+    const auto system_time{Clock::TimeSpanType::FromSeconds(GetExternalRtcValue())};
+    SetupStandardSteadyClock(system, Common::UUID::Generate(), system_time, {}, {});
+    SetupStandardLocalSystemClock(system, {}, system_time.ToSeconds());
+    SetupStandardNetworkSystemClock({}, standard_network_clock_accuracy);
+    SetupStandardUserSystemClock(system, {}, Clock::SteadyClockTimePoint::GetRandom());
+    SetupEphemeralNetworkSystemClock();
+}
+
+TimeManager::~TimeManager() = default;
+
+void TimeManager::SetupTimeZoneManager(std::string location_name,
+                                       Clock::SteadyClockTimePoint time_zone_updated_time_point,
+                                       std::size_t total_location_name_count,
+                                       u128 time_zone_rule_version,
+                                       FileSys::VirtualFile& vfs_file) {
+    if (time_zone_content_manager.GetTimeZoneManager().SetDeviceLocationNameWithTimeZoneRule(
+            location_name, vfs_file) != RESULT_SUCCESS) {
+        UNREACHABLE();
+        return;
+    }
+
+    time_zone_content_manager.GetTimeZoneManager().SetUpdatedTime(time_zone_updated_time_point);
+    time_zone_content_manager.GetTimeZoneManager().SetTotalLocationNameCount(
+        total_location_name_count);
+    time_zone_content_manager.GetTimeZoneManager().SetTimeZoneRuleVersion(time_zone_rule_version);
+    time_zone_content_manager.GetTimeZoneManager().MarkAsInitialized();
+}
+
+void TimeManager::SetupStandardSteadyClock(Core::System& system, Common::UUID clock_source_id,
+                                           Clock::TimeSpanType setup_value,
+                                           Clock::TimeSpanType internal_offset,
+                                           bool is_rtc_reset_detected) {
+    standard_steady_clock_core.SetClockSourceId(clock_source_id);
+    standard_steady_clock_core.SetSetupValue(setup_value);
+    standard_steady_clock_core.SetInternalOffset(internal_offset);
+    standard_steady_clock_core.MarkAsInitialized();
+
+    const auto current_time_point{standard_steady_clock_core.GetCurrentRawTimePoint(system)};
+    shared_memory.SetupStandardSteadyClock(system, clock_source_id, current_time_point);
+}
+
+void TimeManager::SetupStandardLocalSystemClock(Core::System& system,
+                                                Clock::SystemClockContext clock_context,
+                                                s64 posix_time) {
+    standard_local_system_clock_core.SetUpdateCallbackInstance(local_system_clock_context_writer);
+
+    const auto current_time_point{
+        standard_local_system_clock_core.GetSteadyClockCore().GetCurrentTimePoint(system)};
+    if (current_time_point.clock_source_id == clock_context.steady_time_point.clock_source_id) {
+        standard_local_system_clock_core.SetSystemClockContext(clock_context);
+    } else {
+        if (standard_local_system_clock_core.SetCurrentTime(system, posix_time) != RESULT_SUCCESS) {
+            UNREACHABLE();
+            return;
+        }
+    }
+
+    standard_local_system_clock_core.MarkAsInitialized();
+}
+
+void TimeManager::SetupStandardNetworkSystemClock(Clock::SystemClockContext clock_context,
+                                                  Clock::TimeSpanType sufficient_accuracy) {
+    standard_network_system_clock_core.SetUpdateCallbackInstance(
+        network_system_clock_context_writer);
+
+    if (standard_network_system_clock_core.SetSystemClockContext(clock_context) != RESULT_SUCCESS) {
+        UNREACHABLE();
+        return;
+    }
+
+    standard_network_system_clock_core.SetStandardNetworkClockSufficientAccuracy(
+        sufficient_accuracy);
+    standard_network_system_clock_core.MarkAsInitialized();
+}
+
+void TimeManager::SetupStandardUserSystemClock(
+    Core::System& system, bool is_automatic_correction_enabled,
+    Clock::SteadyClockTimePoint steady_clock_time_point) {
+    if (standard_user_system_clock_core.SetAutomaticCorrectionEnabled(
+            system, is_automatic_correction_enabled) != RESULT_SUCCESS) {
+        UNREACHABLE();
+        return;
+    }
+
+    standard_user_system_clock_core.SetAutomaticCorrectionUpdatedTime(steady_clock_time_point);
+    standard_user_system_clock_core.MarkAsInitialized();
+    shared_memory.SetAutomaticCorrectionEnabled(is_automatic_correction_enabled);
+}
+
+void TimeManager::SetupEphemeralNetworkSystemClock() {
+    ephemeral_network_system_clock_core.SetUpdateCallbackInstance(
+        ephemeral_network_system_clock_context_writer);
+    ephemeral_network_system_clock_core.MarkAsInitialized();
+}
+
 } // namespace Service::Time

src/core/hle/service/time/time_manager.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "common/time_zone.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/service/time/clock_types.h"
 #include "core/hle/service/time/ephemeral_network_system_clock_core.h"
@@ -33,46 +32,86 @@ public:
     explicit TimeManager(Core::System& system);
     ~TimeManager();
 
-    void Initialize();
+    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() {
+        return standard_steady_clock_core;
+    }
 
-    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore();
+    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const {
+        return standard_steady_clock_core;
+    }
 
-    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const;
+    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() {
+        return standard_local_system_clock_core;
+    }
 
-    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore();
+    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const {
+        return standard_local_system_clock_core;
+    }
 
-    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const;
+    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() {
+        return standard_network_system_clock_core;
+    }
 
-    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore();
+    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const {
+        return standard_network_system_clock_core;
+    }
 
-    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const;
+    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() {
+        return standard_user_system_clock_core;
+    }
 
-    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore();
+    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const {
+        return standard_user_system_clock_core;
+    }
 
-    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const;
+    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() {
+        return time_zone_content_manager;
+    }
 
-    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager();
+    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const {
+        return time_zone_content_manager;
+    }
 
-    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const;
+    SharedMemory& GetSharedMemory() {
+        return shared_memory;
+    }
 
-    void UpdateLocalSystemClockTime(s64 posix_time);
-
-    SharedMemory& GetSharedMemory();
-
-    const SharedMemory& GetSharedMemory() const;
+    const SharedMemory& GetSharedMemory() const {
+        return shared_memory;
+    }
 
     void SetupTimeZoneManager(std::string location_name,
                               Clock::SteadyClockTimePoint time_zone_updated_time_point,
                               std::size_t total_location_name_count, u128 time_zone_rule_version,
                               FileSys::VirtualFile& vfs_file);
 
-    static s64 GetExternalTimeZoneOffset();
-
 private:
-    Core::System& system;
+    void SetupStandardSteadyClock(Core::System& system, Common::UUID clock_source_id,
+                                  Clock::TimeSpanType setup_value,
+                                  Clock::TimeSpanType internal_offset, bool is_rtc_reset_detected);
+    void SetupStandardLocalSystemClock(Core::System& system,
+                                       Clock::SystemClockContext clock_context, s64 posix_time);
+    void SetupStandardNetworkSystemClock(Clock::SystemClockContext clock_context,
+                                         Clock::TimeSpanType sufficient_accuracy);
+    void SetupStandardUserSystemClock(Core::System& system, bool is_automatic_correction_enabled,
+                                      Clock::SteadyClockTimePoint steady_clock_time_point);
+    void SetupEphemeralNetworkSystemClock();
 
-    struct Impl;
-    std::unique_ptr<Impl> impl;
+    SharedMemory shared_memory;
+
+    Clock::StandardSteadyClockCore standard_steady_clock_core;
+    Clock::TickBasedSteadyClockCore tick_based_steady_clock_core;
+    Clock::StandardLocalSystemClockCore standard_local_system_clock_core;
+    Clock::StandardNetworkSystemClockCore standard_network_system_clock_core;
+    Clock::StandardUserSystemClockCore standard_user_system_clock_core;
+    Clock::EphemeralNetworkSystemClockCore ephemeral_network_system_clock_core;
+
+    std::shared_ptr<Clock::LocalSystemClockContextWriter> local_system_clock_context_writer;
+    std::shared_ptr<Clock::NetworkSystemClockContextWriter> network_system_clock_context_writer;
+    std::shared_ptr<Clock::EphemeralNetworkSystemClockContextWriter>
+        ephemeral_network_system_clock_context_writer;
+
+    TimeZone::TimeZoneContentManager time_zone_content_manager;
 };
 
 } // namespace Service::Time

src/core/hle/service/time/time_zone_content_manager.cpp

@@ -68,10 +68,9 @@ static std::vector<std::string> BuildLocationNameCache(Core::System& system) {
     return location_name_cache;
 }
 
-TimeZoneContentManager::TimeZoneContentManager(Core::System& system)
-    : system{system}, location_name_cache{BuildLocationNameCache(system)} {}
+TimeZoneContentManager::TimeZoneContentManager(TimeManager& time_manager, Core::System& system)
+    : system{system}, location_name_cache{BuildLocationNameCache(system)} {
 
-void TimeZoneContentManager::Initialize(TimeManager& time_manager) {
     std::string location_name;
     const auto timezone_setting = Settings::GetTimeZoneString();
     if (timezone_setting == "auto" || timezone_setting == "default") {

src/core/hle/service/time/time_zone_content_manager.h

@@ -21,9 +21,7 @@ namespace Service::Time::TimeZone {
 
 class TimeZoneContentManager final {
 public:
-    explicit TimeZoneContentManager(Core::System& system);
-
-    void Initialize(TimeManager& time_manager);
+    TimeZoneContentManager(TimeManager& time_manager, Core::System& system);
 
     TimeZoneManager& GetTimeZoneManager() {
         return time_zone_manager;

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

@@ -215,9 +215,10 @@ public:
     explicit IGBPConnectRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
+    ~IGBPConnectRequestParcel() override = default;
 
     void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
+        std::u16string token = ReadInterfaceToken();
         data = Read<Data>();
     }
 
@@ -278,9 +279,10 @@ public:
         : Parcel(std::move(buffer)) {
         Deserialize();
     }
+    ~IGBPSetPreallocatedBufferRequestParcel() override = default;
 
     void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
+        std::u16string token = ReadInterfaceToken();
         data = Read<Data>();
         buffer = Read<NVFlinger::IGBPBuffer>();
     }
@@ -304,40 +306,15 @@ protected:
     }
 };
 
-class IGBPCancelBufferRequestParcel : public Parcel {
-public:
-    explicit IGBPCancelBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
-        Deserialize();
-    }
-
-    void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
-        data = Read<Data>();
-    }
-
-    struct Data {
-        u32_le slot;
-        Service::Nvidia::MultiFence multi_fence;
-    };
-
-    Data data;
-};
-
-class IGBPCancelBufferResponseParcel : public Parcel {
-protected:
-    void SerializeData() override {
-        Write<u32>(0); // Success
-    }
-};
-
 class IGBPDequeueBufferRequestParcel : public Parcel {
 public:
     explicit IGBPDequeueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
+    ~IGBPDequeueBufferRequestParcel() override = default;
 
     void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
+        std::u16string token = ReadInterfaceToken();
         data = Read<Data>();
     }
 
@@ -356,6 +333,7 @@ class IGBPDequeueBufferResponseParcel : public Parcel {
 public:
     explicit IGBPDequeueBufferResponseParcel(u32 slot, Service::Nvidia::MultiFence& multi_fence)
         : slot(slot), multi_fence(multi_fence) {}
+    ~IGBPDequeueBufferResponseParcel() override = default;
 
 protected:
     void SerializeData() override {
@@ -374,9 +352,10 @@ public:
     explicit IGBPRequestBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
+    ~IGBPRequestBufferRequestParcel() override = default;
 
     void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
+        std::u16string token = ReadInterfaceToken();
         slot = Read<u32_le>();
     }
 
@@ -405,9 +384,10 @@ public:
     explicit IGBPQueueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
+    ~IGBPQueueBufferRequestParcel() override = default;
 
     void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
+        std::u16string token = ReadInterfaceToken();
         data = Read<Data>();
     }
 
@@ -467,9 +447,10 @@ public:
     explicit IGBPQueryRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
+    ~IGBPQueryRequestParcel() override = default;
 
     void DeserializeData() override {
-        [[maybe_unused]] const std::u16string token = ReadInterfaceToken();
+        std::u16string token = ReadInterfaceToken();
         type = Read<u32_le>();
     }
 
@@ -615,12 +596,7 @@ private:
             break;
         }
         case TransactionId::CancelBuffer: {
-            IGBPCancelBufferRequestParcel request{ctx.ReadBuffer()};
-
-            buffer_queue.CancelBuffer(request.data.slot, request.data.multi_fence);
-
-            IGBPCancelBufferResponseParcel response{};
-            ctx.WriteBuffer(response.Serialize());
+            LOG_CRITICAL(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
             break;
         }
         case TransactionId::Disconnect: {

src/core/network/network.cpp

@@ -148,7 +148,7 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
 }
 
 int WSAPoll(WSAPOLLFD* fds, ULONG nfds, int timeout) {
-    return poll(fds, static_cast<nfds_t>(nfds), timeout);
+    return poll(fds, nfds, timeout);
 }
 
 int closesocket(SOCKET fd) {

src/core/settings.cpp

@@ -63,7 +63,6 @@ void LogSettings() {
     log_setting("Renderer_GPUAccuracyLevel", values.gpu_accuracy.GetValue());
     log_setting("Renderer_UseAsynchronousGpuEmulation",
                 values.use_asynchronous_gpu_emulation.GetValue());
-    log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
     log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
     log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
@@ -120,7 +119,6 @@ void RestoreGlobalState() {
     values.use_disk_shader_cache.SetGlobal(true);
     values.gpu_accuracy.SetGlobal(true);
     values.use_asynchronous_gpu_emulation.SetGlobal(true);
-    values.use_nvdec_emulation.SetGlobal(true);
     values.use_vsync.SetGlobal(true);
     values.use_assembly_shaders.SetGlobal(true);
     values.use_asynchronous_shaders.SetGlobal(true);

src/core/settings.h

@@ -111,7 +111,6 @@ struct Values {
     Setting<bool> use_disk_shader_cache;
     Setting<GPUAccuracy> gpu_accuracy;
     Setting<bool> use_asynchronous_gpu_emulation;
-    Setting<bool> use_nvdec_emulation;
     Setting<bool> use_vsync;
     Setting<bool> use_assembly_shaders;
     Setting<bool> use_asynchronous_shaders;

src/core/telemetry_session.cpp

@@ -206,8 +206,6 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
              TranslateGPUAccuracyLevel(Settings::values.gpu_accuracy.GetValue()));
     AddField(field_type, "Renderer_UseAsynchronousGpuEmulation",
              Settings::values.use_asynchronous_gpu_emulation.GetValue());
-    AddField(field_type, "Renderer_UseNvdecEmulation",
-             Settings::values.use_nvdec_emulation.GetValue());
     AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync.GetValue());
     AddField(field_type, "Renderer_UseAssemblyShaders",
              Settings::values.use_assembly_shaders.GetValue());

src/input_common/CMakeLists.txt

@@ -29,35 +29,6 @@ add_library(input_common STATIC
     udp/udp.h
 )
 
-if (MSVC)
-    target_compile_options(input_common PRIVATE
-        # 'expression' : signed/unsigned mismatch
-        /we4018
-        # 'argument' : conversion from 'type1' to 'type2', possible loss of data (floating-point)
-        /we4244
-        # 'conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch
-        /we4245
-        # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /we4254
-        # 'var' : conversion from 'size_t' to 'type', possible loss of data
-        /we4267
-        # 'context' : truncation from 'type1' to 'type2'
-        /we4305
-    )
-else()
-    target_compile_options(input_common PRIVATE
-        -Werror=conversion
-        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Werror=shadow
-        -Werror=sign-compare
-        -Werror=unused-but-set-parameter
-        -Werror=unused-but-set-variable
-        -Werror=unused-variable
-    )
-endif()
-
 if(SDL2_FOUND)
     target_sources(input_common PRIVATE
         sdl/sdl_impl.cpp

src/input_common/analog_from_button.cpp

@@ -20,22 +20,18 @@ public:
         constexpr float SQRT_HALF = 0.707106781f;
         int x = 0, y = 0;
 
-        if (right->GetStatus()) {
+        if (right->GetStatus())
             ++x;
-        }
-        if (left->GetStatus()) {
+        if (left->GetStatus())
             --x;
-        }
-        if (up->GetStatus()) {
+        if (up->GetStatus())
             ++y;
-        }
-        if (down->GetStatus()) {
+        if (down->GetStatus())
             --y;
-        }
 
-        const float coef = modifier->GetStatus() ? modifier_scale : 1.0f;
-        return std::make_tuple(static_cast<float>(x) * coef * (y == 0 ? 1.0f : SQRT_HALF),
-                               static_cast<float>(y) * coef * (x == 0 ? 1.0f : SQRT_HALF));
+        float coef = modifier->GetStatus() ? modifier_scale : 1.0f;
+        return std::make_tuple(x * coef * (y == 0 ? 1.0f : SQRT_HALF),
+                               y * coef * (x == 0 ? 1.0f : SQRT_HALF));
     }
 
     bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {

src/input_common/gcadapter/gc_adapter.cpp

@@ -21,7 +21,7 @@
 
 namespace GCAdapter {
 
-// Used to loop through and assign button in poller
+/// Used to loop through and assign button in poller
 constexpr std::array<PadButton, 12> PadButtonArray{
     PadButton::PAD_BUTTON_LEFT, PadButton::PAD_BUTTON_RIGHT, PadButton::PAD_BUTTON_DOWN,
     PadButton::PAD_BUTTON_UP,   PadButton::PAD_TRIGGER_Z,    PadButton::PAD_TRIGGER_R,
@@ -29,18 +29,6 @@ constexpr std::array<PadButton, 12> PadButtonArray{
     PadButton::PAD_BUTTON_X,    PadButton::PAD_BUTTON_Y,     PadButton::PAD_BUTTON_START,
 };
 
-static void PadToState(const GCPadStatus& pad, GCState& out_state) {
-    for (const auto& button : PadButtonArray) {
-        const auto button_key = static_cast<u16>(button);
-        const auto button_value = (pad.button & button_key) != 0;
-        out_state.buttons.insert_or_assign(static_cast<s32>(button_key), button_value);
-    }
-
-    for (std::size_t i = 0; i < pad.axis_values.size(); ++i) {
-        out_state.axes.insert_or_assign(static_cast<u32>(i), pad.axis_values[i]);
-    }
-}
-
 Adapter::Adapter() {
     if (usb_adapter_handle != nullptr) {
         return;
@@ -90,17 +78,17 @@ GCPadStatus Adapter::GetPadStatus(std::size_t port, const std::array<u8, 37>& ad
 
         for (std::size_t i = 0; i < b1_buttons.size(); ++i) {
             if ((b1 & (1U << i)) != 0) {
-                pad.button = static_cast<u16>(pad.button | static_cast<u16>(b1_buttons[i]));
+                pad.button |= static_cast<u16>(b1_buttons[i]);
             }
         }
 
         for (std::size_t j = 0; j < b2_buttons.size(); ++j) {
             if ((b2 & (1U << j)) != 0) {
-                pad.button = static_cast<u16>(pad.button | static_cast<u16>(b2_buttons[j]));
+                pad.button |= static_cast<u16>(b2_buttons[j]);
             }
         }
         for (PadAxes axis : axes) {
-            const auto index = static_cast<std::size_t>(axis);
+            const std::size_t index = static_cast<std::size_t>(axis);
             pad.axis_values[index] = adapter_payload[offset + 3 + index];
         }
 
@@ -112,6 +100,17 @@ GCPadStatus Adapter::GetPadStatus(std::size_t port, const std::array<u8, 37>& ad
     return pad;
 }
 
+void Adapter::PadToState(const GCPadStatus& pad, GCState& state) {
+    for (const auto& button : PadButtonArray) {
+        const u16 button_value = static_cast<u16>(button);
+        state.buttons.insert_or_assign(button_value, pad.button & button_value);
+    }
+
+    for (size_t i = 0; i < pad.axis_values.size(); ++i) {
+        state.axes.insert_or_assign(static_cast<u8>(i), pad.axis_values[i]);
+    }
+}
+
 void Adapter::Read() {
     LOG_DEBUG(Input, "GC Adapter Read() thread started");
 
@@ -251,7 +250,7 @@ void Adapter::GetGCEndpoint(libusb_device* device) {
             const libusb_interface_descriptor* interface = &interfaceContainer->altsetting[i];
             for (u8 e = 0; e < interface->bNumEndpoints; e++) {
                 const libusb_endpoint_descriptor* endpoint = &interface->endpoint[e];
-                if ((endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) != 0) {
+                if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) {
                     input_endpoint = endpoint->bEndpointAddress;
                 } else {
                     output_endpoint = endpoint->bEndpointAddress;
@@ -420,7 +419,7 @@ const std::array<GCState, 4>& Adapter::GetPadState() const {
     return state;
 }
 
-int Adapter::GetOriginValue(u32 port, u32 axis) const {
+int Adapter::GetOriginValue(int port, int axis) const {
     return origin_status[port].axis_values[axis];
 }
 

src/input_common/gcadapter/gc_adapter.h

@@ -60,7 +60,7 @@ struct GCPadStatus {
 
 struct GCState {
     std::unordered_map<int, bool> buttons;
-    std::unordered_map<u32, u16> axes;
+    std::unordered_map<int, u16> axes;
 };
 
 enum class ControllerTypes { None, Wired, Wireless };
@@ -89,11 +89,13 @@ public:
     std::array<GCState, 4>& GetPadState();
     const std::array<GCState, 4>& GetPadState() const;
 
-    int GetOriginValue(u32 port, u32 axis) const;
+    int GetOriginValue(int port, int axis) const;
 
 private:
     GCPadStatus GetPadStatus(std::size_t port, const std::array<u8, 37>& adapter_payload);
 
+    void PadToState(const GCPadStatus& pad, GCState& state);
+
     void Read();
 
     /// Resets status of device connected to port

src/input_common/gcadapter/gc_poller.cpp

@@ -15,7 +15,7 @@ namespace InputCommon {
 
 class GCButton final : public Input::ButtonDevice {
 public:
-    explicit GCButton(u32 port_, int button_, const GCAdapter::Adapter* adapter)
+    explicit GCButton(int port_, int button_, const GCAdapter::Adapter* adapter)
         : port(port_), button(button_), gcadapter(adapter) {}
 
     ~GCButton() override;
@@ -28,14 +28,14 @@ public:
     }
 
 private:
-    const u32 port;
+    const int port;
     const int button;
     const GCAdapter::Adapter* gcadapter;
 };
 
 class GCAxisButton final : public Input::ButtonDevice {
 public:
-    explicit GCAxisButton(u32 port_, u32 axis_, float threshold_, bool trigger_if_greater_,
+    explicit GCAxisButton(int port_, int axis_, float threshold_, bool trigger_if_greater_,
                           const GCAdapter::Adapter* adapter)
         : port(port_), axis(axis_), threshold(threshold_), trigger_if_greater(trigger_if_greater_),
           gcadapter(adapter),
@@ -56,8 +56,8 @@ public:
     }
 
 private:
-    const u32 port;
-    const u32 axis;
+    const int port;
+    const int axis;
     float threshold;
     bool trigger_if_greater;
     const GCAdapter::Adapter* gcadapter;
@@ -70,8 +70,8 @@ GCButtonFactory::GCButtonFactory(std::shared_ptr<GCAdapter::Adapter> adapter_)
 GCButton::~GCButton() = default;
 
 std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::ParamPackage& params) {
-    const auto button_id = params.Get("button", 0);
-    const auto port = static_cast<u32>(params.Get("port", 0));
+    const int button_id = params.Get("button", 0);
+    const int port = params.Get("port", 0);
 
     constexpr int PAD_STICK_ID = static_cast<u16>(GCAdapter::PadButton::PAD_STICK);
 
@@ -149,27 +149,25 @@ void GCButtonFactory::EndConfiguration() {
 
 class GCAnalog final : public Input::AnalogDevice {
 public:
-    explicit GCAnalog(u32 port_, u32 axis_x_, u32 axis_y_, float deadzone_,
-                      const GCAdapter::Adapter* adapter, float range_)
+    GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_,
+             const GCAdapter::Adapter* adapter, float range_)
         : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter),
           origin_value_x(static_cast<float>(adapter->GetOriginValue(port_, axis_x_))),
           origin_value_y(static_cast<float>(adapter->GetOriginValue(port_, axis_y_))),
           range(range_) {}
 
-    float GetAxis(u32 axis) const {
+    float GetAxis(int axis) const {
         if (gcadapter->DeviceConnected(port)) {
             std::lock_guard lock{mutex};
             const auto origin_value = axis % 2 == 0 ? origin_value_x : origin_value_y;
-            const auto axis_value =
-                static_cast<float>(gcadapter->GetPadState()[port].axes.at(axis));
-            return (axis_value - origin_value) / (100.0f * range);
+            return (gcadapter->GetPadState()[port].axes.at(axis) - origin_value) / (100.0f * range);
         }
         return 0.0f;
     }
 
-    std::pair<float, float> GetAnalog(u32 analog_axis_x, u32 analog_axis_y) const {
-        float x = GetAxis(analog_axis_x);
-        float y = GetAxis(analog_axis_y);
+    std::pair<float, float> GetAnalog(int axis_x, int axis_y) const {
+        float x = GetAxis(axis_x);
+        float y = GetAxis(axis_y);
 
         // Make sure the coordinates are in the unit circle,
         // otherwise normalize it.
@@ -210,9 +208,9 @@ public:
     }
 
 private:
-    const u32 port;
-    const u32 axis_x;
-    const u32 axis_y;
+    const int port;
+    const int axis_x;
+    const int axis_y;
     const float deadzone;
     const GCAdapter::Adapter* gcadapter;
     const float origin_value_x;
@@ -233,11 +231,11 @@ GCAnalogFactory::GCAnalogFactory(std::shared_ptr<GCAdapter::Adapter> adapter_)
  *     - "axis_y": the index of the axis to be bind as y-axis
  */
 std::unique_ptr<Input::AnalogDevice> GCAnalogFactory::Create(const Common::ParamPackage& params) {
-    const auto port = static_cast<u32>(params.Get("port", 0));
-    const auto axis_x = static_cast<u32>(params.Get("axis_x", 0));
-    const auto axis_y = static_cast<u32>(params.Get("axis_y", 1));
-    const auto deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f);
-    const auto range = std::clamp(params.Get("range", 1.0f), 0.50f, 1.50f);
+    const int port = params.Get("port", 0);
+    const int axis_x = params.Get("axis_x", 0);
+    const int axis_y = params.Get("axis_y", 1);
+    const float deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f);
+    const float range = std::clamp(params.Get("range", 1.0f), 0.50f, 1.50f);
 
     return std::make_unique<GCAnalog>(port, axis_x, axis_y, deadzone, adapter.get(), range);
 }
@@ -258,7 +256,7 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
     for (std::size_t port = 0; port < queue.size(); ++port) {
         while (queue[port].Pop(pad)) {
             if (pad.axis == GCAdapter::PadAxes::Undefined ||
-                std::abs((static_cast<float>(pad.axis_value) - 128.0f) / 128.0f) < 0.1f) {
+                std::abs((pad.axis_value - 128.0f) / 128.0f) < 0.1) {
                 continue;
             }
             // An analog device needs two axes, so we need to store the axis for later and wait for

src/input_common/keyboard.cpp

@@ -49,9 +49,8 @@ public:
     void ChangeKeyStatus(int key_code, bool pressed) {
         std::lock_guard guard{mutex};
         for (const KeyButtonPair& pair : list) {
-            if (pair.key_code == key_code) {
+            if (pair.key_code == key_code)
                 pair.key_button->status.store(pressed);
-            }
         }
     }
 
@@ -74,7 +73,7 @@ KeyButton::~KeyButton() {
 }
 
 std::unique_ptr<Input::ButtonDevice> Keyboard::Create(const Common::ParamPackage& params) {
-    const int key_code = params.Get("code", 0);
+    int key_code = params.Get("code", 0);
     std::unique_ptr<KeyButton> button = std::make_unique<KeyButton>(key_button_list);
     key_button_list->AddKeyButton(key_code, button.get());
     return button;

src/input_common/main.cpp

@@ -196,10 +196,6 @@ ButtonMapping InputSubsystem::GetButtonMappingForDevice(const Common::ParamPacka
     return impl->GetButtonMappingForDevice(device);
 }
 
-MotionMapping InputSubsystem::GetMotionMappingForDevice(const Common::ParamPackage& device) const {
-    return impl->GetMotionMappingForDevice(device);
-}
-
 GCAnalogFactory* InputSubsystem::GetGCAnalogs() {
     return impl->gcanalog.get();
 }

src/input_common/motion_emu.cpp

@@ -18,11 +18,11 @@ namespace InputCommon {
 // Implementation class of the motion emulation device
 class MotionEmuDevice {
 public:
-    explicit MotionEmuDevice(int update_millisecond_, float sensitivity_)
-        : update_millisecond(update_millisecond_),
+    MotionEmuDevice(int update_millisecond, float sensitivity)
+        : update_millisecond(update_millisecond),
           update_duration(std::chrono::duration_cast<std::chrono::steady_clock::duration>(
               std::chrono::milliseconds(update_millisecond))),
-          sensitivity(sensitivity_), motion_emu_thread(&MotionEmuDevice::MotionEmuThread, this) {}
+          sensitivity(sensitivity), motion_emu_thread(&MotionEmuDevice::MotionEmuThread, this) {}
 
     ~MotionEmuDevice() {
         if (motion_emu_thread.joinable()) {
@@ -37,18 +37,16 @@ public:
     }
 
     void Tilt(int x, int y) {
-        if (!is_tilting) {
-            return;
-        }
-
-        std::lock_guard guard{tilt_mutex};
-        const auto mouse_move = Common::MakeVec(x, y) - mouse_origin;
-        if (mouse_move.x == 0 && mouse_move.y == 0) {
-            tilt_angle = 0;
-        } else {
-            tilt_direction = mouse_move.Cast<float>();
-            tilt_angle =
-                std::clamp(tilt_direction.Normalize() * sensitivity, 0.0f, Common::PI * 0.5f);
+        auto mouse_move = Common::MakeVec(x, y) - mouse_origin;
+        if (is_tilting) {
+            std::lock_guard guard{tilt_mutex};
+            if (mouse_move.x == 0 && mouse_move.y == 0) {
+                tilt_angle = 0;
+            } else {
+                tilt_direction = mouse_move.Cast<float>();
+                tilt_angle =
+                    std::clamp(tilt_direction.Normalize() * sensitivity, 0.0f, Common::PI * 0.5f);
+            }
         }
     }
 
@@ -88,10 +86,11 @@ private:
     void MotionEmuThread() {
         auto update_time = std::chrono::steady_clock::now();
         Common::Quaternion<float> q = Common::MakeQuaternion(Common::Vec3<float>(), 0);
+        Common::Quaternion<float> old_q;
 
         while (!shutdown_event.WaitUntil(update_time)) {
             update_time += update_duration;
-            const Common::Quaternion<float> old_q = q;
+            old_q = q;
 
             {
                 std::lock_guard guard{tilt_mutex};
@@ -101,14 +100,14 @@ private:
                     Common::MakeVec(-tilt_direction.y, 0.0f, tilt_direction.x), tilt_angle);
             }
 
-            const auto inv_q = q.Inverse();
+            auto inv_q = q.Inverse();
 
             // Set the gravity vector in world space
             auto gravity = Common::MakeVec(0.0f, -1.0f, 0.0f);
 
             // Find the angular rate vector in world space
             auto angular_rate = ((q - old_q) * inv_q).xyz * 2;
-            angular_rate *= static_cast<float>(1000 / update_millisecond) / Common::PI * 180.0f;
+            angular_rate *= 1000 / update_millisecond / Common::PI * 180;
 
             // Transform the two vectors from world space to 3DS space
             gravity = QuaternionRotate(inv_q, gravity);
@@ -137,7 +136,7 @@ private:
 // can forward all the inputs to the implementation only when it is valid.
 class MotionEmuDeviceWrapper : public Input::MotionDevice {
 public:
-    explicit MotionEmuDeviceWrapper(int update_millisecond, float sensitivity) {
+    MotionEmuDeviceWrapper(int update_millisecond, float sensitivity) {
         device = std::make_shared<MotionEmuDevice>(update_millisecond, sensitivity);
     }
 
@@ -149,8 +148,8 @@ public:
 };
 
 std::unique_ptr<Input::MotionDevice> MotionEmu::Create(const Common::ParamPackage& params) {
-    const int update_period = params.Get("update_period", 100);
-    const float sensitivity = params.Get("sensitivity", 0.01f);
+    int update_period = params.Get("update_period", 100);
+    float sensitivity = params.Get("sensitivity", 0.01f);
     auto device_wrapper = std::make_unique<MotionEmuDeviceWrapper>(update_period, sensitivity);
     // Previously created device is disconnected here. Having two motion devices for 3DS is not
     // expected.

src/input_common/motion_from_button.cpp

@@ -11,7 +11,7 @@ class MotionKey final : public Input::MotionDevice {
 public:
     using Button = std::unique_ptr<Input::ButtonDevice>;
 
-    explicit MotionKey(Button key_) : key(std::move(key_)) {}
+    MotionKey(Button key_) : key(std::move(key_)) {}
 
     Input::MotionStatus GetStatus() const override {
 

src/input_common/motion_input.cpp

@@ -8,7 +8,8 @@
 
 namespace InputCommon {
 
-MotionInput::MotionInput(f32 new_kp, f32 new_ki, f32 new_kd) : kp(new_kp), ki(new_ki), kd(new_kd) {}
+MotionInput::MotionInput(f32 new_kp, f32 new_ki, f32 new_kd)
+    : kp(new_kp), ki(new_ki), kd(new_kd), quat{{0, 0, -1}, 0} {}
 
 void MotionInput::SetAcceleration(const Common::Vec3f& acceleration) {
     accel = acceleration;
@@ -58,7 +59,7 @@ bool MotionInput::IsCalibrated(f32 sensitivity) const {
 }
 
 void MotionInput::UpdateRotation(u64 elapsed_time) {
-    const auto sample_period = static_cast<f32>(elapsed_time) / 1000000.0f;
+    const f32 sample_period = elapsed_time / 1000000.0f;
     if (sample_period > 0.1f) {
         return;
     }
@@ -74,7 +75,7 @@ void MotionInput::UpdateOrientation(u64 elapsed_time) {
     f32 q2 = quat.xyz[0];
     f32 q3 = quat.xyz[1];
     f32 q4 = quat.xyz[2];
-    const auto sample_period = static_cast<f32>(elapsed_time) / 1000000.0f;
+    const f32 sample_period = elapsed_time / 1000000.0f;
 
     // Ignore invalid elapsed time
     if (sample_period > 0.1f) {
@@ -202,21 +203,21 @@ Input::MotionStatus MotionInput::GetRandomMotion(int accel_magnitude, int gyro_m
     std::random_device device;
     std::mt19937 gen(device());
     std::uniform_int_distribution<s16> distribution(-1000, 1000);
-    const Common::Vec3f gyroscope{
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
+    const Common::Vec3f gyroscope = {
+        distribution(gen) * 0.001f,
+        distribution(gen) * 0.001f,
+        distribution(gen) * 0.001f,
     };
-    const Common::Vec3f accelerometer{
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
-        static_cast<f32>(distribution(gen)) * 0.001f,
+    const Common::Vec3f accelerometer = {
+        distribution(gen) * 0.001f,
+        distribution(gen) * 0.001f,
+        distribution(gen) * 0.001f,
     };
-    constexpr Common::Vec3f rotation;
-    constexpr std::array orientation{
-        Common::Vec3f{1.0f, 0.0f, 0.0f},
-        Common::Vec3f{0.0f, 1.0f, 0.0f},
-        Common::Vec3f{0.0f, 0.0f, 1.0f},
+    const Common::Vec3f rotation = {};
+    const std::array<Common::Vec3f, 3> orientation = {
+        Common::Vec3f{1.0f, 0, 0},
+        Common::Vec3f{0, 1.0f, 0},
+        Common::Vec3f{0, 0, 1.0f},
     };
     return {accelerometer * accel_magnitude, gyroscope * gyro_magnitude, rotation, orientation};
 }
@@ -246,6 +247,9 @@ void MotionInput::SetOrientationFromAccelerometer() {
     const f32 sample_period = 0.015f;
 
     const auto normal_accel = accel.Normalized();
+    const f32 ax = -normal_accel.x;
+    const f32 ay = normal_accel.y;
+    const f32 az = -normal_accel.z;
 
     while (!IsCalibrated(0.01f) && ++iterations < 100) {
         // Short name local variable for readability
@@ -254,7 +258,7 @@ void MotionInput::SetOrientationFromAccelerometer() {
         f32 q3 = quat.xyz[1];
         f32 q4 = quat.xyz[2];
 
-        Common::Vec3f rad_gyro;
+        Common::Vec3f rad_gyro = {};
         const f32 ax = -normal_accel.x;
         const f32 ay = normal_accel.y;
         const f32 az = -normal_accel.z;

src/input_common/motion_input.h

@@ -22,7 +22,7 @@ public:
     MotionInput& operator=(MotionInput&&) = default;
 
     void SetAcceleration(const Common::Vec3f& acceleration);
-    void SetGyroscope(const Common::Vec3f& gyroscope);
+    void SetGyroscope(const Common::Vec3f& acceleration);
     void SetQuaternion(const Common::Quaternion<f32>& quaternion);
     void SetGyroDrift(const Common::Vec3f& drift);
     void SetGyroThreshold(f32 threshold);
@@ -49,16 +49,16 @@ private:
     void SetOrientationFromAccelerometer();
 
     // PID constants
-    f32 kp;
-    f32 ki;
-    f32 kd;
+    const f32 kp;
+    const f32 ki;
+    const f32 kd;
 
     // PID errors
     Common::Vec3f real_error;
     Common::Vec3f integral_error;
     Common::Vec3f derivative_error;
 
-    Common::Quaternion<f32> quat{{0.0f, 0.0f, -1.0f}, 0.0f};
+    Common::Quaternion<f32> quat;
     Common::Vec3f rotations;
     Common::Vec3f accel;
     Common::Vec3f gyro;

src/input_common/sdl/sdl_impl.cpp

@@ -56,9 +56,9 @@ static int SDLEventWatcher(void* user_data, SDL_Event* event) {
 class SDLJoystick {
 public:
     SDLJoystick(std::string guid_, int port_, SDL_Joystick* joystick,
-                SDL_GameController* game_controller)
+                SDL_GameController* gamecontroller)
         : guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, &SDL_JoystickClose},
-          sdl_controller{game_controller, &SDL_GameControllerClose} {}
+          sdl_controller{gamecontroller, &SDL_GameControllerClose} {}
 
     void SetButton(int button, bool value) {
         std::lock_guard lock{mutex};
@@ -77,10 +77,10 @@ public:
 
     float GetAxis(int axis, float range) const {
         std::lock_guard lock{mutex};
-        return static_cast<float>(state.axes.at(axis)) / (32767.0f * range);
+        return state.axes.at(axis) / (32767.0f * range);
     }
 
-    bool RumblePlay(f32 amp_low, f32 amp_high, u32 time) {
+    bool RumblePlay(f32 amp_low, f32 amp_high, int time) {
         const u16 raw_amp_low = static_cast<u16>(amp_low * 0xFFFF);
         const u16 raw_amp_high = static_cast<u16>(amp_high * 0xFFFF);
         // Lower drastically the number of state changes
@@ -124,7 +124,7 @@ public:
         return std::make_tuple(x, y);
     }
 
-    const MotionInput& GetMotion() const {
+    const InputCommon::MotionInput& GetMotion() const {
         return motion;
     }
 
@@ -155,13 +155,13 @@ public:
         return sdl_joystick.get();
     }
 
-    SDL_GameController* GetSDLGameController() const {
-        return sdl_controller.get();
+    void SetSDLJoystick(SDL_Joystick* joystick, SDL_GameController* controller) {
+        sdl_controller.reset(controller);
+        sdl_joystick.reset(joystick);
     }
 
-    void SetSDLJoystick(SDL_Joystick* joystick, SDL_GameController* controller) {
-        sdl_joystick.reset(joystick);
-        sdl_controller.reset(controller);
+    SDL_GameController* GetSDLGameController() const {
+        return sdl_controller.get();
     }
 
 private:
@@ -172,72 +172,83 @@ private:
     } state;
     std::string guid;
     int port;
-    u16 last_state_rumble_high = 0;
-    u16 last_state_rumble_low = 0;
+    u16 last_state_rumble_high;
+    u16 last_state_rumble_low;
     std::chrono::time_point<std::chrono::system_clock> last_vibration;
     std::unique_ptr<SDL_Joystick, decltype(&SDL_JoystickClose)> sdl_joystick;
     std::unique_ptr<SDL_GameController, decltype(&SDL_GameControllerClose)> sdl_controller;
     mutable std::mutex mutex;
 
-    // Motion is initialized without PID values as motion input is not aviable for SDL2
-    MotionInput motion{0.0f, 0.0f, 0.0f};
+    // motion is initalized without PID values as motion input is not aviable for SDL2
+    InputCommon::MotionInput motion{0.0f, 0.0f, 0.0f};
 };
 
 std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& guid, int port) {
     std::lock_guard lock{joystick_map_mutex};
     const auto it = joystick_map.find(guid);
-
     if (it != joystick_map.end()) {
         while (it->second.size() <= static_cast<std::size_t>(port)) {
             auto joystick = std::make_shared<SDLJoystick>(guid, static_cast<int>(it->second.size()),
                                                           nullptr, nullptr);
             it->second.emplace_back(std::move(joystick));
         }
-
-        return it->second[static_cast<std::size_t>(port)];
+        return it->second[port];
     }
-
     auto joystick = std::make_shared<SDLJoystick>(guid, 0, nullptr, nullptr);
-
     return joystick_map[guid].emplace_back(std::move(joystick));
 }
 
 std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
     auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
+    auto sdl_controller = SDL_GameControllerFromInstanceID(sdl_id);
     const std::string guid = GetGUID(sdl_joystick);
 
     std::lock_guard lock{joystick_map_mutex};
     const auto map_it = joystick_map.find(guid);
+    if (map_it != joystick_map.end()) {
+        const auto vec_it =
+            std::find_if(map_it->second.begin(), map_it->second.end(),
+                         [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
+                             return sdl_joystick == joystick->GetSDLJoystick();
+                         });
+        if (vec_it != map_it->second.end()) {
+            // This is the common case: There is already an existing SDL_Joystick maped to a
+            // SDLJoystick. return the SDLJoystick
+            return *vec_it;
+        }
 
-    if (map_it == joystick_map.end()) {
-        return nullptr;
+        // Search for a SDLJoystick without a mapped SDL_Joystick...
+        const auto nullptr_it = std::find_if(map_it->second.begin(), map_it->second.end(),
+                                             [](const std::shared_ptr<SDLJoystick>& joystick) {
+                                                 return !joystick->GetSDLJoystick();
+                                             });
+        if (nullptr_it != map_it->second.end()) {
+            // ... and map it
+            (*nullptr_it)->SetSDLJoystick(sdl_joystick, sdl_controller);
+            return *nullptr_it;
+        }
+
+        // There is no SDLJoystick without a mapped SDL_Joystick
+        // Create a new SDLJoystick
+        const int port = static_cast<int>(map_it->second.size());
+        auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick, sdl_controller);
+        return map_it->second.emplace_back(std::move(joystick));
     }
 
-    const auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
-                                     [&sdl_joystick](const auto& joystick) {
-                                         return joystick->GetSDLJoystick() == sdl_joystick;
-                                     });
-
-    if (vec_it == map_it->second.end()) {
-        return nullptr;
-    }
-
-    return *vec_it;
+    auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick, sdl_controller);
+    return joystick_map[guid].emplace_back(std::move(joystick));
 }
 
 void SDLState::InitJoystick(int joystick_index) {
     SDL_Joystick* sdl_joystick = SDL_JoystickOpen(joystick_index);
     SDL_GameController* sdl_gamecontroller = nullptr;
-
     if (SDL_IsGameController(joystick_index)) {
         sdl_gamecontroller = SDL_GameControllerOpen(joystick_index);
     }
-
     if (!sdl_joystick) {
         LOG_ERROR(Input, "Failed to open joystick {}", joystick_index);
         return;
     }
-
     const std::string guid = GetGUID(sdl_joystick);
 
     std::lock_guard lock{joystick_map_mutex};
@@ -246,17 +257,14 @@ void SDLState::InitJoystick(int joystick_index) {
         joystick_map[guid].emplace_back(std::move(joystick));
         return;
     }
-
     auto& joystick_guid_list = joystick_map[guid];
-    const auto joystick_it =
-        std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
-                     [](const auto& joystick) { return !joystick->GetSDLJoystick(); });
-
-    if (joystick_it != joystick_guid_list.end()) {
-        (*joystick_it)->SetSDLJoystick(sdl_joystick, sdl_gamecontroller);
+    const auto it = std::find_if(
+        joystick_guid_list.begin(), joystick_guid_list.end(),
+        [](const std::shared_ptr<SDLJoystick>& joystick) { return !joystick->GetSDLJoystick(); });
+    if (it != joystick_guid_list.end()) {
+        (*it)->SetSDLJoystick(sdl_joystick, sdl_gamecontroller);
         return;
     }
-
     const int port = static_cast<int>(joystick_guid_list.size());
     auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick, sdl_gamecontroller);
     joystick_guid_list.emplace_back(std::move(joystick));
@@ -265,15 +273,22 @@ void SDLState::InitJoystick(int joystick_index) {
 void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
     const std::string guid = GetGUID(sdl_joystick);
 
-    std::lock_guard lock{joystick_map_mutex};
-    // This call to guid is safe since the joystick is guaranteed to be in the map
-    const auto& joystick_guid_list = joystick_map[guid];
-    const auto joystick_it = std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
-                                          [&sdl_joystick](const auto& joystick) {
-                                              return joystick->GetSDLJoystick() == sdl_joystick;
-                                          });
+    std::shared_ptr<SDLJoystick> joystick;
+    {
+        std::lock_guard lock{joystick_map_mutex};
+        // This call to guid is safe since the joystick is guaranteed to be in the map
+        const auto& joystick_guid_list = joystick_map[guid];
+        const auto joystick_it =
+            std::find_if(joystick_guid_list.begin(), joystick_guid_list.end(),
+                         [&sdl_joystick](const std::shared_ptr<SDLJoystick>& joystick) {
+                             return joystick->GetSDLJoystick() == sdl_joystick;
+                         });
+        joystick = *joystick_it;
+    }
 
-    (*joystick_it)->SetSDLJoystick(nullptr, nullptr);
+    // Destruct SDL_Joystick outside the lock guard because SDL can internally call the
+    // event callback which locks the mutex again.
+    joystick->SetSDLJoystick(nullptr, nullptr);
 }
 
 void SDLState::HandleGameControllerEvent(const SDL_Event& event) {
@@ -377,8 +392,8 @@ private:
 
 class SDLAnalog final : public Input::AnalogDevice {
 public:
-    explicit SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_,
-                       float deadzone_, float range_)
+    SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_, float deadzone_,
+              float range_)
         : joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_),
           range(range_) {}
 
@@ -657,13 +672,13 @@ SDLState::SDLState() {
     RegisterFactory<ButtonDevice>("sdl", button_factory);
     RegisterFactory<MotionDevice>("sdl", motion_factory);
 
-    // If the frontend is going to manage the event loop, then we don't start one here
-    start_thread = SDL_WasInit(SDL_INIT_JOYSTICK) == 0;
+    // If the frontend is going to manage the event loop, then we dont start one here
+    start_thread = !SDL_WasInit(SDL_INIT_JOYSTICK);
     if (start_thread && SDL_Init(SDL_INIT_JOYSTICK) < 0) {
         LOG_CRITICAL(Input, "SDL_Init(SDL_INIT_JOYSTICK) failed with: {}", SDL_GetError());
         return;
     }
-    has_gamecontroller = SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0;
+    has_gamecontroller = SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
     if (SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1") == SDL_FALSE) {
         LOG_ERROR(Input, "Failed to set hint for background events with: {}", SDL_GetError());
     }
@@ -708,7 +723,8 @@ std::vector<Common::ParamPackage> SDLState::GetInputDevices() {
     std::vector<Common::ParamPackage> devices;
     for (const auto& [key, value] : joystick_map) {
         for (const auto& joystick : value) {
-            if (auto* const controller = joystick->GetSDLGameController()) {
+            auto joy = joystick->GetSDLJoystick();
+            if (auto controller = joystick->GetSDLGameController()) {
                 std::string name =
                     fmt::format("{} {}", SDL_GameControllerName(controller), joystick->GetPort());
                 devices.emplace_back(Common::ParamPackage{
@@ -717,7 +733,7 @@ std::vector<Common::ParamPackage> SDLState::GetInputDevices() {
                     {"guid", joystick->GetGUID()},
                     {"port", std::to_string(joystick->GetPort())},
                 });
-            } else if (auto* const joy = joystick->GetSDLJoystick()) {
+            } else if (joy) {
                 std::string name = fmt::format("{} {}", SDL_JoystickName(joy), joystick->GetPort());
                 devices.emplace_back(Common::ParamPackage{
                     {"class", "sdl"},
@@ -732,7 +748,7 @@ std::vector<Common::ParamPackage> SDLState::GetInputDevices() {
 }
 
 namespace {
-Common::ParamPackage BuildAnalogParamPackageForButton(int port, std::string guid, s32 axis,
+Common::ParamPackage BuildAnalogParamPackageForButton(int port, std::string guid, u8 axis,
                                                       float value = 0.1f) {
     Common::ParamPackage params({{"engine", "sdl"}});
     params.Set("port", port);
@@ -748,7 +764,7 @@ Common::ParamPackage BuildAnalogParamPackageForButton(int port, std::string guid
     return params;
 }
 
-Common::ParamPackage BuildButtonParamPackageForButton(int port, std::string guid, s32 button) {
+Common::ParamPackage BuildButtonParamPackageForButton(int port, std::string guid, u8 button) {
     Common::ParamPackage params({{"engine", "sdl"}});
     params.Set("port", port);
     params.Set("guid", std::move(guid));
@@ -756,7 +772,7 @@ Common::ParamPackage BuildButtonParamPackageForButton(int port, std::string guid
     return params;
 }
 
-Common::ParamPackage BuildHatParamPackageForButton(int port, std::string guid, s32 hat, s32 value) {
+Common::ParamPackage BuildHatParamPackageForButton(int port, std::string guid, u8 hat, u8 value) {
     Common::ParamPackage params({{"engine", "sdl"}});
 
     params.Set("port", port);
@@ -784,27 +800,19 @@ Common::ParamPackage BuildHatParamPackageForButton(int port, std::string guid, s
 Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Event& event) {
     switch (event.type) {
     case SDL_JOYAXISMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-            return BuildAnalogParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jaxis.axis),
-                                                    event.jaxis.value);
-        }
-        break;
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        return BuildAnalogParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
+                                                event.jaxis.axis, event.jaxis.value);
     }
     case SDL_JOYBUTTONUP: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which)) {
-            return BuildButtonParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jbutton.button));
-        }
-        break;
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
+        return BuildButtonParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
+                                                event.jbutton.button);
     }
     case SDL_JOYHATMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which)) {
-            return BuildHatParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                 static_cast<s32>(event.jhat.hat),
-                                                 static_cast<s32>(event.jhat.value));
-        }
-        break;
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
+        return BuildHatParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
+                                             event.jhat.hat, event.jhat.value);
     }
     }
     return {};
@@ -813,27 +821,19 @@ Common::ParamPackage SDLEventToButtonParamPackage(SDLState& state, const SDL_Eve
 Common::ParamPackage SDLEventToMotionParamPackage(SDLState& state, const SDL_Event& event) {
     switch (event.type) {
     case SDL_JOYAXISMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-            return BuildAnalogParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jaxis.axis),
-                                                    event.jaxis.value);
-        }
-        break;
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+        return BuildAnalogParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
+                                                event.jaxis.axis, event.jaxis.value);
     }
     case SDL_JOYBUTTONUP: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which)) {
-            return BuildButtonParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                    static_cast<s32>(event.jbutton.button));
-        }
-        break;
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jbutton.which);
+        return BuildButtonParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
+                                                event.jbutton.button);
     }
     case SDL_JOYHATMOTION: {
-        if (const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which)) {
-            return BuildHatParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
-                                                 static_cast<s32>(event.jhat.hat),
-                                                 static_cast<s32>(event.jhat.value));
-        }
-        break;
+        const auto joystick = state.GetSDLJoystickBySDLID(event.jhat.which);
+        return BuildHatParamPackageForButton(joystick->GetPort(), joystick->GetGUID(),
+                                             event.jhat.hat, event.jhat.value);
     }
     }
     return {};
@@ -1061,8 +1061,9 @@ public:
             // Simplify controller config by testing if game controller support is enabled.
             if (event.type == SDL_JOYAXISMOTION) {
                 const auto axis = event.jaxis.axis;
-                if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
-                    auto* const controller = joystick->GetSDLGameController()) {
+                const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+                const auto controller = joystick->GetSDLGameController();
+                if (controller) {
                     const auto axis_left_x =
                         SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_LEFTX)
                             .value.axis;
@@ -1096,13 +1097,12 @@ public:
         }
 
         if (analog_x_axis != -1 && analog_y_axis != -1) {
-            if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-                auto params = BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
-                                                         analog_x_axis, analog_y_axis);
-                analog_x_axis = -1;
-                analog_y_axis = -1;
-                return params;
-            }
+            const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which);
+            auto params = BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
+                                                     analog_x_axis, analog_y_axis);
+            analog_x_axis = -1;
+            analog_y_axis = -1;
+            return params;
         }
         return {};
     }

src/input_common/settings.h

@@ -331,6 +331,8 @@ struct PlayerInput {
     ButtonsRaw buttons;
     AnalogsRaw analogs;
     MotionRaw motions;
+    std::string lstick_mod;
+    std::string rstick_mod;
 
     u32 body_color_left;
     u32 body_color_right;

src/input_common/touch_from_button.cpp

@@ -11,11 +11,9 @@ namespace InputCommon {
 class TouchFromButtonDevice final : public Input::TouchDevice {
 public:
     TouchFromButtonDevice() {
-        const auto button_index =
-            static_cast<std::size_t>(Settings::values.touch_from_button_map_index);
-        const auto& buttons = Settings::values.touch_from_button_maps[button_index].buttons;
-
-        for (const auto& config_entry : buttons) {
+        for (const auto& config_entry :
+             Settings::values.touch_from_button_maps[Settings::values.touch_from_button_map_index]
+                 .buttons) {
             const Common::ParamPackage package{config_entry};
             map.emplace_back(
                 Input::CreateDevice<Input::ButtonDevice>(config_entry),

src/input_common/udp/client.cpp

@@ -26,11 +26,11 @@ class Socket {
 public:
     using clock = std::chrono::system_clock;
 
-    explicit Socket(const std::string& host, u16 port, std::size_t pad_index_, u32 client_id_,
-                    SocketCallback callback_)
-        : callback(std::move(callback_)), timer(io_service),
-          socket(io_service, udp::endpoint(udp::v4(), 0)), client_id(client_id_),
-          pad_index(pad_index_) {
+    explicit Socket(const std::string& host, u16 port, u8 pad_index, u32 client_id,
+                    SocketCallback callback)
+        : callback(std::move(callback)), timer(io_service),
+          socket(io_service, udp::endpoint(udp::v4(), 0)), client_id(client_id),
+          pad_index(pad_index) {
         boost::system::error_code ec{};
         auto ipv4 = boost::asio::ip::make_address_v4(host, ec);
         if (ec.value() != boost::system::errc::success) {
@@ -93,17 +93,13 @@ private:
     void HandleSend(const boost::system::error_code& error) {
         boost::system::error_code _ignored{};
         // Send a request for getting port info for the pad
-        const Request::PortInfo port_info{1, {static_cast<u8>(pad_index), 0, 0, 0}};
+        Request::PortInfo port_info{1, {pad_index, 0, 0, 0}};
         const auto port_message = Request::Create(port_info, client_id);
         std::memcpy(&send_buffer1, &port_message, PORT_INFO_SIZE);
         socket.send_to(boost::asio::buffer(send_buffer1), send_endpoint, {}, _ignored);
 
         // Send a request for getting pad data for the pad
-        const Request::PadData pad_data{
-            Request::PadData::Flags::Id,
-            static_cast<u8>(pad_index),
-            EMPTY_MAC_ADDRESS,
-        };
+        Request::PadData pad_data{Request::PadData::Flags::Id, pad_index, EMPTY_MAC_ADDRESS};
         const auto pad_message = Request::Create(pad_data, client_id);
         std::memcpy(send_buffer2.data(), &pad_message, PAD_DATA_SIZE);
         socket.send_to(boost::asio::buffer(send_buffer2), send_endpoint, {}, _ignored);
@@ -116,7 +112,7 @@ private:
     udp::socket socket;
 
     u32 client_id{};
-    std::size_t pad_index{};
+    u8 pad_index{};
 
     static constexpr std::size_t PORT_INFO_SIZE = sizeof(Message<Request::PortInfo>);
     static constexpr std::size_t PAD_DATA_SIZE = sizeof(Message<Request::PadData>);
@@ -137,7 +133,7 @@ static void SocketLoop(Socket* socket) {
 Client::Client() {
     LOG_INFO(Input, "Udp Initialization started");
     for (std::size_t client = 0; client < clients.size(); client++) {
-        const auto pad = client % 4;
+        u8 pad = client % 4;
         StartCommunication(client, Settings::values.udp_input_address,
                            Settings::values.udp_input_port, pad, 24872);
         // Set motion parameters
@@ -170,9 +166,9 @@ std::vector<Common::ParamPackage> Client::GetInputDevices() const {
 bool Client::DeviceConnected(std::size_t pad) const {
     // Use last timestamp to detect if the socket has stopped sending data
     const auto now = std::chrono::system_clock::now();
-    const auto time_difference = static_cast<u64>(
+    u64 time_difference =
         std::chrono::duration_cast<std::chrono::milliseconds>(now - clients[pad].last_motion_update)
-            .count());
+            .count();
     return time_difference < 1000 && clients[pad].active == 1;
 }
 
@@ -181,9 +177,9 @@ void Client::ReloadUDPClient() {
         ReloadSocket(Settings::values.udp_input_address, Settings::values.udp_input_port, client);
     }
 }
-void Client::ReloadSocket(const std::string& host, u16 port, std::size_t pad_index, u32 client_id) {
+void Client::ReloadSocket(const std::string& host, u16 port, u8 pad_index, u32 client_id) {
     // client number must be determined from host / port and pad index
-    const std::size_t client = pad_index;
+    std::size_t client = pad_index;
     clients[client].socket->Stop();
     clients[client].thread.join();
     StartCommunication(client, host, port, pad_index, client_id);
@@ -198,8 +194,8 @@ void Client::OnPortInfo(Response::PortInfo data) {
 }
 
 void Client::OnPadData(Response::PadData data) {
-    // Client number must be determined from host / port and pad index
-    const std::size_t client = data.info.id;
+    // client number must be determined from host / port and pad index
+    std::size_t client = data.info.id;
     LOG_TRACE(Input, "PadData packet received");
     if (data.packet_counter == clients[client].packet_sequence) {
         LOG_WARNING(
@@ -211,12 +207,11 @@ void Client::OnPadData(Response::PadData data) {
     clients[client].active = data.info.is_pad_active;
     clients[client].packet_sequence = data.packet_counter;
     const auto now = std::chrono::system_clock::now();
-    const auto time_difference =
-        static_cast<u64>(std::chrono::duration_cast<std::chrono::microseconds>(
-                             now - clients[client].last_motion_update)
-                             .count());
+    u64 time_difference = std::chrono::duration_cast<std::chrono::microseconds>(
+                              now - clients[client].last_motion_update)
+                              .count();
     clients[client].last_motion_update = now;
-    const Common::Vec3f raw_gyroscope = {data.gyro.pitch, data.gyro.roll, -data.gyro.yaw};
+    Common::Vec3f raw_gyroscope = {data.gyro.pitch, data.gyro.roll, -data.gyro.yaw};
     clients[client].motion.SetAcceleration({data.accel.x, -data.accel.z, data.accel.y});
     // Gyroscope values are not it the correct scale from better joy.
     // Dividing by 312 allows us to make one full turn = 1 turn
@@ -242,11 +237,9 @@ void Client::OnPadData(Response::PadData data) {
             const u16 min_y = clients[client].status.touch_calibration->min_y;
             const u16 max_y = clients[client].status.touch_calibration->max_y;
 
-            x = static_cast<float>(std::clamp(static_cast<u16>(data.touch_1.x), min_x, max_x) -
-                                   min_x) /
+            x = (std::clamp(static_cast<u16>(data.touch_1.x), min_x, max_x) - min_x) /
                 static_cast<float>(max_x - min_x);
-            y = static_cast<float>(std::clamp(static_cast<u16>(data.touch_1.y), min_y, max_y) -
-                                   min_y) /
+            y = (std::clamp(static_cast<u16>(data.touch_1.y), min_y, max_y) - min_y) /
                 static_cast<float>(max_y - min_y);
         }
 
@@ -260,8 +253,8 @@ void Client::OnPadData(Response::PadData data) {
     }
 }
 
-void Client::StartCommunication(std::size_t client, const std::string& host, u16 port,
-                                std::size_t pad_index, u32 client_id) {
+void Client::StartCommunication(std::size_t client, const std::string& host, u16 port, u8 pad_index,
+                                u32 client_id) {
     SocketCallback callback{[this](Response::Version version) { OnVersion(version); },
                             [this](Response::PortInfo info) { OnPortInfo(info); },
                             [this](Response::PadData data) { OnPadData(data); }};
@@ -271,9 +264,9 @@ void Client::StartCommunication(std::size_t client, const std::string& host, u16
 }
 
 void Client::Reset() {
-    for (auto& client : clients) {
-        client.socket->Stop();
-        client.thread.join();
+    for (std::size_t client = 0; client < clients.size(); client++) {
+        clients[client].socket->Stop();
+        clients[client].thread.join();
     }
 }
 
@@ -332,19 +325,16 @@ const std::array<Common::SPSCQueue<UDPPadStatus>, 4>& Client::GetPadQueue() cons
     return pad_queue;
 }
 
-void TestCommunication(const std::string& host, u16 port, std::size_t pad_index, u32 client_id,
-                       const std::function<void()>& success_callback,
-                       const std::function<void()>& failure_callback) {
+void TestCommunication(const std::string& host, u16 port, u8 pad_index, u32 client_id,
+                       std::function<void()> success_callback,
+                       std::function<void()> failure_callback) {
     std::thread([=] {
         Common::Event success_event;
-        SocketCallback callback{
-            .version = [](Response::Version) {},
-            .port_info = [](Response::PortInfo) {},
-            .pad_data = [&](Response::PadData) { success_event.Set(); },
-        };
+        SocketCallback callback{[](Response::Version version) {}, [](Response::PortInfo info) {},
+                                [&](Response::PadData data) { success_event.Set(); }};
         Socket socket{host, port, pad_index, client_id, std::move(callback)};
         std::thread worker_thread{SocketLoop, &socket};
-        const bool result = success_event.WaitFor(std::chrono::seconds(8));
+        bool result = success_event.WaitFor(std::chrono::seconds(8));
         socket.Stop();
         worker_thread.join();
         if (result) {
@@ -356,7 +346,7 @@ void TestCommunication(const std::string& host, u16 port, std::size_t pad_index,
 }
 
 CalibrationConfigurationJob::CalibrationConfigurationJob(
-    const std::string& host, u16 port, std::size_t pad_index, u32 client_id,
+    const std::string& host, u16 port, u8 pad_index, u32 client_id,
     std::function<void(Status)> status_callback,
     std::function<void(u16, u16, u16, u16)> data_callback) {
 
@@ -376,7 +366,7 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
                                         current_status = Status::Ready;
                                         status_callback(current_status);
                                     }
-                                    if (data.touch_1.is_active == 0) {
+                                    if (!data.touch_1.is_active) {
                                         return;
                                     }
                                     LOG_DEBUG(Input, "Current touch: {} {}", data.touch_1.x,

src/input_common/udp/client.h

@@ -84,8 +84,8 @@ public:
 
     bool DeviceConnected(std::size_t pad) const;
     void ReloadUDPClient();
-    void ReloadSocket(const std::string& host = "127.0.0.1", u16 port = 26760,
-                      std::size_t pad_index = 0, u32 client_id = 24872);
+    void ReloadSocket(const std::string& host = "127.0.0.1", u16 port = 26760, u8 pad_index = 0,
+                      u32 client_id = 24872);
 
     std::array<Common::SPSCQueue<UDPPadStatus>, 4>& GetPadQueue();
     const std::array<Common::SPSCQueue<UDPPadStatus>, 4>& GetPadQueue() const;
@@ -99,7 +99,7 @@ private:
         DeviceStatus status;
         std::thread thread;
         u64 packet_sequence = 0;
-        u8 active = 0;
+        u8 active;
 
         // Realtime values
         // motion is initalized with PID values for drift correction on joycons
@@ -113,8 +113,8 @@ private:
     void OnVersion(Response::Version);
     void OnPortInfo(Response::PortInfo);
     void OnPadData(Response::PadData);
-    void StartCommunication(std::size_t client, const std::string& host, u16 port,
-                            std::size_t pad_index, u32 client_id);
+    void StartCommunication(std::size_t client, const std::string& host, u16 port, u8 pad_index,
+                            u32 client_id);
     void UpdateYuzuSettings(std::size_t client, const Common::Vec3<float>& acc,
                             const Common::Vec3<float>& gyro, bool touch);
 
@@ -139,7 +139,7 @@ public:
      * @param status_callback Callback for job status updates
      * @param data_callback Called when calibration data is ready
      */
-    explicit CalibrationConfigurationJob(const std::string& host, u16 port, std::size_t pad_index,
+    explicit CalibrationConfigurationJob(const std::string& host, u16 port, u8 pad_index,
                                          u32 client_id, std::function<void(Status)> status_callback,
                                          std::function<void(u16, u16, u16, u16)> data_callback);
     ~CalibrationConfigurationJob();
@@ -149,8 +149,8 @@ private:
     Common::Event complete_event;
 };
 
-void TestCommunication(const std::string& host, u16 port, std::size_t pad_index, u32 client_id,
-                       const std::function<void()>& success_callback,
-                       const std::function<void()>& failure_callback);
+void TestCommunication(const std::string& host, u16 port, u8 pad_index, u32 client_id,
+                       std::function<void()> success_callback,
+                       std::function<void()> failure_callback);
 
 } // namespace InputCommon::CemuhookUDP

src/input_common/udp/udp.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <atomic>
+#include <list>
 #include <mutex>
 #include <utility>
 #include "common/assert.h"
@@ -13,8 +15,8 @@ namespace InputCommon {
 
 class UDPMotion final : public Input::MotionDevice {
 public:
-    explicit UDPMotion(std::string ip_, int port_, u32 pad_, CemuhookUDP::Client* client_)
-        : ip(std::move(ip_)), port(port_), pad(pad_), client(client_) {}
+    UDPMotion(std::string ip_, int port_, int pad_, CemuhookUDP::Client* client_)
+        : ip(ip_), port(port_), pad(pad_), client(client_) {}
 
     Input::MotionStatus GetStatus() const override {
         return client->GetPadState(pad).motion_status;
@@ -23,7 +25,7 @@ public:
 private:
     const std::string ip;
     const int port;
-    const u32 pad;
+    const int pad;
     CemuhookUDP::Client* client;
     mutable std::mutex mutex;
 };
@@ -38,11 +40,11 @@ UDPMotionFactory::UDPMotionFactory(std::shared_ptr<CemuhookUDP::Client> client_)
  *     - "port": the nth jcpad on the adapter
  */
 std::unique_ptr<Input::MotionDevice> UDPMotionFactory::Create(const Common::ParamPackage& params) {
-    auto ip = params.Get("ip", "127.0.0.1");
-    const auto port = params.Get("port", 26760);
-    const auto pad = static_cast<u32>(params.Get("pad_index", 0));
+    const std::string ip = params.Get("ip", "127.0.0.1");
+    const int port = params.Get("port", 26760);
+    const int pad = params.Get("pad_index", 0);
 
-    return std::make_unique<UDPMotion>(std::move(ip), port, pad, client.get());
+    return std::make_unique<UDPMotion>(ip, port, pad, client.get());
 }
 
 void UDPMotionFactory::BeginConfiguration() {
@@ -77,7 +79,7 @@ Common::ParamPackage UDPMotionFactory::GetNextInput() {
 
 class UDPTouch final : public Input::TouchDevice {
 public:
-    explicit UDPTouch(std::string ip_, int port_, u32 pad_, CemuhookUDP::Client* client_)
+    UDPTouch(std::string ip_, int port_, int pad_, CemuhookUDP::Client* client_)
         : ip(std::move(ip_)), port(port_), pad(pad_), client(client_) {}
 
     std::tuple<float, float, bool> GetStatus() const override {
@@ -87,7 +89,7 @@ public:
 private:
     const std::string ip;
     const int port;
-    const u32 pad;
+    const int pad;
     CemuhookUDP::Client* client;
     mutable std::mutex mutex;
 };
@@ -102,11 +104,11 @@ UDPTouchFactory::UDPTouchFactory(std::shared_ptr<CemuhookUDP::Client> client_)
  *     - "port": the nth jcpad on the adapter
  */
 std::unique_ptr<Input::TouchDevice> UDPTouchFactory::Create(const Common::ParamPackage& params) {
-    auto ip = params.Get("ip", "127.0.0.1");
-    const auto port = params.Get("port", 26760);
-    const auto pad = static_cast<u32>(params.Get("pad_index", 0));
+    const std::string ip = params.Get("ip", "127.0.0.1");
+    const int port = params.Get("port", 26760);
+    const int pad = params.Get("pad_index", 0);
 
-    return std::make_unique<UDPTouch>(std::move(ip), port, pad, client.get());
+    return std::make_unique<UDPTouch>(ip, port, pad, client.get());
 }
 
 void UDPTouchFactory::BeginConfiguration() {

src/video_core/CMakeLists.txt

@@ -5,24 +5,6 @@ add_library(video_core STATIC
     buffer_cache/buffer_cache.h
     buffer_cache/map_interval.cpp
     buffer_cache/map_interval.h
-    cdma_pusher.cpp
-    cdma_pusher.h
-    command_classes/codecs/codec.cpp
-    command_classes/codecs/codec.h
-    command_classes/codecs/h264.cpp
-    command_classes/codecs/h264.h
-    command_classes/codecs/vp9.cpp
-    command_classes/codecs/vp9.h
-    command_classes/codecs/vp9_types.h
-    command_classes/host1x.cpp
-    command_classes/host1x.h
-    command_classes/nvdec.cpp
-    command_classes/nvdec.h
-    command_classes/nvdec_common.h
-    command_classes/sync_manager.cpp
-    command_classes/sync_manager.h
-    command_classes/vic.cpp
-    command_classes/vic.h
     compatible_formats.cpp
     compatible_formats.h
     dirty_flags.cpp
@@ -268,14 +250,6 @@ create_target_directory_groups(video_core)
 target_link_libraries(video_core PUBLIC common core)
 target_link_libraries(video_core PRIVATE glad xbyak)
 
-if (MSVC)
-    target_include_directories(video_core PRIVATE ${FFMPEG_INCLUDE_DIR})
-    target_link_libraries(video_core PUBLIC ${FFMPEG_LIBRARY_DIR}/swscale.lib ${FFMPEG_LIBRARY_DIR}/avcodec.lib ${FFMPEG_LIBRARY_DIR}/avutil.lib)
-else()
-    target_include_directories(video_core PRIVATE ${FFMPEG_INCLUDE_DIR})
-    target_link_libraries(video_core PRIVATE ${FFMPEG_LIBRARIES})
-endif()
-
 add_dependencies(video_core host_shaders)
 target_include_directories(video_core PRIVATE ${HOST_SHADERS_INCLUDE})
 
@@ -304,9 +278,7 @@ else()
         -Wno-error=sign-conversion
         -Werror=switch
         -Werror=unused-variable
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
+        -Werror=unused-but-set-variable
+        -Werror=class-memaccess
     )
 endif()

src/video_core/cdma_pusher.cpp

@@ -1,171 +0,0 @@
-// MIT License
-//
-// Copyright (c) Ryujinx Team and Contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-// associated documentation files (the "Software"), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute,
-// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-#include "command_classes/host1x.h"
-#include "command_classes/nvdec.h"
-#include "command_classes/vic.h"
-#include "common/bit_util.h"
-#include "video_core/cdma_pusher.h"
-#include "video_core/command_classes/nvdec_common.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
-
-namespace Tegra {
-CDmaPusher::CDmaPusher(GPU& gpu)
-    : gpu(gpu), nvdec_processor(std::make_shared<Nvdec>(gpu)),
-      vic_processor(std::make_unique<Vic>(gpu, nvdec_processor)),
-      host1x_processor(std::make_unique<Host1x>(gpu)),
-      nvdec_sync(std::make_unique<SyncptIncrManager>(gpu)),
-      vic_sync(std::make_unique<SyncptIncrManager>(gpu)) {}
-
-CDmaPusher::~CDmaPusher() = default;
-
-void CDmaPusher::Push(ChCommandHeaderList&& entries) {
-    cdma_queue.push(std::move(entries));
-}
-
-void CDmaPusher::DispatchCalls() {
-    while (!cdma_queue.empty()) {
-        Step();
-    }
-}
-
-void CDmaPusher::Step() {
-    const auto entries{cdma_queue.front()};
-    cdma_queue.pop();
-
-    std::vector<u32> values(entries.size());
-    std::memcpy(values.data(), entries.data(), entries.size() * sizeof(u32));
-
-    for (const u32 value : values) {
-        if (mask != 0) {
-            const u32 lbs = Common::CountTrailingZeroes32(mask);
-            mask &= ~(1U << lbs);
-            ExecuteCommand(static_cast<u32>(offset + lbs), value);
-            continue;
-        } else if (count != 0) {
-            --count;
-            ExecuteCommand(static_cast<u32>(offset), value);
-            if (incrementing) {
-                ++offset;
-            }
-            continue;
-        }
-        const auto mode = static_cast<ChSubmissionMode>((value >> 28) & 0xf);
-        switch (mode) {
-        case ChSubmissionMode::SetClass: {
-            mask = value & 0x3f;
-            offset = (value >> 16) & 0xfff;
-            current_class = static_cast<ChClassId>((value >> 6) & 0x3ff);
-            break;
-        }
-        case ChSubmissionMode::Incrementing:
-        case ChSubmissionMode::NonIncrementing:
-            count = value & 0xffff;
-            offset = (value >> 16) & 0xfff;
-            incrementing = mode == ChSubmissionMode::Incrementing;
-            break;
-        case ChSubmissionMode::Mask:
-            mask = value & 0xffff;
-            offset = (value >> 16) & 0xfff;
-            break;
-        case ChSubmissionMode::Immediate: {
-            const u32 data = value & 0xfff;
-            offset = (value >> 16) & 0xfff;
-            ExecuteCommand(static_cast<u32>(offset), data);
-            break;
-        }
-        default:
-            UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!", static_cast<u32>(mode));
-            break;
-        }
-    }
-}
-
-void CDmaPusher::ExecuteCommand(u32 offset, u32 data) {
-    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) {
-                nvdec_sync->Increment(syncpoint_id);
-            } else {
-                nvdec_sync->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id);
-                nvdec_sync->SignalDone(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(
-                static_cast<Tegra::Nvdec::Method>(nvdec_thi_state.method_0), {data});
-            break;
-        default:
-            break;
-        }
-        break;
-    case ChClassId::GraphicsVic:
-        ThiStateWrite(vic_thi_state, static_cast<u32>(offset), {data});
-        switch (static_cast<ThiMethod>(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) {
-                vic_sync->Increment(syncpoint_id);
-            } else {
-                vic_sync->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id);
-                vic_sync->SignalDone(syncpoint_id);
-            }
-            break;
-        }
-        case ThiMethod::SetMethod1:
-            LOG_DEBUG(Service_NVDRV, "VIC method 0x{:X}, Args=({})",
-                      static_cast<u32>(vic_thi_state.method_0));
-            vic_processor->ProcessMethod(static_cast<Tegra::Vic::Method>(vic_thi_state.method_0),
-                                         {data});
-            break;
-        default:
-            break;
-        }
-        break;
-    case ChClassId::Host1x:
-        // This device is mainly for syncpoint synchronization
-        LOG_DEBUG(Service_NVDRV, "Host1X Class Method");
-        host1x_processor->ProcessMethod(static_cast<Tegra::Host1x::Method>(offset), {data});
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Current class not implemented {:X}", static_cast<u32>(current_class));
-        break;
-    }
-}
-
-void CDmaPusher::ThiStateWrite(ThiRegisters& state, u32 offset, const std::vector<u32>& arguments) {
-    u8* const state_offset = reinterpret_cast<u8*>(&state) + sizeof(u32) * offset;
-    std::memcpy(state_offset, arguments.data(), sizeof(u32) * arguments.size());
-}
-
-} // namespace Tegra

src/video_core/cdma_pusher.h

@@ -1,138 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-#include <vector>
-#include <queue>
-
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "video_core/command_classes/sync_manager.h"
-
-namespace Tegra {
-
-class GPU;
-class Nvdec;
-class Vic;
-class Host1x;
-
-enum class ChSubmissionMode : u32 {
-    SetClass = 0,
-    Incrementing = 1,
-    NonIncrementing = 2,
-    Mask = 3,
-    Immediate = 4,
-    Restart = 5,
-    Gather = 6,
-};
-
-enum class ChClassId : u32 {
-    NoClass = 0x0,
-    Host1x = 0x1,
-    VideoEncodeMpeg = 0x20,
-    VideoEncodeNvEnc = 0x21,
-    VideoStreamingVi = 0x30,
-    VideoStreamingIsp = 0x32,
-    VideoStreamingIspB = 0x34,
-    VideoStreamingViI2c = 0x36,
-    GraphicsVic = 0x5d,
-    Graphics3D = 0x60,
-    GraphicsGpu = 0x61,
-    Tsec = 0xe0,
-    TsecB = 0xe1,
-    NvJpg = 0xc0,
-    NvDec = 0xf0
-};
-
-enum class ChMethod : u32 {
-    Empty = 0,
-    SetMethod = 0x10,
-    SetData = 0x11,
-};
-
-union ChCommandHeader {
-    u32 raw;
-    BitField<0, 16, u32> value;
-    BitField<16, 12, ChMethod> method_offset;
-    BitField<28, 4, ChSubmissionMode> submission_mode;
-};
-static_assert(sizeof(ChCommandHeader) == sizeof(u32), "ChCommand header is an invalid size");
-
-struct ChCommand {
-    ChClassId class_id{};
-    int method_offset{};
-    std::vector<u32> arguments;
-};
-
-using ChCommandHeaderList = std::vector<Tegra::ChCommandHeader>;
-using ChCommandList = std::vector<Tegra::ChCommand>;
-
-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{};
-};
-
-enum class ThiMethod : u32 {
-    IncSyncpt = offsetof(ThiRegisters, increment_syncpt) / sizeof(u32),
-    SetMethod0 = offsetof(ThiRegisters, method_0) / sizeof(u32),
-    SetMethod1 = offsetof(ThiRegisters, method_1) / sizeof(u32),
-};
-
-class CDmaPusher {
-public:
-    explicit CDmaPusher(GPU& gpu);
-    ~CDmaPusher();
-
-    /// Push NVDEC command buffer entries into queue
-    void Push(ChCommandHeaderList&& entries);
-
-    /// Process queued command buffer entries
-    void DispatchCalls();
-
-    /// Process one queue element
-    void Step();
-
-    /// Invoke command class devices to execute the command based on the current state
-    void ExecuteCommand(u32 offset, u32 data);
-
-private:
-    /// Write arguments value to the ThiRegisters member at the specified offset
-    void ThiStateWrite(ThiRegisters& state, u32 offset, const std::vector<u32>& arguments);
-
-    GPU& gpu;
-
-    std::shared_ptr<Tegra::Nvdec> nvdec_processor;
-    std::unique_ptr<Tegra::Vic> vic_processor;
-    std::unique_ptr<Tegra::Host1x> host1x_processor;
-    std::unique_ptr<SyncptIncrManager> nvdec_sync;
-    std::unique_ptr<SyncptIncrManager> vic_sync;
-    ChClassId current_class{};
-    ThiRegisters vic_thi_state{};
-    ThiRegisters nvdec_thi_state{};
-
-    s32 count{};
-    s32 offset{};
-    s32 mask{};
-    bool incrementing{};
-
-    // Queue of command lists to be processed
-    std::queue<ChCommandHeaderList> cdma_queue;
-};
-
-} // namespace Tegra

src/video_core/command_classes/codecs/codec.cpp

@@ -1,114 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <fstream>
-#include "common/assert.h"
-#include "video_core/command_classes/codecs/codec.h"
-#include "video_core/command_classes/codecs/h264.h"
-#include "video_core/command_classes/codecs/vp9.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
-
-extern "C" {
-#include <libavutil/opt.h>
-}
-
-namespace Tegra {
-
-Codec::Codec(GPU& gpu_)
-    : gpu(gpu_), h264_decoder(std::make_unique<Decoder::H264>(gpu)),
-      vp9_decoder(std::make_unique<Decoder::VP9>(gpu)) {}
-
-Codec::~Codec() {
-    if (!initialized) {
-        return;
-    }
-    // Free libav memory
-    avcodec_send_packet(av_codec_ctx, nullptr);
-    avcodec_receive_frame(av_codec_ctx, av_frame);
-    avcodec_flush_buffers(av_codec_ctx);
-
-    av_frame_unref(av_frame);
-    av_free(av_frame);
-    avcodec_close(av_codec_ctx);
-}
-
-void Codec::SetTargetCodec(NvdecCommon::VideoCodec codec) {
-    LOG_INFO(Service_NVDRV, "NVDEC video codec initialized to {}", static_cast<u32>(codec));
-    current_codec = codec;
-}
-
-void Codec::StateWrite(u32 offset, u64 arguments) {
-    u8* const state_offset = reinterpret_cast<u8*>(&state) + offset * sizeof(u64);
-    std::memcpy(state_offset, &arguments, sizeof(u64));
-}
-
-void Codec::Decode() {
-    bool is_first_frame = false;
-
-    if (!initialized) {
-        if (current_codec == NvdecCommon::VideoCodec::H264) {
-            av_codec = avcodec_find_decoder(AV_CODEC_ID_H264);
-        } else if (current_codec == NvdecCommon::VideoCodec::Vp9) {
-            av_codec = avcodec_find_decoder(AV_CODEC_ID_VP9);
-        } else {
-            LOG_ERROR(Service_NVDRV, "Unknown video codec {}", static_cast<u32>(current_codec));
-            return;
-        }
-
-        av_codec_ctx = avcodec_alloc_context3(av_codec);
-        av_frame = av_frame_alloc();
-        av_opt_set(av_codec_ctx->priv_data, "tune", "zerolatency", 0);
-
-        // TODO(ameerj): libavcodec gpu hw acceleration
-
-        const auto av_error = avcodec_open2(av_codec_ctx, av_codec, nullptr);
-        if (av_error < 0) {
-            LOG_ERROR(Service_NVDRV, "avcodec_open2() Failed.");
-            av_frame_unref(av_frame);
-            av_free(av_frame);
-            avcodec_close(av_codec_ctx);
-            return;
-        }
-        initialized = true;
-        is_first_frame = true;
-    }
-    bool vp9_hidden_frame = false;
-
-    AVPacket packet{};
-    av_init_packet(&packet);
-    std::vector<u8> frame_data;
-
-    if (current_codec == NvdecCommon::VideoCodec::H264) {
-        frame_data = h264_decoder->ComposeFrameHeader(state, is_first_frame);
-    } else if (current_codec == NvdecCommon::VideoCodec::Vp9) {
-        frame_data = vp9_decoder->ComposeFrameHeader(state);
-        vp9_hidden_frame = vp9_decoder->WasFrameHidden();
-    }
-
-    packet.data = frame_data.data();
-    packet.size = static_cast<int>(frame_data.size());
-
-    avcodec_send_packet(av_codec_ctx, &packet);
-
-    if (!vp9_hidden_frame) {
-        // Only receive/store visible frames
-        avcodec_receive_frame(av_codec_ctx, av_frame);
-    }
-}
-
-AVFrame* Codec::GetCurrentFrame() {
-    return av_frame;
-}
-
-const AVFrame* Codec::GetCurrentFrame() const {
-    return av_frame;
-}
-
-NvdecCommon::VideoCodec Codec::GetCurrentCodec() const {
-    return current_codec;
-}
-
-} // namespace Tegra

src/video_core/command_classes/codecs/codec.h

@@ -1,68 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "video_core/command_classes/nvdec_common.h"
-
-extern "C" {
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif
-#include <libavcodec/avcodec.h>
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-}
-
-namespace Tegra {
-class GPU;
-struct VicRegisters;
-
-namespace Decoder {
-class H264;
-class VP9;
-} // namespace Decoder
-
-class Codec {
-public:
-    explicit Codec(GPU& gpu);
-    ~Codec();
-
-    /// Sets NVDEC video stream codec
-    void SetTargetCodec(NvdecCommon::VideoCodec codec);
-
-    /// Populate NvdecRegisters state with argument value at the provided offset
-    void StateWrite(u32 offset, u64 arguments);
-
-    /// Call decoders to construct headers, decode AVFrame with ffmpeg
-    void Decode();
-
-    /// Returns most recently decoded frame
-    AVFrame* GetCurrentFrame();
-    const AVFrame* GetCurrentFrame() const;
-
-    /// Returns the value of current_codec
-    NvdecCommon::VideoCodec GetCurrentCodec() const;
-
-private:
-    bool initialized{};
-    NvdecCommon::VideoCodec current_codec{NvdecCommon::VideoCodec::None};
-
-    AVCodec* av_codec{nullptr};
-    AVCodecContext* av_codec_ctx{nullptr};
-    AVFrame* av_frame{nullptr};
-
-    GPU& gpu;
-    std::unique_ptr<Decoder::H264> h264_decoder;
-    std::unique_ptr<Decoder::VP9> vp9_decoder;
-
-    NvdecCommon::NvdecRegisters state{};
-};
-
-} // namespace Tegra

src/video_core/command_classes/codecs/h264.cpp

@@ -1,276 +0,0 @@
-// MIT License
-//
-// Copyright (c) Ryujinx Team and Contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-// associated documentation files (the "Software"), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute,
-// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-#include "common/bit_util.h"
-#include "video_core/command_classes/codecs/h264.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
-
-namespace Tegra::Decoder {
-H264::H264(GPU& gpu_) : gpu(gpu_) {}
-
-H264::~H264() = default;
-
-std::vector<u8>& H264::ComposeFrameHeader(NvdecCommon::NvdecRegisters& state, bool is_first_frame) {
-    H264DecoderContext context{};
-    gpu.MemoryManager().ReadBlock(state.picture_info_offset, &context, sizeof(H264DecoderContext));
-
-    const s32 frame_number = static_cast<s32>((context.h264_parameter_set.flags >> 46) & 0x1ffff);
-    if (!is_first_frame && frame_number != 0) {
-        frame.resize(context.frame_data_size);
-
-        gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset, frame.data(), frame.size());
-    } else {
-        /// Encode header
-        H264BitWriter writer{};
-        writer.WriteU(1, 24);
-        writer.WriteU(0, 1);
-        writer.WriteU(3, 2);
-        writer.WriteU(7, 5);
-        writer.WriteU(100, 8);
-        writer.WriteU(0, 8);
-        writer.WriteU(31, 8);
-        writer.WriteUe(0);
-        const s32 chroma_format_idc = (context.h264_parameter_set.flags >> 12) & 0x3;
-        writer.WriteUe(chroma_format_idc);
-        if (chroma_format_idc == 3) {
-            writer.WriteBit(false);
-        }
-
-        writer.WriteUe(0);
-        writer.WriteUe(0);
-        writer.WriteBit(false); // QpprimeYZeroTransformBypassFlag
-        writer.WriteBit(false); // Scaling matrix present flag
-
-        const s32 order_cnt_type = static_cast<s32>((context.h264_parameter_set.flags >> 14) & 3);
-        writer.WriteUe(static_cast<s32>((context.h264_parameter_set.flags >> 8) & 0xf));
-        writer.WriteUe(order_cnt_type);
-        if (order_cnt_type == 0) {
-            writer.WriteUe(context.h264_parameter_set.log2_max_pic_order_cnt);
-        } else if (order_cnt_type == 1) {
-            writer.WriteBit(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.pic_height_in_map_units /
-                               (context.h264_parameter_set.frame_mbs_only_flag ? 1 : 2);
-
-        writer.WriteUe(16);
-        writer.WriteBit(false);
-        writer.WriteUe(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);
-
-        if (!context.h264_parameter_set.frame_mbs_only_flag) {
-            writer.WriteBit(((context.h264_parameter_set.flags >> 0) & 1) != 0);
-        }
-
-        writer.WriteBit(((context.h264_parameter_set.flags >> 1) & 1) != 0);
-        writer.WriteBit(false); // Frame cropping flag
-        writer.WriteBit(false); // VUI parameter present flag
-
-        writer.End();
-
-        // H264 PPS
-        writer.WriteU(1, 24);
-        writer.WriteU(0, 1);
-        writer.WriteU(3, 2);
-        writer.WriteU(8, 5);
-
-        writer.WriteUe(0);
-        writer.WriteUe(0);
-
-        writer.WriteBit(context.h264_parameter_set.entropy_coding_mode_flag);
-        writer.WriteBit(false);
-        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 >> 2) & 1) != 0);
-        writer.WriteU(static_cast<s32>((context.h264_parameter_set.flags >> 32) & 0x3), 2);
-        s32 pic_init_qp = static_cast<s32>((context.h264_parameter_set.flags >> 16) & 0x3f);
-        pic_init_qp = (pic_init_qp << 26) >> 26;
-        writer.WriteSe(pic_init_qp);
-        writer.WriteSe(0);
-        s32 chroma_qp_index_offset =
-            static_cast<s32>((context.h264_parameter_set.flags >> 22) & 0x1f);
-        chroma_qp_index_offset = (chroma_qp_index_offset << 27) >> 27;
-
-        writer.WriteSe(chroma_qp_index_offset);
-        writer.WriteBit(context.h264_parameter_set.deblocking_filter_control_flag != 0);
-        writer.WriteBit(((context.h264_parameter_set.flags >> 3) & 1) != 0);
-        writer.WriteBit(context.h264_parameter_set.redundant_pic_count_flag != 0);
-        writer.WriteBit(context.h264_parameter_set.transform_8x8_mode_flag != 0);
-
-        writer.WriteBit(true);
-
-        for (s32 index = 0; index < 6; index++) {
-            writer.WriteBit(true);
-            const auto matrix_x4 =
-                std::vector<u8>(context.scaling_matrix_4.begin(), context.scaling_matrix_4.end());
-            writer.WriteScalingList(matrix_x4, index * 16, 16);
-        }
-
-        if (context.h264_parameter_set.transform_8x8_mode_flag) {
-            for (s32 index = 0; index < 2; index++) {
-                writer.WriteBit(true);
-                const auto matrix_x8 = std::vector<u8>(context.scaling_matrix_8.begin(),
-                                                       context.scaling_matrix_8.end());
-
-                writer.WriteScalingList(matrix_x8, index * 64, 64);
-            }
-        }
-
-        s32 chroma_qp_index_offset2 =
-            static_cast<s32>((context.h264_parameter_set.flags >> 27) & 0x1f);
-        chroma_qp_index_offset2 = (chroma_qp_index_offset2 << 27) >> 27;
-
-        writer.WriteSe(chroma_qp_index_offset2);
-
-        writer.End();
-
-        const auto& encoded_header = writer.GetByteArray();
-        frame.resize(encoded_header.size() + context.frame_data_size);
-        std::memcpy(frame.data(), encoded_header.data(), encoded_header.size());
-
-        gpu.MemoryManager().ReadBlock(state.frame_bitstream_offset,
-                                      frame.data() + encoded_header.size(),
-                                      context.frame_data_size);
-    }
-
-    return frame;
-}
-
-H264BitWriter::H264BitWriter() = default;
-
-H264BitWriter::~H264BitWriter() = default;
-
-void H264BitWriter::WriteU(s32 value, s32 value_sz) {
-    WriteBits(value, value_sz);
-}
-
-void H264BitWriter::WriteSe(s32 value) {
-    WriteExpGolombCodedInt(value);
-}
-
-void H264BitWriter::WriteUe(s32 value) {
-    WriteExpGolombCodedUInt((u32)value);
-}
-
-void H264BitWriter::End() {
-    WriteBit(true);
-    Flush();
-}
-
-void H264BitWriter::WriteBit(bool state) {
-    WriteBits(state ? 1 : 0, 1);
-}
-
-void H264BitWriter::WriteScalingList(const std::vector<u8>& list, s32 start, s32 count) {
-    std::vector<u8> scan(count);
-    if (count == 16) {
-        std::memcpy(scan.data(), zig_zag_scan.data(), scan.size());
-    } else {
-        std::memcpy(scan.data(), zig_zag_direct.data(), scan.size());
-    }
-    u8 last_scale = 8;
-
-    for (s32 index = 0; index < count; index++) {
-        const u8 value = list[start + scan[index]];
-        const s32 delta_scale = static_cast<s32>(value - last_scale);
-
-        WriteSe(delta_scale);
-
-        last_scale = value;
-    }
-}
-
-std::vector<u8>& H264BitWriter::GetByteArray() {
-    return byte_array;
-}
-
-const std::vector<u8>& H264BitWriter::GetByteArray() const {
-    return byte_array;
-}
-
-void H264BitWriter::WriteBits(s32 value, s32 bit_count) {
-    s32 value_pos = 0;
-
-    s32 remaining = bit_count;
-
-    while (remaining > 0) {
-        s32 copy_size = remaining;
-
-        const s32 free_bits = GetFreeBufferBits();
-
-        if (copy_size > free_bits) {
-            copy_size = free_bits;
-        }
-
-        const s32 mask = (1 << copy_size) - 1;
-
-        const s32 src_shift = (bit_count - value_pos) - copy_size;
-        const s32 dst_shift = (buffer_size - buffer_pos) - copy_size;
-
-        buffer |= ((value >> src_shift) & mask) << dst_shift;
-
-        value_pos += copy_size;
-        buffer_pos += copy_size;
-        remaining -= copy_size;
-    }
-}
-
-void H264BitWriter::WriteExpGolombCodedInt(s32 value) {
-    const s32 sign = value <= 0 ? 0 : 1;
-    if (value < 0) {
-        value = -value;
-    }
-    value = (value << 1) - sign;
-    WriteExpGolombCodedUInt(value);
-}
-
-void H264BitWriter::WriteExpGolombCodedUInt(u32 value) {
-    const s32 size = 32 - Common::CountLeadingZeroes32(static_cast<s32>(value + 1));
-    WriteBits(1, size);
-
-    value -= (1U << (size - 1)) - 1;
-    WriteBits(static_cast<s32>(value), size - 1);
-}
-
-s32 H264BitWriter::GetFreeBufferBits() {
-    if (buffer_pos == buffer_size) {
-        Flush();
-    }
-
-    return buffer_size - buffer_pos;
-}
-
-void H264BitWriter::Flush() {
-    if (buffer_pos == 0) {
-        return;
-    }
-    byte_array.push_back(static_cast<u8>(buffer));
-
-    buffer = 0;
-    buffer_pos = 0;
-}
-} // namespace Tegra::Decoder

src/video_core/command_classes/codecs/h264.h

@@ -1,130 +0,0 @@
-// MIT License
-//
-// Copyright (c) Ryujinx Team and Contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-// associated documentation files (the "Software"), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute,
-// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-#pragma once
-
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "video_core/command_classes/nvdec_common.h"
-
-namespace Tegra {
-class GPU;
-namespace Decoder {
-
-class H264BitWriter {
-public:
-    H264BitWriter();
-    ~H264BitWriter();
-
-    /// The following Write methods are based on clause 9.1 in the H.264 specification.
-    /// WriteSe and WriteUe write in the Exp-Golomb-coded syntax
-    void WriteU(s32 value, s32 value_sz);
-    void WriteSe(s32 value);
-    void WriteUe(s32 value);
-
-    /// Finalize the bitstream
-    void End();
-
-    /// append a bit to the stream, equivalent value to the state parameter
-    void WriteBit(bool state);
-
-    /// Based on section 7.3.2.1.1.1 and Table 7-4 in the H.264 specification
-    /// Writes the scaling matrices of the sream
-    void WriteScalingList(const std::vector<u8>& list, s32 start, s32 count);
-
-    /// Return the bitstream as a vector.
-    std::vector<u8>& GetByteArray();
-    const std::vector<u8>& GetByteArray() const;
-
-private:
-    // ZigZag LUTs from libavcodec.
-    static constexpr std::array<u8, 64> zig_zag_direct{
-        0,  1,  8,  16, 9,  2,  3,  10, 17, 24, 32, 25, 18, 11, 4,  5,  12, 19, 26, 33, 40, 48,
-        41, 34, 27, 20, 13, 6,  7,  14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23,
-        30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
-    };
-
-    static constexpr std::array<u8, 16> zig_zag_scan{
-        0 + 0 * 4, 1 + 0 * 4, 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 2 + 0 * 4, 3 + 0 * 4, 2 + 1 * 4,
-        1 + 2 * 4, 0 + 3 * 4, 1 + 3 * 4, 2 + 2 * 4, 3 + 1 * 4, 3 + 2 * 4, 2 + 3 * 4, 3 + 3 * 4,
-    };
-
-    void WriteBits(s32 value, s32 bit_count);
-    void WriteExpGolombCodedInt(s32 value);
-    void WriteExpGolombCodedUInt(u32 value);
-    s32 GetFreeBufferBits();
-    void Flush();
-
-    s32 buffer_size{8};
-
-    s32 buffer{};
-    s32 buffer_pos{};
-    std::vector<u8> byte_array;
-};
-
-class H264 {
-public:
-    explicit H264(GPU& gpu);
-    ~H264();
-
-    /// Compose the H264 header of the frame for FFmpeg decoding
-    std::vector<u8>& ComposeFrameHeader(NvdecCommon::NvdecRegisters& state,
-                                        bool is_first_frame = false);
-
-private:
-    struct H264ParameterSet {
-        u32 log2_max_pic_order_cnt{};
-        u32 delta_pic_order_always_zero_flag{};
-        u32 frame_mbs_only_flag{};
-        u32 pic_width_in_mbs{};
-        u32 pic_height_in_map_units{};
-        INSERT_PADDING_WORDS(1);
-        u32 entropy_coding_mode_flag{};
-        u32 bottom_field_pic_order_flag{};
-        u32 num_refidx_l0_default_active{};
-        u32 num_refidx_l1_default_active{};
-        u32 deblocking_filter_control_flag{};
-        u32 redundant_pic_count_flag{};
-        u32 transform_8x8_mode_flag{};
-        INSERT_PADDING_WORDS(9);
-        u64 flags{};
-        u32 frame_number{};
-        u32 frame_number2{};
-    };
-    static_assert(sizeof(H264ParameterSet) == 0x68, "H264ParameterSet is an invalid size");
-
-    struct H264DecoderContext {
-        INSERT_PADDING_BYTES(0x48);
-        u32 frame_data_size{};
-        INSERT_PADDING_BYTES(0xc);
-        H264ParameterSet h264_parameter_set{};
-        INSERT_PADDING_BYTES(0x100);
-        std::array<u8, 0x60> scaling_matrix_4;
-        std::array<u8, 0x80> scaling_matrix_8;
-    };
-    static_assert(sizeof(H264DecoderContext) == 0x2a0, "H264DecoderContext is an invalid size");
-
-    std::vector<u8> frame;
-    GPU& gpu;
-};
-
-} // namespace Decoder
-} // namespace Tegra

src/video_core/command_classes/codecs/vp9.h

@@ -1,216 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <unordered_map>
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/stream.h"
-#include "video_core/command_classes/codecs/vp9_types.h"
-#include "video_core/command_classes/nvdec_common.h"
-
-namespace Tegra {
-class GPU;
-enum class FrameType { KeyFrame = 0, InterFrame = 1 };
-namespace Decoder {
-
-/// The VpxRangeEncoder, and VpxBitStreamWriter classes are used to compose the
-/// VP9 header bitstreams.
-
-class VpxRangeEncoder {
-public:
-    VpxRangeEncoder();
-    ~VpxRangeEncoder();
-
-    /// Writes the rightmost value_size bits from value into the stream
-    void Write(s32 value, s32 value_size);
-
-    /// Writes a single bit with half probability
-    void Write(bool bit);
-
-    /// Writes a bit to the base_stream encoded with probability
-    void Write(bool bit, s32 probability);
-
-    /// Signal the end of the bitstream
-    void End();
-
-    std::vector<u8>& GetBuffer() {
-        return base_stream.GetBuffer();
-    }
-
-    const std::vector<u8>& GetBuffer() const {
-        return base_stream.GetBuffer();
-    }
-
-private:
-    u8 PeekByte();
-    Common::Stream base_stream{};
-    u32 low_value{};
-    u32 range{0xff};
-    s32 count{-24};
-    s32 half_probability{128};
-    static constexpr std::array<s32, 256> norm_lut{
-        0, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-        3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    };
-};
-
-class VpxBitStreamWriter {
-public:
-    VpxBitStreamWriter();
-    ~VpxBitStreamWriter();
-
-    /// Write an unsigned integer value
-    void WriteU(u32 value, u32 value_size);
-
-    /// Write a signed integer value
-    void WriteS(s32 value, u32 value_size);
-
-    /// Based on 6.2.10 of VP9 Spec, writes a delta coded value
-    void WriteDeltaQ(u32 value);
-
-    /// Write a single bit.
-    void WriteBit(bool state);
-
-    /// Pushes current buffer into buffer_array, resets buffer
-    void Flush();
-
-    /// Returns byte_array
-    std::vector<u8>& GetByteArray();
-
-    /// Returns const byte_array
-    const std::vector<u8>& GetByteArray() const;
-
-private:
-    /// Write bit_count bits from value into buffer
-    void WriteBits(u32 value, u32 bit_count);
-
-    /// Gets next available position in buffer, invokes Flush() if buffer is full
-    s32 GetFreeBufferBits();
-
-    s32 buffer_size{8};
-
-    s32 buffer{};
-    s32 buffer_pos{};
-    std::vector<u8> byte_array;
-};
-
-class VP9 {
-public:
-    explicit VP9(GPU& gpu);
-    ~VP9();
-
-    /// Composes the VP9 frame from the GPU state information. Based on the official VP9 spec
-    /// documentation
-    std::vector<u8>& ComposeFrameHeader(NvdecCommon::NvdecRegisters& state);
-
-    /// Returns true if the most recent frame was a hidden frame.
-    bool WasFrameHidden() const {
-        return hidden;
-    }
-
-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,
-                                const std::array<T, N>& old_prob);
-
-    /// Generates compressed header probability updates in the bitstream writer
-    /// If probs are not equal, WriteProbabilityDelta is invoked
-    void WriteProbabilityUpdate(VpxRangeEncoder& writer, u8 new_prob, u8 old_prob);
-
-    /// Generates compressed header probability deltas in the bitstream writer
-    void WriteProbabilityDelta(VpxRangeEncoder& writer, u8 new_prob, u8 old_prob);
-
-    /// Adjusts old_prob depending on new_prob. Based on section 6.3.5 of VP9 Specification
-    s32 RemapProbability(s32 new_prob, s32 old_prob);
-
-    /// Recenters probability. Based on section 6.3.6 of VP9 Specification
-    s32 RecenterNonNeg(s32 new_prob, s32 old_prob);
-
-    /// Inverse of 6.3.4 Decode term subexp
-    void EncodeTermSubExp(VpxRangeEncoder& writer, s32 value);
-
-    /// Writes if the value is less than the test value
-    bool WriteLessThan(VpxRangeEncoder& writer, s32 value, s32 test);
-
-    /// Writes probability updates for the Coef probabilities
-    void WriteCoefProbabilityUpdate(VpxRangeEncoder& writer, s32 tx_mode,
-                                    const std::array<u8, 2304>& new_prob,
-                                    const std::array<u8, 2304>& old_prob);
-
-    /// Write probabilities for 4-byte aligned structures
-    template <typename T, std::size_t N>
-    void WriteProbabilityUpdateAligned4(VpxRangeEncoder& writer, const std::array<T, N>& new_prob,
-                                        const std::array<T, N>& old_prob);
-
-    /// Write motion vector probability updates. 6.3.17 in the spec
-    void WriteMvProbabilityUpdate(VpxRangeEncoder& writer, u8 new_prob, u8 old_prob);
-
-    /// 6.2.14 Tile size calculation
-    s32 CalcMinLog2TileCols(s32 frame_width);
-    s32 CalcMaxLog2TileCols(s32 frame_width);
-
-    /// Returns VP9 information from NVDEC provided offset and size
-    Vp9PictureInfo GetVp9PictureInfo(const NvdecCommon::NvdecRegisters& state);
-
-    /// Read and convert NVDEC provided entropy probs to Vp9EntropyProbs struct
-    void InsertEntropy(u64 offset, Vp9EntropyProbs& dst);
-
-    /// Returns frame to be decoded after buffering
-    Vp9FrameContainer GetCurrentFrame(const NvdecCommon::NvdecRegisters& state);
-
-    /// Use NVDEC providied information to compose the headers for the current frame
-    std::vector<u8> ComposeCompressedHeader();
-    VpxBitStreamWriter ComposeUncompressedHeader();
-
-    GPU& gpu;
-    std::vector<u8> frame;
-
-    std::array<s8, 4> loop_filter_ref_deltas{};
-    std::array<s8, 2> loop_filter_mode_deltas{};
-
-    bool hidden;
-    s64 current_frame_number = -2; // since we buffer 2 frames
-    s32 grace_period = 6;          // frame offsets need to stabilize
-    std::array<FrameContexts, 4> frame_ctxs{};
-    Vp9FrameContainer next_frame{};
-    Vp9FrameContainer next_next_frame{};
-    bool swap_next_golden{};
-
-    Vp9PictureInfo current_frame_info{};
-    Vp9EntropyProbs prev_frame_probs{};
-
-    s32 diff_update_probability = 252;
-    s32 frame_sync_code = 0x498342;
-    static constexpr std::array<s32, 254> map_lut = {
-        20,  21,  22,  23,  24,  25,  0,   26,  27,  28,  29,  30,  31,  32,  33,  34,  35,
-        36,  37,  1,   38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  2,   50,
-        51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  3,   62,  63,  64,  65,  66,
-        67,  68,  69,  70,  71,  72,  73,  4,   74,  75,  76,  77,  78,  79,  80,  81,  82,
-        83,  84,  85,  5,   86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  6,
-        98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 7,   110, 111, 112, 113,
-        114, 115, 116, 117, 118, 119, 120, 121, 8,   122, 123, 124, 125, 126, 127, 128, 129,
-        130, 131, 132, 133, 9,   134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
-        10,  146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 11,  158, 159, 160,
-        161, 162, 163, 164, 165, 166, 167, 168, 169, 12,  170, 171, 172, 173, 174, 175, 176,
-        177, 178, 179, 180, 181, 13,  182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
-        193, 14,  194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 15,  206, 207,
-        208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 16,  218, 219, 220, 221, 222, 223,
-        224, 225, 226, 227, 228, 229, 17,  230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
-        240, 241, 18,  242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 19,
-    };
-};
-
-} // namespace Decoder
-} // namespace Tegra

src/video_core/command_classes/codecs/vp9_types.h

@@ -1,369 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-#include <list>
-#include <vector>
-#include "common/cityhash.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "video_core/command_classes/nvdec_common.h"
-
-namespace Tegra {
-class GPU;
-
-namespace Decoder {
-struct Vp9FrameDimensions {
-    s16 width{};
-    s16 height{};
-    s16 luma_pitch{};
-    s16 chroma_pitch{};
-};
-static_assert(sizeof(Vp9FrameDimensions) == 0x8, "Vp9 Vp9FrameDimensions is an invalid size");
-
-enum FrameFlags : u32 {
-    IsKeyFrame = 1 << 0,
-    LastFrameIsKeyFrame = 1 << 1,
-    FrameSizeChanged = 1 << 2,
-    ErrorResilientMode = 1 << 3,
-    LastShowFrame = 1 << 4,
-    IntraOnly = 1 << 5,
-};
-
-enum class MvJointType {
-    MvJointZero = 0,   /* Zero vector */
-    MvJointHnzvz = 1,  /* Vert zero, hor nonzero */
-    MvJointHzvnz = 2,  /* Hor zero, vert nonzero */
-    MvJointHnzvnz = 3, /* Both components nonzero */
-};
-enum class MvClassType {
-    MvClass0 = 0,   /* (0, 2]     integer pel */
-    MvClass1 = 1,   /* (2, 4]     integer pel */
-    MvClass2 = 2,   /* (4, 8]     integer pel */
-    MvClass3 = 3,   /* (8, 16]    integer pel */
-    MvClass4 = 4,   /* (16, 32]   integer pel */
-    MvClass5 = 5,   /* (32, 64]   integer pel */
-    MvClass6 = 6,   /* (64, 128]  integer pel */
-    MvClass7 = 7,   /* (128, 256] integer pel */
-    MvClass8 = 8,   /* (256, 512] integer pel */
-    MvClass9 = 9,   /* (512, 1024] integer pel */
-    MvClass10 = 10, /* (1024,2048] integer pel */
-};
-
-enum class BlockSize {
-    Block4x4 = 0,
-    Block4x8 = 1,
-    Block8x4 = 2,
-    Block8x8 = 3,
-    Block8x16 = 4,
-    Block16x8 = 5,
-    Block16x16 = 6,
-    Block16x32 = 7,
-    Block32x16 = 8,
-    Block32x32 = 9,
-    Block32x64 = 10,
-    Block64x32 = 11,
-    Block64x64 = 12,
-    BlockSizes = 13,
-    BlockInvalid = BlockSizes
-};
-
-enum class PredictionMode {
-    DcPred = 0,   // Average of above and left pixels
-    VPred = 1,    // Vertical
-    HPred = 2,    // Horizontal
-    D45Pred = 3,  // Directional 45  deg = round(arctan(1 / 1) * 180 / pi)
-    D135Pred = 4, // Directional 135 deg = 180 - 45
-    D117Pred = 5, // Directional 117 deg = 180 - 63
-    D153Pred = 6, // Directional 153 deg = 180 - 27
-    D207Pred = 7, // Directional 207 deg = 180 + 27
-    D63Pred = 8,  // Directional 63  deg = round(arctan(2 / 1) * 180 / pi)
-    TmPred = 9,   // True-motion
-    NearestMv = 10,
-    NearMv = 11,
-    ZeroMv = 12,
-    NewMv = 13,
-    MbModeCount = 14
-};
-
-enum class TxSize {
-    Tx4x4 = 0,   // 4x4 transform
-    Tx8x8 = 1,   // 8x8 transform
-    Tx16x16 = 2, // 16x16 transform
-    Tx32x32 = 3, // 32x32 transform
-    TxSizes = 4
-};
-
-enum class TxMode {
-    Only4X4 = 0,      // Only 4x4 transform used
-    Allow8X8 = 1,     // Allow block transform size up to 8x8
-    Allow16X16 = 2,   // Allow block transform size up to 16x16
-    Allow32X32 = 3,   // Allow block transform size up to 32x32
-    TxModeSelect = 4, // Transform specified for each block
-    TxModes = 5
-};
-
-enum class reference_mode {
-    SingleReference = 0,
-    CompoundReference = 1,
-    ReferenceModeSelect = 2,
-    ReferenceModes = 3
-};
-
-struct Segmentation {
-    u8 enabled{};
-    u8 update_map{};
-    u8 temporal_update{};
-    u8 abs_delta{};
-    std::array<u32, 8> feature_mask{};
-    std::array<std::array<s16, 4>, 8> feature_data{};
-};
-static_assert(sizeof(Segmentation) == 0x64, "Segmentation is an invalid size");
-
-struct LoopFilter {
-    u8 mode_ref_delta_enabled{};
-    std::array<s8, 4> ref_deltas{};
-    std::array<s8, 2> mode_deltas{};
-};
-static_assert(sizeof(LoopFilter) == 0x7, "LoopFilter is an invalid size");
-
-struct Vp9EntropyProbs {
-    std::array<u8, 36> y_mode_prob{};
-    std::array<u8, 64> partition_prob{};
-    std::array<u8, 2304> coef_probs{};
-    std::array<u8, 8> switchable_interp_prob{};
-    std::array<u8, 28> inter_mode_prob{};
-    std::array<u8, 4> intra_inter_prob{};
-    std::array<u8, 5> comp_inter_prob{};
-    std::array<u8, 10> single_ref_prob{};
-    std::array<u8, 5> comp_ref_prob{};
-    std::array<u8, 6> tx_32x32_prob{};
-    std::array<u8, 4> tx_16x16_prob{};
-    std::array<u8, 2> tx_8x8_prob{};
-    std::array<u8, 3> skip_probs{};
-    std::array<u8, 3> joints{};
-    std::array<u8, 2> sign{};
-    std::array<u8, 20> classes{};
-    std::array<u8, 2> class_0{};
-    std::array<u8, 20> prob_bits{};
-    std::array<u8, 12> class_0_fr{};
-    std::array<u8, 6> fr{};
-    std::array<u8, 2> class_0_hp{};
-    std::array<u8, 2> high_precision{};
-};
-static_assert(sizeof(Vp9EntropyProbs) == 0x9F4, "Vp9EntropyProbs is an invalid size");
-
-struct Vp9PictureInfo {
-    bool is_key_frame{};
-    bool intra_only{};
-    bool last_frame_was_key{};
-    bool frame_size_changed{};
-    bool error_resilient_mode{};
-    bool last_frame_shown{};
-    bool show_frame{};
-    std::array<s8, 4> ref_frame_sign_bias{};
-    s32 base_q_index{};
-    s32 y_dc_delta_q{};
-    s32 uv_dc_delta_q{};
-    s32 uv_ac_delta_q{};
-    bool lossless{};
-    s32 transform_mode{};
-    bool allow_high_precision_mv{};
-    s32 interp_filter{};
-    s32 reference_mode{};
-    s8 comp_fixed_ref{};
-    std::array<s8, 2> comp_var_ref{};
-    s32 log2_tile_cols{};
-    s32 log2_tile_rows{};
-    bool segment_enabled{};
-    bool segment_map_update{};
-    bool segment_map_temporal_update{};
-    s32 segment_abs_delta{};
-    std::array<u32, 8> segment_feature_enable{};
-    std::array<std::array<s16, 4>, 8> segment_feature_data{};
-    bool mode_ref_delta_enabled{};
-    bool use_prev_in_find_mv_refs{};
-    std::array<s8, 4> ref_deltas{};
-    std::array<s8, 2> mode_deltas{};
-    Vp9EntropyProbs entropy{};
-    Vp9FrameDimensions frame_size{};
-    u8 first_level{};
-    u8 sharpness_level{};
-    u32 bitstream_size{};
-    std::array<u64, 4> frame_offsets{};
-    std::array<bool, 4> refresh_frame{};
-};
-
-struct Vp9FrameContainer {
-    Vp9PictureInfo info{};
-    std::vector<u8> bit_stream;
-};
-
-struct PictureInfo {
-    INSERT_PADDING_WORDS(12);
-    u32 bitstream_size{};
-    INSERT_PADDING_WORDS(5);
-    Vp9FrameDimensions last_frame_size{};
-    Vp9FrameDimensions golden_frame_size{};
-    Vp9FrameDimensions alt_frame_size{};
-    Vp9FrameDimensions current_frame_size{};
-    u32 vp9_flags{};
-    std::array<s8, 4> ref_frame_sign_bias{};
-    u8 first_level{};
-    u8 sharpness_level{};
-    u8 base_q_index{};
-    u8 y_dc_delta_q{};
-    u8 uv_ac_delta_q{};
-    u8 uv_dc_delta_q{};
-    u8 lossless{};
-    u8 tx_mode{};
-    u8 allow_high_precision_mv{};
-    u8 interp_filter{};
-    u8 reference_mode{};
-    s8 comp_fixed_ref{};
-    std::array<s8, 2> comp_var_ref{};
-    u8 log2_tile_cols{};
-    u8 log2_tile_rows{};
-    Segmentation segmentation{};
-    LoopFilter loop_filter{};
-    INSERT_PADDING_BYTES(5);
-    u32 surface_params{};
-    INSERT_PADDING_WORDS(3);
-
-    Vp9PictureInfo Convert() const {
-
-        return Vp9PictureInfo{
-            .is_key_frame = (vp9_flags & FrameFlags::IsKeyFrame) != 0,
-            .intra_only = (vp9_flags & FrameFlags::IntraOnly) != 0,
-            .last_frame_was_key = (vp9_flags & FrameFlags::LastFrameIsKeyFrame) != 0,
-            .frame_size_changed = (vp9_flags & FrameFlags::FrameSizeChanged) != 0,
-            .error_resilient_mode = (vp9_flags & FrameFlags::ErrorResilientMode) != 0,
-            .last_frame_shown = (vp9_flags & FrameFlags::LastShowFrame) != 0,
-            .ref_frame_sign_bias = ref_frame_sign_bias,
-            .base_q_index = base_q_index,
-            .y_dc_delta_q = y_dc_delta_q,
-            .uv_dc_delta_q = uv_dc_delta_q,
-            .uv_ac_delta_q = uv_ac_delta_q,
-            .lossless = lossless != 0,
-            .transform_mode = tx_mode,
-            .allow_high_precision_mv = allow_high_precision_mv != 0,
-            .interp_filter = interp_filter,
-            .reference_mode = reference_mode,
-            .comp_fixed_ref = comp_fixed_ref,
-            .comp_var_ref = comp_var_ref,
-            .log2_tile_cols = log2_tile_cols,
-            .log2_tile_rows = log2_tile_rows,
-            .segment_enabled = segmentation.enabled != 0,
-            .segment_map_update = segmentation.update_map != 0,
-            .segment_map_temporal_update = segmentation.temporal_update != 0,
-            .segment_abs_delta = segmentation.abs_delta,
-            .segment_feature_enable = segmentation.feature_mask,
-            .segment_feature_data = segmentation.feature_data,
-            .mode_ref_delta_enabled = loop_filter.mode_ref_delta_enabled != 0,
-            .use_prev_in_find_mv_refs = !(vp9_flags == (FrameFlags::ErrorResilientMode)) &&
-                                        !(vp9_flags == (FrameFlags::FrameSizeChanged)) &&
-                                        !(vp9_flags == (FrameFlags::IntraOnly)) &&
-                                        (vp9_flags == (FrameFlags::LastShowFrame)) &&
-                                        !(vp9_flags == (FrameFlags::LastFrameIsKeyFrame)),
-            .ref_deltas = loop_filter.ref_deltas,
-            .mode_deltas = loop_filter.mode_deltas,
-            .frame_size = current_frame_size,
-            .first_level = first_level,
-            .sharpness_level = sharpness_level,
-            .bitstream_size = bitstream_size,
-        };
-    }
-};
-static_assert(sizeof(PictureInfo) == 0x100, "PictureInfo is an invalid size");
-
-struct EntropyProbs {
-    INSERT_PADDING_BYTES(1024);
-    std::array<std::array<u8, 4>, 7> inter_mode_prob{};
-    std::array<u8, 4> intra_inter_prob{};
-    INSERT_PADDING_BYTES(80);
-    std::array<std::array<u8, 1>, 2> tx_8x8_prob{};
-    std::array<std::array<u8, 2>, 2> tx_16x16_prob{};
-    std::array<std::array<u8, 3>, 2> tx_32x32_prob{};
-    std::array<u8, 4> y_mode_prob_e8{};
-    std::array<std::array<u8, 8>, 4> y_mode_prob_e0e7{};
-    INSERT_PADDING_BYTES(64);
-    std::array<std::array<u8, 4>, 16> partition_prob{};
-    INSERT_PADDING_BYTES(10);
-    std::array<std::array<u8, 2>, 4> switchable_interp_prob{};
-    std::array<u8, 5> comp_inter_prob{};
-    std::array<u8, 4> skip_probs{};
-    std::array<u8, 3> joints{};
-    std::array<u8, 2> sign{};
-    std::array<std::array<u8, 1>, 2> class_0{};
-    std::array<std::array<u8, 3>, 2> fr{};
-    std::array<u8, 2> class_0_hp{};
-    std::array<u8, 2> high_precision{};
-    std::array<std::array<u8, 10>, 2> classes{};
-    std::array<std::array<std::array<u8, 3>, 2>, 2> class_0_fr{};
-    std::array<std::array<u8, 10>, 2> pred_bits{};
-    std::array<std::array<u8, 2>, 5> single_ref_prob{};
-    std::array<u8, 5> comp_ref_prob{};
-    INSERT_PADDING_BYTES(17);
-    std::array<std::array<std::array<std::array<std::array<std::array<u8, 4>, 6>, 6>, 2>, 2>, 4>
-        coef_probs{};
-
-    void Convert(Vp9EntropyProbs& fc) {
-        std::memcpy(fc.inter_mode_prob.data(), inter_mode_prob.data(), fc.inter_mode_prob.size());
-
-        std::memcpy(fc.intra_inter_prob.data(), intra_inter_prob.data(),
-                    fc.intra_inter_prob.size());
-
-        std::memcpy(fc.tx_8x8_prob.data(), tx_8x8_prob.data(), fc.tx_8x8_prob.size());
-        std::memcpy(fc.tx_16x16_prob.data(), tx_16x16_prob.data(), fc.tx_16x16_prob.size());
-        std::memcpy(fc.tx_32x32_prob.data(), tx_32x32_prob.data(), fc.tx_32x32_prob.size());
-
-        for (s32 i = 0; i < 4; i++) {
-            for (s32 j = 0; j < 9; j++) {
-                fc.y_mode_prob[j + 9 * i] = j < 8 ? y_mode_prob_e0e7[i][j] : y_mode_prob_e8[i];
-            }
-        }
-
-        std::memcpy(fc.partition_prob.data(), partition_prob.data(), fc.partition_prob.size());
-
-        std::memcpy(fc.switchable_interp_prob.data(), switchable_interp_prob.data(),
-                    fc.switchable_interp_prob.size());
-        std::memcpy(fc.comp_inter_prob.data(), comp_inter_prob.data(), fc.comp_inter_prob.size());
-        std::memcpy(fc.skip_probs.data(), skip_probs.data(), fc.skip_probs.size());
-
-        std::memcpy(fc.joints.data(), joints.data(), fc.joints.size());
-
-        std::memcpy(fc.sign.data(), sign.data(), fc.sign.size());
-        std::memcpy(fc.class_0.data(), class_0.data(), fc.class_0.size());
-        std::memcpy(fc.fr.data(), fr.data(), fc.fr.size());
-        std::memcpy(fc.class_0_hp.data(), class_0_hp.data(), fc.class_0_hp.size());
-        std::memcpy(fc.high_precision.data(), high_precision.data(), fc.high_precision.size());
-        std::memcpy(fc.classes.data(), classes.data(), fc.classes.size());
-        std::memcpy(fc.class_0_fr.data(), class_0_fr.data(), fc.class_0_fr.size());
-        std::memcpy(fc.prob_bits.data(), pred_bits.data(), fc.prob_bits.size());
-        std::memcpy(fc.single_ref_prob.data(), single_ref_prob.data(), fc.single_ref_prob.size());
-        std::memcpy(fc.comp_ref_prob.data(), comp_ref_prob.data(), fc.comp_ref_prob.size());
-
-        std::memcpy(fc.coef_probs.data(), coef_probs.data(), fc.coef_probs.size());
-    }
-};
-static_assert(sizeof(EntropyProbs) == 0xEA0, "EntropyProbs is an invalid size");
-
-enum class Ref { Last, Golden, AltRef };
-
-struct RefPoolElement {
-    s64 frame{};
-    Ref ref{};
-    bool refresh{};
-};
-
-struct FrameContexts {
-    s64 from{};
-    bool adapted{};
-    Vp9EntropyProbs probs{};
-};
-
-}; // namespace Decoder
-}; // namespace Tegra

src/video_core/command_classes/host1x.cpp

@@ -1,39 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "video_core/command_classes/host1x.h"
-#include "video_core/gpu.h"
-
-Tegra::Host1x::Host1x(GPU& gpu_) : gpu(gpu_) {}
-
-Tegra::Host1x::~Host1x() = default;
-
-void Tegra::Host1x::StateWrite(u32 offset, u32 arguments) {
-    u8* const state_offset = reinterpret_cast<u8*>(&state) + offset * sizeof(u32);
-    std::memcpy(state_offset, &arguments, sizeof(u32));
-}
-
-void Tegra::Host1x::ProcessMethod(Host1x::Method method, const std::vector<u32>& arguments) {
-    StateWrite(static_cast<u32>(method), arguments[0]);
-    switch (method) {
-    case Method::WaitSyncpt:
-        Execute(arguments[0]);
-        break;
-    case Method::LoadSyncptPayload32:
-        syncpoint_value = arguments[0];
-        break;
-    case Method::WaitSyncpt32:
-        Execute(arguments[0]);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Host1x method 0x{:X}", static_cast<u32>(method));
-        break;
-    }
-}
-
-void Tegra::Host1x::Execute(u32 data) {
-    // This method waits on a valid syncpoint.
-    // TODO: Implement when proper Async is in place
-}

src/video_core/command_classes/host1x.h

@@ -1,78 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-
-namespace Tegra {
-class GPU;
-class Nvdec;
-
-class Host1x {
-public:
-    struct Host1xClassRegisters {
-        u32 incr_syncpt{};
-        u32 incr_syncpt_ctrl{};
-        u32 incr_syncpt_error{};
-        INSERT_PADDING_WORDS(5);
-        u32 wait_syncpt{};
-        u32 wait_syncpt_base{};
-        u32 wait_syncpt_incr{};
-        u32 load_syncpt_base{};
-        u32 incr_syncpt_base{};
-        u32 clear{};
-        u32 wait{};
-        u32 wait_with_interrupt{};
-        u32 delay_use{};
-        u32 tick_count_high{};
-        u32 tick_count_low{};
-        u32 tick_ctrl{};
-        INSERT_PADDING_WORDS(23);
-        u32 ind_ctrl{};
-        u32 ind_off2{};
-        u32 ind_off{};
-        std::array<u32, 31> ind_data{};
-        INSERT_PADDING_WORDS(1);
-        u32 load_syncpoint_payload32{};
-        u32 stall_ctrl{};
-        u32 wait_syncpt32{};
-        u32 wait_syncpt_base32{};
-        u32 load_syncpt_base32{};
-        u32 incr_syncpt_base32{};
-        u32 stall_count_high{};
-        u32 stall_count_low{};
-        u32 xref_ctrl{};
-        u32 channel_xref_high{};
-        u32 channel_xref_low{};
-    };
-    static_assert(sizeof(Host1xClassRegisters) == 0x164, "Host1xClassRegisters is an invalid size");
-
-    enum class Method : u32 {
-        WaitSyncpt = offsetof(Host1xClassRegisters, wait_syncpt) / 4,
-        LoadSyncptPayload32 = offsetof(Host1xClassRegisters, load_syncpoint_payload32) / 4,
-        WaitSyncpt32 = offsetof(Host1xClassRegisters, wait_syncpt32) / 4,
-    };
-
-    explicit Host1x(GPU& gpu);
-    ~Host1x();
-
-    /// Writes the method into the state, Invoke Execute() if encountered
-    void ProcessMethod(Host1x::Method method, const std::vector<u32>& arguments);
-
-private:
-    /// For Host1x, execute is waiting on a syncpoint previously written into the state
-    void Execute(u32 data);
-
-    /// Write argument into the provided offset
-    void StateWrite(u32 offset, u32 arguments);
-
-    u32 syncpoint_value{};
-    Host1xClassRegisters state{};
-    GPU& gpu;
-};
-
-} // namespace Tegra

src/video_core/command_classes/nvdec.cpp

@@ -1,56 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <bitset>
-#include "common/assert.h"
-#include "common/bit_util.h"
-#include "core/memory.h"
-#include "video_core/command_classes/nvdec.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
-
-namespace Tegra {
-
-Nvdec::Nvdec(GPU& gpu_) : gpu(gpu_), codec(std::make_unique<Codec>(gpu)) {}
-
-Nvdec::~Nvdec() = default;
-
-void Nvdec::ProcessMethod(Nvdec::Method method, const std::vector<u32>& arguments) {
-    if (method == Method::SetVideoCodec) {
-        codec->StateWrite(static_cast<u32>(method), arguments[0]);
-    } else {
-        codec->StateWrite(static_cast<u32>(method), static_cast<u64>(arguments[0]) << 8);
-    }
-
-    switch (method) {
-    case Method::SetVideoCodec:
-        codec->SetTargetCodec(static_cast<NvdecCommon::VideoCodec>(arguments[0]));
-        break;
-    case Method::Execute:
-        Execute();
-        break;
-    }
-}
-
-AVFrame* Nvdec::GetFrame() {
-    return codec->GetCurrentFrame();
-}
-
-const AVFrame* Nvdec::GetFrame() const {
-    return codec->GetCurrentFrame();
-}
-
-void Nvdec::Execute() {
-    switch (codec->GetCurrentCodec()) {
-    case NvdecCommon::VideoCodec::H264:
-    case NvdecCommon::VideoCodec::Vp9:
-        codec->Decode();
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unknown codec {}", static_cast<u32>(codec->GetCurrentCodec()));
-        break;
-    }
-}
-
-} // namespace Tegra

src/video_core/command_classes/nvdec.h

@@ -1,39 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "video_core/command_classes/codecs/codec.h"
-
-namespace Tegra {
-class GPU;
-
-class Nvdec {
-public:
-    enum class Method : u32 {
-        SetVideoCodec = 0x80,
-        Execute = 0xc0,
-    };
-
-    explicit Nvdec(GPU& gpu);
-    ~Nvdec();
-
-    /// Writes the method into the state, Invoke Execute() if encountered
-    void ProcessMethod(Nvdec::Method method, const std::vector<u32>& arguments);
-
-    /// Return most recently decoded frame
-    AVFrame* GetFrame();
-    const AVFrame* GetFrame() const;
-
-private:
-    /// Invoke codec to decode a frame
-    void Execute();
-
-    GPU& gpu;
-    std::unique_ptr<Tegra::Codec> codec;
-};
-} // namespace Tegra

src/video_core/command_classes/nvdec_common.h

@@ -1,48 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-
-namespace Tegra::NvdecCommon {
-
-struct NvdecRegisters {
-    INSERT_PADDING_WORDS(256);
-    u64 set_codec_id{};
-    INSERT_PADDING_WORDS(254);
-    u64 set_platform_id{};
-    u64 picture_info_offset{};
-    u64 frame_bitstream_offset{};
-    u64 frame_number{};
-    u64 h264_slice_data_offsets{};
-    u64 h264_mv_dump_offset{};
-    INSERT_PADDING_WORDS(6);
-    u64 frame_stats_offset{};
-    u64 h264_last_surface_luma_offset{};
-    u64 h264_last_surface_chroma_offset{};
-    std::array<u64, 17> surface_luma_offset{};
-    std::array<u64, 17> surface_chroma_offset{};
-    INSERT_PADDING_WORDS(132);
-    u64 vp9_entropy_probs_offset{};
-    u64 vp9_backward_updates_offset{};
-    u64 vp9_last_frame_segmap_offset{};
-    u64 vp9_curr_frame_segmap_offset{};
-    INSERT_PADDING_WORDS(2);
-    u64 vp9_last_frame_mvs_offset{};
-    u64 vp9_curr_frame_mvs_offset{};
-    INSERT_PADDING_WORDS(2);
-};
-static_assert(sizeof(NvdecRegisters) == (0xBC0), "NvdecRegisters is incorrect size");
-
-enum class VideoCodec : u32 {
-    None = 0x0,
-    H264 = 0x3,
-    Vp8 = 0x5,
-    H265 = 0x7,
-    Vp9 = 0x9,
-};
-
-} // namespace Tegra::NvdecCommon

src/video_core/command_classes/sync_manager.cpp

@@ -1,60 +0,0 @@
-// MIT License
-//
-// Copyright (c) Ryujinx Team and Contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-// associated documentation files (the "Software"), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute,
-// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-#include <algorithm>
-#include "sync_manager.h"
-#include "video_core/gpu.h"
-
-namespace Tegra {
-SyncptIncrManager::SyncptIncrManager(GPU& gpu_) : gpu(gpu_) {}
-SyncptIncrManager::~SyncptIncrManager() = default;
-
-void SyncptIncrManager::Increment(u32 id) {
-    increments.push_back(SyncptIncr{0, id, true});
-    IncrementAllDone();
-}
-
-u32 SyncptIncrManager::IncrementWhenDone(u32 class_id, u32 id) {
-    const u32 handle = current_id++;
-    increments.push_back(SyncptIncr{handle, class_id, id});
-    return handle;
-}
-
-void SyncptIncrManager::SignalDone(u32 handle) {
-    auto done_incr = std::find_if(increments.begin(), increments.end(),
-                                  [handle](SyncptIncr incr) { return incr.id == handle; });
-    if (done_incr != increments.end()) {
-        const SyncptIncr incr = *done_incr;
-        *done_incr = SyncptIncr{incr.id, incr.class_id, incr.syncpt_id, true};
-    }
-    IncrementAllDone();
-}
-
-void SyncptIncrManager::IncrementAllDone() {
-    std::size_t done_count = 0;
-    for (; done_count < increments.size(); ++done_count) {
-        if (!increments[done_count].complete) {
-            break;
-        }
-        gpu.IncrementSyncPoint(increments[done_count].syncpt_id);
-    }
-    increments.erase(increments.begin(), increments.begin() + done_count);
-}
-} // namespace Tegra

src/video_core/command_classes/sync_manager.h

@@ -1,64 +0,0 @@
-// MIT License
-//
-// Copyright (c) Ryujinx Team and Contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-// associated documentation files (the "Software"), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute,
-// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or
-// substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-#pragma once
-
-#include <mutex>
-#include <vector>
-#include "common/common_types.h"
-
-namespace Tegra {
-class GPU;
-struct SyncptIncr {
-    u32 id;
-    u32 class_id;
-    u32 syncpt_id;
-    bool complete;
-
-    SyncptIncr(u32 id, u32 syncpt_id_, u32 class_id_, bool done = false)
-        : id(id), class_id(class_id_), syncpt_id(syncpt_id_), complete(done) {}
-};
-
-class SyncptIncrManager {
-public:
-    explicit SyncptIncrManager(GPU& gpu);
-    ~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{};
-
-    GPU& gpu;
-};
-
-} // namespace Tegra

src/video_core/command_classes/vic.cpp

@@ -1,180 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include "common/assert.h"
-#include "video_core/command_classes/nvdec.h"
-#include "video_core/command_classes/vic.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
-#include "video_core/texture_cache/surface_params.h"
-
-extern "C" {
-#include <libswscale/swscale.h>
-}
-
-namespace Tegra {
-
-Vic::Vic(GPU& gpu_, std::shared_ptr<Nvdec> nvdec_processor_)
-    : gpu(gpu_), nvdec_processor(std::move(nvdec_processor_)) {}
-Vic::~Vic() = default;
-
-void Vic::VicStateWrite(u32 offset, u32 arguments) {
-    u8* const state_offset = reinterpret_cast<u8*>(&vic_state) + offset * sizeof(u32);
-    std::memcpy(state_offset, &arguments, sizeof(u32));
-}
-
-void Vic::ProcessMethod(Vic::Method method, const std::vector<u32>& arguments) {
-    LOG_DEBUG(HW_GPU, "Vic method 0x{:X}", static_cast<u32>(method));
-    VicStateWrite(static_cast<u32>(method), arguments[0]);
-    const u64 arg = static_cast<u64>(arguments[0]) << 8;
-    switch (method) {
-    case Method::Execute:
-        Execute();
-        break;
-    case Method::SetConfigStructOffset:
-        config_struct_address = arg;
-        break;
-    case Method::SetOutputSurfaceLumaOffset:
-        output_surface_luma_address = arg;
-        break;
-    case Method::SetOutputSurfaceChromaUOffset:
-        output_surface_chroma_u_address = arg;
-        break;
-    case Method::SetOutputSurfaceChromaVOffset:
-        output_surface_chroma_v_address = arg;
-        break;
-    default:
-        break;
-    }
-}
-
-void Vic::Execute() {
-    if (output_surface_luma_address == 0) {
-        LOG_ERROR(Service_NVDRV, "VIC Luma address not set. Recieved 0x{:X}",
-                  vic_state.output_surface.luma_offset);
-        return;
-    }
-    const VicConfig config{gpu.MemoryManager().Read<u64>(config_struct_address + 0x20)};
-    const VideoPixelFormat pixel_format =
-        static_cast<VideoPixelFormat>(config.pixel_format.Value());
-    switch (pixel_format) {
-    case VideoPixelFormat::BGRA8:
-    case VideoPixelFormat::RGBA8: {
-        LOG_TRACE(Service_NVDRV, "Writing RGB Frame");
-        const auto* frame = nvdec_processor->GetFrame();
-
-        if (!frame || frame->width == 0 || frame->height == 0) {
-            return;
-        }
-        if (scaler_ctx == nullptr || frame->width != scaler_width ||
-            frame->height != scaler_height) {
-            const AVPixelFormat target_format =
-                (pixel_format == VideoPixelFormat::RGBA8) ? AV_PIX_FMT_RGBA : AV_PIX_FMT_BGRA;
-
-            sws_freeContext(scaler_ctx);
-            scaler_ctx = nullptr;
-
-            // FFmpeg returns all frames in YUV420, convert it into expected format
-            scaler_ctx =
-                sws_getContext(frame->width, frame->height, AV_PIX_FMT_YUV420P, frame->width,
-                               frame->height, target_format, 0, nullptr, nullptr, nullptr);
-
-            scaler_width = frame->width;
-            scaler_height = frame->height;
-        }
-        // Get Converted frame
-        const std::size_t linear_size = frame->width * frame->height * 4;
-
-        using AVMallocPtr = std::unique_ptr<u8, decltype(&av_free)>;
-        AVMallocPtr converted_frame_buffer{static_cast<u8*>(av_malloc(linear_size)), av_free};
-
-        const int converted_stride{frame->width * 4};
-        u8* const converted_frame_buf_addr{converted_frame_buffer.get()};
-
-        sws_scale(scaler_ctx, frame->data, frame->linesize, 0, frame->height,
-                  &converted_frame_buf_addr, &converted_stride);
-
-        const u32 blk_kind = static_cast<u32>(config.block_linear_kind);
-        if (blk_kind != 0) {
-            // swizzle pitch linear to block linear
-            const u32 block_height = static_cast<u32>(config.block_linear_height_log2);
-            const auto size = Tegra::Texture::CalculateSize(true, 4, frame->width, frame->height, 1,
-                                                            block_height, 0);
-            std::vector<u8> swizzled_data(size);
-            Tegra::Texture::CopySwizzledData(frame->width, frame->height, 1, 4, 4,
-                                             swizzled_data.data(), converted_frame_buffer.get(),
-                                             false, block_height, 0, 1);
-
-            gpu.MemoryManager().WriteBlock(output_surface_luma_address, swizzled_data.data(), size);
-            gpu.Maxwell3D().OnMemoryWrite();
-        } else {
-            // send pitch linear frame
-            gpu.MemoryManager().WriteBlock(output_surface_luma_address, converted_frame_buf_addr,
-                                           linear_size);
-            gpu.Maxwell3D().OnMemoryWrite();
-        }
-        break;
-    }
-    case VideoPixelFormat::Yuv420: {
-        LOG_TRACE(Service_NVDRV, "Writing YUV420 Frame");
-
-        const auto* frame = nvdec_processor->GetFrame();
-
-        if (!frame || frame->width == 0 || frame->height == 0) {
-            return;
-        }
-
-        const std::size_t surface_width = config.surface_width_minus1 + 1;
-        const std::size_t surface_height = config.surface_height_minus1 + 1;
-        const std::size_t half_width = surface_width / 2;
-        const std::size_t half_height = config.surface_height_minus1 / 2;
-        const std::size_t aligned_width = (surface_width + 0xff) & ~0xff;
-
-        const auto* luma_ptr = frame->data[0];
-        const auto* chroma_b_ptr = frame->data[1];
-        const auto* chroma_r_ptr = frame->data[2];
-        const auto stride = frame->linesize[0];
-        const auto half_stride = frame->linesize[1];
-
-        std::vector<u8> luma_buffer(aligned_width * surface_height);
-        std::vector<u8> chroma_buffer(aligned_width * half_height);
-
-        // Populate luma buffer
-        for (std::size_t y = 0; y < surface_height - 1; ++y) {
-            std::size_t src = y * stride;
-            std::size_t dst = y * aligned_width;
-
-            std::size_t size = surface_width;
-
-            for (std::size_t offset = 0; offset < size; ++offset) {
-                luma_buffer[dst + offset] = luma_ptr[src + offset];
-            }
-        }
-        gpu.MemoryManager().WriteBlock(output_surface_luma_address, luma_buffer.data(),
-                                       luma_buffer.size());
-
-        // Populate chroma buffer from both channels with interleaving.
-        for (std::size_t y = 0; y < half_height; ++y) {
-            std::size_t src = y * half_stride;
-            std::size_t dst = y * aligned_width;
-
-            for (std::size_t x = 0; x < half_width; ++x) {
-                chroma_buffer[dst + x * 2] = chroma_b_ptr[src + x];
-                chroma_buffer[dst + x * 2 + 1] = chroma_r_ptr[src + x];
-            }
-        }
-        gpu.MemoryManager().WriteBlock(output_surface_chroma_u_address, chroma_buffer.data(),
-                                       chroma_buffer.size());
-        gpu.Maxwell3D().OnMemoryWrite();
-        break;
-    }
-    default:
-        UNIMPLEMENTED_MSG("Unknown video pixel format {}", config.pixel_format.Value());
-        break;
-    }
-}
-
-} // namespace Tegra

src/video_core/command_classes/vic.h

@@ -1,110 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-
-struct SwsContext;
-
-namespace Tegra {
-class GPU;
-class Nvdec;
-
-struct PlaneOffsets {
-    u32 luma_offset{};
-    u32 chroma_u_offset{};
-    u32 chroma_v_offset{};
-};
-
-struct VicRegisters {
-    INSERT_PADDING_WORDS(64);
-    u32 nop{};
-    INSERT_PADDING_WORDS(15);
-    u32 pm_trigger{};
-    INSERT_PADDING_WORDS(47);
-    u32 set_application_id{};
-    u32 set_watchdog_timer{};
-    INSERT_PADDING_WORDS(17);
-    u32 context_save_area{};
-    u32 context_switch{};
-    INSERT_PADDING_WORDS(43);
-    u32 execute{};
-    INSERT_PADDING_WORDS(63);
-    std::array<std::array<PlaneOffsets, 8>, 8> surfacex_slots{};
-    u32 picture_index{};
-    u32 control_params{};
-    u32 config_struct_offset{};
-    u32 filter_struct_offset{};
-    u32 palette_offset{};
-    u32 hist_offset{};
-    u32 context_id{};
-    u32 fce_ucode_size{};
-    PlaneOffsets output_surface{};
-    u32 fce_ucode_offset{};
-    INSERT_PADDING_WORDS(4);
-    std::array<u32, 8> slot_context_id{};
-    INSERT_PADDING_WORDS(16);
-};
-static_assert(sizeof(VicRegisters) == 0x7A0, "VicRegisters is an invalid size");
-
-class Vic {
-public:
-    enum class Method : u32 {
-        Execute = 0xc0,
-        SetControlParams = 0x1c1,
-        SetConfigStructOffset = 0x1c2,
-        SetOutputSurfaceLumaOffset = 0x1c8,
-        SetOutputSurfaceChromaUOffset = 0x1c9,
-        SetOutputSurfaceChromaVOffset = 0x1ca
-    };
-
-    explicit Vic(GPU& gpu, std::shared_ptr<Tegra::Nvdec> nvdec_processor);
-    ~Vic();
-
-    /// Write to the device state.
-    void ProcessMethod(Vic::Method method, const std::vector<u32>& arguments);
-
-private:
-    void Execute();
-
-    void VicStateWrite(u32 offset, u32 arguments);
-    VicRegisters vic_state{};
-
-    enum class VideoPixelFormat : u64_le {
-        RGBA8 = 0x1f,
-        BGRA8 = 0x20,
-        Yuv420 = 0x44,
-    };
-
-    union VicConfig {
-        u64_le raw{};
-        BitField<0, 7, u64_le> pixel_format;
-        BitField<7, 2, u64_le> chroma_loc_horiz;
-        BitField<9, 2, u64_le> chroma_loc_vert;
-        BitField<11, 4, u64_le> block_linear_kind;
-        BitField<15, 4, u64_le> block_linear_height_log2;
-        BitField<19, 3, u64_le> reserved0;
-        BitField<22, 10, u64_le> reserved1;
-        BitField<32, 14, u64_le> surface_width_minus1;
-        BitField<46, 14, u64_le> surface_height_minus1;
-    };
-
-    GPU& gpu;
-    std::shared_ptr<Tegra::Nvdec> nvdec_processor;
-
-    GPUVAddr config_struct_address{};
-    GPUVAddr output_surface_luma_address{};
-    GPUVAddr output_surface_chroma_u_address{};
-    GPUVAddr output_surface_chroma_v_address{};
-
-    SwsContext* scaler_ctx{};
-    s32 scaler_width{};
-    s32 scaler_height{};
-};
-
-} // namespace Tegra

src/video_core/gpu.cpp

@@ -27,10 +27,9 @@ namespace Tegra {
 
 MICROPROFILE_DEFINE(GPU_wait, "GPU", "Wait for the GPU", MP_RGB(128, 128, 192));
 
-GPU::GPU(Core::System& system_, bool is_async_, bool use_nvdec_)
+GPU::GPU(Core::System& system_, bool is_async_)
     : system{system_}, memory_manager{std::make_unique<Tegra::MemoryManager>(system)},
       dma_pusher{std::make_unique<Tegra::DmaPusher>(system, *this)},
-      cdma_pusher{std::make_unique<Tegra::CDmaPusher>(*this)}, use_nvdec{use_nvdec_},
       maxwell_3d{std::make_unique<Engines::Maxwell3D>(system, *memory_manager)},
       fermi_2d{std::make_unique<Engines::Fermi2D>()},
       kepler_compute{std::make_unique<Engines::KeplerCompute>(system, *memory_manager)},
@@ -78,18 +77,10 @@ DmaPusher& GPU::DmaPusher() {
     return *dma_pusher;
 }
 
-Tegra::CDmaPusher& GPU::CDmaPusher() {
-    return *cdma_pusher;
-}
-
 const DmaPusher& GPU::DmaPusher() const {
     return *dma_pusher;
 }
 
-const Tegra::CDmaPusher& GPU::CDmaPusher() const {
-    return *cdma_pusher;
-}
-
 void GPU::WaitFence(u32 syncpoint_id, u32 value) {
     // Synced GPU, is always in sync
     if (!is_async) {

src/video_core/gpu.h

@@ -13,7 +13,6 @@
 #include "common/common_types.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
-#include "video_core/cdma_pusher.h"
 #include "video_core/dma_pusher.h"
 
 using CacheAddr = std::uintptr_t;
@@ -158,7 +157,7 @@ public:
               method_count(method_count) {}
     };
 
-    explicit GPU(Core::System& system, bool is_async, bool use_nvdec);
+    explicit GPU(Core::System& system, bool is_async);
     virtual ~GPU();
 
     /// Binds a renderer to the GPU.
@@ -210,15 +209,6 @@ public:
     /// Returns a reference to the GPU DMA pusher.
     Tegra::DmaPusher& DmaPusher();
 
-    /// Returns a const reference to the GPU DMA pusher.
-    const Tegra::DmaPusher& DmaPusher() const;
-
-    /// Returns a reference to the GPU CDMA pusher.
-    Tegra::CDmaPusher& CDmaPusher();
-
-    /// Returns a const reference to the GPU CDMA pusher.
-    const Tegra::CDmaPusher& CDmaPusher() const;
-
     VideoCore::RendererBase& Renderer() {
         return *renderer;
     }
@@ -259,9 +249,8 @@ public:
         return is_async;
     }
 
-    bool UseNvdec() const {
-        return use_nvdec;
-    }
+    /// Returns a const reference to the GPU DMA pusher.
+    const Tegra::DmaPusher& DmaPusher() const;
 
     struct Regs {
         static constexpr size_t NUM_REGS = 0x40;
@@ -322,9 +311,6 @@ public:
     /// Push GPU command entries to be processed
     virtual void PushGPUEntries(Tegra::CommandList&& entries) = 0;
 
-    /// Push GPU command buffer entries to be processed
-    virtual void PushCommandBuffer(Tegra::ChCommandHeaderList& entries) = 0;
-
     /// Swap buffers (render frame)
     virtual void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) = 0;
 
@@ -363,9 +349,7 @@ protected:
     Core::System& system;
     std::unique_ptr<Tegra::MemoryManager> memory_manager;
     std::unique_ptr<Tegra::DmaPusher> dma_pusher;
-    std::unique_ptr<Tegra::CDmaPusher> cdma_pusher;
     std::unique_ptr<VideoCore::RendererBase> renderer;
-    const bool use_nvdec;
 
 private:
     /// Mapping of command subchannels to their bound engine ids
@@ -388,7 +372,6 @@ private:
     std::array<std::list<u32>, Service::Nvidia::MaxSyncPoints> syncpt_interrupts;
 
     std::mutex sync_mutex;
-    std::mutex device_mutex;
 
     std::condition_variable sync_cv;
 

src/video_core/gpu_asynch.cpp

@@ -10,13 +10,12 @@
 
 namespace VideoCommon {
 
-GPUAsynch::GPUAsynch(Core::System& system, bool use_nvdec)
-    : GPU{system, true, use_nvdec}, gpu_thread{system} {}
+GPUAsynch::GPUAsynch(Core::System& system) : GPU{system, true}, gpu_thread{system} {}
 
 GPUAsynch::~GPUAsynch() = default;
 
 void GPUAsynch::Start() {
-    gpu_thread.StartThread(*renderer, renderer->Context(), *dma_pusher, *cdma_pusher);
+    gpu_thread.StartThread(*renderer, renderer->Context(), *dma_pusher);
     cpu_context = renderer->GetRenderWindow().CreateSharedContext();
     cpu_context->MakeCurrent();
 }
@@ -33,27 +32,6 @@ void GPUAsynch::PushGPUEntries(Tegra::CommandList&& entries) {
     gpu_thread.SubmitList(std::move(entries));
 }
 
-void GPUAsynch::PushCommandBuffer(Tegra::ChCommandHeaderList& entries) {
-    if (!use_nvdec) {
-        return;
-    }
-    // This condition fires when a video stream ends, clear all intermediary data
-    if (entries[0].raw == 0xDEADB33F) {
-        cdma_pusher.reset();
-        return;
-    }
-    if (!cdma_pusher) {
-        cdma_pusher = std::make_unique<Tegra::CDmaPusher>(*this);
-    }
-
-    // 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_pusher->Push(std::move(entries));
-    cdma_pusher->DispatchCalls();
-}
-
 void GPUAsynch::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     gpu_thread.SwapBuffers(framebuffer);
 }

src/video_core/gpu_asynch.h

@@ -20,14 +20,13 @@ namespace VideoCommon {
 /// Implementation of GPU interface that runs the GPU asynchronously
 class GPUAsynch final : public Tegra::GPU {
 public:
-    explicit GPUAsynch(Core::System& system, bool use_nvdec);
+    explicit GPUAsynch(Core::System& system);
     ~GPUAsynch() override;
 
     void Start() override;
     void ObtainContext() override;
     void ReleaseContext() override;
     void PushGPUEntries(Tegra::CommandList&& entries) override;
-    void PushCommandBuffer(Tegra::ChCommandHeaderList& entries) override;
     void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override;
     void FlushRegion(VAddr addr, u64 size) override;
     void InvalidateRegion(VAddr addr, u64 size) override;

src/video_core/gpu_synch.cpp

@@ -7,7 +7,7 @@
 
 namespace VideoCommon {
 
-GPUSynch::GPUSynch(Core::System& system, bool use_nvdec) : GPU{system, false, use_nvdec} {}
+GPUSynch::GPUSynch(Core::System& system) : GPU{system, false} {}
 
 GPUSynch::~GPUSynch() = default;
 
@@ -26,22 +26,6 @@ void GPUSynch::PushGPUEntries(Tegra::CommandList&& entries) {
     dma_pusher->DispatchCalls();
 }
 
-void GPUSynch::PushCommandBuffer(Tegra::ChCommandHeaderList& entries) {
-    if (!use_nvdec) {
-        return;
-    }
-    // This condition fires when a video stream ends, clears all intermediary data
-    if (entries[0].raw == 0xDEADB33F) {
-        cdma_pusher.reset();
-        return;
-    }
-    if (!cdma_pusher) {
-        cdma_pusher = std::make_unique<Tegra::CDmaPusher>(*this);
-    }
-    cdma_pusher->Push(std::move(entries));
-    cdma_pusher->DispatchCalls();
-}
-
 void GPUSynch::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     renderer->SwapBuffers(framebuffer);
 }

src/video_core/gpu_synch.h

@@ -19,14 +19,13 @@ namespace VideoCommon {
 /// Implementation of GPU interface that runs the GPU synchronously
 class GPUSynch final : public Tegra::GPU {
 public:
-    explicit GPUSynch(Core::System& system, bool use_nvdec);
+    explicit GPUSynch(Core::System& system);
     ~GPUSynch() override;
 
     void Start() override;
     void ObtainContext() override;
     void ReleaseContext() override;
     void PushGPUEntries(Tegra::CommandList&& entries) override;
-    void PushCommandBuffer(Tegra::ChCommandHeaderList& entries) override;
     void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) override;
     void FlushRegion(VAddr addr, u64 size) override;
     void InvalidateRegion(VAddr addr, u64 size) override;

src/video_core/gpu_thread.cpp

@@ -18,7 +18,7 @@ namespace VideoCommon::GPUThread {
 /// Runs the GPU thread
 static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
                       Core::Frontend::GraphicsContext& context, Tegra::DmaPusher& dma_pusher,
-                      SynchState& state, Tegra::CDmaPusher& cdma_pusher) {
+                      SynchState& state) {
     std::string name = "yuzu:GPU";
     MicroProfileOnThreadCreate(name.c_str());
     Common::SetCurrentThreadName(name.c_str());
@@ -42,10 +42,6 @@ static void RunThread(Core::System& system, VideoCore::RendererBase& renderer,
         if (const auto submit_list = std::get_if<SubmitListCommand>(&next.data)) {
             dma_pusher.Push(std::move(submit_list->entries));
             dma_pusher.DispatchCalls();
-        } else if (const auto command_list = std::get_if<SubmitChCommandEntries>(&next.data)) {
-            // NVDEC
-            cdma_pusher.Push(std::move(command_list->entries));
-            cdma_pusher.DispatchCalls();
         } else if (const auto data = std::get_if<SwapBuffersCommand>(&next.data)) {
             renderer.SwapBuffers(data->framebuffer ? &*data->framebuffer : nullptr);
         } else if (std::holds_alternative<OnCommandListEndCommand>(next.data)) {
@@ -79,19 +75,15 @@ ThreadManager::~ThreadManager() {
 
 void ThreadManager::StartThread(VideoCore::RendererBase& renderer,
                                 Core::Frontend::GraphicsContext& context,
-                                Tegra::DmaPusher& dma_pusher, Tegra::CDmaPusher& cdma_pusher) {
-    thread = std::thread(RunThread, std::ref(system), std::ref(renderer), std::ref(context),
-                         std::ref(dma_pusher), std::ref(state), std::ref(cdma_pusher));
+                                Tegra::DmaPusher& dma_pusher) {
+    thread = std::thread{RunThread,         std::ref(system),     std::ref(renderer),
+                         std::ref(context), std::ref(dma_pusher), std::ref(state)};
 }
 
 void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
     PushCommand(SubmitListCommand(std::move(entries)));
 }
 
-void ThreadManager::SubmitCommandBuffer(Tegra::ChCommandHeaderList&& entries) {
-    PushCommand(SubmitChCommandEntries(std::move(entries)));
-}
-
 void ThreadManager::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     PushCommand(SwapBuffersCommand(framebuffer ? std::make_optional(*framebuffer) : std::nullopt));
 }

src/video_core/gpu_thread.h

@@ -37,14 +37,6 @@ struct SubmitListCommand final {
     Tegra::CommandList entries;
 };
 
-/// Command to signal to the GPU thread that a cdma command list is ready for processing
-struct SubmitChCommandEntries final {
-    explicit SubmitChCommandEntries(Tegra::ChCommandHeaderList&& entries)
-        : entries{std::move(entries)} {}
-
-    Tegra::ChCommandHeaderList entries;
-};
-
 /// Command to signal to the GPU thread that a swap buffers is pending
 struct SwapBuffersCommand final {
     explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer)
@@ -85,9 +77,9 @@ struct OnCommandListEndCommand final {};
 struct GPUTickCommand final {};
 
 using CommandData =
-    std::variant<EndProcessingCommand, SubmitListCommand, SubmitChCommandEntries,
-                 SwapBuffersCommand, FlushRegionCommand, InvalidateRegionCommand,
-                 FlushAndInvalidateRegionCommand, OnCommandListEndCommand, GPUTickCommand>;
+    std::variant<EndProcessingCommand, SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
+                 InvalidateRegionCommand, FlushAndInvalidateRegionCommand, OnCommandListEndCommand,
+                 GPUTickCommand>;
 
 struct CommandDataContainer {
     CommandDataContainer() = default;
@@ -117,14 +109,11 @@ public:
 
     /// Creates and starts the GPU thread.
     void StartThread(VideoCore::RendererBase& renderer, Core::Frontend::GraphicsContext& context,
-                     Tegra::DmaPusher& dma_pusher, Tegra::CDmaPusher& cdma_pusher);
+                     Tegra::DmaPusher& dma_pusher);
 
     /// Push GPU command entries to be processed
     void SubmitList(Tegra::CommandList&& entries);
 
-    /// Push GPU CDMA command buffer entries to be processed
-    void SubmitCommandBuffer(Tegra::ChCommandHeaderList&& entries);
-
     /// Swap buffers (render frame)
     void SwapBuffers(const Tegra::FramebufferConfig* framebuffer);
 

src/video_core/host_shaders/CMakeLists.txt

@@ -1,16 +1,23 @@
-set(SHADER_SOURCES
+set(SHADER_FILES
     opengl_present.frag
     opengl_present.vert
 )
 
 set(SHADER_INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/include)
-set(SHADER_DIR ${SHADER_INCLUDE}/video_core/host_shaders)
 set(HOST_SHADERS_INCLUDE ${SHADER_INCLUDE} PARENT_SCOPE)
 
+set(SHADER_DIR ${SHADER_INCLUDE}/video_core/host_shaders)
+add_custom_command(
+    OUTPUT
+        ${SHADER_DIR}
+    COMMAND
+        ${CMAKE_COMMAND} -E make_directory ${SHADER_DIR}
+)
+
 set(INPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/source_shader.h.in)
 set(HEADER_GENERATOR ${CMAKE_CURRENT_SOURCE_DIR}/StringShaderHeader.cmake)
 
-foreach(FILENAME IN ITEMS ${SHADER_SOURCES})
+foreach(FILENAME IN ITEMS ${SHADER_FILES})
     string(REPLACE "." "_" SHADER_NAME ${FILENAME})
     set(SOURCE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME})
     set(HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}.h)
@@ -22,8 +29,8 @@ foreach(FILENAME IN ITEMS ${SHADER_SOURCES})
         MAIN_DEPENDENCY
             ${SOURCE_FILE}
         DEPENDS
+            ${HEADER_GENERATOR}
             ${INPUT_FILE}
-            # HEADER_GENERATOR should be included here but msbuild seems to assume it's always modified
     )
     set(SHADER_HEADERS ${SHADER_HEADERS} ${HEADER_FILE})
 endforeach()
@@ -32,5 +39,5 @@ add_custom_target(host_shaders
     DEPENDS
         ${SHADER_HEADERS}
     SOURCES
-        ${SHADER_SOURCES}
+        ${SHADER_FILES}
 )

src/video_core/host_shaders/StringShaderHeader.cmake

@@ -8,6 +8,4 @@ string(TOUPPER ${CONTENTS_NAME} CONTENTS_NAME)
 
 file(READ ${SOURCE_FILE} CONTENTS)
 
-get_filename_component(OUTPUT_DIR ${HEADER_FILE} DIRECTORY)
-make_directory(${OUTPUT_DIR})
 configure_file(${INPUT_FILE} ${HEADER_FILE} @ONLY)

src/video_core/memory_manager.cpp

@@ -11,7 +11,6 @@
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
-#include "video_core/renderer_base.h"
 
 namespace Tegra {
 
@@ -45,12 +44,6 @@ GPUVAddr MemoryManager::MapAllocate(VAddr cpu_addr, std::size_t size, std::size_
     return Map(cpu_addr, *FindFreeRange(size, align), size);
 }
 
-GPUVAddr MemoryManager::MapAllocate32(VAddr cpu_addr, std::size_t size) {
-    const std::optional<GPUVAddr> gpu_addr = FindFreeRange(size, 1, true);
-    ASSERT(gpu_addr);
-    return Map(cpu_addr, *gpu_addr, size);
-}
-
 void MemoryManager::Unmap(GPUVAddr gpu_addr, std::size_t size) {
     if (!size) {
         return;
@@ -115,8 +108,7 @@ void MemoryManager::SetPageEntry(GPUVAddr gpu_addr, PageEntry page_entry, std::s
     page_table[PageEntryIndex(gpu_addr)] = page_entry;
 }
 
-std::optional<GPUVAddr> MemoryManager::FindFreeRange(std::size_t size, std::size_t align,
-                                                     bool start_32bit_address) const {
+std::optional<GPUVAddr> MemoryManager::FindFreeRange(std::size_t size, std::size_t align) const {
     if (!align) {
         align = page_size;
     } else {
@@ -124,7 +116,7 @@ std::optional<GPUVAddr> MemoryManager::FindFreeRange(std::size_t size, std::size
     }
 
     u64 available_size{};
-    GPUVAddr gpu_addr{start_32bit_address ? address_space_start_low : address_space_start};
+    GPUVAddr gpu_addr{address_space_start};
     while (gpu_addr + available_size < address_space_size) {
         if (GetPageEntry(gpu_addr + available_size).IsUnmapped()) {
             available_size += page_size;

src/video_core/memory_manager.h

@@ -116,7 +116,6 @@ public:
 
     [[nodiscard]] GPUVAddr Map(VAddr cpu_addr, GPUVAddr gpu_addr, std::size_t size);
     [[nodiscard]] GPUVAddr MapAllocate(VAddr cpu_addr, std::size_t size, std::size_t align);
-    [[nodiscard]] GPUVAddr MapAllocate32(VAddr cpu_addr, std::size_t size);
     [[nodiscard]] std::optional<GPUVAddr> AllocateFixed(GPUVAddr gpu_addr, std::size_t size);
     [[nodiscard]] GPUVAddr Allocate(std::size_t size, std::size_t align);
     void Unmap(GPUVAddr gpu_addr, std::size_t size);
@@ -125,8 +124,7 @@ private:
     [[nodiscard]] PageEntry GetPageEntry(GPUVAddr gpu_addr) const;
     void SetPageEntry(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size = page_size);
     GPUVAddr UpdateRange(GPUVAddr gpu_addr, PageEntry page_entry, std::size_t size);
-    [[nodiscard]] std::optional<GPUVAddr> FindFreeRange(std::size_t size, std::size_t align,
-                                                        bool start_32bit_address = false) const;
+    [[nodiscard]] std::optional<GPUVAddr> FindFreeRange(std::size_t size, std::size_t align) const;
 
     void TryLockPage(PageEntry page_entry, std::size_t size);
     void TryUnlockPage(PageEntry page_entry, std::size_t size);
@@ -137,7 +135,6 @@ private:
 
     static constexpr u64 address_space_size = 1ULL << 40;
     static constexpr u64 address_space_start = 1ULL << 32;
-    static constexpr u64 address_space_start_low = 1ULL << 16;
     static constexpr u64 page_bits{16};
     static constexpr u64 page_size{1 << page_bits};
     static constexpr u64 page_mask{page_size - 1};

src/video_core/renderer_opengl/gl_arb_decompiler.cpp

@@ -376,11 +376,9 @@ private:
         std::string temporary = AllocTemporary();
         std::string address;
         std::string_view opname;
-        bool robust = false;
         if (const auto gmem = std::get_if<GmemNode>(&*operation[0])) {
             address = GlobalMemoryPointer(*gmem);
             opname = "ATOM";
-            robust = true;
         } else if (const auto smem = std::get_if<SmemNode>(&*operation[0])) {
             address = fmt::format("shared_mem[{}]", Visit(smem->GetAddress()));
             opname = "ATOMS";
@@ -388,15 +386,7 @@ private:
             UNREACHABLE();
             return "{0, 0, 0, 0}";
         }
-        if (robust) {
-            AddLine("IF NE.x;");
-        }
         AddLine("{}.{}.{} {}, {}, {};", opname, op, type, temporary, Visit(operation[1]), address);
-        if (robust) {
-            AddLine("ELSE;");
-            AddLine("MOV.S {}, 0;", temporary);
-            AddLine("ENDIF;");
-        }
         return temporary;
     }
 
@@ -990,9 +980,10 @@ void ARBDecompiler::DeclareLocalMemory() {
 }
 
 void ARBDecompiler::DeclareGlobalMemory() {
-    const size_t num_entries = ir.GetGlobalMemory().size();
+    const std::size_t num_entries = ir.GetGlobalMemory().size();
     if (num_entries > 0) {
-        AddLine("PARAM c[{}] = {{ program.local[0..{}] }};", num_entries, num_entries - 1);
+        const std::size_t num_vectors = Common::AlignUp(num_entries, 2) / 2;
+        AddLine("PARAM c[{}] = {{ program.local[0..{}] }};", num_vectors, num_vectors - 1);
     }
 }
 
@@ -1372,8 +1363,7 @@ std::string ARBDecompiler::Visit(const Node& node) {
 
     if (const auto gmem = std::get_if<GmemNode>(&*node)) {
         std::string temporary = AllocTemporary();
-        AddLine("MOV {}, 0;", temporary);
-        AddLine("LOAD.U32 {} (NE.x), {};", temporary, GlobalMemoryPointer(*gmem));
+        AddLine("LOAD.U32 {}, {};", temporary, GlobalMemoryPointer(*gmem));
         return temporary;
     }
 
@@ -1451,21 +1441,18 @@ std::string ARBDecompiler::BuildAoffi(Operation operation) {
 }
 
 std::string ARBDecompiler::GlobalMemoryPointer(const GmemNode& gmem) {
-    // Read a bindless SSBO, return its address and set CC accordingly
-    // address = c[binding].xy
-    // length  = c[binding].z
     const u32 binding = global_memory_names.at(gmem.GetDescriptor());
+    const char result_swizzle = binding % 2 == 0 ? 'x' : 'y';
 
     const std::string pointer = AllocLongVectorTemporary();
     std::string temporary = AllocTemporary();
 
-    AddLine("PK64.U {}, c[{}];", pointer, binding);
+    const u32 local_index = binding / 2;
+    AddLine("PK64.U {}, c[{}];", pointer, local_index);
     AddLine("SUB.U {}, {}, {};", temporary, Visit(gmem.GetRealAddress()),
             Visit(gmem.GetBaseAddress()));
     AddLine("CVT.U64.U32 {}.z, {};", pointer, temporary);
-    AddLine("ADD.U64 {}.x, {}.x, {}.z;", pointer, pointer, pointer);
-    // Compare offset to length and set CC
-    AddLine("SLT.U.CC RC.x, {}, c[{}].z;", temporary, binding);
+    AddLine("ADD.U64 {}.x, {}.{}, {}.z;", pointer, pointer, result_swizzle, pointer);
     return fmt::format("{}.x", pointer);
 }
 
@@ -1565,9 +1552,7 @@ std::string ARBDecompiler::Assign(Operation operation) {
         ResetTemporaries();
         return {};
     } else if (const auto gmem = std::get_if<GmemNode>(&*dest)) {
-        AddLine("IF NE.x;");
         AddLine("STORE.U32 {}, {};", Visit(src), GlobalMemoryPointer(*gmem));
-        AddLine("ENDIF;");
         ResetTemporaries();
         return {};
     } else {

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -139,12 +139,16 @@ void oglEnable(GLenum cap, bool state) {
     (state ? glEnable : glDisable)(cap);
 }
 
-void UpdateBindlessSSBOs(GLenum target, const BindlessSSBO* ssbos, size_t num_ssbos) {
-    if (num_ssbos == 0) {
+void UpdateBindlessPointers(GLenum target, GLuint64EXT* pointers, std::size_t num_entries) {
+    if (num_entries == 0) {
         return;
     }
-    glProgramLocalParametersI4uivNV(target, 0, static_cast<GLsizei>(num_ssbos),
-                                    reinterpret_cast<const GLuint*>(ssbos));
+    if (num_entries % 2 == 1) {
+        pointers[num_entries] = 0;
+    }
+    const GLsizei num_vectors = static_cast<GLsizei>((num_entries + 1) / 2);
+    glProgramLocalParametersI4uivNV(target, 0, num_vectors,
+                                    reinterpret_cast<const GLuint*>(pointers));
 }
 
 } // Anonymous namespace
@@ -896,11 +900,11 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
 }
 
 void RasterizerOpenGL::SetupDrawConstBuffers(std::size_t stage_index, Shader* shader) {
-    static constexpr std::array PARAMETER_LUT{
-        GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV,          GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,
+    static constexpr std::array PARAMETER_LUT = {
+        GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV, GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,
         GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV, GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV,
-        GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV,
-    };
+        GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV};
+
     MICROPROFILE_SCOPE(OpenGL_UBO);
     const auto& stages = maxwell3d.state.shader_stages;
     const auto& shader_stage = stages[stage_index];
@@ -1003,8 +1007,8 @@ void RasterizerOpenGL::SetupDrawGlobalMemory(std::size_t stage_index, Shader* sh
     const auto& cbufs{maxwell3d.state.shader_stages[stage_index]};
     const auto& entries{shader->GetEntries().global_memory_entries};
 
-    std::array<BindlessSSBO, 32> ssbos;
-    ASSERT(entries.size() < ssbos.size());
+    std::array<GLuint64EXT, 32> pointers;
+    ASSERT(entries.size() < pointers.size());
 
     const bool assembly_shaders = device.UseAssemblyShaders();
     u32 binding = assembly_shaders ? 0 : device.GetBaseBindings(stage_index).shader_storage_buffer;
@@ -1012,11 +1016,11 @@ void RasterizerOpenGL::SetupDrawGlobalMemory(std::size_t stage_index, Shader* sh
         const GPUVAddr addr{cbufs.const_buffers[entry.cbuf_index].address + entry.cbuf_offset};
         const GPUVAddr gpu_addr{gpu_memory.Read<u64>(addr)};
         const u32 size{gpu_memory.Read<u32>(addr + 8)};
-        SetupGlobalMemory(binding, entry, gpu_addr, size, &ssbos[binding]);
+        SetupGlobalMemory(binding, entry, gpu_addr, size, &pointers[binding]);
         ++binding;
     }
     if (assembly_shaders) {
-        UpdateBindlessSSBOs(TARGET_LUT[stage_index], ssbos.data(), entries.size());
+        UpdateBindlessPointers(TARGET_LUT[stage_index], pointers.data(), entries.size());
     }
 }
 
@@ -1024,32 +1028,29 @@ void RasterizerOpenGL::SetupComputeGlobalMemory(Shader* kernel) {
     const auto& cbufs{kepler_compute.launch_description.const_buffer_config};
     const auto& entries{kernel->GetEntries().global_memory_entries};
 
-    std::array<BindlessSSBO, 32> ssbos;
-    ASSERT(entries.size() < ssbos.size());
+    std::array<GLuint64EXT, 32> pointers;
+    ASSERT(entries.size() < pointers.size());
 
     u32 binding = 0;
     for (const auto& entry : entries) {
         const GPUVAddr addr{cbufs[entry.cbuf_index].Address() + entry.cbuf_offset};
         const GPUVAddr gpu_addr{gpu_memory.Read<u64>(addr)};
         const u32 size{gpu_memory.Read<u32>(addr + 8)};
-        SetupGlobalMemory(binding, entry, gpu_addr, size, &ssbos[binding]);
+        SetupGlobalMemory(binding, entry, gpu_addr, size, &pointers[binding]);
         ++binding;
     }
     if (device.UseAssemblyShaders()) {
-        UpdateBindlessSSBOs(GL_COMPUTE_PROGRAM_NV, ssbos.data(), ssbos.size());
+        UpdateBindlessPointers(GL_COMPUTE_PROGRAM_NV, pointers.data(), entries.size());
     }
 }
 
 void RasterizerOpenGL::SetupGlobalMemory(u32 binding, const GlobalMemoryEntry& entry,
-                                         GPUVAddr gpu_addr, size_t size, BindlessSSBO* ssbo) {
-    const size_t alignment{device.GetShaderStorageBufferAlignment()};
+                                         GPUVAddr gpu_addr, std::size_t size,
+                                         GLuint64EXT* pointer) {
+    const std::size_t alignment{device.GetShaderStorageBufferAlignment()};
     const auto info = buffer_cache.UploadMemory(gpu_addr, size, alignment, entry.is_written);
     if (device.UseAssemblyShaders()) {
-        *ssbo = BindlessSSBO{
-            .address = static_cast<GLuint64EXT>(info.address + info.offset),
-            .length = static_cast<GLsizei>(size),
-            .padding = 0,
-        };
+        *pointer = info.address + info.offset;
     } else {
         glBindBufferRange(GL_SHADER_STORAGE_BUFFER, binding, info.handle, info.offset,
                           static_cast<GLsizeiptr>(size));

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -53,13 +53,6 @@ namespace OpenGL {
 struct ScreenInfo;
 struct DrawParameters;
 
-struct BindlessSSBO {
-    GLuint64EXT address;
-    GLsizei length;
-    GLsizei padding;
-};
-static_assert(sizeof(BindlessSSBO) * CHAR_BIT == 128);
-
 class RasterizerOpenGL : public VideoCore::RasterizerAccelerated {
 public:
     explicit RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window, Tegra::GPU& gpu,
@@ -133,7 +126,7 @@ private:
 
     /// Configures a global memory buffer.
     void SetupGlobalMemory(u32 binding, const GlobalMemoryEntry& entry, GPUVAddr gpu_addr,
-                           size_t size, BindlessSSBO* ssbo);
+                           std::size_t size, GLuint64EXT* pointer);
 
     /// Configures the current textures to use for the draw command.
     void SetupDrawTextures(std::size_t stage_index, Shader* shader);

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -58,7 +58,6 @@ void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_sta
     logic_op_enable.Assign(regs.logic_op.enable != 0 ? 1 : 0);
     logic_op.Assign(PackLogicOp(regs.logic_op.operation));
     rasterize_enable.Assign(regs.rasterize_enable != 0 ? 1 : 0);
-    topology.Assign(regs.draw.topology);
 
     std::memcpy(&point_size, &regs.point_size, sizeof(point_size)); // TODO: C++20 std::bit_cast
 
@@ -132,6 +131,7 @@ void FixedPipelineState::BlendingAttachment::Fill(const Maxwell& regs, std::size
 }
 
 void FixedPipelineState::DynamicState::Fill(const Maxwell& regs) {
+    const u32 topology_index = static_cast<u32>(regs.draw.topology.Value());
     u32 packed_front_face = PackFrontFace(regs.front_face);
     if (regs.screen_y_control.triangle_rast_flip != 0) {
         // Flip front face
@@ -161,6 +161,7 @@ void FixedPipelineState::DynamicState::Fill(const Maxwell& regs) {
     depth_test_enable.Assign(regs.depth_test_enable);
     front_face.Assign(packed_front_face);
     depth_test_func.Assign(PackComparisonOp(regs.depth_test_func));
+    topology.Assign(topology_index);
     cull_face.Assign(PackCullFace(regs.cull_face));
     cull_enable.Assign(regs.cull_test_enabled != 0 ? 1 : 0);
 

src/video_core/renderer_vulkan/fixed_pipeline_state.h

@@ -150,8 +150,9 @@ struct FixedPipelineState {
         };
         union {
             u32 raw2;
-            BitField<0, 2, u32> cull_face;
-            BitField<2, 1, u32> cull_enable;
+            BitField<0, 4, u32> topology;
+            BitField<4, 2, u32> cull_face;
+            BitField<6, 1, u32> cull_enable;
         };
         std::array<VertexBinding, Maxwell::NumVertexArrays> vertex_bindings;
 
@@ -168,6 +169,10 @@ struct FixedPipelineState {
         Maxwell::FrontFace FrontFace() const noexcept {
             return UnpackFrontFace(front_face.Value());
         }
+
+        constexpr Maxwell::PrimitiveTopology Topology() const noexcept {
+            return static_cast<Maxwell::PrimitiveTopology>(topology.Value());
+        }
     };
 
     union {
@@ -185,7 +190,6 @@ struct FixedPipelineState {
         BitField<18, 1, u32> logic_op_enable;
         BitField<19, 4, u32> logic_op;
         BitField<23, 1, u32> rasterize_enable;
-        BitField<24, 4, Maxwell::PrimitiveTopology> topology;
     };
     u32 point_size;
     std::array<u32, Maxwell::NumVertexArrays> binding_divisors;

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -92,9 +92,9 @@ Common::DynamicLibrary OpenVulkanLibrary() {
     return library;
 }
 
-std::pair<vk::Instance, u32> CreateInstance(
-    Common::DynamicLibrary& library, vk::InstanceDispatch& dld,
-    WindowSystemType window_type = WindowSystemType::Headless, bool enable_layers = false) {
+vk::Instance CreateInstance(Common::DynamicLibrary& library, vk::InstanceDispatch& dld,
+                            WindowSystemType window_type = WindowSystemType::Headless,
+                            bool enable_layers = false) {
     if (!library.IsOpen()) {
         LOG_ERROR(Render_Vulkan, "Vulkan library not available");
         return {};
@@ -180,10 +180,7 @@ std::pair<vk::Instance, u32> CreateInstance(
         }
     }
 
-    // Limit the maximum version of Vulkan to avoid using untested version.
-    const u32 version = std::min(vk::AvailableVersion(dld), static_cast<u32>(VK_API_VERSION_1_1));
-
-    vk::Instance instance = vk::Instance::Create(version, layers, extensions, dld);
+    vk::Instance instance = vk::Instance::Create(layers, extensions, dld);
     if (!instance) {
         LOG_ERROR(Render_Vulkan, "Failed to create Vulkan instance");
         return {};
@@ -191,7 +188,7 @@ std::pair<vk::Instance, u32> CreateInstance(
     if (!vk::Load(*instance, dld)) {
         LOG_ERROR(Render_Vulkan, "Failed to load Vulkan instance function pointers");
     }
-    return std::make_pair(std::move(instance), version);
+    return instance;
 }
 
 std::string GetReadableVersion(u32 version) {
@@ -288,8 +285,8 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
 
 bool RendererVulkan::Init() {
     library = OpenVulkanLibrary();
-    std::tie(instance, instance_version) = CreateInstance(
-        library, dld, render_window.GetWindowInfo().type, Settings::values.renderer_debug);
+    instance = CreateInstance(library, dld, render_window.GetWindowInfo().type,
+                              Settings::values.renderer_debug);
     if (!instance || !CreateDebugCallback() || !CreateSurface() || !PickDevices()) {
         return false;
     }
@@ -419,8 +416,7 @@ bool RendererVulkan::PickDevices() {
         return false;
     }
 
-    device =
-        std::make_unique<VKDevice>(*instance, instance_version, physical_device, *surface, dld);
+    device = std::make_unique<VKDevice>(*instance, physical_device, *surface, dld);
     return device->Create();
 }
 
@@ -430,7 +426,7 @@ void RendererVulkan::Report() const {
     const std::string driver_version = GetDriverVersion(*device);
     const std::string driver_name = fmt::format("{} {}", vendor_name, driver_version);
 
-    const std::string api_version = GetReadableVersion(device->ApiVersion());
+    const std::string api_version = GetReadableVersion(device->GetApiVersion());
 
     const std::string extensions = BuildCommaSeparatedExtensions(device->GetAvailableExtensions());
 
@@ -449,7 +445,7 @@ void RendererVulkan::Report() const {
 std::vector<std::string> RendererVulkan::EnumerateDevices() {
     vk::InstanceDispatch dld;
     Common::DynamicLibrary library = OpenVulkanLibrary();
-    vk::Instance instance = CreateInstance(library, dld).first;
+    vk::Instance instance = CreateInstance(library, dld);
     if (!instance) {
         return {};
     }