profile_manager: Resize any image bigger than 256p

Fixup channel submit IOCTL syncpoint parameters

CMakeLists.txt

@@ -411,12 +411,13 @@ if (CONAN_REQUIRED_LIBS)
     # Download conan.cmake automatically, you can also just copy the conan.cmake file
     if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
         message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
+        # TODO: Use a tagged release. The latest tagged release does not support VS2022 as of this writing.
+        file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/43e385830ee35377dbd2dcbe8d5a9e750301ea00/conan.cmake"
                         "${CMAKE_BINARY_DIR}/conan.cmake")
     endif()
     include(${CMAKE_BINARY_DIR}/conan.cmake)
 
-    conan_check(VERSION 1.24.0 REQUIRED)
+    conan_check(VERSION 1.41.0 REQUIRED)
 
     # Manually add iconv to fix a dep conflict between qt and sdl2
     # We don't need to add it through find_package or anything since the other two can find it just fine

src/common/alignment.h

@@ -64,7 +64,7 @@ public:
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;
     using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::true_type;
+    using is_always_equal = std::false_type;
 
     constexpr AlignmentAllocator() noexcept = default;
 
@@ -83,6 +83,11 @@ public:
     struct rebind {
         using other = AlignmentAllocator<T2, Align>;
     };
+
+    template <typename T2, size_t Align2>
+    constexpr bool operator==(const AlignmentAllocator<T2, Align2>&) const noexcept {
+        return std::is_same_v<T, T2> && Align == Align2;
+    }
 };
 
 } // namespace Common

src/common/logging/backend.cpp

@@ -186,10 +186,6 @@ public:
         initialization_in_progress_suppress_logging = false;
     }
 
-    static void Start() {
-        instance->StartBackendThread();
-    }
-
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
@@ -205,59 +201,54 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, const char* message) {
+                   const char* function, std::string message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
-            CreateEntry(log_class, log_level, filename, line_num, function, message);
-        message_queue.push(entry);
+            CreateEntry(log_class, log_level, filename, line_num, function, std::move(message));
+        message_queue.Push(entry);
     }
 
 private:
     Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename} {}
+        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
+              Common::SetCurrentThreadName("yuzu:Log");
+              Entry entry;
+              const auto write_logs = [this, &entry]() {
+                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+              };
+              while (true) {
+                  entry = message_queue.PopWait();
+                  if (entry.final_entry) {
+                      break;
+                  }
+                  write_logs();
+              }
+              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+              // case where a system is repeatedly spamming logs even on close.
+              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+              while (max_logs_to_write-- && message_queue.Pop(entry)) {
+                  write_logs();
+              }
+          })} {}
 
     ~Impl() {
         StopBackendThread();
     }
 
-    void StartBackendThread() {
-        backend_thread = std::thread([this] {
-            Common::SetCurrentThreadName("yuzu:Log");
-            Entry entry;
-            const auto write_logs = [this, &entry]() {
-                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-            };
-            while (true) {
-                if (!message_queue.try_pop(entry)) {
-                    continue;
-                }
-                if (entry.final_entry) {
-                    break;
-                }
-                write_logs();
-            }
-            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-            // case where a system is repeatedly spamming logs even on close.
-            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.try_pop(entry)) {
-                write_logs();
-            }
-        });
-    }
-
     void StopBackendThread() {
         Entry stop_entry{};
         stop_entry.final_entry = true;
-        message_queue.push(stop_entry);
+        message_queue.Push(stop_entry);
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, const char* message) const {
+                      const char* function, std::string message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
+
         return {
             .timestamp = duration_cast<microseconds>(steady_clock::now() - time_origin),
             .log_class = log_class,
@@ -265,7 +256,7 @@ private:
             .filename = filename,
             .line_num = line_nr,
             .function = function,
-            .message = message,
+            .message = std::move(message),
             .final_entry = false,
         };
     }
@@ -288,7 +279,7 @@ private:
     FileBackend file_backend;
 
     std::thread backend_thread;
-    MPMCQueue<Entry> message_queue{100000};
+    MPSCQueue<Entry> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -297,10 +288,6 @@ void Initialize() {
     Impl::Initialize();
 }
 
-void Start() {
-    Impl::Start();
-}
-
 void DisableLoggingInTests() {
     initialization_in_progress_suppress_logging = true;
 }
@@ -314,14 +301,11 @@ void SetColorConsoleBackendEnabled(bool enabled) {
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
-        std::string message = fmt::vformat(format, args);
-        auto len = message.size() + 1;
-        char* msg = new char[len];
-        memcpy(msg, message.data(), len);
-        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function, msg);
+        Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,
+                                   fmt::vformat(format, args));
     }
 }
 } // namespace Common::Log

src/common/logging/backend.h

@@ -14,8 +14,6 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();
 
-void Start();
-
 void DisableLoggingInTests();
 
 /**

src/common/logging/log.h

@@ -24,12 +24,12 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args);
 
 template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, fmt::string_view format, const Args&... args) {
+                   const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
                       fmt::make_format_args(args...));
 }

src/common/logging/log_entry.h

@@ -14,14 +14,14 @@ namespace Common::Log {
  * A log entry. Log entries are store in a structured format to permit more varied output
  * formatting on different frontends, as well as facilitating filtering and aggregation.
  */
-struct Entry final {
+struct Entry {
     std::chrono::microseconds timestamp;
     Class log_class{};
     Level log_level{};
     const char* filename = nullptr;
     unsigned int line_num = 0;
-    const char* function;
-    const char* message;
+    std::string function;
+    std::string message;
     bool final_entry = false;
 };
 

src/common/settings.h

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
-#include <chrono>
 #include <map>
 #include <optional>
 #include <string>
@@ -487,9 +486,9 @@ struct Values {
     // System
     Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
-    std::optional<std::chrono::seconds> custom_rtc;
+    std::optional<s64> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
-    std::chrono::seconds custom_rtc_differential;
+    s64 custom_rtc_differential;
 
     BasicSetting<s32> current_user{0, "current_user"};
     RangedSetting<s32> language_index{1, 0, 17, "language_index"};

src/common/threadsafe_queue.h

@@ -1,287 +1,195 @@
-/*
-Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
-
-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.
- */
+// Copyright 2010 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
 
 #pragma once
 
-#include <atomic>
-#include <cassert>
-#include <cstddef> // offsetof
-#include <limits>
-#include <memory>
-#include <new> // std::hardware_destructive_interference_size
-#include <stdexcept>
+// a simple lockless thread-safe,
+// single reader, single writer queue
 
-#ifndef __cpp_aligned_new
-#ifdef _WIN32
-#include <malloc.h> // _aligned_malloc
-#else
-#include <stdlib.h> // posix_memalign
-#endif
-#endif
+#include <atomic>
+#include <condition_variable>
+#include <cstddef>
+#include <mutex>
+#include <utility>
 
 namespace Common {
-namespace mpmc {
-#ifdef __cpp_lib_hardware_interference_size
-static constexpr size_t hardwareInterferenceSize = std::hardware_destructive_interference_size;
-#else
-static constexpr size_t hardwareInterferenceSize = 64;
-#endif
-
-#if defined(_MSC_VER)
-// Disables "structure was padded due to alignment specifier" warnings.
-#pragma warning(suppress : 4324)
-#endif
-
-#if defined(__cpp_aligned_new)
-template <typename T>
-using AlignedAllocator = std::allocator<T>;
-#else
-template <typename T>
-struct AlignedAllocator {
-    using value_type = T;
-
-    T* allocate(std::size_t n) {
-        if (n > std::numeric_limits<std::size_t>::max() / sizeof(T)) {
-            throw std::bad_array_new_length();
-        }
-#ifdef _WIN32
-        auto* p = static_cast<T*>(_aligned_malloc(sizeof(T) * n, alignof(T)));
-        if (p == nullptr) {
-            throw std::bad_alloc();
-        }
-#else
-        T* p;
-        if (posix_memalign(reinterpret_cast<void**>(&p), alignof(T), sizeof(T) * n) != 0) {
-            throw std::bad_alloc();
-        }
-#endif
-        return p;
-    }
-
-    void deallocate(T* p, std::size_t) {
-#ifdef _WIN32
-        _aligned_free(p);
-#else
-        free(p);
-#endif
-    }
-};
-#endif
-
-template <typename T>
-struct Slot {
-    ~Slot() noexcept {
-        if (turn & 1) {
-            destroy();
-        }
-    }
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
-                      "T must be nothrow constructible with Args&&...");
-        new (&storage) T(std::forward<Args>(args)...);
-    }
-
-    void destroy() noexcept {
-        static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
-        reinterpret_cast<T*>(&storage)->~T();
-    }
-
-    T&& move() noexcept {
-        return reinterpret_cast<T&&>(storage);
-    }
-
-    // Align to avoid false sharing between adjacent slots
-    alignas(hardwareInterferenceSize) std::atomic<size_t> turn = {0};
-    typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
-};
-
-template <typename T, typename Allocator = AlignedAllocator<Slot<T>>>
-class Queue {
-private:
-    static_assert(std::is_nothrow_copy_assignable<T>::value ||
-                      std::is_nothrow_move_assignable<T>::value,
-                  "T must be nothrow copy or move assignable");
-
-    static_assert(std::is_nothrow_destructible<T>::value, "T must be nothrow destructible");
-
+template <typename T, bool with_stop_token = false>
+class SPSCQueue {
 public:
-    explicit Queue(const size_t capacity, const Allocator& allocator = Allocator())
-        : capacity_(capacity), allocator_(allocator), head_(0), tail_(0) {
-        if (capacity_ < 1) {
-            throw std::invalid_argument("capacity < 1");
-        }
-        // Allocate one extra slot to prevent false sharing on the last slot
-        slots_ = allocator_.allocate(capacity_ + 1);
-        // Allocators are not required to honor alignment for over-aligned types
-        // (see http://eel.is/c++draft/allocator.requirements#10) so we verify
-        // alignment here
-        if (reinterpret_cast<size_t>(slots_) % alignof(Slot<T>) != 0) {
-            allocator_.deallocate(slots_, capacity_ + 1);
-            throw std::bad_alloc();
-        }
-        for (size_t i = 0; i < capacity_; ++i) {
-            new (&slots_[i]) Slot<T>();
-        }
-        static_assert(alignof(Slot<T>) == hardwareInterferenceSize,
-                      "Slot must be aligned to cache line boundary to prevent false sharing");
-        static_assert(sizeof(Slot<T>) % hardwareInterferenceSize == 0,
-                      "Slot size must be a multiple of cache line size to prevent "
-                      "false sharing between adjacent slots");
-        static_assert(sizeof(Queue) % hardwareInterferenceSize == 0,
-                      "Queue size must be a multiple of cache line size to "
-                      "prevent false sharing between adjacent queues");
-        static_assert(offsetof(Queue, tail_) - offsetof(Queue, head_) ==
-                          static_cast<std::ptrdiff_t>(hardwareInterferenceSize),
-                      "head and tail must be a cache line apart to prevent false sharing");
+    SPSCQueue() {
+        write_ptr = read_ptr = new ElementPtr();
+    }
+    ~SPSCQueue() {
+        // this will empty out the whole queue
+        delete read_ptr;
     }
 
-    ~Queue() noexcept {
-        for (size_t i = 0; i < capacity_; ++i) {
-            slots_[i].~Slot();
-        }
-        allocator_.deallocate(slots_, capacity_ + 1);
+    [[nodiscard]] std::size_t Size() const {
+        return size.load();
     }
 
-    // non-copyable and non-movable
-    Queue(const Queue&) = delete;
-    Queue& operator=(const Queue&) = delete;
-
-    template <typename... Args>
-    void emplace(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
-                      "T must be nothrow constructible with Args&&...");
-        auto const head = head_.fetch_add(1);
-        auto& slot = slots_[idx(head)];
-        while (turn(head) * 2 != slot.turn.load(std::memory_order_acquire))
-            ;
-        slot.construct(std::forward<Args>(args)...);
-        slot.turn.store(turn(head) * 2 + 1, std::memory_order_release);
+    [[nodiscard]] bool Empty() const {
+        return Size() == 0;
     }
 
-    template <typename... Args>
-    bool try_emplace(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible<T, Args&&...>::value,
-                      "T must be nothrow constructible with Args&&...");
-        auto head = head_.load(std::memory_order_acquire);
-        for (;;) {
-            auto& slot = slots_[idx(head)];
-            if (turn(head) * 2 == slot.turn.load(std::memory_order_acquire)) {
-                if (head_.compare_exchange_strong(head, head + 1)) {
-                    slot.construct(std::forward<Args>(args)...);
-                    slot.turn.store(turn(head) * 2 + 1, std::memory_order_release);
-                    return true;
-                }
-            } else {
-                auto const prevHead = head;
-                head = head_.load(std::memory_order_acquire);
-                if (head == prevHead) {
-                    return false;
-                }
-            }
+    [[nodiscard]] T& Front() const {
+        return read_ptr->current;
+    }
+
+    template <typename Arg>
+    void Push(Arg&& t) {
+        // create the element, add it to the queue
+        write_ptr->current = std::forward<Arg>(t);
+        // set the next pointer to a new element ptr
+        // then advance the write pointer
+        ElementPtr* new_ptr = new ElementPtr();
+        write_ptr->next.store(new_ptr, std::memory_order_release);
+        write_ptr = new_ptr;
+        ++size;
+
+        // cv_mutex must be held or else there will be a missed wakeup if the other thread is in the
+        // line before cv.wait
+        // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
+        // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
+        std::lock_guard lock{cv_mutex};
+        cv.notify_one();
+    }
+
+    void Pop() {
+        --size;
+
+        ElementPtr* tmpptr = read_ptr;
+        // advance the read pointer
+        read_ptr = tmpptr->next.load();
+        // set the next element to nullptr to stop the recursive deletion
+        tmpptr->next.store(nullptr);
+        delete tmpptr; // this also deletes the element
+    }
+
+    bool Pop(T& t) {
+        if (Empty())
+            return false;
+
+        --size;
+
+        ElementPtr* tmpptr = read_ptr;
+        read_ptr = tmpptr->next.load(std::memory_order_acquire);
+        t = std::move(tmpptr->current);
+        tmpptr->next.store(nullptr);
+        delete tmpptr;
+        return true;
+    }
+
+    void Wait() {
+        if (Empty()) {
+            std::unique_lock lock{cv_mutex};
+            cv.wait(lock, [this] { return !Empty(); });
         }
     }
 
-    void push(const T& v) noexcept {
-        static_assert(std::is_nothrow_copy_constructible<T>::value,
-                      "T must be nothrow copy constructible");
-        emplace(v);
+    T PopWait() {
+        Wait();
+        T t;
+        Pop(t);
+        return t;
     }
 
-    template <typename P, typename = typename std::enable_if<
-                              std::is_nothrow_constructible<T, P&&>::value>::type>
-    void push(P&& v) noexcept {
-        emplace(std::forward<P>(v));
-    }
-
-    bool try_push(const T& v) noexcept {
-        static_assert(std::is_nothrow_copy_constructible<T>::value,
-                      "T must be nothrow copy constructible");
-        return try_emplace(v);
-    }
-
-    template <typename P, typename = typename std::enable_if<
-                              std::is_nothrow_constructible<T, P&&>::value>::type>
-    bool try_push(P&& v) noexcept {
-        return try_emplace(std::forward<P>(v));
-    }
-
-    void pop(T& v) noexcept {
-        auto const tail = tail_.fetch_add(1);
-        auto& slot = slots_[idx(tail)];
-        while (turn(tail) * 2 + 1 != slot.turn.load(std::memory_order_acquire))
-            ;
-        v = slot.move();
-        slot.destroy();
-        slot.turn.store(turn(tail) * 2 + 2, std::memory_order_release);
-    }
-
-    bool try_pop(T& v) noexcept {
-        auto tail = tail_.load(std::memory_order_acquire);
-        for (;;) {
-            auto& slot = slots_[idx(tail)];
-            if (turn(tail) * 2 + 1 == slot.turn.load(std::memory_order_acquire)) {
-                if (tail_.compare_exchange_strong(tail, tail + 1)) {
-                    v = slot.move();
-                    slot.destroy();
-                    slot.turn.store(turn(tail) * 2 + 2, std::memory_order_release);
-                    return true;
-                }
-            } else {
-                auto const prevTail = tail;
-                tail = tail_.load(std::memory_order_acquire);
-                if (tail == prevTail) {
-                    return false;
-                }
-            }
+    T PopWait(std::stop_token stop_token) {
+        if (Empty()) {
+            std::unique_lock lock{cv_mutex};
+            cv.wait(lock, stop_token, [this] { return !Empty(); });
         }
+        if (stop_token.stop_requested()) {
+            return T{};
+        }
+        T t;
+        Pop(t);
+        return t;
+    }
+
+    // not thread-safe
+    void Clear() {
+        size.store(0);
+        delete read_ptr;
+        write_ptr = read_ptr = new ElementPtr();
     }
 
 private:
-    constexpr size_t idx(size_t i) const noexcept {
-        return i % capacity_;
-    }
+    // stores a pointer to element
+    // and a pointer to the next ElementPtr
+    class ElementPtr {
+    public:
+        ElementPtr() {}
+        ~ElementPtr() {
+            ElementPtr* next_ptr = next.load();
 
-    constexpr size_t turn(size_t i) const noexcept {
-        return i / capacity_;
-    }
+            if (next_ptr)
+                delete next_ptr;
+        }
 
-private:
-    const size_t capacity_;
-    Slot<T>* slots_;
-#if defined(__has_cpp_attribute) && __has_cpp_attribute(no_unique_address)
-    Allocator allocator_ [[no_unique_address]];
-#else
-    Allocator allocator_;
-#endif
+        T current;
+        std::atomic<ElementPtr*> next{nullptr};
+    };
 
-    // Align to avoid false sharing between head_ and tail_
-    alignas(hardwareInterferenceSize) std::atomic<size_t> head_;
-    alignas(hardwareInterferenceSize) std::atomic<size_t> tail_;
+    ElementPtr* write_ptr;
+    ElementPtr* read_ptr;
+    std::atomic_size_t size{0};
+    std::mutex cv_mutex;
+    std::conditional_t<with_stop_token, std::condition_variable_any, std::condition_variable> cv;
 };
-} // namespace mpmc
 
-template <typename T, typename Allocator = mpmc::AlignedAllocator<mpmc::Slot<T>>>
-using MPMCQueue = mpmc::Queue<T, Allocator>;
+// a simple thread-safe,
+// single reader, multiple writer queue
 
-} // namespace Common
+template <typename T, bool with_stop_token = false>
+class MPSCQueue {
+public:
+    [[nodiscard]] std::size_t Size() const {
+        return spsc_queue.Size();
+    }
+
+    [[nodiscard]] bool Empty() const {
+        return spsc_queue.Empty();
+    }
+
+    [[nodiscard]] T& Front() const {
+        return spsc_queue.Front();
+    }
+
+    template <typename Arg>
+    void Push(Arg&& t) {
+        std::lock_guard lock{write_lock};
+        spsc_queue.Push(t);
+    }
+
+    void Pop() {
+        return spsc_queue.Pop();
+    }
+
+    bool Pop(T& t) {
+        return spsc_queue.Pop(t);
+    }
+
+    void Wait() {
+        spsc_queue.Wait();
+    }
+
+    T PopWait() {
+        return spsc_queue.PopWait();
+    }
+
+    T PopWait(std::stop_token stop_token) {
+        return spsc_queue.PopWait(stop_token);
+    }
+
+    // not thread-safe
+    void Clear() {
+        spsc_queue.Clear();
+    }
+
+private:
+    SPSCQueue<T, with_stop_token> spsc_queue;
+    std::mutex write_lock;
+};
+} // namespace Common

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -263,7 +263,7 @@ void ARM_Dynarmic_64::Run() {
 }
 
 void ARM_Dynarmic_64::Step() {
-    cb->InterpreterFallback(jit->GetPC(), 1);
+    jit->Step();
 }
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,

src/core/core.cpp

@@ -196,8 +196,9 @@ struct System::Impl {
         cpu_manager.Initialize();
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
-            std::chrono::system_clock::now().time_since_epoch());
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
         Settings::values.custom_rtc_differential =
             Settings::values.custom_rtc.value_or(current_time) - current_time;
 

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

@@ -69,8 +69,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     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);
+    std::vector<u32> fence_thresholds(params.fence_count);
 
     // Slice input into their respective buffers
     std::size_t offset = sizeof(IoctlSubmit);
@@ -78,15 +77,13 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset += SliceVectors(input, relocs, params.relocation_count, offset);
     offset += SliceVectors(input, reloc_shifts, params.relocation_count, offset);
     offset += SliceVectors(input, syncpt_increments, params.syncpoint_count, offset);
-    offset += SliceVectors(input, wait_checks, params.syncpoint_count, offset);
-    offset += SliceVectors(input, fences, params.fence_count, offset);
+    offset += SliceVectors(input, fence_thresholds, params.fence_count, offset);
 
     auto& gpu = system.GPU();
     if (gpu.UseNvdec()) {
         for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
             const SyncptIncr& syncpt_incr = syncpt_increments[i];
-            fences[i].id = syncpt_incr.id;
-            fences[i].value =
+            fence_thresholds[i] =
                 syncpoint_manager.IncreaseSyncpoint(syncpt_incr.id, syncpt_incr.increments);
         }
     }
@@ -98,11 +95,6 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
                                   cmdlist.size() * sizeof(u32));
         gpu.PushCommandBuffer(cmdlist);
     }
-    if (gpu.UseNvdec()) {
-        fences[0].value = syncpoint_manager.IncreaseSyncpoint(fences[0].id, 1);
-        Tegra::ChCommandHeaderList cmdlist{{(4 << 28) | fences[0].id}};
-        gpu.PushCommandBuffer(cmdlist);
-    }
     std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
     // Some games expect command_buffers to be written back
     offset = sizeof(IoctlSubmit);
@@ -110,8 +102,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
     offset += WriteVectors(output, relocs, offset);
     offset += WriteVectors(output, reloc_shifts, offset);
     offset += WriteVectors(output, syncpt_increments, offset);
-    offset += WriteVectors(output, wait_checks, offset);
-    offset += WriteVectors(output, fences, offset);
+    offset += WriteVectors(output, fence_thresholds, offset);
 
     return NvResult::Success;
 }

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

@@ -56,19 +56,16 @@ protected:
         s32 target{};
         s32 target_offset{};
     };
-    static_assert(sizeof(Reloc) == 0x10, "CommandBuffer has incorrect size");
+    static_assert(sizeof(Reloc) == 0x10, "Reloc has incorrect size");
 
     struct SyncptIncr {
         u32 id{};
         u32 increments{};
+        u32 unk0{};
+        u32 unk1{};
+        u32 unk2{};
     };
-    static_assert(sizeof(SyncptIncr) == 0x8, "CommandBuffer has incorrect size");
-
-    struct Fence {
-        u32 id{};
-        u32 value{};
-    };
-    static_assert(sizeof(Fence) == 0x8, "CommandBuffer has incorrect size");
+    static_assert(sizeof(SyncptIncr) == 0x14, "SyncptIncr has incorrect size");
 
     struct IoctlGetSyncpoint {
         // Input

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

@@ -13,18 +13,19 @@
 #include "core/hle/service/time/time_manager.h"
 
 namespace Service::Time {
-
+namespace {
 constexpr Clock::TimeSpanType standard_network_clock_accuracy{0x0009356907420000ULL};
 
-static std::chrono::seconds GetSecondsSinceEpoch() {
-    return std::chrono::duration_cast<std::chrono::seconds>(
-               std::chrono::system_clock::now().time_since_epoch()) +
+s64 GetSecondsSinceEpoch() {
+    const auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch();
+    return std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch).count() +
            Settings::values.custom_rtc_differential;
 }
 
-static s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch().count() + TimeManager::GetExternalTimeZoneOffset();
+s64 GetExternalRtcValue() {
+    return GetSecondsSinceEpoch() + TimeManager::GetExternalTimeZoneOffset();
 }
+} // Anonymous namespace
 
 struct TimeManager::Impl final {
     explicit Impl(Core::System& system)

src/input_common/gcadapter/gc_adapter.cpp

@@ -170,7 +170,7 @@ void Adapter::UpdateYuzuSettings(std::size_t port) {
 
     if (pads[port].buttons != 0) {
         pad_status.button = pads[port].last_button;
-        pad_queue.push(pad_status);
+        pad_queue.Push(pad_status);
     }
 
     // Accounting for a threshold here to ensure an intentional press
@@ -181,7 +181,7 @@ void Adapter::UpdateYuzuSettings(std::size_t port) {
             pad_status.axis = static_cast<PadAxes>(i);
             pad_status.axis_value = value;
             pad_status.axis_threshold = axis_threshold;
-            pad_queue.push(pad_status);
+            pad_queue.Push(pad_status);
         }
     }
 }
@@ -478,18 +478,20 @@ bool Adapter::DeviceConnected(std::size_t port) const {
 }
 
 void Adapter::BeginConfiguration() {
+    pad_queue.Clear();
     configuring = true;
 }
 
 void Adapter::EndConfiguration() {
+    pad_queue.Clear();
     configuring = false;
 }
 
-Common::MPMCQueue<GCPadStatus>& Adapter::GetPadQueue() {
+Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() {
     return pad_queue;
 }
 
-const Common::MPMCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
+const Common::SPSCQueue<GCPadStatus>& Adapter::GetPadQueue() const {
     return pad_queue;
 }
 

src/input_common/gcadapter/gc_adapter.h

@@ -85,8 +85,8 @@ public:
     void BeginConfiguration();
     void EndConfiguration();
 
-    Common::MPMCQueue<GCPadStatus>& GetPadQueue();
-    const Common::MPMCQueue<GCPadStatus>& GetPadQueue() const;
+    Common::SPSCQueue<GCPadStatus>& GetPadQueue();
+    const Common::SPSCQueue<GCPadStatus>& GetPadQueue() const;
 
     GCController& GetPadState(std::size_t port);
     const GCController& GetPadState(std::size_t port) const;
@@ -145,7 +145,7 @@ private:
 
     libusb_device_handle* usb_adapter_handle = nullptr;
     std::array<GCController, 4> pads;
-    Common::MPMCQueue<GCPadStatus> pad_queue{1024};
+    Common::SPSCQueue<GCPadStatus> pad_queue;
 
     std::thread adapter_input_thread;
     std::thread adapter_scan_thread;

src/input_common/gcadapter/gc_poller.cpp

@@ -103,7 +103,7 @@ Common::ParamPackage GCButtonFactory::GetNextInput() const {
     Common::ParamPackage params;
     GCAdapter::GCPadStatus pad;
     auto& queue = adapter->GetPadQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         params.Set("engine", "gcpad");
         params.Set("port", static_cast<s32>(pad.port));
@@ -263,7 +263,7 @@ Common::ParamPackage GCAnalogFactory::GetNextInput() {
     GCAdapter::GCPadStatus pad;
     Common::ParamPackage params;
     auto& queue = adapter->GetPadQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         if (pad.button != GCAdapter::PadButton::Undefined) {
             params.Set("engine", "gcpad");
             params.Set("port", static_cast<s32>(pad.port));

src/input_common/mouse/mouse_input.cpp

@@ -52,7 +52,7 @@ void Mouse::UpdateYuzuSettings() {
         return;
     }
 
-    mouse_queue.push(MouseStatus{
+    mouse_queue.Push(MouseStatus{
         .button = last_button,
     });
 }
@@ -153,6 +153,7 @@ void Mouse::ReleaseAllButtons() {
 void Mouse::BeginConfiguration() {
     buttons = 0;
     last_button = MouseButton::Undefined;
+    mouse_queue.Clear();
     configuring = true;
 }
 
@@ -164,6 +165,7 @@ void Mouse::EndConfiguration() {
         info.data.axis = {0, 0};
     }
     last_button = MouseButton::Undefined;
+    mouse_queue.Clear();
     configuring = false;
 }
 
@@ -203,11 +205,11 @@ bool Mouse::UnlockButton(std::size_t button_) {
     return button_state;
 }
 
-Common::MPMCQueue<MouseStatus>& Mouse::GetMouseQueue() {
+Common::SPSCQueue<MouseStatus>& Mouse::GetMouseQueue() {
     return mouse_queue;
 }
 
-const Common::MPMCQueue<MouseStatus>& Mouse::GetMouseQueue() const {
+const Common::SPSCQueue<MouseStatus>& Mouse::GetMouseQueue() const {
     return mouse_queue;
 }
 

src/input_common/mouse/mouse_input.h

@@ -79,8 +79,8 @@ public:
     [[nodiscard]] bool ToggleButton(std::size_t button_);
     [[nodiscard]] bool UnlockButton(std::size_t button_);
 
-    [[nodiscard]] Common::MPMCQueue<MouseStatus>& GetMouseQueue();
-    [[nodiscard]] const Common::MPMCQueue<MouseStatus>& GetMouseQueue() const;
+    [[nodiscard]] Common::SPSCQueue<MouseStatus>& GetMouseQueue();
+    [[nodiscard]] const Common::SPSCQueue<MouseStatus>& GetMouseQueue() const;
 
     [[nodiscard]] MouseData& GetMouseState(std::size_t button);
     [[nodiscard]] const MouseData& GetMouseState(std::size_t button) const;
@@ -109,7 +109,7 @@ private:
     std::jthread update_thread;
     MouseButton last_button{MouseButton::Undefined};
     std::array<MouseInfo, 7> mouse_info;
-    Common::MPMCQueue<MouseStatus> mouse_queue{1024};
+    Common::SPSCQueue<MouseStatus> mouse_queue;
     bool configuring{false};
     int mouse_panning_timout{};
 };

src/input_common/mouse/mouse_poller.cpp

@@ -52,7 +52,7 @@ Common::ParamPackage MouseButtonFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -184,7 +184,7 @@ Common::ParamPackage MouseAnalogFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -227,7 +227,7 @@ Common::ParamPackage MouseMotionFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
@@ -275,7 +275,7 @@ Common::ParamPackage MouseTouchFactory::GetNextInput() const {
     MouseInput::MouseStatus pad;
     Common::ParamPackage params;
     auto& queue = mouse_input->GetMouseQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         // This while loop will break on the earliest detected button
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");

src/input_common/sdl/sdl_impl.cpp

@@ -46,7 +46,7 @@ static int SDLEventWatcher(void* user_data, SDL_Event* event) {
 
     // Don't handle the event if we are configuring
     if (sdl_state->polling) {
-        sdl_state->event_queue.push(*event);
+        sdl_state->event_queue.Push(*event);
     } else {
         sdl_state->HandleGameControllerEvent(*event);
     }
@@ -1460,6 +1460,7 @@ public:
     explicit SDLPoller(SDLState& state_) : state(state_) {}
 
     void Start([[maybe_unused]] const std::string& device_id) override {
+        state.event_queue.Clear();
         state.polling = true;
     }
 
@@ -1477,7 +1478,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.try_pop(event)) {
+        while (state.event_queue.Pop(event)) {
             const auto package = FromEvent(event);
             if (package) {
                 return *package;
@@ -1549,7 +1550,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.try_pop(event)) {
+        while (state.event_queue.Pop(event)) {
             const auto package = FromEvent(event);
             if (package) {
                 return *package;
@@ -1591,7 +1592,7 @@ public:
 
     Common::ParamPackage GetNextInput() override {
         SDL_Event event;
-        while (state.event_queue.try_pop(event)) {
+        while (state.event_queue.Pop(event)) {
             if (event.type != SDL_JOYAXISMOTION) {
                 // Check for a button press
                 auto button_press = button_poller.FromEvent(event);

src/input_common/sdl/sdl_impl.h

@@ -59,7 +59,7 @@ public:
 
     /// Used by the Pollers during config
     std::atomic<bool> polling = false;
-    Common::MPMCQueue<SDL_Event> event_queue{1024};
+    Common::SPSCQueue<SDL_Event> event_queue;
 
     std::vector<Common::ParamPackage> GetInputDevices() override;
 

src/input_common/udp/client.cpp

@@ -338,7 +338,7 @@ void Client::UpdateYuzuSettings(std::size_t client, std::size_t pad_index,
                   gyro[0], gyro[1], gyro[2], acc[0], acc[1], acc[2]);
     }
     UDPPadStatus pad{
-        .host = clients[client].host.c_str(),
+        .host = clients[client].host,
         .port = clients[client].port,
         .pad_index = pad_index,
     };
@@ -346,12 +346,12 @@ void Client::UpdateYuzuSettings(std::size_t client, std::size_t pad_index,
         if (gyro[i] > 5.0f || gyro[i] < -5.0f) {
             pad.motion = static_cast<PadMotion>(i);
             pad.motion_value = gyro[i];
-            pad_queue.push(pad);
+            pad_queue.Push(pad);
         }
         if (acc[i] > 1.75f || acc[i] < -1.75f) {
             pad.motion = static_cast<PadMotion>(i + 3);
             pad.motion_value = acc[i];
-            pad_queue.push(pad);
+            pad_queue.Push(pad);
         }
     }
 }
@@ -401,10 +401,12 @@ void Client::UpdateTouchInput(Response::TouchPad& touch_pad, std::size_t client,
 }
 
 void Client::BeginConfiguration() {
+    pad_queue.Clear();
     configuring = true;
 }
 
 void Client::EndConfiguration() {
+    pad_queue.Clear();
     configuring = false;
 }
 
@@ -432,11 +434,11 @@ const Input::TouchStatus& Client::GetTouchState() const {
     return touch_status;
 }
 
-Common::MPMCQueue<UDPPadStatus>& Client::GetPadQueue() {
+Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() {
     return pad_queue;
 }
 
-const Common::MPMCQueue<UDPPadStatus>& Client::GetPadQueue() const {
+const Common::SPSCQueue<UDPPadStatus>& Client::GetPadQueue() const {
     return pad_queue;
 }
 
@@ -469,46 +471,42 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
     std::function<void(u16, u16, u16, u16)> data_callback) {
 
     std::thread([=, this] {
-        constexpr u16 CALIBRATION_THRESHOLD = 100;
-
-        u16 min_x{UINT16_MAX};
-        u16 min_y{UINT16_MAX};
-        u16 max_x{};
-        u16 max_y{};
-
         Status current_status{Status::Initialized};
-        SocketCallback callback{[](Response::Version) {}, [](Response::PortInfo) {},
-                                [&](Response::PadData data) {
-                                    if (current_status == Status::Initialized) {
-                                        // Receiving data means the communication is ready now
-                                        current_status = Status::Ready;
-                                        status_callback(current_status);
-                                    }
-                                    if (data.touch[0].is_active == 0) {
-                                        return;
-                                    }
-                                    LOG_DEBUG(Input, "Current touch: {} {}", data.touch[0].x,
-                                              data.touch[0].y);
-                                    min_x = std::min(min_x, static_cast<u16>(data.touch[0].x));
-                                    min_y = std::min(min_y, static_cast<u16>(data.touch[0].y));
-                                    if (current_status == Status::Ready) {
-                                        // First touch - min data (min_x/min_y)
-                                        current_status = Status::Stage1Completed;
-                                        status_callback(current_status);
-                                    }
-                                    if (data.touch[0].x - min_x > CALIBRATION_THRESHOLD &&
-                                        data.touch[0].y - min_y > CALIBRATION_THRESHOLD) {
-                                        // Set the current position as max value and finishes
-                                        // configuration
-                                        max_x = data.touch[0].x;
-                                        max_y = data.touch[0].y;
-                                        current_status = Status::Completed;
-                                        data_callback(min_x, min_y, max_x, max_y);
-                                        status_callback(current_status);
+        SocketCallback callback{
+            [](Response::Version) {}, [](Response::PortInfo) {},
+            [&](Response::PadData data) {
+                static constexpr u16 CALIBRATION_THRESHOLD = 100;
+                static constexpr u16 MAX_VALUE = UINT16_MAX;
 
-                                        complete_event.Set();
-                                    }
-                                }};
+                if (current_status == Status::Initialized) {
+                    // Receiving data means the communication is ready now
+                    current_status = Status::Ready;
+                    status_callback(current_status);
+                }
+                const auto& touchpad_0 = data.touch[0];
+                if (touchpad_0.is_active == 0) {
+                    return;
+                }
+                LOG_DEBUG(Input, "Current touch: {} {}", touchpad_0.x, touchpad_0.y);
+                const u16 min_x = std::min(MAX_VALUE, static_cast<u16>(touchpad_0.x));
+                const u16 min_y = std::min(MAX_VALUE, static_cast<u16>(touchpad_0.y));
+                if (current_status == Status::Ready) {
+                    // First touch - min data (min_x/min_y)
+                    current_status = Status::Stage1Completed;
+                    status_callback(current_status);
+                }
+                if (touchpad_0.x - min_x > CALIBRATION_THRESHOLD &&
+                    touchpad_0.y - min_y > CALIBRATION_THRESHOLD) {
+                    // Set the current position as max value and finishes configuration
+                    const u16 max_x = touchpad_0.x;
+                    const u16 max_y = touchpad_0.y;
+                    current_status = Status::Completed;
+                    data_callback(min_x, min_y, max_x, max_y);
+                    status_callback(current_status);
+
+                    complete_event.Set();
+                }
+            }};
         Socket socket{host, port, std::move(callback)};
         std::thread worker_thread{SocketLoop, &socket};
         complete_event.Wait();

src/input_common/udp/client.h

@@ -46,7 +46,7 @@ enum class PadTouch {
 };
 
 struct UDPPadStatus {
-    const char* host{"127.0.0.1"};
+    std::string host{"127.0.0.1"};
     u16 port{26760};
     std::size_t pad_index{};
     PadMotion motion{PadMotion::Undefined};
@@ -85,8 +85,8 @@ public:
     bool DeviceConnected(std::size_t pad) const;
     void ReloadSockets();
 
-    Common::MPMCQueue<UDPPadStatus>& GetPadQueue();
-    const Common::MPMCQueue<UDPPadStatus>& GetPadQueue() const;
+    Common::SPSCQueue<UDPPadStatus>& GetPadQueue();
+    const Common::SPSCQueue<UDPPadStatus>& GetPadQueue() const;
 
     DeviceStatus& GetPadState(const std::string& host, u16 port, std::size_t pad);
     const DeviceStatus& GetPadState(const std::string& host, u16 port, std::size_t pad) const;
@@ -146,7 +146,7 @@ private:
     static constexpr std::size_t MAX_TOUCH_FINGERS = MAX_UDP_CLIENTS * 2;
     std::array<PadData, MAX_UDP_CLIENTS * PADS_PER_CLIENT> pads{};
     std::array<ClientConnection, MAX_UDP_CLIENTS> clients{};
-    Common::MPMCQueue<UDPPadStatus> pad_queue{1024};
+    Common::SPSCQueue<UDPPadStatus> pad_queue{};
     Input::TouchStatus touch_status{};
     std::array<std::size_t, MAX_TOUCH_FINGERS> finger_id{};
 };

src/input_common/udp/udp.cpp

@@ -59,7 +59,7 @@ Common::ParamPackage UDPMotionFactory::GetNextInput() {
     Common::ParamPackage params;
     CemuhookUDP::UDPPadStatus pad;
     auto& queue = client->GetPadQueue();
-    while (queue.try_pop(pad)) {
+    while (queue.Pop(pad)) {
         if (pad.motion == CemuhookUDP::PadMotion::Undefined || std::abs(pad.motion_value) < 1) {
             continue;
         }

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -492,7 +492,7 @@ void TexturePass(Environment& env, IR::Program& program) {
             const auto insert_point{IR::Block::InstructionList::s_iterator_to(*inst)};
             IR::IREmitter ir{*texture_inst.block, insert_point};
             const IR::U32 shift{ir.Imm32(std::countr_zero(DESCRIPTOR_SIZE))};
-            inst->SetArg(0, ir.SMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
+            inst->SetArg(0, ir.UMin(ir.ShiftRightArithmetic(cbuf.dynamic_offset, shift),
                                     ir.Imm32(DESCRIPTOR_SIZE - 1)));
         } else {
             inst->SetArg(0, IR::Value{});

src/video_core/dirty_flags.h

@@ -38,6 +38,9 @@ enum : u8 {
 
     Shaders,
 
+    // Special entries
+    DepthBiasGlobal,
+
     LastCommonEntry,
 };
 

src/video_core/gpu_thread.cpp

@@ -32,8 +32,7 @@ static void RunThread(std::stop_token stop_token, Core::System& system,
     VideoCore::RasterizerInterface* const rasterizer = renderer.ReadRasterizer();
 
     while (!stop_token.stop_requested()) {
-        CommandDataContainer next;
-        state.queue.pop(next);
+        CommandDataContainer next = state.queue.PopWait(stop_token);
         if (stop_token.stop_requested()) {
             break;
         }
@@ -120,7 +119,7 @@ u64 ThreadManager::PushCommand(CommandData&& command_data, bool block) {
 
     std::unique_lock lk(state.write_lock);
     const u64 fence{++state.last_fence};
-    state.queue.push(CommandDataContainer(std::move(command_data), fence, block));
+    state.queue.Push(CommandDataContainer(std::move(command_data), fence, block));
 
     if (block) {
         state.cv.wait(lk, thread.get_stop_token(), [this, fence] {

src/video_core/gpu_thread.h

@@ -97,9 +97,9 @@ struct CommandDataContainer {
 
 /// Struct used to synchronize the GPU thread
 struct SynchState final {
-    using CommandQueue = Common::MPMCQueue<CommandDataContainer>;
+    using CommandQueue = Common::SPSCQueue<CommandDataContainer, true>;
     std::mutex write_lock;
-    CommandQueue queue{100000};
+    CommandQueue queue;
     u64 last_fence{};
     std::atomic<u64> signaled_fence{};
     std::condition_variable_any cv;

src/video_core/renderer_opengl/gl_device.cpp

@@ -10,6 +10,7 @@
 #include <limits>
 #include <optional>
 #include <span>
+#include <stdexcept>
 #include <vector>
 
 #include <glad/glad.h>

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -627,9 +627,21 @@ void RasterizerVulkan::UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs) {
     if (!state_tracker.TouchDepthBias()) {
         return;
     }
-    scheduler.Record([constant = regs.polygon_offset_units, clamp = regs.polygon_offset_clamp,
+    float units = regs.polygon_offset_units / 2.0f;
+    const bool is_d24 = regs.zeta.format == Tegra::DepthFormat::S8_UINT_Z24_UNORM ||
+                        regs.zeta.format == Tegra::DepthFormat::D24X8_UNORM ||
+                        regs.zeta.format == Tegra::DepthFormat::D24S8_UNORM ||
+                        regs.zeta.format == Tegra::DepthFormat::D24C8_UNORM;
+    if (is_d24 && !device.SupportsD24DepthBuffer()) {
+        // the base formulas can be obtained from here:
+        //   https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-output-merger-stage-depth-bias
+        const double rescale_factor =
+            static_cast<double>(1ULL << (32 - 24)) / (static_cast<double>(0x1.ep+127));
+        units = static_cast<float>(static_cast<double>(units) * rescale_factor);
+    }
+    scheduler.Record([constant = units, clamp = regs.polygon_offset_clamp,
                       factor = regs.polygon_offset_factor](vk::CommandBuffer cmdbuf) {
-        cmdbuf.SetDepthBias(constant, clamp, factor / 2.0f);
+        cmdbuf.SetDepthBias(constant, clamp, factor);
     });
 }
 

src/video_core/renderer_vulkan/vk_state_tracker.cpp

@@ -54,6 +54,7 @@ void SetupDirtyViewports(Tables& tables) {
     FillBlock(tables[0], OFF(viewport_transform), NUM(viewport_transform), Viewports);
     FillBlock(tables[0], OFF(viewports), NUM(viewports), Viewports);
     tables[0][OFF(viewport_transform_enabled)] = Viewports;
+    tables[1][OFF(screen_y_control)] = Viewports;
 }
 
 void SetupDirtyScissors(Tables& tables) {

src/video_core/renderer_vulkan/vk_state_tracker.h

@@ -79,7 +79,8 @@ public:
     }
 
     bool TouchDepthBias() {
-        return Exchange(Dirty::DepthBias, false);
+        return Exchange(Dirty::DepthBias, false) ||
+               Exchange(VideoCommon::Dirty::DepthBiasGlobal, false);
     }
 
     bool TouchBlendConstants() {

src/video_core/texture_cache/texture_cache.h

@@ -221,6 +221,7 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         BindRenderTarget(&render_targets.depth_buffer_id, FindDepthBuffer(is_clear));
     }
     const ImageViewId depth_buffer_id = render_targets.depth_buffer_id;
+
     PrepareImageView(depth_buffer_id, true, is_clear && IsFullClear(depth_buffer_id));
 
     for (size_t index = 0; index < NUM_RT; ++index) {
@@ -230,6 +231,8 @@ void TextureCache<P>::UpdateRenderTargets(bool is_clear) {
         maxwell3d.regs.render_area.width,
         maxwell3d.regs.render_area.height,
     };
+
+    flags[Dirty::DepthBiasGlobal] = true;
 }
 
 template <class P>

src/video_core/vulkan_common/vulkan_device.cpp

@@ -623,6 +623,10 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
         is_float16_supported = false;
     }
 
+    supports_d24_depth =
+        IsFormatSupported(VK_FORMAT_D24_UNORM_S8_UINT,
+                          VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, FormatType::Optimal);
+
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);
 }

src/video_core/vulkan_common/vulkan_device.h

@@ -332,6 +332,10 @@ public:
         return sets_per_pool;
     }
 
+    bool SupportsD24DepthBuffer() const {
+        return supports_d24_depth;
+    }
+
 private:
     /// Checks if the physical device is suitable.
     void CheckSuitability(bool requires_swapchain) const;
@@ -425,6 +429,7 @@ private:
     bool has_broken_cube_compatibility{};   ///< Has broken cube compatiblity bit
     bool has_renderdoc{};                   ///< Has RenderDoc attached
     bool has_nsight_graphics{};             ///< Has Nsight Graphics attached
+    bool supports_d24_depth{};              ///< Supports D24 depth buffers.
 
     // Telemetry parameters
     std::string vendor_name;                       ///< Device's driver name.

src/yuzu/configuration/config.cpp

@@ -918,8 +918,7 @@ void Config::ReadSystemValues() {
         const auto custom_rtc_enabled =
             ReadSetting(QStringLiteral("custom_rtc_enabled"), false).toBool();
         if (custom_rtc_enabled) {
-            Settings::values.custom_rtc =
-                std::chrono::seconds(ReadSetting(QStringLiteral("custom_rtc"), 0).toULongLong());
+            Settings::values.custom_rtc = ReadSetting(QStringLiteral("custom_rtc"), 0).toLongLong();
         } else {
             Settings::values.custom_rtc = std::nullopt;
         }
@@ -1450,9 +1449,7 @@ void Config::SaveSystemValues() {
         WriteSetting(QStringLiteral("custom_rtc_enabled"), Settings::values.custom_rtc.has_value(),
                      false);
         WriteSetting(QStringLiteral("custom_rtc"),
-                     QVariant::fromValue<long long>(
-                         Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()),
-                     0);
+                     QVariant::fromValue<long long>(Settings::values.custom_rtc.value_or(0)), 0);
     }
 
     WriteGlobalSetting(Settings::values.sound_index);

src/yuzu/configuration/configure_profile_manager.cpp

@@ -306,6 +306,17 @@ void ConfigureProfileManager::SetUserImage() {
         return;
     }
 
+    // Some games crash when the profile image is too big. Resize any image bigger than 256x256
+    QImage image(image_path);
+    if (image.width() > 256 || image.height() > 256) {
+        image = image.scaled(256, 256, Qt::KeepAspectRatio);
+        if (!image.save(image_path)) {
+            QMessageBox::warning(this, tr("Error resizing user image"),
+                                 tr("Unable to resize image"));
+            return;
+        }
+    }
+
     const auto username = GetAccountUsername(*profile_manager, *uuid);
     item_model->setItem(index, 0,
                         new QStandardItem{GetIcon(*uuid), FormatUserEntryText(username, *uuid)});

src/yuzu/configuration/configure_system.cpp

@@ -65,8 +65,7 @@ void ConfigureSystem::SetConfiguration() {
         QStringLiteral("%1")
             .arg(Settings::values.rng_seed.GetValue().value_or(0), 8, 16, QLatin1Char{'0'})
             .toUpper();
-    const auto rtc_time = Settings::values.custom_rtc.value_or(
-        std::chrono::seconds(QDateTime::currentSecsSinceEpoch()));
+    const auto rtc_time = Settings::values.custom_rtc.value_or(QDateTime::currentSecsSinceEpoch());
 
     ui->rng_seed_checkbox->setChecked(Settings::values.rng_seed.GetValue().has_value());
     ui->rng_seed_edit->setEnabled(Settings::values.rng_seed.GetValue().has_value() &&
@@ -75,7 +74,7 @@ void ConfigureSystem::SetConfiguration() {
 
     ui->custom_rtc_checkbox->setChecked(Settings::values.custom_rtc.has_value());
     ui->custom_rtc_edit->setEnabled(Settings::values.custom_rtc.has_value());
-    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time.count()));
+    ui->custom_rtc_edit->setDateTime(QDateTime::fromSecsSinceEpoch(rtc_time));
 
     if (Settings::IsConfiguringGlobal()) {
         ui->combo_language->setCurrentIndex(Settings::values.language_index.GetValue());
@@ -108,10 +107,9 @@ void ConfigureSystem::ApplyConfiguration() {
     // to allow in-game time to be fast forwarded
     if (Settings::IsConfiguringGlobal()) {
         if (ui->custom_rtc_checkbox->isChecked()) {
-            Settings::values.custom_rtc =
-                std::chrono::seconds(ui->custom_rtc_edit->dateTime().toSecsSinceEpoch());
+            Settings::values.custom_rtc = ui->custom_rtc_edit->dateTime().toSecsSinceEpoch();
             if (system.IsPoweredOn()) {
-                const s64 posix_time{Settings::values.custom_rtc->count() +
+                const s64 posix_time{*Settings::values.custom_rtc +
                                      Service::Time::TimeManager::GetExternalTimeZoneOffset()};
                 system.GetTimeManager().UpdateLocalSystemClockTime(posix_time);
             }

src/yuzu/configuration/configure_tas.ui

@@ -14,14 +14,14 @@
         <item row="0" column="0" colspan="4">
          <widget class="QLabel" name="label_1">
           <property name="text">
-           <string>Reads controller input from scripts in the same format as TAS-nx scripts.&lt;br/&gt;For a more detailed explanation please consult the FAQ on the yuzu website.</string>
+           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Reads controller input from scripts in the same format as TAS-nx scripts.&lt;br/&gt;For a more detailed explanation, please consult the &lt;a href=&quot;https://yuzu-emu.org/help/feature/tas/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#039be5;&quot;&gt;help page&lt;/span&gt;&lt;/a&gt; on the yuzu website.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
           </property>
          </widget>
         </item>
         <item row="1" column="0" colspan="4">
          <widget class="QLabel" name="label_2">
           <property name="text">
-           <string>To check which hotkeys control the playback/recording, please refer to the Hotkey settings (General -&gt; Hotkeys).</string>
+           <string>To check which hotkeys control the playback/recording, please refer to the Hotkey settings (Configure -&gt; General -&gt; Hotkeys).</string>
           </property>
           <property name="wordWrap">
            <bool>true</bool>

src/yuzu/main.cpp

@@ -287,8 +287,6 @@ GMainWindow::GMainWindow()
 
     ui->action_Fullscreen->setChecked(false);
 
-    Common::Log::Start();
-
     QStringList args = QApplication::arguments();
 
     if (args.size() < 2) {

src/yuzu_cmd/config.cpp

@@ -412,8 +412,7 @@ void Config::ReadValues() {
 
     const auto custom_rtc_enabled = sdl2_config->GetBoolean("System", "custom_rtc_enabled", false);
     if (custom_rtc_enabled) {
-        Settings::values.custom_rtc =
-            std::chrono::seconds(sdl2_config->GetInteger("System", "custom_rtc", 0));
+        Settings::values.custom_rtc = sdl2_config->GetInteger("System", "custom_rtc", 0);
     } else {
         Settings::values.custom_rtc = std::nullopt;
     }