Android #152

README.md

@@ -1,5 +1,6 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
+| [12236](https://github.com/yuzu-emu/yuzu//pull/12236) | [`f0ee3e29c`](https://github.com/yuzu-emu/yuzu//pull/12236/files) | core: refactor emulated cpu core activation | [liamwhite](https://github.com/liamwhite/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

dist/72-yuzu-input.rules

@@ -1,19 +0,0 @@
-# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-# Allow systemd-logind to manage user access to hidraw with this file
-# On most systems, this file should be installed to /etc/udev/rules.d/72-yuzu-input.rules
-# Consult your distro if this is not the case
-
-# Switch Pro Controller (USB/Bluetooth)
-KERNEL=="hidraw*", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2009", MODE="0660", TAG+="uaccess"
-KERNEL=="hidraw*", KERNELS=="*057e:2009*", MODE="0660", TAG+="uaccess"
-
-# Joy-Con L (Bluetooth)
-KERNEL=="hidraw*", KERNELS=="*057e:2006*", MODE="0660", TAG+="uaccess"
-
-# Joy-Con R (Bluetooth)
-KERNEL=="hidraw*", KERNELS=="*057e:2007*", MODE="0660", TAG+="uaccess"
-
-# Joy-Con Charging Grip (USB)
-KERNEL=="hidraw*", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="200e", MODE="0660", TAG+="uaccess"

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <cstring>
-#include <span>
 #include <string_view>
 #include "common/alignment.h"
 #include "common/assert.h"
@@ -135,7 +134,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
 
         child->size = child->source->GetSize();
 
-        AddFile(parent, std::move(child));
+        AddFile(parent, child);
     }
 
     for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) {
@@ -164,24 +163,36 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
 
 bool RomFSBuildContext::AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
                                      std::shared_ptr<RomFSBuildDirectoryContext> dir_ctx) {
+    // Check whether it's already in the known directories.
+    const auto [it, is_new] = directories.emplace(dir_ctx->path, nullptr);
+    if (!is_new) {
+        return false;
+    }
+
     // Add a new directory.
     num_dirs++;
     dir_table_size +=
         sizeof(RomFSDirectoryEntry) + Common::AlignUp(dir_ctx->path_len - dir_ctx->cur_path_ofs, 4);
-    dir_ctx->parent = std::move(parent_dir_ctx);
-    directories.emplace_back(std::move(dir_ctx));
+    dir_ctx->parent = parent_dir_ctx;
+    it->second = dir_ctx;
 
     return true;
 }
 
 bool RomFSBuildContext::AddFile(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
                                 std::shared_ptr<RomFSBuildFileContext> file_ctx) {
+    // Check whether it's already in the known files.
+    const auto [it, is_new] = files.emplace(file_ctx->path, nullptr);
+    if (!is_new) {
+        return false;
+    }
+
     // Add a new file.
     num_files++;
     file_table_size +=
         sizeof(RomFSFileEntry) + Common::AlignUp(file_ctx->path_len - file_ctx->cur_path_ofs, 4);
-    file_ctx->parent = std::move(parent_dir_ctx);
-    files.emplace_back(std::move(file_ctx));
+    file_ctx->parent = parent_dir_ctx;
+    it->second = file_ctx;
 
     return true;
 }
@@ -190,7 +201,7 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
     : base(std::move(base_)), ext(std::move(ext_)) {
     root = std::make_shared<RomFSBuildDirectoryContext>();
     root->path = "\0";
-    directories.emplace_back(root);
+    directories.emplace(root->path, root);
     num_dirs = 1;
     dir_table_size = 0x18;
 
@@ -199,43 +210,28 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
 
 RomFSBuildContext::~RomFSBuildContext() = default;
 
-std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() {
+std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
     const u64 dir_hash_table_entry_count = romfs_get_hash_table_count(num_dirs);
     const u64 file_hash_table_entry_count = romfs_get_hash_table_count(num_files);
     dir_hash_table_size = 4 * dir_hash_table_entry_count;
     file_hash_table_size = 4 * file_hash_table_entry_count;
 
-    // Assign metadata pointers.
+    // Assign metadata pointers
     RomFSHeader header{};
 
-    std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size +
-                             dir_table_size);
-    u32* const dir_hash_table_pointer = reinterpret_cast<u32*>(metadata.data());
-    u8* const dir_table_pointer = metadata.data() + dir_hash_table_size;
-    u32* const file_hash_table_pointer =
-        reinterpret_cast<u32*>(metadata.data() + dir_hash_table_size + dir_table_size);
-    u8* const file_table_pointer =
-        metadata.data() + dir_hash_table_size + dir_table_size + file_hash_table_size;
+    std::vector<u32> dir_hash_table(dir_hash_table_entry_count, ROMFS_ENTRY_EMPTY);
+    std::vector<u32> file_hash_table(file_hash_table_entry_count, ROMFS_ENTRY_EMPTY);
 
-    std::span<u32> dir_hash_table(dir_hash_table_pointer, dir_hash_table_entry_count);
-    std::span<u32> file_hash_table(file_hash_table_pointer, file_hash_table_entry_count);
-    std::span<u8> dir_table(dir_table_pointer, dir_table_size);
-    std::span<u8> file_table(file_table_pointer, file_table_size);
+    std::vector<u8> dir_table(dir_table_size);
+    std::vector<u8> file_table(file_table_size);
 
-    // Initialize hash tables.
-    std::memset(dir_hash_table.data(), 0xFF, dir_hash_table.size_bytes());
-    std::memset(file_hash_table.data(), 0xFF, file_hash_table.size_bytes());
-
-    // Sort tables by name.
-    std::sort(files.begin(), files.end(),
-              [](const auto& a, const auto& b) { return a->path < b->path; });
-    std::sort(directories.begin(), directories.end(),
-              [](const auto& a, const auto& b) { return a->path < b->path; });
+    std::shared_ptr<RomFSBuildFileContext> cur_file;
 
     // Determine file offsets.
     u32 entry_offset = 0;
     std::shared_ptr<RomFSBuildFileContext> prev_file = nullptr;
-    for (const auto& cur_file : files) {
+    for (const auto& it : files) {
+        cur_file = it.second;
         file_partition_size = Common::AlignUp(file_partition_size, 16);
         cur_file->offset = file_partition_size;
         file_partition_size += cur_file->size;
@@ -247,48 +243,34 @@ std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() {
     }
     // Assign deferred parent/sibling ownership.
     for (auto it = files.rbegin(); it != files.rend(); ++it) {
-        auto& cur_file = *it;
+        cur_file = it->second;
         cur_file->sibling = cur_file->parent->file;
         cur_file->parent->file = cur_file;
     }
 
+    std::shared_ptr<RomFSBuildDirectoryContext> cur_dir;
+
     // Determine directory offsets.
     entry_offset = 0;
-    for (const auto& cur_dir : directories) {
+    for (const auto& it : directories) {
+        cur_dir = it.second;
         cur_dir->entry_offset = entry_offset;
         entry_offset +=
             static_cast<u32>(sizeof(RomFSDirectoryEntry) +
                              Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4));
     }
     // Assign deferred parent/sibling ownership.
-    for (auto it = directories.rbegin(); (*it) != root; ++it) {
-        auto& cur_dir = *it;
+    for (auto it = directories.rbegin(); it->second != root; ++it) {
+        cur_dir = it->second;
         cur_dir->sibling = cur_dir->parent->child;
         cur_dir->parent->child = cur_dir;
     }
 
-    // Create output map.
-    std::vector<std::pair<u64, VirtualFile>> out;
-    out.reserve(num_files + 2);
-
-    // Set header fields.
-    header.header_size = sizeof(RomFSHeader);
-    header.file_hash_table_size = file_hash_table_size;
-    header.file_table_size = file_table_size;
-    header.dir_hash_table_size = dir_hash_table_size;
-    header.dir_table_size = dir_table_size;
-    header.file_partition_ofs = ROMFS_FILEPARTITION_OFS;
-    header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4);
-    header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size;
-    header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size;
-    header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size;
-
-    std::vector<u8> header_data(sizeof(RomFSHeader));
-    std::memcpy(header_data.data(), &header, header_data.size());
-    out.emplace_back(0, std::make_shared<VectorVfsFile>(std::move(header_data)));
+    std::multimap<u64, VirtualFile> out;
 
     // Populate file tables.
-    for (const auto& cur_file : files) {
+    for (const auto& it : files) {
+        cur_file = it.second;
         RomFSFileEntry cur_entry{};
 
         cur_entry.parent = cur_file->parent->entry_offset;
@@ -305,7 +287,7 @@ std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() {
 
         cur_entry.name_size = name_size;
 
-        out.emplace_back(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source));
+        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source));
         std::memcpy(file_table.data() + cur_file->entry_offset, &cur_entry, sizeof(RomFSFileEntry));
         std::memset(file_table.data() + cur_file->entry_offset + sizeof(RomFSFileEntry), 0,
                     Common::AlignUp(cur_entry.name_size, 4));
@@ -314,7 +296,8 @@ std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() {
     }
 
     // Populate dir tables.
-    for (const auto& cur_dir : directories) {
+    for (const auto& it : directories) {
+        cur_dir = it.second;
         RomFSDirectoryEntry cur_entry{};
 
         cur_entry.parent = cur_dir == root ? 0 : cur_dir->parent->entry_offset;
@@ -340,13 +323,34 @@ std::vector<std::pair<u64, VirtualFile>> RomFSBuildContext::Build() {
                     cur_dir->path.data() + cur_dir->cur_path_ofs, name_size);
     }
 
-    // Write metadata.
-    out.emplace_back(header.dir_hash_table_ofs,
-                     std::make_shared<VectorVfsFile>(std::move(metadata)));
+    // Set header fields.
+    header.header_size = sizeof(RomFSHeader);
+    header.file_hash_table_size = file_hash_table_size;
+    header.file_table_size = file_table_size;
+    header.dir_hash_table_size = dir_hash_table_size;
+    header.dir_table_size = dir_table_size;
+    header.file_partition_ofs = ROMFS_FILEPARTITION_OFS;
+    header.dir_hash_table_ofs = Common::AlignUp(header.file_partition_ofs + file_partition_size, 4);
+    header.dir_table_ofs = header.dir_hash_table_ofs + header.dir_hash_table_size;
+    header.file_hash_table_ofs = header.dir_table_ofs + header.dir_table_size;
+    header.file_table_ofs = header.file_hash_table_ofs + header.file_hash_table_size;
 
-    // Sort the output.
-    std::sort(out.begin(), out.end(),
-              [](const auto& a, const auto& b) { return a.first < b.first; });
+    std::vector<u8> header_data(sizeof(RomFSHeader));
+    std::memcpy(header_data.data(), &header, header_data.size());
+    out.emplace(0, std::make_shared<VectorVfsFile>(std::move(header_data)));
+
+    std::vector<u8> metadata(file_hash_table_size + file_table_size + dir_hash_table_size +
+                             dir_table_size);
+    std::size_t index = 0;
+    std::memcpy(metadata.data(), dir_hash_table.data(), dir_hash_table.size() * sizeof(u32));
+    index += dir_hash_table.size() * sizeof(u32);
+    std::memcpy(metadata.data() + index, dir_table.data(), dir_table.size());
+    index += dir_table.size();
+    std::memcpy(metadata.data() + index, file_hash_table.data(),
+                file_hash_table.size() * sizeof(u32));
+    index += file_hash_table.size() * sizeof(u32);
+    std::memcpy(metadata.data() + index, file_table.data(), file_table.size());
+    out.emplace(header.dir_hash_table_ofs, std::make_shared<VectorVfsFile>(std::move(metadata)));
 
     return out;
 }

src/core/file_sys/fsmitm_romfsbuild.h

@@ -22,14 +22,14 @@ public:
     ~RomFSBuildContext();
 
     // This finalizes the context.
-    std::vector<std::pair<u64, VirtualFile>> Build();
+    std::multimap<u64, VirtualFile> Build();
 
 private:
     VirtualDir base;
     VirtualDir ext;
     std::shared_ptr<RomFSBuildDirectoryContext> root;
-    std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> directories;
-    std::vector<std::shared_ptr<RomFSBuildFileContext>> files;
+    std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories;
+    std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files;
     u64 num_dirs = 0;
     u64 num_files = 0;
     u64 dir_table_size = 0;

src/core/file_sys/romfs.cpp

@@ -55,68 +55,44 @@ struct FileEntry {
 };
 static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size.");
 
-struct RomFSTraversalContext {
-    RomFSHeader header;
-    VirtualFile file;
-    std::vector<u8> directory_meta;
-    std::vector<u8> file_meta;
-};
-
-template <typename EntryType, auto Member>
-std::pair<EntryType, std::string> GetEntry(const RomFSTraversalContext& ctx, size_t offset) {
-    const size_t entry_end = offset + sizeof(EntryType);
-    const std::vector<u8>& vec = ctx.*Member;
-    const size_t size = vec.size();
-    const u8* data = vec.data();
-    EntryType entry{};
-
-    if (entry_end > size) {
+template <typename Entry>
+std::pair<Entry, std::string> GetEntry(const VirtualFile& file, std::size_t offset) {
+    Entry entry{};
+    if (file->ReadObject(&entry, offset) != sizeof(Entry))
         return {};
-    }
-    std::memcpy(&entry, data + offset, sizeof(EntryType));
-
-    const size_t name_length = std::min(entry_end + entry.name_length, size) - entry_end;
-    std::string name(reinterpret_cast<const char*>(data + entry_end), name_length);
-
-    return {entry, std::move(name)};
+    std::string string(entry.name_length, '\0');
+    if (file->ReadArray(&string[0], string.size(), offset + sizeof(Entry)) != string.size())
+        return {};
+    return {entry, string};
 }
 
-std::pair<DirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx,
-                                                         size_t directory_offset) {
-    return GetEntry<DirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset);
-}
-
-std::pair<FileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx,
-                                               size_t file_offset) {
-    return GetEntry<FileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset);
-}
-
-void ProcessFile(const RomFSTraversalContext& ctx, u32 this_file_offset,
-                 std::shared_ptr<VectorVfsDirectory>& parent) {
+void ProcessFile(const VirtualFile& file, std::size_t file_offset, std::size_t data_offset,
+                 u32 this_file_offset, std::shared_ptr<VectorVfsDirectory>& parent) {
     while (this_file_offset != ROMFS_ENTRY_EMPTY) {
-        auto entry = GetFileEntry(ctx, this_file_offset);
+        auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset);
 
-        parent->AddFile(std::make_shared<OffsetVfsFile>(ctx.file, entry.first.size,
-                                                        entry.first.offset + ctx.header.data_offset,
-                                                        std::move(entry.second)));
+        parent->AddFile(std::make_shared<OffsetVfsFile>(
+            file, entry.first.size, entry.first.offset + data_offset, entry.second));
 
         this_file_offset = entry.first.sibling;
     }
 }
 
-void ProcessDirectory(const RomFSTraversalContext& ctx, u32 this_dir_offset,
+void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size_t file_offset,
+                      std::size_t data_offset, u32 this_dir_offset,
                       std::shared_ptr<VectorVfsDirectory>& parent) {
     while (this_dir_offset != ROMFS_ENTRY_EMPTY) {
-        auto entry = GetDirectoryEntry(ctx, this_dir_offset);
+        auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset);
         auto current = std::make_shared<VectorVfsDirectory>(
             std::vector<VirtualFile>{}, std::vector<VirtualDir>{}, entry.second);
 
         if (entry.first.child_file != ROMFS_ENTRY_EMPTY) {
-            ProcessFile(ctx, entry.first.child_file, current);
+            ProcessFile(file, file_offset, data_offset, entry.first.child_file, current);
         }
 
         if (entry.first.child_dir != ROMFS_ENTRY_EMPTY) {
-            ProcessDirectory(ctx, entry.first.child_dir, current);
+            ProcessDirectory(file, dir_offset, file_offset, data_offset, entry.first.child_dir,
+                             current);
         }
 
         parent->AddDirectory(current);
@@ -131,25 +107,22 @@ VirtualDir ExtractRomFS(VirtualFile file) {
         return root_container;
     }
 
-    RomFSTraversalContext ctx{};
-
-    if (file->ReadObject(&ctx.header) != sizeof(RomFSHeader)) {
-        return nullptr;
+    RomFSHeader header{};
+    if (file->ReadObject(&header) != sizeof(RomFSHeader)) {
+        return root_container;
     }
 
-    if (ctx.header.header_size != sizeof(RomFSHeader)) {
-        return nullptr;
+    if (header.header_size != sizeof(RomFSHeader)) {
+        return root_container;
     }
 
-    ctx.file = file;
-    ctx.directory_meta =
-        file->ReadBytes(ctx.header.directory_meta.size, ctx.header.directory_meta.offset);
-    ctx.file_meta = file->ReadBytes(ctx.header.file_meta.size, ctx.header.file_meta.offset);
+    const u64 file_offset = header.file_meta.offset;
+    const u64 dir_offset = header.directory_meta.offset;
 
-    ProcessDirectory(ctx, 0, root_container);
+    ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root_container);
 
     if (auto root = root_container->GetSubdirectory(""); root) {
-        return root;
+        return std::make_shared<CachedVfsDirectory>(std::move(root));
     }
 
     ASSERT(false);

src/core/file_sys/vfs_concat.cpp

@@ -59,8 +59,8 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name,
     return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
 }
 
-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(
-    u8 filler_byte, std::string&& name, std::vector<std::pair<u64, VirtualFile>>&& files) {
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::string&& name,
+                                                      std::multimap<u64, VirtualFile>&& files) {
     // Fold trivial cases.
     if (files.empty()) {
         return nullptr;

src/core/file_sys/vfs_concat.h

@@ -37,7 +37,7 @@ public:
     /// Convenience function that turns a map of offsets to files into a concatenated file, filling
     /// gaps with a given filler byte.
     static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name,
-                                            std::vector<std::pair<u64, VirtualFile>>&& files);
+                                            std::multimap<u64, VirtualFile>&& files);
 
     std::string GetName() const override;
     std::size_t GetSize() const override;

src/core/file_sys/vfs_layered.cpp

@@ -3,7 +3,6 @@
 
 #include <algorithm>
 #include <set>
-#include <unordered_set>
 #include <utility>
 #include "core/file_sys/vfs_layered.h"
 
@@ -60,12 +59,13 @@ std::string LayeredVfsDirectory::GetFullPath() const {
 
 std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
     std::vector<VirtualFile> out;
-    std::unordered_set<std::string> out_names;
+    std::set<std::string, std::less<>> out_names;
 
     for (const auto& layer : dirs) {
         for (auto& file : layer->GetFiles()) {
-            const auto [it, is_new] = out_names.emplace(file->GetName());
-            if (is_new) {
+            auto file_name = file->GetName();
+            if (!out_names.contains(file_name)) {
+                out_names.emplace(std::move(file_name));
                 out.emplace_back(std::move(file));
             }
         }
@@ -75,19 +75,18 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
 }
 
 std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
-    std::vector<VirtualDir> out;
-    std::unordered_set<std::string> out_names;
-
+    std::vector<std::string> names;
     for (const auto& layer : dirs) {
         for (const auto& sd : layer->GetSubdirectories()) {
-            out_names.emplace(sd->GetName());
+            if (std::find(names.begin(), names.end(), sd->GetName()) == names.end())
+                names.push_back(sd->GetName());
         }
     }
 
-    out.reserve(out_names.size());
-    for (const auto& subdir : out_names) {
+    std::vector<VirtualDir> out;
+    out.reserve(names.size());
+    for (const auto& subdir : names)
         out.emplace_back(GetSubdirectory(subdir));
-    }
 
     return out;
 }

src/video_core/host1x/ffmpeg/ffmpeg.cpp

@@ -233,12 +233,7 @@ std::unique_ptr<Frame> DecoderContext::ReceiveFrame(bool* out_is_interlaced) {
             return false;
         }
 
-        *out_is_interlaced =
-#if defined(FF_API_INTERLACED_FRAME) || LIBAVUTIL_VERSION_MAJOR >= 59
-            (frame->flags & AV_FRAME_FLAG_INTERLACED) != 0;
-#else
-            frame->interlaced_frame != 0;
-#endif
+        *out_is_interlaced = frame->interlaced_frame != 0;
         return true;
     };
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -714,8 +714,7 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
 
     std::scoped_lock lock{texture_cache.mutex};
-    ImageView* const image_view{
-        texture_cache.TryFindFramebufferImageView(config, framebuffer_addr)};
+    ImageView* const image_view{texture_cache.TryFindFramebufferImageView(framebuffer_addr)};
     if (!image_view) {
         return false;
     }
@@ -726,6 +725,7 @@ bool RasterizerOpenGL::AccelerateDisplay(const Tegra::FramebufferConfig& config,
     screen_info.texture.width = image_view->size.width;
     screen_info.texture.height = image_view->size.height;
     screen_info.display_texture = image_view->Handle(Shader::TextureType::Color2D);
+    screen_info.display_srgb = VideoCore::Surface::IsPixelFormatSRGB(image_view->format);
     return true;
 }
 

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -653,7 +653,11 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
     };
     glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), std::data(vertices));
 
-    glDisable(GL_FRAMEBUFFER_SRGB);
+    if (screen_info.display_srgb) {
+        glEnable(GL_FRAMEBUFFER_SRGB);
+    } else {
+        glDisable(GL_FRAMEBUFFER_SRGB);
+    }
     glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width),
                        static_cast<GLfloat>(layout.height));
 
@@ -706,7 +710,8 @@ void RendererOpenGL::RenderScreenshot() {
     GLuint renderbuffer;
     glGenRenderbuffers(1, &renderbuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_SRGB8, layout.width, layout.height);
+    glRenderbufferStorage(GL_RENDERBUFFER, screen_info.display_srgb ? GL_SRGB8 : GL_RGB8,
+                          layout.width, layout.height);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer);
 
     DrawScreen(layout);

src/video_core/renderer_opengl/renderer_opengl.h

@@ -53,6 +53,7 @@ struct TextureInfo {
 struct ScreenInfo {
     GLuint display_texture{};
     bool was_accelerated = false;
+    bool display_srgb{};
     const Common::Rectangle<float> display_texcoords{0.0f, 0.0f, 1.0f, 1.0f};
     TextureInfo texture;
 };

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -94,7 +94,7 @@ RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
       device(CreateDevice(instance, dld, *surface)), memory_allocator(device), state_tracker(),
       scheduler(device, state_tracker),
       swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
-                render_window.GetFramebufferLayout().height),
+                render_window.GetFramebufferLayout().height, false),
       present_manager(instance, render_window, device, memory_allocator, scheduler, swapchain,
                       surface),
       blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, present_manager,
@@ -131,10 +131,11 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
     const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
     const bool use_accelerated =
         rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
+    const bool is_srgb = use_accelerated && screen_info.is_srgb;
     RenderScreenshot(*framebuffer, use_accelerated);
 
     Frame* frame = present_manager.GetRenderFrame();
-    blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated);
+    blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated, is_srgb);
     scheduler.Flush(*frame->render_ready);
     present_manager.Present(frame);
 
@@ -204,7 +205,7 @@ void Vulkan::RendererVulkan::RenderScreenshot(const Tegra::FramebufferConfig& fr
         .flags = 0,
         .image = *staging_image,
         .viewType = VK_IMAGE_VIEW_TYPE_2D,
-        .format = VK_FORMAT_B8G8R8A8_UNORM,
+        .format = screen_info.is_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM,
         .components{
             .r = VK_COMPONENT_SWIZZLE_IDENTITY,
             .g = VK_COMPONENT_SWIZZLE_IDENTITY,

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -127,9 +127,9 @@ BlitScreen::BlitScreen(Core::Memory::Memory& cpu_memory_, Core::Frontend::EmuWin
                        Scheduler& scheduler_, const ScreenInfo& screen_info_)
     : cpu_memory{cpu_memory_}, render_window{render_window_}, device{device_},
       memory_allocator{memory_allocator_}, swapchain{swapchain_}, present_manager{present_manager_},
-      scheduler{scheduler_}, image_count{swapchain.GetImageCount()}, screen_info{screen_info_} {
+      scheduler{scheduler_}, image_count{swapchain.GetImageCount()}, screen_info{screen_info_},
+      current_srgb{swapchain.IsSrgb()}, image_view_format{swapchain.GetImageViewFormat()} {
     resource_ticks.resize(image_count);
-    swapchain_view_format = swapchain.GetImageViewFormat();
 
     CreateStaticResources();
     CreateDynamicResources();
@@ -480,22 +480,28 @@ void BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer,
 }
 
 void BlitScreen::DrawToSwapchain(Frame* frame, const Tegra::FramebufferConfig& framebuffer,
-                                 bool use_accelerated) {
-    // Recreate dynamic resources if the the image count or input format changed
-    const VkFormat current_framebuffer_format =
-        std::exchange(framebuffer_view_format, GetFormat(framebuffer));
+                                 bool use_accelerated, bool is_srgb) {
+    // Recreate dynamic resources if the the image count or colorspace changed
     if (const std::size_t swapchain_images = swapchain.GetImageCount();
-        swapchain_images != image_count || current_framebuffer_format != framebuffer_view_format) {
+        swapchain_images != image_count || current_srgb != is_srgb) {
+        current_srgb = is_srgb;
+#ifdef ANDROID
+        // Android is already ordered the same as Switch.
+        image_view_format = current_srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
+#else
+        image_view_format = current_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM;
+#endif
         image_count = swapchain_images;
         Recreate();
     }
 
     // Recreate the presentation frame if the dimensions of the window changed
     const Layout::FramebufferLayout layout = render_window.GetFramebufferLayout();
-    if (layout.width != frame->width || layout.height != frame->height) {
+    if (layout.width != frame->width || layout.height != frame->height ||
+        is_srgb != frame->is_srgb) {
         Recreate();
-        present_manager.RecreateFrame(frame, layout.width, layout.height, swapchain_view_format,
-                                      *renderpass);
+        present_manager.RecreateFrame(frame, layout.width, layout.height, is_srgb,
+                                      image_view_format, *renderpass);
     }
 
     const VkExtent2D render_area{frame->width, frame->height};
@@ -623,7 +629,7 @@ void BlitScreen::CreateDescriptorPool() {
 }
 
 void BlitScreen::CreateRenderPass() {
-    renderpass = CreateRenderPassImpl(swapchain_view_format);
+    renderpass = CreateRenderPassImpl(image_view_format);
 }
 
 vk::RenderPass BlitScreen::CreateRenderPassImpl(VkFormat format) {
@@ -1143,7 +1149,7 @@ void BlitScreen::CreateRawImages(const Tegra::FramebufferConfig& framebuffer) {
             .pNext = nullptr,
             .flags = 0,
             .imageType = VK_IMAGE_TYPE_2D,
-            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : framebuffer_view_format,
+            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : GetFormat(framebuffer),
             .extent =
                 {
                     .width = (up_scale * framebuffer.width) >> down_shift,
@@ -1168,7 +1174,7 @@ void BlitScreen::CreateRawImages(const Tegra::FramebufferConfig& framebuffer) {
             .flags = 0,
             .image = *image,
             .viewType = VK_IMAGE_VIEW_TYPE_2D,
-            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : framebuffer_view_format,
+            .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : GetFormat(framebuffer),
             .components =
                 {
                     .r = VK_COMPONENT_SWIZZLE_IDENTITY,

src/video_core/renderer_vulkan/vk_blit_screen.h

@@ -52,6 +52,7 @@ struct ScreenInfo {
     VkImageView image_view{};
     u32 width{};
     u32 height{};
+    bool is_srgb{};
 };
 
 class BlitScreen {
@@ -68,7 +69,7 @@ public:
               const Layout::FramebufferLayout layout, VkExtent2D render_area, bool use_accelerated);
 
     void DrawToSwapchain(Frame* frame, const Tegra::FramebufferConfig& framebuffer,
-                         bool use_accelerated);
+                         bool use_accelerated, bool is_srgb);
 
     [[nodiscard]] vk::Framebuffer CreateFramebuffer(const VkImageView& image_view,
                                                     VkExtent2D extent);
@@ -160,8 +161,8 @@ private:
     u32 raw_width = 0;
     u32 raw_height = 0;
     Service::android::PixelFormat pixel_format{};
-    VkFormat framebuffer_view_format;
-    VkFormat swapchain_view_format;
+    bool current_srgb;
+    VkFormat image_view_format;
 
     std::unique_ptr<FSR> fsr;
     std::unique_ptr<SMAA> smaa;

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -172,12 +172,13 @@ void PresentManager::Present(Frame* frame) {
     });
 }
 
-void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format,
-                                   VkRenderPass rd) {
+void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, bool is_srgb,
+                                   VkFormat image_view_format, VkRenderPass rd) {
     auto& dld = device.GetLogical();
 
     frame->width = width;
     frame->height = height;
+    frame->is_srgb = is_srgb;
 
     frame->image = memory_allocator.CreateImage({
         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
@@ -288,7 +289,7 @@ void PresentManager::PresentThread(std::stop_token token) {
 }
 
 void PresentManager::RecreateSwapchain(Frame* frame) {
-    swapchain.Create(*surface, frame->width, frame->height);
+    swapchain.Create(*surface, frame->width, frame->height, frame->is_srgb);
     image_count = swapchain.GetImageCount();
 }
 
@@ -318,12 +319,12 @@ void PresentManager::CopyToSwapchain(Frame* frame) {
 void PresentManager::CopyToSwapchainImpl(Frame* frame) {
     MICROPROFILE_SCOPE(Vulkan_CopyToSwapchain);
 
-    // If the size of the incoming frames has changed, recreate the swapchain
+    // If the size or colorspace of the incoming frames has changed, recreate the swapchain
     // to account for that.
-    const bool is_suboptimal = swapchain.NeedsRecreation();
+    const bool srgb_changed = swapchain.NeedsRecreation(frame->is_srgb);
     const bool size_changed =
         swapchain.GetWidth() != frame->width || swapchain.GetHeight() != frame->height;
-    if (is_suboptimal || size_changed) {
+    if (srgb_changed || size_changed) {
         RecreateSwapchain(frame);
     }
 

src/video_core/renderer_vulkan/vk_present_manager.h

@@ -25,6 +25,7 @@ class Swapchain;
 struct Frame {
     u32 width;
     u32 height;
+    bool is_srgb;
     vk::Image image;
     vk::ImageView image_view;
     vk::Framebuffer framebuffer;
@@ -47,8 +48,8 @@ public:
     void Present(Frame* frame);
 
     /// Recreates the present frame to match the provided parameters
-    void RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format,
-                       VkRenderPass rd);
+    void RecreateFrame(Frame* frame, u32 width, u32 height, bool is_srgb,
+                       VkFormat image_view_format, VkRenderPass rd);
 
     /// Waits for the present thread to finish presenting all queued frames.
     void WaitPresent();

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -783,8 +783,7 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config,
         return false;
     }
     std::scoped_lock lock{texture_cache.mutex};
-    ImageView* const image_view =
-        texture_cache.TryFindFramebufferImageView(config, framebuffer_addr);
+    ImageView* const image_view = texture_cache.TryFindFramebufferImageView(framebuffer_addr);
     if (!image_view) {
         return false;
     }
@@ -793,6 +792,7 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config,
     screen_info.image_view = image_view->Handle(Shader::TextureType::Color2D);
     screen_info.width = image_view->size.width;
     screen_info.height = image_view->size.height;
+    screen_info.is_srgb = VideoCore::Surface::IsPixelFormatSRGB(image_view->format);
     return true;
 }
 

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -105,14 +105,14 @@ VkCompositeAlphaFlagBitsKHR ChooseAlphaFlags(const VkSurfaceCapabilitiesKHR& cap
 } // Anonymous namespace
 
 Swapchain::Swapchain(VkSurfaceKHR surface_, const Device& device_, Scheduler& scheduler_,
-                     u32 width_, u32 height_)
+                     u32 width_, u32 height_, bool srgb)
     : surface{surface_}, device{device_}, scheduler{scheduler_} {
-    Create(surface_, width_, height_);
+    Create(surface_, width_, height_, srgb);
 }
 
 Swapchain::~Swapchain() = default;
 
-void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_) {
+void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_, bool srgb) {
     is_outdated = false;
     is_suboptimal = false;
     width = width_;
@@ -127,7 +127,7 @@ void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_) {
 
     Destroy();
 
-    CreateSwapchain(capabilities);
+    CreateSwapchain(capabilities, srgb);
     CreateSemaphores();
 
     resource_ticks.clear();
@@ -196,7 +196,7 @@ void Swapchain::Present(VkSemaphore render_semaphore) {
     }
 }
 
-void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
+void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bool srgb) {
     const auto physical_device{device.GetPhysical()};
     const auto formats{physical_device.GetSurfaceFormatsKHR(surface)};
     const auto present_modes = physical_device.GetSurfacePresentModesKHR(surface);
@@ -274,14 +274,15 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) {
     swapchain = device.GetLogical().CreateSwapchainKHR(swapchain_ci);
 
     extent = swapchain_ci.imageExtent;
+    current_srgb = srgb;
 
     images = swapchain.GetImages();
     image_count = static_cast<u32>(images.size());
 #ifdef ANDROID
     // Android is already ordered the same as Switch.
-    image_view_format = VK_FORMAT_R8G8B8A8_UNORM;
+    image_view_format = srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
 #else
-    image_view_format = VK_FORMAT_B8G8R8A8_UNORM;
+    image_view_format = srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM;
 #endif
 }
 

src/video_core/renderer_vulkan/vk_swapchain.h

@@ -20,11 +20,11 @@ class Scheduler;
 class Swapchain {
 public:
     explicit Swapchain(VkSurfaceKHR surface, const Device& device, Scheduler& scheduler, u32 width,
-                       u32 height);
+                       u32 height, bool srgb);
     ~Swapchain();
 
     /// Creates (or recreates) the swapchain with a given size.
-    void Create(VkSurfaceKHR surface, u32 width, u32 height);
+    void Create(VkSurfaceKHR surface, u32 width, u32 height, bool srgb);
 
     /// Acquires the next image in the swapchain, waits as needed.
     bool AcquireNextImage();
@@ -33,8 +33,13 @@ public:
     void Present(VkSemaphore render_semaphore);
 
     /// Returns true when the swapchain needs to be recreated.
-    bool NeedsRecreation() const {
-        return IsSubOptimal() || NeedsPresentModeUpdate();
+    bool NeedsRecreation(bool is_srgb) const {
+        return HasColorSpaceChanged(is_srgb) || IsSubOptimal() || NeedsPresentModeUpdate();
+    }
+
+    /// Returns true when the color space has changed.
+    bool HasColorSpaceChanged(bool is_srgb) const {
+        return current_srgb != is_srgb;
     }
 
     /// Returns true when the swapchain is outdated.
@@ -47,6 +52,11 @@ public:
         return is_suboptimal;
     }
 
+    /// Returns true when the swapchain format is in the srgb color space
+    bool IsSrgb() const {
+        return current_srgb;
+    }
+
     VkExtent2D GetSize() const {
         return extent;
     }
@@ -100,7 +110,7 @@ public:
     }
 
 private:
-    void CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities);
+    void CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bool srgb);
     void CreateSemaphores();
     void CreateImageViews();
 
@@ -134,6 +144,7 @@ private:
     bool has_mailbox{false};
     bool has_fifo_relaxed{false};
 
+    bool current_srgb{};
     bool is_outdated{};
     bool is_suboptimal{};
 };

src/video_core/texture_cache/texture_cache.h

@@ -712,15 +712,14 @@ bool TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
 }
 
 template <class P>
-typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(
-    const Tegra::FramebufferConfig& config, VAddr cpu_addr) {
+typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_addr) {
     // TODO: Properly implement this
     const auto it = page_table.find(cpu_addr >> YUZU_PAGEBITS);
     if (it == page_table.end()) {
         return nullptr;
     }
     const auto& image_map_ids = it->second;
-    boost::container::small_vector<ImageId, 4> valid_image_ids;
+    boost::container::small_vector<const ImageBase*, 4> valid_images;
     for (const ImageMapId map_id : image_map_ids) {
         const ImageMapView& map = slot_map_views[map_id];
         const ImageBase& image = slot_images[map.image_id];
@@ -730,34 +729,18 @@ typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(
         if (image.image_view_ids.empty()) {
             continue;
         }
-        valid_image_ids.push_back(map.image_id);
+        valid_images.push_back(&image);
     }
 
-    const auto view_format = [&]() {
-        switch (config.pixel_format) {
-        case Service::android::PixelFormat::Rgb565:
-            return PixelFormat::R5G6B5_UNORM;
-        case Service::android::PixelFormat::Bgra8888:
-            return PixelFormat::B8G8R8A8_UNORM;
-        default:
-            return PixelFormat::A8B8G8R8_UNORM;
-        }
-    }();
-
-    const auto GetImageViewForFramebuffer = [&](ImageId image_id) {
-        const ImageViewInfo info{ImageViewType::e2D, view_format};
-        return &slot_image_views[FindOrEmplaceImageView(image_id, info)];
-    };
-
-    if (valid_image_ids.size() == 1) [[likely]] {
-        return GetImageViewForFramebuffer(valid_image_ids.front());
+    if (valid_images.size() == 1) [[likely]] {
+        return &slot_image_views[valid_images[0]->image_view_ids.at(0)];
     }
 
-    if (valid_image_ids.size() > 0) [[unlikely]] {
-        auto most_recent = std::ranges::max_element(valid_image_ids, [&](auto a, auto b) {
-            return slot_images[a].modification_tick < slot_images[b].modification_tick;
+    if (valid_images.size() > 0) [[unlikely]] {
+        std::ranges::sort(valid_images, [](const auto* a, const auto* b) {
+            return a->modification_tick > b->modification_tick;
         });
-        return GetImageViewForFramebuffer(*most_recent);
+        return &slot_image_views[valid_images[0]->image_view_ids.at(0)];
     }
 
     return nullptr;

src/video_core/texture_cache/texture_cache_base.h

@@ -209,8 +209,7 @@ public:
                    const Tegra::Engines::Fermi2D::Config& copy);
 
     /// Try to find a cached image view in the given CPU address
-    [[nodiscard]] ImageView* TryFindFramebufferImageView(const Tegra::FramebufferConfig& config,
-                                                         VAddr cpu_addr);
+    [[nodiscard]] ImageView* TryFindFramebufferImageView(VAddr cpu_addr);
 
     /// Return true when there are uncommitted images to be downloaded
     [[nodiscard]] bool HasUncommittedFlushes() const noexcept;