Mark accelerted DMA destination buffers and images as GPU-modified

Allow searching by a substring of the title ID

src/common/settings_common.cpp

@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <functional>
 #include <string>
+#include <vector>
 #include "common/settings_common.h"
 
 namespace Settings {

src/common/settings_enums.h

@@ -12,8 +12,8 @@ namespace Settings {
 
 template <typename T>
 struct EnumMetadata {
-    static constexpr std::vector<std::pair<std::string, T>> Canonicalizations();
-    static constexpr u32 Index();
+    static std::vector<std::pair<std::string, T>> Canonicalizations();
+    static u32 Index();
 };
 
 #define PAIR_45(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_46(N, __VA_ARGS__))
@@ -66,11 +66,11 @@ struct EnumMetadata {
 #define ENUM(NAME, ...)                                                                            \
     enum class NAME : u32 { __VA_ARGS__ };                                                         \
     template <>                                                                                    \
-    constexpr std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {  \
+    inline std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {     \
         return {PAIR(NAME, __VA_ARGS__)};                                                          \
     }                                                                                              \
     template <>                                                                                    \
-    constexpr u32 EnumMetadata<NAME>::Index() {                                                    \
+    inline u32 EnumMetadata<NAME>::Index() {                                                       \
         return __COUNTER__;                                                                        \
     }
 
@@ -85,7 +85,7 @@ enum class AudioEngine : u32 {
 };
 
 template <>
-constexpr std::vector<std::pair<std::string, AudioEngine>>
+inline std::vector<std::pair<std::string, AudioEngine>>
 EnumMetadata<AudioEngine>::Canonicalizations() {
     return {
         {"auto", AudioEngine::Auto},
@@ -96,7 +96,7 @@ EnumMetadata<AudioEngine>::Canonicalizations() {
 }
 
 template <>
-constexpr u32 EnumMetadata<AudioEngine>::Index() {
+inline u32 EnumMetadata<AudioEngine>::Index() {
     // This is just a sufficiently large number that is more than the number of other enums declared
     // here
     return 100;
@@ -147,7 +147,7 @@ ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
 
 template <typename Type>
-constexpr std::string CanonicalizeEnum(Type id) {
+inline std::string CanonicalizeEnum(Type id) {
     const auto group = EnumMetadata<Type>::Canonicalizations();
     for (auto& [name, value] : group) {
         if (value == id) {
@@ -158,7 +158,7 @@ constexpr std::string CanonicalizeEnum(Type id) {
 }
 
 template <typename Type>
-constexpr Type ToEnum(const std::string& canonicalization) {
+inline Type ToEnum(const std::string& canonicalization) {
     const auto group = EnumMetadata<Type>::Canonicalizations();
     for (auto& [name, value] : group) {
         if (name == canonicalization) {

src/common/settings_setting.h

@@ -190,7 +190,7 @@ public:
         }
     }
 
-    [[nodiscard]] std::string constexpr Canonicalize() const override final {
+    [[nodiscard]] std::string Canonicalize() const override final {
         if constexpr (std::is_enum_v<Type>) {
             return CanonicalizeEnum(this->GetValue());
         } else {
@@ -256,11 +256,11 @@ public:
      * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
      * @param other_setting_ A second Setting to associate to this one in metadata
      */
+    template <typename T = BasicSetting>
     explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
                                Category category_, u32 specialization_ = Specialization::Default,
                                bool save_ = true, bool runtime_modifiable_ = false,
-                               BasicSetting* other_setting_ = nullptr)
-        requires(!ranged)
+                               typename std::enable_if<!ranged, T*>::type other_setting_ = nullptr)
         : Setting<Type, false>{
               linkage, default_val,         name,          category_, specialization_,
               save_,   runtime_modifiable_, other_setting_} {
@@ -282,12 +282,12 @@ public:
      * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
      * @param other_setting_ A second Setting to associate to this one in metadata
      */
+    template <typename T = BasicSetting>
     explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
                                const Type& max_val, const std::string& name, Category category_,
                                u32 specialization_ = Specialization::Default, bool save_ = true,
                                bool runtime_modifiable_ = false,
-                               BasicSetting* other_setting_ = nullptr)
-        requires(ranged)
+                               typename std::enable_if<ranged, T*>::type other_setting_ = nullptr)
         : Setting<Type, true>{linkage,         default_val, min_val,
                               max_val,         name,        category_,
                               specialization_, save_,       runtime_modifiable_,

src/core/hle/service/pctl/pctl_module.cpp

@@ -152,7 +152,7 @@ private:
         if (pin_code[0] == '\0') {
             return true;
         }
-        if (!restriction_settings.is_free_communication_default_on) {
+        if (!settings.is_free_communication_default_on) {
             return true;
         }
         // TODO(ogniK): Check for blacklisted/exempted applications. Return false can happen here
@@ -168,21 +168,21 @@ private:
         if (pin_code[0] == '\0') {
             return true;
         }
-        if (!restriction_settings.is_stero_vision_restricted) {
+        if (!settings.is_stero_vision_restricted) {
             return false;
         }
         return true;
     }
 
     void SetStereoVisionRestrictionImpl(bool is_restricted) {
-        if (restriction_settings.disabled) {
+        if (settings.disabled) {
             return;
         }
 
         if (pin_code[0] == '\0') {
             return;
         }
-        restriction_settings.is_stero_vision_restricted = is_restricted;
+        settings.is_stero_vision_restricted = is_restricted;
     }
 
     void Initialize(HLERequestContext& ctx) {
@@ -430,7 +430,7 @@ private:
         }
 
         rb.Push(ResultSuccess);
-        rb.Push(restriction_settings.is_stero_vision_restricted);
+        rb.Push(settings.is_stero_vision_restricted);
     }
 
     void ResetConfirmedStereoVisionPermission(HLERequestContext& ctx) {
@@ -460,22 +460,28 @@ private:
         bool stereo_vision{};
     };
 
-    // This is nn::pctl::RestrictionSettings
-    struct RestrictionSettings {
+    struct ParentalControlSettings {
         bool is_stero_vision_restricted{};
         bool is_free_communication_default_on{};
         bool disabled{};
     };
+
+    // This is nn::pctl::RestrictionSettings
+    struct RestrictionSettings {
+        u8 rating_age;
+        bool sns_post_restriction;
+        bool free_communication_restriction;
+    };
     static_assert(sizeof(RestrictionSettings) == 0x3, "RestrictionSettings has incorrect size.");
 
     // This is nn::pctl::PlayTimerSettings
     struct PlayTimerSettings {
-        // TODO: RE the actual contents of this struct
-        std::array<u8, 0x34> settings;
+        std::array<u32, 13> settings;
     };
     static_assert(sizeof(PlayTimerSettings) == 0x34, "PlayTimerSettings has incorrect size.");
 
     States states{};
+    ParentalControlSettings settings{};
     RestrictionSettings restriction_settings{};
     std::array<char, 8> pin_code{};
     Capability capability{};

src/core/memory.h

@@ -509,9 +509,9 @@ class GuestMemory {
 
 public:
     GuestMemory() = delete;
-    explicit GuestMemory(M& memory_, u64 addr_, std::size_t size_,
+    explicit GuestMemory(M& memory, u64 addr, std::size_t size,
                          Common::ScratchBuffer<T>* backup = nullptr)
-        : memory{memory_}, addr{addr_}, size{size_} {
+        : m_memory{memory}, m_addr{addr}, m_size{size} {
         static_assert(FLAGS & GuestMemoryFlags::Read || FLAGS & GuestMemoryFlags::Write);
         if constexpr (FLAGS & GuestMemoryFlags::Read) {
             Read(addr, size, backup);
@@ -521,89 +521,97 @@ public:
     ~GuestMemory() = default;
 
     T* data() noexcept {
-        return data_span.data();
+        return m_data_span.data();
     }
 
     const T* data() const noexcept {
-        return data_span.data();
+        return m_data_span.data();
+    }
+
+    size_t size() const noexcept {
+        return m_size;
+    }
+
+    size_t size_bytes() const noexcept {
+        return this->size() * sizeof(T);
     }
 
     [[nodiscard]] T* begin() noexcept {
-        return data();
+        return this->data();
     }
 
     [[nodiscard]] const T* begin() const noexcept {
-        return data();
+        return this->data();
     }
 
     [[nodiscard]] T* end() noexcept {
-        return data() + size;
+        return this->data() + this->size();
     }
 
     [[nodiscard]] const T* end() const noexcept {
-        return data() + size;
+        return this->data() + this->size();
     }
 
     T& operator[](size_t index) noexcept {
-        return data_span[index];
+        return m_data_span[index];
     }
 
     const T& operator[](size_t index) const noexcept {
-        return data_span[index];
+        return m_data_span[index];
     }
 
-    void SetAddressAndSize(u64 addr_, std::size_t size_) noexcept {
-        addr = addr_;
-        size = size_;
-        addr_changed = true;
+    void SetAddressAndSize(u64 addr, std::size_t size) noexcept {
+        m_addr = addr;
+        m_size = size;
+        m_addr_changed = true;
     }
 
-    std::span<T> Read(u64 addr_, std::size_t size_,
+    std::span<T> Read(u64 addr, std::size_t size,
                       Common::ScratchBuffer<T>* backup = nullptr) noexcept {
-        addr = addr_;
-        size = size_;
-        if (size == 0) {
-            is_data_copy = true;
+        m_addr = addr;
+        m_size = size;
+        if (m_size == 0) {
+            m_is_data_copy = true;
             return {};
         }
 
-        if (TrySetSpan()) {
+        if (this->TrySetSpan()) {
             if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                memory.FlushRegion(addr, size * sizeof(T));
+                m_memory.FlushRegion(m_addr, this->size_bytes());
             }
         } else {
             if (backup) {
-                backup->resize_destructive(size);
-                data_span = *backup;
+                backup->resize_destructive(this->size());
+                m_data_span = *backup;
             } else {
-                data_copy.resize(size);
-                data_span = std::span(data_copy);
+                m_data_copy.resize(this->size());
+                m_data_span = std::span(m_data_copy);
             }
-            is_data_copy = true;
-            span_valid = true;
+            m_is_data_copy = true;
+            m_span_valid = true;
             if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                memory.ReadBlock(addr, data_span.data(), size * sizeof(T));
+                m_memory.ReadBlock(m_addr, this->data(), this->size_bytes());
             } else {
-                memory.ReadBlockUnsafe(addr, data_span.data(), size * sizeof(T));
+                m_memory.ReadBlockUnsafe(m_addr, this->data(), this->size_bytes());
             }
         }
-        return data_span;
+        return m_data_span;
     }
 
     void Write(std::span<T> write_data) noexcept {
         if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-            memory.WriteBlockCached(addr, write_data.data(), size * sizeof(T));
+            m_memory.WriteBlockCached(m_addr, write_data.data(), this->size_bytes());
         } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-            memory.WriteBlock(addr, write_data.data(), size * sizeof(T));
+            m_memory.WriteBlock(m_addr, write_data.data(), this->size_bytes());
         } else {
-            memory.WriteBlockUnsafe(addr, write_data.data(), size * sizeof(T));
+            m_memory.WriteBlockUnsafe(m_addr, write_data.data(), this->size_bytes());
         }
     }
 
     bool TrySetSpan() noexcept {
-        if (u8* ptr = memory.GetSpan(addr, size * sizeof(T)); ptr) {
-            data_span = {reinterpret_cast<T*>(ptr), size};
-            span_valid = true;
+        if (u8* ptr = m_memory.GetSpan(m_addr, this->size_bytes()); ptr) {
+            m_data_span = {reinterpret_cast<T*>(ptr), this->size()};
+            m_span_valid = true;
             return true;
         }
         return false;
@@ -611,36 +619,36 @@ public:
 
 protected:
     bool IsDataCopy() const noexcept {
-        return is_data_copy;
+        return m_is_data_copy;
     }
 
     bool AddressChanged() const noexcept {
-        return addr_changed;
+        return m_addr_changed;
     }
 
-    M& memory;
-    u64 addr;
-    size_t size;
-    std::span<T> data_span{};
-    std::vector<T> data_copy;
-    bool span_valid{false};
-    bool is_data_copy{false};
-    bool addr_changed{false};
+    M& m_memory;
+    u64 m_addr{};
+    size_t m_size{};
+    std::span<T> m_data_span{};
+    std::vector<T> m_data_copy{};
+    bool m_span_valid{false};
+    bool m_is_data_copy{false};
+    bool m_addr_changed{false};
 };
 
 template <typename M, typename T, GuestMemoryFlags FLAGS>
 class GuestMemoryScoped : public GuestMemory<M, T, FLAGS> {
 public:
     GuestMemoryScoped() = delete;
-    explicit GuestMemoryScoped(M& memory_, u64 addr_, std::size_t size_,
+    explicit GuestMemoryScoped(M& memory, u64 addr, std::size_t size,
                                Common::ScratchBuffer<T>* backup = nullptr)
-        : GuestMemory<M, T, FLAGS>(memory_, addr_, size_, backup) {
+        : GuestMemory<M, T, FLAGS>(memory, addr, size, backup) {
         if constexpr (!(FLAGS & GuestMemoryFlags::Read)) {
             if (!this->TrySetSpan()) {
                 if (backup) {
-                    this->data_span = *backup;
-                    this->span_valid = true;
-                    this->is_data_copy = true;
+                    this->m_data_span = *backup;
+                    this->m_span_valid = true;
+                    this->m_is_data_copy = true;
                 }
             }
         }
@@ -648,24 +656,21 @@ public:
 
     ~GuestMemoryScoped() {
         if constexpr (FLAGS & GuestMemoryFlags::Write) {
-            if (this->size == 0) [[unlikely]] {
+            if (this->size() == 0) [[unlikely]] {
                 return;
             }
 
             if (this->AddressChanged() || this->IsDataCopy()) {
-                ASSERT(this->span_valid);
+                ASSERT(this->m_span_valid);
                 if constexpr (FLAGS & GuestMemoryFlags::Cached) {
-                    this->memory.WriteBlockCached(this->addr, this->data_span.data(),
-                                                  this->size * sizeof(T));
+                    this->m_memory.WriteBlockCached(this->m_addr, this->data(), this->size_bytes());
                 } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                    this->memory.WriteBlock(this->addr, this->data_span.data(),
-                                            this->size * sizeof(T));
+                    this->m_memory.WriteBlock(this->m_addr, this->data(), this->size_bytes());
                 } else {
-                    this->memory.WriteBlockUnsafe(this->addr, this->data_span.data(),
-                                                  this->size * sizeof(T));
+                    this->m_memory.WriteBlockUnsafe(this->m_addr, this->data(), this->size_bytes());
                 }
             } else if constexpr (FLAGS & GuestMemoryFlags::Safe) {
-                this->memory.InvalidateRegion(this->addr, this->size * sizeof(T));
+                this->m_memory.InvalidateRegion(this->m_addr, this->size_bytes());
             }
         }
     }

src/video_core/engines/maxwell_dma.cpp

@@ -5,6 +5,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/memory.h"

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -1335,7 +1335,8 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     }
     const u32 buffer_size = static_cast<u32>(buffer_operand.pitch * buffer_operand.height);
     static constexpr auto sync_info = VideoCommon::ObtainBufferSynchronize::FullSynchronize;
-    const auto post_op = VideoCommon::ObtainBufferOperation::DoNothing;
+    const auto post_op = IS_IMAGE_UPLOAD ? VideoCommon::ObtainBufferOperation::DoNothing
+                                         : VideoCommon::ObtainBufferOperation::MarkAsWritten;
     const auto [buffer, offset] =
         buffer_cache.ObtainBuffer(buffer_operand.address, buffer_size, sync_info, post_op);
 
@@ -1344,8 +1345,12 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     const std::span copy_span{&copy, 1};
 
     if constexpr (IS_IMAGE_UPLOAD) {
+        texture_cache.PrepareImage(image_id, true, false);
         image->UploadMemory(buffer->Handle(), offset, copy_span);
     } else {
+        if (offset % BytesPerBlock(image->info.format)) {
+            return false;
+        }
         texture_cache.DownloadImageIntoBuffer(image, buffer->Handle(), offset, copy_span,
                                               buffer_operand.address, buffer_size);
     }

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -830,7 +830,8 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     }
     const u32 buffer_size = static_cast<u32>(buffer_operand.pitch * buffer_operand.height);
     static constexpr auto sync_info = VideoCommon::ObtainBufferSynchronize::FullSynchronize;
-    const auto post_op = VideoCommon::ObtainBufferOperation::DoNothing;
+    const auto post_op = IS_IMAGE_UPLOAD ? VideoCommon::ObtainBufferOperation::DoNothing
+                                         : VideoCommon::ObtainBufferOperation::MarkAsWritten;
     const auto [buffer, offset] =
         buffer_cache.ObtainBuffer(buffer_operand.address, buffer_size, sync_info, post_op);
 
@@ -839,8 +840,12 @@ bool AccelerateDMA::DmaBufferImageCopy(const Tegra::DMA::ImageCopy& copy_info,
     const std::span copy_span{&copy, 1};
 
     if constexpr (IS_IMAGE_UPLOAD) {
+        texture_cache.PrepareImage(image_id, true, false);
         image->UploadMemory(buffer->Handle(), offset, copy_span);
     } else {
+        if (offset % BytesPerBlock(image->info.format)) {
+            return false;
+        }
         texture_cache.DownloadImageIntoBuffer(image, buffer->Handle(), offset, copy_span,
                                               buffer_operand.address, buffer_size);
     }

src/video_core/texture_cache/texture_cache_base.h

@@ -243,6 +243,9 @@ public:
     /// Create channel state.
     void CreateChannel(Tegra::Control::ChannelState& channel) final override;
 
+    /// Prepare an image to be used
+    void PrepareImage(ImageId image_id, bool is_modification, bool invalidate);
+
     std::recursive_mutex mutex;
 
 private:
@@ -387,9 +390,6 @@ private:
     /// Synchronize image aliases, copying data if needed
     void SynchronizeAliases(ImageId image_id);
 
-    /// Prepare an image to be used
-    void PrepareImage(ImageId image_id, bool is_modification, bool invalidate);
-
     /// Prepare an image view to be used
     void PrepareImageView(ImageViewId image_view_id, bool is_modification, bool invalidate);
 

src/yuzu/game_list.cpp

@@ -214,13 +214,17 @@ void GameList::OnTextChanged(const QString& new_text) {
             const int children_count = folder->rowCount();
             for (int j = 0; j < children_count; ++j) {
                 ++children_total;
+
                 const QStandardItem* child = folder->child(j, 0);
+
+                const auto program_id = child->data(GameListItemPath::ProgramIdRole).toULongLong();
+
                 const QString file_path =
                     child->data(GameListItemPath::FullPathRole).toString().toLower();
                 const QString file_title =
                     child->data(GameListItemPath::TitleRole).toString().toLower();
                 const QString file_program_id =
-                    child->data(GameListItemPath::ProgramIdRole).toString().toLower();
+                    QStringLiteral("%1").arg(program_id, 16, 16, QLatin1Char{'0'});
 
                 // Only items which filename in combination with its title contains all words
                 // that are in the searchfield will be visible in the gamelist
@@ -231,7 +235,7 @@ void GameList::OnTextChanged(const QString& new_text) {
                     file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) + QLatin1Char{' '} +
                     file_title;
                 if (ContainsAllWords(file_name, edit_filter_text) ||
-                    (file_program_id.count() == 16 && edit_filter_text.contains(file_program_id))) {
+                    (file_program_id.count() == 16 && file_program_id.contains(edit_filter_text))) {
                     tree_view->setRowHidden(j, folder_index, false);
                     ++result_count;
                 } else {