Android #104

fsmitm_romfsbuild: avoid unnecessary copies of vfs pointers

README.md

@@ -1,3 +1,11 @@
+| Pull Request | Commit | Title | Author | Merged? |
+|----|----|----|----|----|
+
+
+End of merge log. You can find the original README.md below the break.
+
+-----
+
 <!--
 SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 SPDX-License-Identifier: GPL-2.0-or-later

src/core/core.cpp

@@ -116,11 +116,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
             }
         }
 
-        if (concat.empty()) {
-            return nullptr;
-        }
-
-        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(concat, dir->GetName());
+        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(dir->GetName(),
+                                                                  std::move(concat));
     }
 
     if (Common::FS::IsDir(path)) {

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -107,62 +107,56 @@ static u64 romfs_get_hash_table_count(u64 num_entries) {
 
 void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir,
                                        std::shared_ptr<RomFSBuildDirectoryContext> parent) {
-    std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> child_dirs;
+    for (auto& child_romfs_file : romfs_dir->GetFiles()) {
+        const auto name = child_romfs_file->GetName();
+        const auto child = std::make_shared<RomFSBuildFileContext>();
+        // Set child's path.
+        child->cur_path_ofs = parent->path_len + 1;
+        child->path_len = child->cur_path_ofs + static_cast<u32>(name.size());
+        child->path = parent->path + "/" + name;
 
-    const auto entries = romfs_dir->GetEntries();
+        if (ext_dir != nullptr && ext_dir->GetFile(name + ".stub") != nullptr) {
+            continue;
+        }
 
-    for (const auto& kv : entries) {
-        if (kv.second == VfsEntryType::Directory) {
-            const auto child = std::make_shared<RomFSBuildDirectoryContext>();
-            // Set child's path.
-            child->cur_path_ofs = parent->path_len + 1;
-            child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
-            child->path = parent->path + "/" + kv.first;
+        // Sanity check on path_len
+        ASSERT(child->path_len < FS_MAX_PATH);
 
-            if (ext_dir != nullptr && ext_dir->GetFile(kv.first + ".stub") != nullptr) {
-                continue;
-            }
+        child->source = std::move(child_romfs_file);
 
-            // Sanity check on path_len
-            ASSERT(child->path_len < FS_MAX_PATH);
-
-            if (AddDirectory(parent, child)) {
-                child_dirs.push_back(child);
-            }
-        } else {
-            const auto child = std::make_shared<RomFSBuildFileContext>();
-            // Set child's path.
-            child->cur_path_ofs = parent->path_len + 1;
-            child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
-            child->path = parent->path + "/" + kv.first;
-
-            if (ext_dir != nullptr && ext_dir->GetFile(kv.first + ".stub") != nullptr) {
-                continue;
-            }
-
-            // Sanity check on path_len
-            ASSERT(child->path_len < FS_MAX_PATH);
-
-            child->source = romfs_dir->GetFile(kv.first);
-
-            if (ext_dir != nullptr) {
-                if (const auto ips = ext_dir->GetFile(kv.first + ".ips")) {
-                    if (auto patched = PatchIPS(child->source, ips)) {
-                        child->source = std::move(patched);
-                    }
+        if (ext_dir != nullptr) {
+            if (const auto ips = ext_dir->GetFile(name + ".ips")) {
+                if (auto patched = PatchIPS(child->source, ips)) {
+                    child->source = std::move(patched);
                 }
             }
-
-            child->size = child->source->GetSize();
-
-            AddFile(parent, child);
         }
+
+        child->size = child->source->GetSize();
+
+        AddFile(parent, child);
     }
 
-    for (auto& child : child_dirs) {
-        auto subdir_name = std::string_view(child->path).substr(child->cur_path_ofs);
-        auto child_romfs_dir = romfs_dir->GetSubdirectory(subdir_name);
-        auto child_ext_dir = ext_dir != nullptr ? ext_dir->GetSubdirectory(subdir_name) : nullptr;
+    for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) {
+        const auto name = child_romfs_dir->GetName();
+        const auto child = std::make_shared<RomFSBuildDirectoryContext>();
+        // Set child's path.
+        child->cur_path_ofs = parent->path_len + 1;
+        child->path_len = child->cur_path_ofs + static_cast<u32>(name.size());
+        child->path = parent->path + "/" + name;
+
+        if (ext_dir != nullptr && ext_dir->GetFile(name + ".stub") != nullptr) {
+            continue;
+        }
+
+        // Sanity check on path_len
+        ASSERT(child->path_len < FS_MAX_PATH);
+
+        if (!AddDirectory(parent, child)) {
+            continue;
+        }
+
+        auto child_ext_dir = ext_dir != nullptr ? ext_dir->GetSubdirectory(name) : nullptr;
         this->VisitDirectory(child_romfs_dir, child_ext_dir, child);
     }
 }
@@ -293,7 +287,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
 
         cur_entry.name_size = name_size;
 
-        out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, 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));

src/core/file_sys/patch_manager.cpp

@@ -377,16 +377,16 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
 
         auto romfs_dir = FindSubdirectoryCaseless(subdir, "romfs");
         if (romfs_dir != nullptr)
-            layers.push_back(std::make_shared<CachedVfsDirectory>(romfs_dir));
+            layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(romfs_dir)));
 
         auto ext_dir = FindSubdirectoryCaseless(subdir, "romfs_ext");
         if (ext_dir != nullptr)
-            layers_ext.push_back(std::make_shared<CachedVfsDirectory>(ext_dir));
+            layers_ext.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(ext_dir)));
 
         if (type == ContentRecordType::HtmlDocument) {
             auto manual_dir = FindSubdirectoryCaseless(subdir, "manual_html");
             if (manual_dir != nullptr)
-                layers.push_back(std::make_shared<CachedVfsDirectory>(manual_dir));
+                layers.emplace_back(std::make_shared<CachedVfsDirectory>(std::move(manual_dir)));
         }
     }
 
@@ -400,7 +400,7 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
         return;
     }
 
-    layers.push_back(std::move(extracted));
+    layers.emplace_back(std::move(extracted));
 
     auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
     if (layered == nullptr) {

src/core/file_sys/registered_cache.cpp

@@ -322,7 +322,8 @@ VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& open_di
         return nullptr;
     }
 
-    return ConcatenatedVfsFile::MakeConcatenatedFile(concat, concat.front()->GetName());
+    auto name = concat.front()->GetName();
+    return ConcatenatedVfsFile::MakeConcatenatedFile(std::move(name), std::move(concat));
 }
 
 VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {

src/core/file_sys/romfs.cpp

@@ -133,7 +133,7 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
         out = out->GetSubdirectories().front();
     }
 
-    return std::make_shared<CachedVfsDirectory>(out);
+    return std::make_shared<CachedVfsDirectory>(std::move(out));
 }
 
 VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
@@ -141,8 +141,7 @@ VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
         return nullptr;
 
     RomFSBuildContext ctx{dir, ext};
-    auto file_map = ctx.Build();
-    return ConcatenatedVfsFile::MakeConcatenatedFile(0, file_map, dir->GetName());
+    return ConcatenatedVfsFile::MakeConcatenatedFile(0, dir->GetName(), ctx.Build());
 }
 
 } // namespace FileSys

src/core/file_sys/vfs_cached.cpp

@@ -6,13 +6,13 @@
 
 namespace FileSys {
 
-CachedVfsDirectory::CachedVfsDirectory(VirtualDir& source_dir)
+CachedVfsDirectory::CachedVfsDirectory(VirtualDir&& source_dir)
     : name(source_dir->GetName()), parent(source_dir->GetParentDirectory()) {
     for (auto& dir : source_dir->GetSubdirectories()) {
-        dirs.emplace(dir->GetName(), std::make_shared<CachedVfsDirectory>(dir));
+        dirs.emplace(dir->GetName(), std::make_shared<CachedVfsDirectory>(std::move(dir)));
     }
     for (auto& file : source_dir->GetFiles()) {
-        files.emplace(file->GetName(), file);
+        files.emplace(file->GetName(), std::move(file));
     }
 }
 

src/core/file_sys/vfs_cached.h

@@ -11,7 +11,7 @@ namespace FileSys {
 
 class CachedVfsDirectory : public ReadOnlyVfsDirectory {
 public:
-    CachedVfsDirectory(VirtualDir& source_directory);
+    CachedVfsDirectory(VirtualDir&& source_directory);
 
     ~CachedVfsDirectory() override;
     VirtualFile GetFile(std::string_view file_name) const override;

src/core/file_sys/vfs_concat.cpp

@@ -10,7 +10,7 @@
 
 namespace FileSys {
 
-ConcatenatedVfsFile::ConcatenatedVfsFile(ConcatenationMap&& concatenation_map_, std::string&& name_)
+ConcatenatedVfsFile::ConcatenatedVfsFile(std::string&& name_, ConcatenationMap&& concatenation_map_)
     : concatenation_map(std::move(concatenation_map_)), name(std::move(name_)) {
     DEBUG_ASSERT(this->VerifyContinuity());
 }
@@ -30,8 +30,8 @@ bool ConcatenatedVfsFile::VerifyContinuity() const {
 
 ConcatenatedVfsFile::~ConcatenatedVfsFile() = default;
 
-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(const std::vector<VirtualFile>& files,
-                                                      std::string&& name) {
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::string&& name,
+                                                      std::vector<VirtualFile>&& files) {
     // Fold trivial cases.
     if (files.empty()) {
         return nullptr;
@@ -46,20 +46,21 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(const std::vector<VirtualF
     u64 last_offset = 0;
 
     for (auto& file : files) {
+        const auto size = file->GetSize();
+
         concatenation_map.emplace_back(ConcatenationEntry{
             .offset = last_offset,
-            .file = file,
+            .file = std::move(file),
         });
 
-        last_offset += file->GetSize();
+        last_offset += size;
     }
 
-    return VirtualFile(new ConcatenatedVfsFile(std::move(concatenation_map), std::move(name)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
 }
 
-VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
-                                                      const std::multimap<u64, VirtualFile>& files,
-                                                      std::string&& name) {
+VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte, std::string&& name,
+                                                      std::multimap<u64, VirtualFile>&& files) {
     // Fold trivial cases.
     if (files.empty()) {
         return nullptr;
@@ -76,6 +77,8 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
 
     // Iteration of a multimap is ordered, so offset will be strictly non-decreasing.
     for (auto& [offset, file] : files) {
+        const auto size = file->GetSize();
+
         if (offset > last_offset) {
             concatenation_map.emplace_back(ConcatenationEntry{
                 .offset = last_offset,
@@ -85,13 +88,13 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
 
         concatenation_map.emplace_back(ConcatenationEntry{
             .offset = offset,
-            .file = file,
+            .file = std::move(file),
         });
 
-        last_offset = offset + file->GetSize();
+        last_offset = offset + size;
     }
 
-    return VirtualFile(new ConcatenatedVfsFile(std::move(concatenation_map), std::move(name)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(name), std::move(concatenation_map)));
 }
 
 std::string ConcatenatedVfsFile::GetName() const {

src/core/file_sys/vfs_concat.h

@@ -24,22 +24,20 @@ private:
     };
     using ConcatenationMap = std::vector<ConcatenationEntry>;
 
-    explicit ConcatenatedVfsFile(std::vector<ConcatenationEntry>&& concatenation_map,
-                                 std::string&& name);
+    explicit ConcatenatedVfsFile(std::string&& name,
+                                 std::vector<ConcatenationEntry>&& concatenation_map);
     bool VerifyContinuity() const;
 
 public:
     ~ConcatenatedVfsFile() override;
 
     /// Wrapper function to allow for more efficient handling of files.size() == 0, 1 cases.
-    static VirtualFile MakeConcatenatedFile(const std::vector<VirtualFile>& files,
-                                            std::string&& name);
+    static VirtualFile MakeConcatenatedFile(std::string&& name, std::vector<VirtualFile>&& files);
 
     /// 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,
-                                            const std::multimap<u64, VirtualFile>& files,
-                                            std::string&& name);
+    static VirtualFile MakeConcatenatedFile(u8 filler_byte, std::string&& name,
+                                            std::multimap<u64, VirtualFile>&& files);
 
     std::string GetName() const override;
     std::size_t GetSize() const override;

src/core/file_sys/vfs_layered.cpp

@@ -38,7 +38,7 @@ VirtualDir LayeredVfsDirectory::GetDirectoryRelative(std::string_view path) cons
     for (const auto& layer : dirs) {
         auto dir = layer->GetDirectoryRelative(path);
         if (dir != nullptr) {
-            out.push_back(std::move(dir));
+            out.emplace_back(std::move(dir));
         }
     }
 
@@ -62,11 +62,11 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
     std::set<std::string, std::less<>> out_names;
 
     for (const auto& layer : dirs) {
-        for (const auto& file : layer->GetFiles()) {
+        for (auto& file : layer->GetFiles()) {
             auto file_name = file->GetName();
             if (!out_names.contains(file_name)) {
                 out_names.emplace(std::move(file_name));
-                out.push_back(file);
+                out.emplace_back(std::move(file));
             }
         }
     }
@@ -86,7 +86,7 @@ std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
     std::vector<VirtualDir> out;
     out.reserve(names.size());
     for (const auto& subdir : names)
-        out.push_back(GetSubdirectory(subdir));
+        out.emplace_back(GetSubdirectory(subdir));
 
     return out;
 }

src/core/hle/service/acc/acc.cpp

@@ -49,7 +49,7 @@ public:
         : ServiceFramework{system_, "IManagerForSystemService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "CheckAvailability"},
+            {0, &IManagerForSystemService::CheckAvailability, "CheckAvailability"},
             {1, nullptr, "GetAccountId"},
             {2, nullptr, "EnsureIdTokenCacheAsync"},
             {3, nullptr, "LoadIdTokenCache"},
@@ -78,6 +78,13 @@ public:
 
         RegisterHandlers(functions);
     }
+
+private:
+    void CheckAvailability(HLERequestContext& ctx) {
+        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
+    }
 };
 
 // 3.0.0+
@@ -837,6 +844,29 @@ void Module::Interface::InitializeApplicationInfoV2(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
+void Module::Interface::BeginUserRegistration(HLERequestContext& ctx) {
+    const auto user_id = Common::UUID::MakeRandom();
+    profile_manager->CreateNewUser(user_id, "yuzu");
+
+    LOG_INFO(Service_ACC, "called, uuid={}", user_id.FormattedString());
+
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(user_id);
+}
+
+void Module::Interface::CompleteUserRegistration(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
+
+    LOG_INFO(Service_ACC, "called, uuid={}", user_id.FormattedString());
+
+    profile_manager->WriteUserSaveFile();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 void Module::Interface::GetProfileEditor(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     Common::UUID user_id = rp.PopRaw<Common::UUID>();
@@ -880,6 +910,17 @@ void Module::Interface::StoreSaveDataThumbnailApplication(HLERequestContext& ctx
     StoreSaveDataThumbnail(ctx, uuid, tid);
 }
 
+void Module::Interface::GetBaasAccountManagerForSystemService(HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto uuid = rp.PopRaw<Common::UUID>();
+
+    LOG_INFO(Service_ACC, "called, uuid=0x{}", uuid.RawString());
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<IManagerForSystemService>(system, uuid);
+}
+
 void Module::Interface::StoreSaveDataThumbnailSystem(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto uuid = rp.PopRaw<Common::UUID>();

src/core/hle/service/acc/acc.h

@@ -33,10 +33,13 @@ public:
         void TrySelectUserWithoutInteraction(HLERequestContext& ctx);
         void IsUserAccountSwitchLocked(HLERequestContext& ctx);
         void InitializeApplicationInfoV2(HLERequestContext& ctx);
+        void BeginUserRegistration(HLERequestContext& ctx);
+        void CompleteUserRegistration(HLERequestContext& ctx);
         void GetProfileEditor(HLERequestContext& ctx);
         void ListQualifiedUsers(HLERequestContext& ctx);
         void ListOpenContextStoredUsers(HLERequestContext& ctx);
         void StoreSaveDataThumbnailApplication(HLERequestContext& ctx);
+        void GetBaasAccountManagerForSystemService(HLERequestContext& ctx);
         void StoreSaveDataThumbnailSystem(HLERequestContext& ctx);
 
     private:

src/core/hle/service/acc/acc_su.cpp

@@ -23,7 +23,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
-        {102, nullptr, "GetBaasAccountManagerForSystemService"},
+        {102, &ACC_SU::GetBaasAccountManagerForSystemService, "GetBaasAccountManagerForSystemService"},
         {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
         {104, nullptr, "GetProfileUpdateNotifier"},
         {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},
@@ -40,8 +40,8 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {152, nullptr, "LoadSignedDeviceIdentifierCacheForNintendoAccount"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
-        {200, nullptr, "BeginUserRegistration"},
-        {201, nullptr, "CompleteUserRegistration"},
+        {200, &ACC_SU::BeginUserRegistration, "BeginUserRegistration"},
+        {201, &ACC_SU::CompleteUserRegistration, "CompleteUserRegistration"},
         {202, nullptr, "CancelUserRegistration"},
         {203, nullptr, "DeleteUser"},
         {204, nullptr, "SetUserPosition"},

src/core/hle/service/acc/profile_manager.h

@@ -96,9 +96,10 @@ public:
     bool SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
                                const UserData& data_new);
 
+    void WriteUserSaveFile();
+
 private:
     void ParseUserSaveFile();
-    void WriteUserSaveFile();
     std::optional<std::size_t> AddToProfiles(const ProfileInfo& profile);
     bool RemoveProfileAtIndex(std::size_t index);
 

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

@@ -210,8 +210,8 @@ IDisplayController::IDisplayController(Core::System& system_)
         {21, nullptr, "ClearAppletTransitionBuffer"},
         {22, nullptr, "AcquireLastApplicationCaptureSharedBuffer"},
         {23, nullptr, "ReleaseLastApplicationCaptureSharedBuffer"},
-        {24, nullptr, "AcquireLastForegroundCaptureSharedBuffer"},
-        {25, nullptr, "ReleaseLastForegroundCaptureSharedBuffer"},
+        {24, &IDisplayController::AcquireLastForegroundCaptureSharedBuffer, "AcquireLastForegroundCaptureSharedBuffer"},
+        {25, &IDisplayController::ReleaseLastForegroundCaptureSharedBuffer, "ReleaseLastForegroundCaptureSharedBuffer"},
         {26, &IDisplayController::AcquireCallerAppletCaptureSharedBuffer, "AcquireCallerAppletCaptureSharedBuffer"},
         {27, &IDisplayController::ReleaseCallerAppletCaptureSharedBuffer, "ReleaseCallerAppletCaptureSharedBuffer"},
         {28, nullptr, "TakeScreenShotOfOwnLayerEx"},
@@ -239,6 +239,22 @@ void IDisplayController::TakeScreenShotOfOwnLayer(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
+void IDisplayController::AcquireLastForegroundCaptureSharedBuffer(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push(1U);
+    rb.Push(0);
+}
+
+void IDisplayController::ReleaseLastForegroundCaptureSharedBuffer(HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
 void IDisplayController::AcquireCallerAppletCaptureSharedBuffer(HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
@@ -1557,7 +1573,7 @@ ILibraryAppletSelfAccessor::ILibraryAppletSelfAccessor(Core::System& system_)
         {100, nullptr, "CreateGameMovieTrimmer"},
         {101, nullptr, "ReserveResourceForMovieOperation"},
         {102, nullptr, "UnreserveResourceForMovieOperation"},
-        {110, nullptr, "GetMainAppletAvailableUsers"},
+        {110, &ILibraryAppletSelfAccessor::GetMainAppletAvailableUsers, "GetMainAppletAvailableUsers"},
         {120, nullptr, "GetLaunchStorageInfoForDebug"},
         {130, nullptr, "GetGpuErrorDetectedSystemEvent"},
         {140, nullptr, "SetApplicationMemoryReservation"},
@@ -1652,6 +1668,25 @@ void ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo(HLERequestContext&
     rb.PushRaw(applet_info);
 }
 
+void ILibraryAppletSelfAccessor::GetMainAppletAvailableUsers(HLERequestContext& ctx) {
+    const Service::Account::ProfileManager manager{};
+    bool is_empty{true};
+    s32 user_count{-1};
+
+    LOG_INFO(Service_AM, "called");
+
+    if (manager.GetUserCount() > 0) {
+        is_empty = false;
+        user_count = static_cast<s32>(manager.GetUserCount());
+        ctx.WriteBuffer(manager.GetAllUsers());
+    }
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(ResultSuccess);
+    rb.Push<u8>(is_empty);
+    rb.Push(user_count);
+}
+
 void ILibraryAppletSelfAccessor::PushInShowAlbum() {
     const Applets::CommonArguments arguments{
         .arguments_version = Applets::CommonArgumentVersion::Version3,

src/core/hle/service/am/am.h

@@ -124,6 +124,8 @@ public:
 private:
     void GetCallerAppletCaptureImageEx(HLERequestContext& ctx);
     void TakeScreenShotOfOwnLayer(HLERequestContext& ctx);
+    void AcquireLastForegroundCaptureSharedBuffer(HLERequestContext& ctx);
+    void ReleaseLastForegroundCaptureSharedBuffer(HLERequestContext& ctx);
     void AcquireCallerAppletCaptureSharedBuffer(HLERequestContext& ctx);
     void ReleaseCallerAppletCaptureSharedBuffer(HLERequestContext& ctx);
 };
@@ -345,6 +347,7 @@ private:
     void GetLibraryAppletInfo(HLERequestContext& ctx);
     void ExitProcessAndReturn(HLERequestContext& ctx);
     void GetCallerAppletIdentityInfo(HLERequestContext& ctx);
+    void GetMainAppletAvailableUsers(HLERequestContext& ctx);
 
     void PushInShowAlbum();
     void PushInShowCabinetData();

src/input_common/drivers/udp_client.cpp

@@ -338,6 +338,7 @@ void UDPClient::StartCommunication(std::size_t client, const std::string& host,
     for (std::size_t index = 0; index < PADS_PER_CLIENT; ++index) {
         const PadIdentifier identifier = GetPadIdentifier(client * PADS_PER_CLIENT + index);
         PreSetController(identifier);
+        PreSetMotion(identifier, 0);
     }
 }
 

src/video_core/buffer_cache/buffer_cache_base.h

@@ -62,7 +62,11 @@ using BufferId = SlotId;
 using VideoCore::Surface::PixelFormat;
 using namespace Common::Literals;
 
+#ifdef __APPLE__
+constexpr u32 NUM_VERTEX_BUFFERS = 16;
+#else
 constexpr u32 NUM_VERTEX_BUFFERS = 32;
+#endif
 constexpr u32 NUM_TRANSFORM_FEEDBACK_BUFFERS = 4;
 constexpr u32 NUM_GRAPHICS_UNIFORM_BUFFERS = 18;
 constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;

src/video_core/host1x/codecs/codec.cpp

@@ -137,16 +137,6 @@ bool Codec::CreateGpuAvDevice() {
                 break;
             }
             if ((config->methods & HW_CONFIG_METHOD) != 0 && config->device_type == type) {
-#if defined(__unix__)
-                // Some linux decoding backends are reported to crash with this config method
-                // TODO(ameerj): Properly support this method
-                if ((config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) != 0) {
-                    // skip zero-copy decoders, we don't currently support them
-                    LOG_DEBUG(Service_NVDRV, "Skipping decoder {} with unsupported capability {}.",
-                              av_hwdevice_get_type_name(type), config->methods);
-                    continue;
-                }
-#endif
                 LOG_INFO(Service_NVDRV, "Using {} GPU decoder", av_hwdevice_get_type_name(type));
                 av_codec_ctx->pix_fmt = config->pix_fmt;
                 return true;

src/video_core/host_shaders/convert_d24s8_to_abgr8.frag

@@ -3,16 +3,16 @@
 
 #version 450
 
+precision mediump int;
+precision highp float;
+
 layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform isampler2D stencil_tex;
+layout(binding = 1) uniform usampler2D stencil_tex;
 
 layout(location = 0) out vec4 color;
 
 void main() {
     ivec2 coord = ivec2(gl_FragCoord.xy);
-    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
-    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
-
     highp uint depth_val =
         uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0));
     lowp uint stencil_val = textureLod(stencil_tex, coord, 0).r;

src/video_core/host_shaders/convert_s8d24_to_abgr8.frag

@@ -3,16 +3,16 @@
 
 #version 450
 
+precision mediump int;
+precision highp float;
+
 layout(binding = 0) uniform sampler2D depth_tex;
-layout(binding = 1) uniform isampler2D stencil_tex;
+layout(binding = 1) uniform usampler2D stencil_tex;
 
 layout(location = 0) out vec4 color;
 
 void main() {
     ivec2 coord = ivec2(gl_FragCoord.xy);
-    uint depth = uint(textureLod(depth_tex, coord, 0).r * (exp2(24.0) - 1.0f));
-    uint stencil = uint(textureLod(stencil_tex, coord, 0).r);
-
     highp uint depth_val =
         uint(textureLod(depth_tex, coord, 0).r * (exp2(32.0) - 1.0));
     lowp uint stencil_val = textureLod(stencil_tex, coord, 0).r;

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1436,6 +1436,7 @@ void QueryCacheRuntime::Barriers(bool is_prebarrier) {
         .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
         .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
     };
+    impl->scheduler.RequestOutsideRenderPassOperationContext();
     if (is_prebarrier) {
         impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -975,6 +975,19 @@ void RasterizerVulkan::UpdateScissorsState(Tegra::Engines::Maxwell3D::Regs& regs
     if (!state_tracker.TouchScissors()) {
         return;
     }
+    if (!regs.viewport_scale_offset_enabled) {
+        const auto x = static_cast<float>(regs.surface_clip.x);
+        const auto y = static_cast<float>(regs.surface_clip.y);
+        const auto width = static_cast<float>(regs.surface_clip.width);
+        const auto height = static_cast<float>(regs.surface_clip.height);
+        VkRect2D scissor;
+        scissor.offset.x = static_cast<u32>(x);
+        scissor.offset.y = static_cast<u32>(y);
+        scissor.extent.width = static_cast<u32>(width != 0.0f ? width : 1.0f);
+        scissor.extent.height = static_cast<u32>(height != 0.0f ? height : 1.0f);
+        scheduler.Record([scissor](vk::CommandBuffer cmdbuf) { cmdbuf.SetScissor(0, scissor); });
+        return;
+    }
     u32 up_scale = 1;
     u32 down_shift = 0;
     if (texture_cache.IsRescaling()) {

src/video_core/renderer_vulkan/vk_render_pass_cache.cpp

@@ -19,7 +19,7 @@ VkAttachmentDescription AttachmentDescription(const Device& device, PixelFormat
                                               VkSampleCountFlagBits samples) {
     using MaxwellToVK::SurfaceFormat;
     return {
-        .flags = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT,
+        .flags = {},
         .format = SurfaceFormat(device, FormatType::Optimal, true, format).format,
         .samples = samples,
         .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,

src/video_core/texture_cache/formatter.cpp

@@ -10,19 +10,23 @@
 #include "video_core/texture_cache/image_info.h"
 #include "video_core/texture_cache/image_view_base.h"
 #include "video_core/texture_cache/render_targets.h"
+#include "video_core/texture_cache/samples_helper.h"
 
 namespace VideoCommon {
 
 std::string Name(const ImageBase& image) {
     const GPUVAddr gpu_addr = image.gpu_addr;
     const ImageInfo& info = image.info;
-    const u32 width = info.size.width;
-    const u32 height = info.size.height;
+    u32 width = info.size.width;
+    u32 height = info.size.height;
     const u32 depth = info.size.depth;
     const u32 num_layers = image.info.resources.layers;
     const u32 num_levels = image.info.resources.levels;
     std::string resource;
     if (image.info.num_samples > 1) {
+        const auto [samples_x, samples_y] = VideoCommon::SamplesLog2(image.info.num_samples);
+        width >>= samples_x;
+        height >>= samples_y;
         resource += fmt::format(":{}xMSAA", image.info.num_samples);
     }
     if (num_layers > 1) {

src/video_core/texture_cache/samples_helper.h

@@ -24,7 +24,7 @@ namespace VideoCommon {
         return {2, 2};
     }
     ASSERT_MSG(false, "Invalid number of samples={}", num_samples);
-    return {1, 1};
+    return {0, 0};
 }
 
 [[nodiscard]] inline int NumSamples(Tegra::Texture::MsaaMode msaa_mode) {

src/video_core/texture_cache/util.cpp

@@ -167,6 +167,13 @@ template <u32 GOB_EXTENT>
 }
 
 [[nodiscard]] constexpr Extent3D TileShift(const LevelInfo& info, u32 level) {
+    if (level == 0 && info.num_levels == 1) {
+        return Extent3D{
+            .width = info.block.width,
+            .height = info.block.height,
+            .depth = info.block.depth,
+        };
+    }
     const Extent3D blocks = NumLevelBlocks(info, level);
     return Extent3D{
         .width = AdjustTileSize(info.block.width, GOB_SIZE_X, blocks.width),
@@ -1293,9 +1300,9 @@ u32 MapSizeBytes(const ImageBase& image) {
 
 static_assert(CalculateLevelSize(LevelInfo{{1920, 1080, 1}, {0, 2, 0}, {1, 1}, 2, 0, 1}, 0) ==
               0x7f8000);
-static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0, 1}, 0) == 0x4000);
+static_assert(CalculateLevelSize(LevelInfo{{32, 32, 1}, {0, 0, 4}, {1, 1}, 4, 0, 1}, 0) == 0x40000);
 
-static_assert(CalculateLevelSize(LevelInfo{{128, 8, 1}, {0, 4, 0}, {1, 1}, 4, 0, 1}, 0) == 0x4000);
+static_assert(CalculateLevelSize(LevelInfo{{128, 8, 1}, {0, 4, 0}, {1, 1}, 4, 0, 1}, 0) == 0x40000);
 
 static_assert(CalculateLevelOffset(PixelFormat::R8_SINT, {1920, 1080, 1}, {0, 2, 0}, 0, 7) ==
               0x2afc00);