diff options
Diffstat (limited to 'src')
55 files changed, 1609 insertions, 245 deletions
diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt index dec2b7cf1..9fab88248 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt @@ -14,8 +14,10 @@ import org.yuzu.yuzu_emu.R import org.yuzu.yuzu_emu.databinding.DialogAddFolderBinding import org.yuzu.yuzu_emu.model.GameDir import org.yuzu.yuzu_emu.model.GamesViewModel +import org.yuzu.yuzu_emu.model.HomeViewModel class AddGameFolderDialogFragment : DialogFragment() { + private val homeViewModel: HomeViewModel by activityViewModels() private val gamesViewModel: GamesViewModel by activityViewModels() override fun onCreateDialog(savedInstanceState: Bundle?): Dialog { @@ -30,6 +32,7 @@ class AddGameFolderDialogFragment : DialogFragment() { .setTitle(R.string.add_game_folder) .setPositiveButton(android.R.string.ok) { _: DialogInterface, _: Int -> val newGameDir = GameDir(folderUriString!!, binding.deepScanSwitch.isChecked) + homeViewModel.setGamesDirSelected(true) gamesViewModel.addFolder(newGameDir) } .setNegativeButton(android.R.string.cancel, null) diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt index c4277735d..eb5edaa10 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt @@ -4,6 +4,7 @@ package org.yuzu.yuzu_emu.fragments import android.Manifest +import android.annotation.SuppressLint import android.content.Intent import android.os.Build import android.os.Bundle @@ -75,6 +76,8 @@ class SetupFragment : Fragment() { return binding.root } + // This is using the correct scope, lint is just acting up + @SuppressLint("UnsafeRepeatOnLifecycleDetector") override fun onViewCreated(view: View, savedInstanceState: Bundle?) { mainActivity = requireActivity() as MainActivity @@ -206,12 +209,24 @@ class SetupFragment : Fragment() { ) } - viewLifecycleOwner.lifecycleScope.launch { - repeatOnLifecycle(Lifecycle.State.CREATED) { - homeViewModel.shouldPageForward.collect { - if (it) { - pageForward() - homeViewModel.setShouldPageForward(false) + viewLifecycleOwner.lifecycleScope.apply { + launch { + repeatOnLifecycle(Lifecycle.State.CREATED) { + homeViewModel.shouldPageForward.collect { + if (it) { + pageForward() + homeViewModel.setShouldPageForward(false) + } + } + } + } + launch { + repeatOnLifecycle(Lifecycle.State.CREATED) { + homeViewModel.gamesDirSelected.collect { + if (it) { + gamesDirCallback.onStepCompleted() + homeViewModel.setGamesDirSelected(false) + } } } } @@ -339,7 +354,6 @@ class SetupFragment : Fragment() { registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { result -> if (result != null) { mainActivity.processGamesDir(result) - gamesDirCallback.onStepCompleted() } } diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt index 752d98c10..fd925235b 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt @@ -133,7 +133,7 @@ class GamesViewModel : ViewModel() { viewModelScope.launch { withContext(Dispatchers.IO) { NativeConfig.addGameDir(gameDir) - getGameDirs() + getGameDirs(true) } } diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt index 251b5a667..07e65b028 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt @@ -6,6 +6,7 @@ package org.yuzu.yuzu_emu.model import androidx.lifecycle.ViewModel import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow class HomeViewModel : ViewModel() { val navigationVisible: StateFlow<Pair<Boolean, Boolean>> get() = _navigationVisible @@ -17,6 +18,9 @@ class HomeViewModel : ViewModel() { val shouldPageForward: StateFlow<Boolean> get() = _shouldPageForward private val _shouldPageForward = MutableStateFlow(false) + private val _gamesDirSelected = MutableStateFlow(false) + val gamesDirSelected get() = _gamesDirSelected.asStateFlow() + var navigatedToSetup = false fun setNavigationVisibility(visible: Boolean, animated: Boolean) { @@ -36,4 +40,8 @@ class HomeViewModel : ViewModel() { fun setShouldPageForward(pageForward: Boolean) { _shouldPageForward.value = pageForward } + + fun setGamesDirSelected(selected: Boolean) { + _gamesDirSelected.value = selected + } } diff --git a/src/common/settings.cpp b/src/common/settings.cpp index 4666bd0a0..88f509ba7 100644 --- a/src/common/settings.cpp +++ b/src/common/settings.cpp @@ -160,12 +160,16 @@ static bool is_nce_enabled = false; void SetNceEnabled(bool is_39bit) { const bool is_nce_selected = values.cpu_backend.GetValue() == CpuBackend::Nce; - is_nce_enabled = IsFastmemEnabled() && is_nce_selected && is_39bit; - if (is_nce_selected && !is_nce_enabled) { + if (is_nce_selected && !IsFastmemEnabled()) { + LOG_WARNING(Common, "Fastmem is required to natively execute code in a performant manner, " + "falling back to Dynarmic"); + } + if (is_nce_selected && !is_39bit) { LOG_WARNING( Common, "Program does not utilize 39-bit address space, unable to natively execute code"); } + is_nce_enabled = IsFastmemEnabled() && is_nce_selected && is_39bit; } bool IsNceEnabled() { diff --git a/src/common/settings.h b/src/common/settings.h index 98341ad96..7dc18fffe 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -180,14 +180,20 @@ struct Values { &use_speed_limit}; // Cpu - SwitchableSetting<CpuBackend, true> cpu_backend{ - linkage, CpuBackend::Dynarmic, CpuBackend::Dynarmic, + SwitchableSetting<CpuBackend, true> cpu_backend{linkage, #ifdef HAS_NCE - CpuBackend::Nce, + CpuBackend::Nce, #else CpuBackend::Dynarmic, #endif - "cpu_backend", Category::Cpu}; + CpuBackend::Dynarmic, +#ifdef HAS_NCE + CpuBackend::Nce, +#else + CpuBackend::Dynarmic, +#endif + "cpu_backend", + Category::Cpu}; SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto, CpuAccuracy::Auto, CpuAccuracy::Paranoid, "cpu_accuracy", Category::Cpu}; diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index e2120bdfe..27d636ed4 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -251,10 +251,16 @@ add_library(core STATIC hle/kernel/k_hardware_timer.h hle/kernel/k_interrupt_manager.cpp hle/kernel/k_interrupt_manager.h + hle/kernel/k_light_client_session.cpp + hle/kernel/k_light_client_session.h hle/kernel/k_light_condition_variable.cpp hle/kernel/k_light_condition_variable.h hle/kernel/k_light_lock.cpp hle/kernel/k_light_lock.h + hle/kernel/k_light_server_session.cpp + hle/kernel/k_light_server_session.h + hle/kernel/k_light_session.cpp + hle/kernel/k_light_session.h hle/kernel/k_memory_block.h hle/kernel/k_memory_block_manager.cpp hle/kernel/k_memory_block_manager.h @@ -543,6 +549,8 @@ add_library(core STATIC hle/service/hid/xcd.cpp hle/service/hid/xcd.h hle/service/hid/errors.h + hle/service/hid/controllers/applet_resource.cpp + hle/service/hid/controllers/applet_resource.h hle/service/hid/controllers/console_six_axis.cpp hle/service/hid/controllers/console_six_axis.h hle/service/hid/controllers/controller_base.cpp diff --git a/src/core/arm/debug.cpp b/src/core/arm/debug.cpp index 1fe37b8ee..af1c34bc3 100644 --- a/src/core/arm/debug.cpp +++ b/src/core/arm/debug.cpp @@ -282,6 +282,8 @@ Loader::AppLoader::Modules FindModules(const Kernel::KProcess* process) { // Ignore leading directories. char* path_pointer = module_path.path.data(); + char* path_end = + path_pointer + std::min(PathLengthMax, module_path.path_length); for (s32 i = 0; i < std::min(PathLengthMax, module_path.path_length) && module_path.path[i] != '\0'; @@ -292,7 +294,8 @@ Loader::AppLoader::Modules FindModules(const Kernel::KProcess* process) { } // Insert output. - modules.emplace(svc_mem_info.base_address, path_pointer); + modules.emplace(svc_mem_info.base_address, + std::string_view(path_pointer, path_end)); } } } diff --git a/src/core/file_sys/fsmitm_romfsbuild.cpp b/src/core/file_sys/fsmitm_romfsbuild.cpp index f1d3e4129..dd9cca103 100644 --- a/src/core/file_sys/fsmitm_romfsbuild.cpp +++ b/src/core/file_sys/fsmitm_romfsbuild.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: GPL-2.0-or-later #include <cstring> +#include <span> #include <string_view> #include "common/alignment.h" #include "common/assert.h" @@ -134,7 +135,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir romfs_dir, VirtualDir ext_dir, child->size = child->source->GetSize(); - AddFile(parent, child); + AddFile(parent, std::move(child)); } for (auto& child_romfs_dir : romfs_dir->GetSubdirectories()) { @@ -163,36 +164,24 @@ 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 = parent_dir_ctx; - it->second = dir_ctx; + dir_ctx->parent = std::move(parent_dir_ctx); + directories.emplace_back(std::move(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 = parent_dir_ctx; - it->second = file_ctx; + file_ctx->parent = std::move(parent_dir_ctx); + files.emplace_back(std::move(file_ctx)); return true; } @@ -201,7 +190,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(root->path, root); + directories.emplace_back(root); num_dirs = 1; dir_table_size = 0x18; @@ -210,28 +199,43 @@ RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_) RomFSBuildContext::~RomFSBuildContext() = default; -std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { +std::vector<std::pair<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<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::vector<u8> dir_table(dir_table_size); - std::vector<u8> file_table(file_table_size); - - std::shared_ptr<RomFSBuildFileContext> cur_file; + 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::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); + + // 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; }); // Determine file offsets. u32 entry_offset = 0; std::shared_ptr<RomFSBuildFileContext> prev_file = nullptr; - for (const auto& it : files) { - cur_file = it.second; + for (const auto& cur_file : files) { file_partition_size = Common::AlignUp(file_partition_size, 16); cur_file->offset = file_partition_size; file_partition_size += cur_file->size; @@ -243,34 +247,48 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { } // Assign deferred parent/sibling ownership. for (auto it = files.rbegin(); it != files.rend(); ++it) { - cur_file = it->second; + auto& cur_file = *it; 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& it : directories) { - cur_dir = it.second; + for (const auto& cur_dir : directories) { 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->second != root; ++it) { - cur_dir = it->second; + for (auto it = directories.rbegin(); (*it) != root; ++it) { + auto& cur_dir = *it; cur_dir->sibling = cur_dir->parent->child; cur_dir->parent->child = cur_dir; } - std::multimap<u64, VirtualFile> out; + // 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))); // Populate file tables. - for (const auto& it : files) { - cur_file = it.second; + for (const auto& cur_file : files) { RomFSFileEntry cur_entry{}; cur_entry.parent = cur_file->parent->entry_offset; @@ -287,7 +305,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { cur_entry.name_size = name_size; - out.emplace(cur_file->offset + ROMFS_FILEPARTITION_OFS, std::move(cur_file->source)); + out.emplace_back(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)); @@ -296,8 +314,7 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { } // Populate dir tables. - for (const auto& it : directories) { - cur_dir = it.second; + for (const auto& cur_dir : directories) { RomFSDirectoryEntry cur_entry{}; cur_entry.parent = cur_dir == root ? 0 : cur_dir->parent->entry_offset; @@ -323,34 +340,13 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() { cur_dir->path.data() + cur_dir->cur_path_ofs, name_size); } - // 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(0, std::make_shared<VectorVfsFile>(std::move(header_data))); + // Write metadata. + out.emplace_back(header.dir_hash_table_ofs, + std::make_shared<VectorVfsFile>(std::move(metadata))); - 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))); + // Sort the output. + std::sort(out.begin(), out.end(), + [](const auto& a, const auto& b) { return a.first < b.first; }); return out; } diff --git a/src/core/file_sys/fsmitm_romfsbuild.h b/src/core/file_sys/fsmitm_romfsbuild.h index 06e5d5a47..f387c79f1 100644 --- a/src/core/file_sys/fsmitm_romfsbuild.h +++ b/src/core/file_sys/fsmitm_romfsbuild.h @@ -22,14 +22,14 @@ public: ~RomFSBuildContext(); // This finalizes the context. - std::multimap<u64, VirtualFile> Build(); + std::vector<std::pair<u64, VirtualFile>> Build(); private: VirtualDir base; VirtualDir ext; std::shared_ptr<RomFSBuildDirectoryContext> root; - std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories; - std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files; + std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> directories; + std::vector<std::shared_ptr<RomFSBuildFileContext>> files; u64 num_dirs = 0; u64 num_files = 0; u64 dir_table_size = 0; diff --git a/src/core/file_sys/romfs.cpp b/src/core/file_sys/romfs.cpp index 6de2103a0..6182598ae 100644 --- a/src/core/file_sys/romfs.cpp +++ b/src/core/file_sys/romfs.cpp @@ -55,44 +55,68 @@ struct FileEntry { }; static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect 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::string string(entry.name_length, '\0'); - if (file->ReadArray(&string[0], string.size(), offset + sizeof(Entry)) != string.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) { return {}; - return {entry, string}; + } + 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::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 VirtualFile& file, std::size_t file_offset, std::size_t data_offset, - u32 this_file_offset, std::shared_ptr<VectorVfsDirectory>& parent) { +void ProcessFile(const RomFSTraversalContext& ctx, u32 this_file_offset, + std::shared_ptr<VectorVfsDirectory>& parent) { while (this_file_offset != ROMFS_ENTRY_EMPTY) { - auto entry = GetEntry<FileEntry>(file, file_offset + this_file_offset); + auto entry = GetFileEntry(ctx, this_file_offset); - parent->AddFile(std::make_shared<OffsetVfsFile>( - file, entry.first.size, entry.first.offset + data_offset, entry.second)); + parent->AddFile(std::make_shared<OffsetVfsFile>(ctx.file, entry.first.size, + entry.first.offset + ctx.header.data_offset, + std::move(entry.second))); this_file_offset = entry.first.sibling; } } -void ProcessDirectory(const VirtualFile& file, std::size_t dir_offset, std::size_t file_offset, - std::size_t data_offset, u32 this_dir_offset, +void ProcessDirectory(const RomFSTraversalContext& ctx, u32 this_dir_offset, std::shared_ptr<VectorVfsDirectory>& parent) { while (this_dir_offset != ROMFS_ENTRY_EMPTY) { - auto entry = GetEntry<DirectoryEntry>(file, dir_offset + this_dir_offset); + auto entry = GetDirectoryEntry(ctx, 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(file, file_offset, data_offset, entry.first.child_file, current); + ProcessFile(ctx, entry.first.child_file, current); } if (entry.first.child_dir != ROMFS_ENTRY_EMPTY) { - ProcessDirectory(file, dir_offset, file_offset, data_offset, entry.first.child_dir, - current); + ProcessDirectory(ctx, entry.first.child_dir, current); } parent->AddDirectory(current); @@ -107,22 +131,25 @@ VirtualDir ExtractRomFS(VirtualFile file) { return root_container; } - RomFSHeader header{}; - if (file->ReadObject(&header) != sizeof(RomFSHeader)) { - return root_container; + RomFSTraversalContext ctx{}; + + if (file->ReadObject(&ctx.header) != sizeof(RomFSHeader)) { + return nullptr; } - if (header.header_size != sizeof(RomFSHeader)) { - return root_container; + if (ctx.header.header_size != sizeof(RomFSHeader)) { + return nullptr; } - const u64 file_offset = header.file_meta.offset; - const u64 dir_offset = header.directory_meta.offset; + 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); - ProcessDirectory(file, dir_offset, file_offset, header.data_offset, 0, root_container); + ProcessDirectory(ctx, 0, root_container); if (auto root = root_container->GetSubdirectory(""); root) { - return std::make_shared<CachedVfsDirectory>(std::move(root)); + return root; } ASSERT(false); diff --git a/src/core/file_sys/vfs_concat.cpp b/src/core/file_sys/vfs_concat.cpp index 168b9cbec..7c7298527 100644 --- a/src/core/file_sys/vfs_concat.cpp +++ b/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::multimap<u64, VirtualFile>&& files) { +VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile( + u8 filler_byte, std::string&& name, std::vector<std::pair<u64, VirtualFile>>&& files) { // Fold trivial cases. if (files.empty()) { return nullptr; diff --git a/src/core/file_sys/vfs_concat.h b/src/core/file_sys/vfs_concat.h index cbddd12bd..b5f3d72e3 100644 --- a/src/core/file_sys/vfs_concat.h +++ b/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::multimap<u64, VirtualFile>&& files); + std::vector<std::pair<u64, VirtualFile>>&& files); std::string GetName() const override; std::size_t GetSize() const override; diff --git a/src/core/file_sys/vfs_layered.cpp b/src/core/file_sys/vfs_layered.cpp index 08daca397..5551743fb 100644 --- a/src/core/file_sys/vfs_layered.cpp +++ b/src/core/file_sys/vfs_layered.cpp @@ -3,6 +3,7 @@ #include <algorithm> #include <set> +#include <unordered_set> #include <utility> #include "core/file_sys/vfs_layered.h" @@ -59,13 +60,12 @@ std::string LayeredVfsDirectory::GetFullPath() const { std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const { std::vector<VirtualFile> out; - std::set<std::string, std::less<>> out_names; + std::unordered_set<std::string> out_names; for (const auto& layer : dirs) { for (auto& file : layer->GetFiles()) { - auto file_name = file->GetName(); - if (!out_names.contains(file_name)) { - out_names.emplace(std::move(file_name)); + const auto [it, is_new] = out_names.emplace(file->GetName()); + if (is_new) { out.emplace_back(std::move(file)); } } @@ -75,18 +75,19 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const { } std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const { - std::vector<std::string> names; + std::vector<VirtualDir> out; + std::unordered_set<std::string> out_names; + for (const auto& layer : dirs) { for (const auto& sd : layer->GetSubdirectories()) { - if (std::find(names.begin(), names.end(), sd->GetName()) == names.end()) - names.push_back(sd->GetName()); + out_names.emplace(sd->GetName()); } } - std::vector<VirtualDir> out; - out.reserve(names.size()); - for (const auto& subdir : names) + out.reserve(out_names.size()); + for (const auto& subdir : out_names) { out.emplace_back(GetSubdirectory(subdir)); + } return out; } diff --git a/src/core/hle/kernel/k_client_port.cpp b/src/core/hle/kernel/k_client_port.cpp index 40e09e532..11b1b977e 100644 --- a/src/core/hle/kernel/k_client_port.cpp +++ b/src/core/hle/kernel/k_client_port.cpp @@ -3,6 +3,7 @@ #include "common/scope_exit.h" #include "core/hle/kernel/k_client_port.h" +#include "core/hle/kernel/k_light_session.h" #include "core/hle/kernel/k_port.h" #include "core/hle/kernel/k_scheduler.h" #include "core/hle/kernel/k_scoped_resource_reservation.h" @@ -63,6 +64,7 @@ Result KClientPort::CreateSession(KClientSession** out) { R_UNLESS(session_reservation.Succeeded(), ResultLimitReached); // Allocate a session normally. + // TODO: Dynamic resource limits session = KSession::Create(m_kernel); // Check that we successfully created a session. @@ -119,4 +121,71 @@ Result KClientPort::CreateSession(KClientSession** out) { R_SUCCEED(); } +Result KClientPort::CreateLightSession(KLightClientSession** out) { + // Declare the session we're going to allocate. + KLightSession* session{}; + + // Reserve a new session from the resource limit. + KScopedResourceReservation session_reservation(GetCurrentProcessPointer(m_kernel), + Svc::LimitableResource::SessionCountMax); + R_UNLESS(session_reservation.Succeeded(), ResultLimitReached); + + // Allocate a session normally. + // TODO: Dynamic resource limits + session = KLightSession::Create(m_kernel); + + // Check that we successfully created a session. + R_UNLESS(session != nullptr, ResultOutOfResource); + + // Update the session counts. + { + ON_RESULT_FAILURE { + session->Close(); + }; + + // Atomically increment the number of sessions. + s32 new_sessions; + { + const auto max = m_max_sessions; + auto cur_sessions = m_num_sessions.load(std::memory_order_acquire); + do { + R_UNLESS(cur_sessions < max, ResultOutOfSessions); + new_sessions = cur_sessions + 1; + } while (!m_num_sessions.compare_exchange_weak(cur_sessions, new_sessions, + std::memory_order_relaxed)); + } + + // Atomically update the peak session tracking. + { + auto peak = m_peak_sessions.load(std::memory_order_acquire); + do { + if (peak >= new_sessions) { + break; + } + } while (!m_peak_sessions.compare_exchange_weak(peak, new_sessions, + std::memory_order_relaxed)); + } + } + + // Initialize the session. + session->Initialize(this, m_parent->GetName()); + + // Commit the session reservation. + session_reservation.Commit(); + + // Register the session. + KLightSession::Register(m_kernel, session); + ON_RESULT_FAILURE { + session->GetClientSession().Close(); + session->GetServerSession().Close(); + }; + + // Enqueue the session with our parent. + R_TRY(m_parent->EnqueueSession(std::addressof(session->GetServerSession()))); + + // We succeeded, so set the output. + *out = std::addressof(session->GetClientSession()); + R_SUCCEED(); +} + } // namespace Kernel diff --git a/src/core/hle/kernel/k_client_port.h b/src/core/hle/kernel/k_client_port.h index 23db06ddf..28b332608 100644 --- a/src/core/hle/kernel/k_client_port.h +++ b/src/core/hle/kernel/k_client_port.h @@ -11,6 +11,7 @@ namespace Kernel { +class KLightClientSession; class KClientSession; class KernelCore; class KPort; @@ -51,6 +52,7 @@ public: bool IsSignaled() const override; Result CreateSession(KClientSession** out); + Result CreateLightSession(KLightClientSession** out); private: std::atomic<s32> m_num_sessions{}; diff --git a/src/core/hle/kernel/k_light_client_session.cpp b/src/core/hle/kernel/k_light_client_session.cpp new file mode 100644 index 000000000..8ce3e1ae4 --- /dev/null +++ b/src/core/hle/kernel/k_light_client_session.cpp @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_session.h" +#include "core/hle/kernel/k_thread.h" + +namespace Kernel { + +KLightClientSession::KLightClientSession(KernelCore& kernel) : KAutoObject(kernel) {} + +KLightClientSession::~KLightClientSession() = default; + +void KLightClientSession::Destroy() { + m_parent->OnClientClosed(); +} + +void KLightClientSession::OnServerClosed() {} + +Result KLightClientSession::SendSyncRequest(u32* data) { + // Get the request thread. + KThread* cur_thread = GetCurrentThreadPointer(m_kernel); + + // Set the light data. + cur_thread->SetLightSessionData(data); + + // Send the request. + R_RETURN(m_parent->OnRequest(cur_thread)); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_client_session.h b/src/core/hle/kernel/k_light_client_session.h new file mode 100644 index 000000000..881a15cbd --- /dev/null +++ b/src/core/hle/kernel/k_light_client_session.h @@ -0,0 +1,39 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "core/hle/kernel/k_auto_object.h" +#include "core/hle/result.h" + +namespace Kernel { + +class KLightSession; + +class KLightClientSession final : public KAutoObject { + KERNEL_AUTOOBJECT_TRAITS(KLightClientSession, KAutoObject); + +public: + explicit KLightClientSession(KernelCore& kernel); + ~KLightClientSession(); + + void Initialize(KLightSession* parent) { + // Set member variables. + m_parent = parent; + } + + virtual void Destroy() override; + + const KLightSession* GetParent() const { + return m_parent; + } + + Result SendSyncRequest(u32* data); + + void OnServerClosed(); + +private: + KLightSession* m_parent; +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_server_session.cpp b/src/core/hle/kernel/k_light_server_session.cpp new file mode 100644 index 000000000..e5ceb01f2 --- /dev/null +++ b/src/core/hle/kernel/k_light_server_session.cpp @@ -0,0 +1,247 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/k_light_session.h" +#include "core/hle/kernel/k_thread.h" +#include "core/hle/kernel/k_thread_queue.h" +#include "core/hle/kernel/svc_results.h" + +namespace Kernel { + +namespace { + +constexpr u64 InvalidThreadId = std::numeric_limits<u64>::max(); + +class ThreadQueueImplForKLightServerSessionRequest final : public KThreadQueue { +private: + KThread::WaiterList* m_wait_list; + +public: + ThreadQueueImplForKLightServerSessionRequest(KernelCore& kernel, KThread::WaiterList* wl) + : KThreadQueue(kernel), m_wait_list(wl) {} + + virtual void EndWait(KThread* waiting_thread, Result wait_result) override { + // Remove the thread from our wait list. + m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread)); + + // Invoke the base end wait handler. + KThreadQueue::EndWait(waiting_thread, wait_result); + } + + virtual void CancelWait(KThread* waiting_thread, Result wait_result, + bool cancel_timer_task) override { + // Remove the thread from our wait list. + m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread)); + + // Invoke the base cancel wait handler. + KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task); + } +}; + +class ThreadQueueImplForKLightServerSessionReceive final : public KThreadQueue { +private: + KThread** m_server_thread; + +public: + ThreadQueueImplForKLightServerSessionReceive(KernelCore& kernel, KThread** st) + : KThreadQueue(kernel), m_server_thread(st) {} + + virtual void EndWait(KThread* waiting_thread, Result wait_result) override { + // Clear the server thread. + *m_server_thread = nullptr; + + // Set the waiting thread as not cancelable. + waiting_thread->ClearCancellable(); + + // Invoke the base end wait handler. + KThreadQueue::EndWait(waiting_thread, wait_result); + } + + virtual void CancelWait(KThread* waiting_thread, Result wait_result, + bool cancel_timer_task) override { + // Clear the server thread. + *m_server_thread = nullptr; + + // Set the waiting thread as not cancelable. + waiting_thread->ClearCancellable(); + + // Invoke the base cancel wait handler. + KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task); + } +}; + +} // namespace + +KLightServerSession::KLightServerSession(KernelCore& kernel) : KAutoObject(kernel) {} +KLightServerSession::~KLightServerSession() = default; + +void KLightServerSession::Destroy() { + this->CleanupRequests(); + + m_parent->OnServerClosed(); +} + +void KLightServerSession::OnClientClosed() { + this->CleanupRequests(); +} + +Result KLightServerSession::OnRequest(KThread* request_thread) { + ThreadQueueImplForKLightServerSessionRequest wait_queue(m_kernel, + std::addressof(m_request_list)); + + // Send the request. + { + // Lock the scheduler. + KScopedSchedulerLock sl(m_kernel); + + // Check that the server isn't closed. + R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed); + + // Check that the request thread isn't terminating. + R_UNLESS(!request_thread->IsTerminationRequested(), ResultTerminationRequested); + + // Add the request thread to our list. + m_request_list.push_back(*request_thread); + + // Begin waiting on the request. + request_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC); + request_thread->BeginWait(std::addressof(wait_queue)); + + // If we have a server thread, end its wait. + if (m_server_thread != nullptr) { + m_server_thread->EndWait(ResultSuccess); + } + } + + // NOTE: Nintendo returns GetCurrentThread().GetWaitResult() here. + // This is technically incorrect, although it doesn't cause problems in practice + // because this is only ever called with request_thread = GetCurrentThreadPointer(). + R_RETURN(request_thread->GetWaitResult()); +} + +Result KLightServerSession::ReplyAndReceive(u32* data) { + // Set the server context. + GetCurrentThread(m_kernel).SetLightSessionData(data); + + // Reply, if we need to. + if (data[0] & KLightSession::ReplyFlag) { + KScopedSchedulerLock sl(m_kernel); + + // Check that we're open. + R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed); + R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed); + + // Check that we have a request to reply to. + R_UNLESS(m_current_request != nullptr, ResultInvalidState); + + // Check that the server thread id is correct. + R_UNLESS(m_server_thread_id == GetCurrentThread(m_kernel).GetId(), ResultInvalidState); + + // If we can reply, do so. + if (!m_current_request->IsTerminationRequested()) { + std::memcpy(m_current_request->GetLightSessionData(), + GetCurrentThread(m_kernel).GetLightSessionData(), KLightSession::DataSize); + m_current_request->EndWait(ResultSuccess); + } + + // Close our current request. + m_current_request->Close(); + + // Clear our current request. + m_current_request = nullptr; + m_server_thread_id = InvalidThreadId; + } + + // Create the wait queue for our receive. + ThreadQueueImplForKLightServerSessionReceive wait_queue(m_kernel, + std::addressof(m_server_thread)); + + // Receive. + while (true) { + // Try to receive a request. + { + KScopedSchedulerLock sl(m_kernel); + + // Check that we aren't already receiving. + R_UNLESS(m_server_thread == nullptr, ResultInvalidState); + R_UNLESS(m_server_thread_id == InvalidThreadId, ResultInvalidState); + + // Check that we're open. + R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed); + R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed); + + // Check that we're not terminating. + R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(), + ResultTerminationRequested); + + // If we have a request available, use it. + if (auto head = m_request_list.begin(); head != m_request_list.end()) { + // Set our current request. + m_current_request = std::addressof(*head); + m_current_request->Open(); + + // Set our server thread id. + m_server_thread_id = GetCurrentThread(m_kernel).GetId(); + + // Copy the client request data. + std::memcpy(GetCurrentThread(m_kernel).GetLightSessionData(), + m_current_request->GetLightSessionData(), KLightSession::DataSize); + + // We successfully received. + R_SUCCEED(); + } + + // We need to wait for a request to come in. + + // Check if we were cancelled. + if (GetCurrentThread(m_kernel).IsWaitCancelled()) { + GetCurrentThread(m_kernel).ClearWaitCancelled(); + R_THROW(ResultCancelled); + } + + // Mark ourselves as cancellable. + GetCurrentThread(m_kernel).SetCancellable(); + + // Wait for a request to come in. + m_server_thread = GetCurrentThreadPointer(m_kernel); + GetCurrentThread(m_kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC); + GetCurrentThread(m_kernel).BeginWait(std::addressof(wait_queue)); + } + + // We waited to receive a request; if our wait failed, return the failing result. + R_TRY(GetCurrentThread(m_kernel).GetWaitResult()); + } +} + +void KLightServerSession::CleanupRequests() { + // Cleanup all pending requests. + { + KScopedSchedulerLock sl(m_kernel); + + // Handle the current request. + if (m_current_request != nullptr) { + // Reply to the current request. + if (!m_current_request->IsTerminationRequested()) { + m_current_request->EndWait(ResultSessionClosed); + } + + // Clear our current request. + m_current_request->Close(); + m_current_request = nullptr; + m_server_thread_id = InvalidThreadId; + } + + // Reply to all other requests. + for (auto& thread : m_request_list) { + thread.EndWait(ResultSessionClosed); + } + + // Wait up our server thread, if we have one. + if (m_server_thread != nullptr) { + m_server_thread->EndWait(ResultSessionClosed); + } + } +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_server_session.h b/src/core/hle/kernel/k_light_server_session.h new file mode 100644 index 000000000..8eca3eab6 --- /dev/null +++ b/src/core/hle/kernel/k_light_server_session.h @@ -0,0 +1,49 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "core/hle/kernel/k_auto_object.h" +#include "core/hle/kernel/k_thread.h" +#include "core/hle/result.h" + +namespace Kernel { + +class KLightSession; + +class KLightServerSession final : public KAutoObject, + public Common::IntrusiveListBaseNode<KLightServerSession> { + KERNEL_AUTOOBJECT_TRAITS(KLightServerSession, KAutoObject); + +private: + KLightSession* m_parent{}; + KThread::WaiterList m_request_list{}; + KThread* m_current_request{}; + u64 m_server_thread_id{std::numeric_limits<u64>::max()}; + KThread* m_server_thread{}; + +public: + explicit KLightServerSession(KernelCore& kernel); + ~KLightServerSession(); + + void Initialize(KLightSession* parent) { + // Set member variables. */ + m_parent = parent; + } + + virtual void Destroy() override; + + constexpr const KLightSession* GetParent() const { + return m_parent; + } + + Result OnRequest(KThread* request_thread); + Result ReplyAndReceive(u32* data); + + void OnClientClosed(); + +private: + void CleanupRequests(); +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_session.cpp b/src/core/hle/kernel/k_light_session.cpp new file mode 100644 index 000000000..d8b1e6958 --- /dev/null +++ b/src/core/hle/kernel/k_light_session.cpp @@ -0,0 +1,81 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core/hle/kernel/k_client_port.h" +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/k_light_session.h" +#include "core/hle/kernel/k_process.h" + +namespace Kernel { + +KLightSession::KLightSession(KernelCore& kernel) + : KAutoObjectWithSlabHeapAndContainer(kernel), m_server(kernel), m_client(kernel) {} +KLightSession::~KLightSession() = default; + +void KLightSession::Initialize(KClientPort* client_port, uintptr_t name) { + // Increment reference count. + // Because reference count is one on creation, this will result + // in a reference count of two. Thus, when both server and client are closed + // this object will be destroyed. + this->Open(); + + // Create our sub sessions. + KAutoObject::Create(std::addressof(m_server)); + KAutoObject::Create(std::addressof(m_client)); + + // Initialize our sub sessions. + m_server.Initialize(this); + m_client.Initialize(this); + + // Set state and name. + m_state = State::Normal; + m_name = name; + + // Set our owner process. + m_process = GetCurrentProcessPointer(m_kernel); + m_process->Open(); + + // Set our port. + m_port = client_port; + if (m_port != nullptr) { + m_port->Open(); + } + + // Mark initialized. + m_initialized = true; +} + +void KLightSession::Finalize() { + if (m_port != nullptr) { + m_port->OnSessionFinalized(); + m_port->Close(); + } +} + +void KLightSession::OnServerClosed() { + if (m_state == State::Normal) { + m_state = State::ServerClosed; + m_client.OnServerClosed(); + } + + this->Close(); +} + +void KLightSession::OnClientClosed() { + if (m_state == State::Normal) { + m_state = State::ClientClosed; + m_server.OnClientClosed(); + } + + this->Close(); +} + +void KLightSession::PostDestroy(uintptr_t arg) { + // Release the session count resource the owner process holds. + KProcess* owner = reinterpret_cast<KProcess*>(arg); + owner->ReleaseResource(Svc::LimitableResource::SessionCountMax, 1); + owner->Close(); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_light_session.h b/src/core/hle/kernel/k_light_session.h new file mode 100644 index 000000000..f78d8e689 --- /dev/null +++ b/src/core/hle/kernel/k_light_session.h @@ -0,0 +1,86 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/slab_helpers.h" +#include "core/hle/result.h" + +namespace Kernel { + +class KClientPort; +class KProcess; + +// TODO: SupportDynamicExpansion for SlabHeap +class KLightSession final + : public KAutoObjectWithSlabHeapAndContainer<KLightSession, KAutoObjectWithList> { + KERNEL_AUTOOBJECT_TRAITS(KLightSession, KAutoObject); + +private: + enum class State : u8 { + Invalid = 0, + Normal = 1, + ClientClosed = 2, + ServerClosed = 3, + }; + +public: + static constexpr size_t DataSize = sizeof(u32) * 7; + static constexpr u32 ReplyFlag = (1U << 31); + +private: + KLightServerSession m_server; + KLightClientSession m_client; + State m_state{State::Invalid}; + KClientPort* m_port{}; + uintptr_t m_name{}; + KProcess* m_process{}; + bool m_initialized{}; + +public: + explicit KLightSession(KernelCore& kernel); + ~KLightSession(); + + void Initialize(KClientPort* client_port, uintptr_t name); + void Finalize() override; + + bool IsInitialized() const override { + return m_initialized; + } + uintptr_t GetPostDestroyArgument() const override { + return reinterpret_cast<uintptr_t>(m_process); + } + + static void PostDestroy(uintptr_t arg); + + void OnServerClosed(); + void OnClientClosed(); + + bool IsServerClosed() const { + return m_state != State::Normal; + } + bool IsClientClosed() const { + return m_state != State::Normal; + } + + Result OnRequest(KThread* request_thread) { + R_RETURN(m_server.OnRequest(request_thread)); + } + + KLightClientSession& GetClientSession() { + return m_client; + } + KLightServerSession& GetServerSession() { + return m_server; + } + const KLightClientSession& GetClientSession() const { + return m_client; + } + const KLightServerSession& GetServerSession() const { + return m_server; + } +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_port.cpp b/src/core/hle/kernel/k_port.cpp index 1621ca1d3..e5f5d8028 100644 --- a/src/core/hle/kernel/k_port.cpp +++ b/src/core/hle/kernel/k_port.cpp @@ -58,4 +58,13 @@ Result KPort::EnqueueSession(KServerSession* session) { R_SUCCEED(); } +Result KPort::EnqueueSession(KLightServerSession* session) { + KScopedSchedulerLock sl{m_kernel}; + + R_UNLESS(m_state == State::Normal, ResultPortClosed); + + m_server.EnqueueSession(session); + R_SUCCEED(); +} + } // namespace Kernel diff --git a/src/core/hle/kernel/k_port.h b/src/core/hle/kernel/k_port.h index 991be27ab..26f5f14ef 100644 --- a/src/core/hle/kernel/k_port.h +++ b/src/core/hle/kernel/k_port.h @@ -13,6 +13,7 @@ namespace Kernel { +class KLightServerSession; class KServerSession; class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjectWithList> { @@ -38,6 +39,7 @@ public: bool IsServerClosed() const; Result EnqueueSession(KServerSession* session); + Result EnqueueSession(KLightServerSession* session); KClientPort& GetClientPort() { return m_client; diff --git a/src/core/hle/kernel/k_server_port.cpp b/src/core/hle/kernel/k_server_port.cpp index a29d34bc1..bb6632f58 100644 --- a/src/core/hle/kernel/k_server_port.cpp +++ b/src/core/hle/kernel/k_server_port.cpp @@ -27,12 +27,14 @@ bool KServerPort::IsLight() const { void KServerPort::CleanupSessions() { // Ensure our preconditions are met. if (this->IsLight()) { - UNIMPLEMENTED(); + ASSERT(m_session_list.empty()); + } else { + ASSERT(m_light_session_list.empty()); } // Cleanup the session list. while (true) { - // Get the last session in the list + // Get the last session in the list. KServerSession* session = nullptr; { KScopedSchedulerLock sl{m_kernel}; @@ -49,6 +51,26 @@ void KServerPort::CleanupSessions() { break; } } + + // Cleanup the light session list. + while (true) { + // Get the last session in the list. + KLightServerSession* session = nullptr; + { + KScopedSchedulerLock sl{m_kernel}; + if (!m_light_session_list.empty()) { + session = std::addressof(m_light_session_list.front()); + m_light_session_list.pop_front(); + } + } + + // Close the session. + if (session != nullptr) { + session->Close(); + } else { + break; + } + } } void KServerPort::Destroy() { @@ -64,8 +86,7 @@ void KServerPort::Destroy() { bool KServerPort::IsSignaled() const { if (this->IsLight()) { - UNIMPLEMENTED(); - return false; + return !m_light_session_list.empty(); } else { return !m_session_list.empty(); } @@ -83,6 +104,18 @@ void KServerPort::EnqueueSession(KServerSession* session) { } } +void KServerPort::EnqueueSession(KLightServerSession* session) { + ASSERT(this->IsLight()); + + KScopedSchedulerLock sl{m_kernel}; + + // Add the session to our queue. + m_light_session_list.push_back(*session); + if (m_light_session_list.size() == 1) { + this->NotifyAvailable(); + } +} + KServerSession* KServerPort::AcceptSession() { ASSERT(!this->IsLight()); @@ -98,4 +131,19 @@ KServerSession* KServerPort::AcceptSession() { return session; } +KLightServerSession* KServerPort::AcceptLightSession() { + ASSERT(this->IsLight()); + + KScopedSchedulerLock sl{m_kernel}; + + // Return the first session in the list. + if (m_light_session_list.empty()) { + return nullptr; + } + + KLightServerSession* session = std::addressof(m_light_session_list.front()); + m_light_session_list.pop_front(); + return session; +} + } // namespace Kernel diff --git a/src/core/hle/kernel/k_server_port.h b/src/core/hle/kernel/k_server_port.h index 625280290..72fdb6734 100644 --- a/src/core/hle/kernel/k_server_port.h +++ b/src/core/hle/kernel/k_server_port.h @@ -9,6 +9,7 @@ #include "common/intrusive_list.h" +#include "core/hle/kernel/k_light_server_session.h" #include "core/hle/kernel/k_server_session.h" #include "core/hle/kernel/k_synchronization_object.h" @@ -28,8 +29,10 @@ public: void Initialize(KPort* parent); void EnqueueSession(KServerSession* session); + void EnqueueSession(KLightServerSession* session); KServerSession* AcceptSession(); + KLightServerSession* AcceptLightSession(); const KPort* GetParent() const { return m_parent; @@ -43,10 +46,12 @@ public: private: using SessionList = Common::IntrusiveListBaseTraits<KServerSession>::ListType; + using LightSessionList = Common::IntrusiveListBaseTraits<KLightServerSession>::ListType; void CleanupSessions(); SessionList m_session_list{}; + LightSessionList m_light_session_list{}; KPort* m_parent{}; }; diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h index 390db2409..e9925d231 100644 --- a/src/core/hle/kernel/k_thread.h +++ b/src/core/hle/kernel/k_thread.h @@ -385,6 +385,13 @@ public: m_cancellable = false; } + u32* GetLightSessionData() const { + return m_light_ipc_data; + } + void SetLightSessionData(u32* data) { + m_light_ipc_data = data; + } + bool IsTerminationRequested() const { return m_termination_requested || GetRawState() == ThreadState::Terminated; } diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 032c4e093..8cb05ca0b 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -1340,6 +1340,7 @@ struct KernelCore::SlabHeapContainer { KSlabHeap<KProcess> process; KSlabHeap<KResourceLimit> resource_limit; KSlabHeap<KSession> session; + KSlabHeap<KLightSession> light_session; KSlabHeap<KSharedMemory> shared_memory; KSlabHeap<KSharedMemoryInfo> shared_memory_info; KSlabHeap<KThread> thread; @@ -1370,6 +1371,8 @@ KSlabHeap<T>& KernelCore::SlabHeap() { return slab_heap_container->resource_limit; } else if constexpr (std::is_same_v<T, KSession>) { return slab_heap_container->session; + } else if constexpr (std::is_same_v<T, KLightSession>) { + return slab_heap_container->light_session; } else if constexpr (std::is_same_v<T, KSharedMemory>) { return slab_heap_container->shared_memory; } else if constexpr (std::is_same_v<T, KSharedMemoryInfo>) { @@ -1407,6 +1410,7 @@ template KSlabHeap<KPort>& KernelCore::SlabHeap(); template KSlabHeap<KProcess>& KernelCore::SlabHeap(); template KSlabHeap<KResourceLimit>& KernelCore::SlabHeap(); template KSlabHeap<KSession>& KernelCore::SlabHeap(); +template KSlabHeap<KLightSession>& KernelCore::SlabHeap(); template KSlabHeap<KSharedMemory>& KernelCore::SlabHeap(); template KSlabHeap<KSharedMemoryInfo>& KernelCore::SlabHeap(); template KSlabHeap<KThread>& KernelCore::SlabHeap(); diff --git a/src/core/hle/kernel/svc/svc_light_ipc.cpp b/src/core/hle/kernel/svc/svc_light_ipc.cpp index d757d5af2..4772cbda1 100644 --- a/src/core/hle/kernel/svc/svc_light_ipc.cpp +++ b/src/core/hle/kernel/svc/svc_light_ipc.cpp @@ -1,21 +1,40 @@ // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include "core/arm/arm_interface.h" #include "core/core.h" +#include "core/hle/kernel/k_light_client_session.h" +#include "core/hle/kernel/k_light_server_session.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/svc.h" #include "core/hle/kernel/svc_results.h" namespace Kernel::Svc { Result SendSyncRequestLight(Core::System& system, Handle session_handle, u32* args) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + // Get the light client session from its handle. + KScopedAutoObject session = GetCurrentProcess(system.Kernel()) + .GetHandleTable() + .GetObject<KLightClientSession>(session_handle); + R_UNLESS(session.IsNotNull(), ResultInvalidHandle); + + // Send the request. + R_TRY(session->SendSyncRequest(args)); + + R_SUCCEED(); } Result ReplyAndReceiveLight(Core::System& system, Handle session_handle, u32* args) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + // Get the light server session from its handle. + KScopedAutoObject session = GetCurrentProcess(system.Kernel()) + .GetHandleTable() + .GetObject<KLightServerSession>(session_handle); + R_UNLESS(session.IsNotNull(), ResultInvalidHandle); + + // Handle the request. + R_TRY(session->ReplyAndReceive(args)); + + R_SUCCEED(); } Result SendSyncRequestLight64(Core::System& system, Handle session_handle, u32* args) { diff --git a/src/core/hle/kernel/svc/svc_port.cpp b/src/core/hle/kernel/svc/svc_port.cpp index abba757c7..737749f7d 100644 --- a/src/core/hle/kernel/svc/svc_port.cpp +++ b/src/core/hle/kernel/svc/svc_port.cpp @@ -5,6 +5,7 @@ #include "core/core.h" #include "core/hle/kernel/k_client_port.h" #include "core/hle/kernel/k_client_session.h" +#include "core/hle/kernel/k_light_client_session.h" #include "core/hle/kernel/k_object_name.h" #include "core/hle/kernel/k_port.h" #include "core/hle/kernel/k_process.h" @@ -51,13 +52,73 @@ Result ConnectToNamedPort(Core::System& system, Handle* out, u64 user_name) { Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client, int32_t max_sessions, bool is_light, uint64_t name) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); + auto& kernel = system.Kernel(); + + // Ensure max sessions is valid. + R_UNLESS(max_sessions > 0, ResultOutOfRange); + + // Get the current handle table. + auto& handle_table = GetCurrentProcess(kernel).GetHandleTable(); + + // Create a new port. + KPort* port = KPort::Create(kernel); + R_UNLESS(port != nullptr, ResultOutOfResource); + + // Initialize the port. + port->Initialize(max_sessions, is_light, name); + + // Ensure that we clean up the port (and its only references are handle table) on function end. + SCOPE_EXIT({ + port->GetServerPort().Close(); + port->GetClientPort().Close(); + }); + + // Register the port. + KPort::Register(kernel, port); + + // Add the client to the handle table. + R_TRY(handle_table.Add(out_client, std::addressof(port->GetClientPort()))); + + // Ensure that we maintain a clean handle state on exit. + ON_RESULT_FAILURE { + handle_table.Remove(*out_client); + }; + + // Add the server to the handle table. + R_RETURN(handle_table.Add(out_server, std::addressof(port->GetServerPort()))); } -Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); +Result ConnectToPort(Core::System& system, Handle* out, Handle port) { + // Get the current handle table. + auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable(); + + // Get the client port. + KScopedAutoObject client_port = handle_table.GetObject<KClientPort>(port); + R_UNLESS(client_port.IsNotNull(), ResultInvalidHandle); + + // Reserve a handle for the port. + // NOTE: Nintendo really does write directly to the output handle here. + R_TRY(handle_table.Reserve(out)); + ON_RESULT_FAILURE { + handle_table.Unreserve(*out); + }; + + // Create the session. + KAutoObject* session; + if (client_port->IsLight()) { + R_TRY(client_port->CreateLightSession( + reinterpret_cast<KLightClientSession**>(std::addressof(session)))); + } else { + R_TRY(client_port->CreateSession( + reinterpret_cast<KClientSession**>(std::addressof(session)))); + } + + // Register the session. + handle_table.Register(*out, session); + session->Close(); + + // We succeeded. + R_SUCCEED(); } Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t user_name, diff --git a/src/core/hle/kernel/svc/svc_session.cpp b/src/core/hle/kernel/svc/svc_session.cpp index 01b8a52ad..2f5905f32 100644 --- a/src/core/hle/kernel/svc/svc_session.cpp +++ b/src/core/hle/kernel/svc/svc_session.cpp @@ -3,8 +3,10 @@ #include "common/scope_exit.h" #include "core/core.h" +#include "core/hle/kernel/k_light_session.h" #include "core/hle/kernel/k_process.h" #include "core/hle/kernel/k_scoped_resource_reservation.h" +#include "core/hle/kernel/k_server_port.h" #include "core/hle/kernel/k_session.h" #include "core/hle/kernel/svc.h" @@ -20,7 +22,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien T* session; // Reserve a new session from the process resource limit. - // FIXME: LimitableResource_SessionCountMax + // TODO: Dynamic resource limits KScopedResourceReservation session_reservation(std::addressof(process), LimitableResource::SessionCountMax); if (session_reservation.Succeeded()) { @@ -92,16 +94,42 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, bool is_light, u64 name) { if (is_light) { - // return CreateSession<KLightSession>(system, out_server, out_client, name); - R_THROW(ResultNotImplemented); + R_RETURN(CreateSession<KLightSession>(system, out_server, out_client, name)); } else { R_RETURN(CreateSession<KSession>(system, out_server, out_client, name)); } } -Result AcceptSession(Core::System& system, Handle* out_handle, Handle port_handle) { - UNIMPLEMENTED(); - R_THROW(ResultNotImplemented); +Result AcceptSession(Core::System& system, Handle* out, Handle port_handle) { + // Get the current handle table. + auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable(); + + // Get the server port. + KScopedAutoObject port = handle_table.GetObject<KServerPort>(port_handle); + R_UNLESS(port.IsNotNull(), ResultInvalidHandle); + + // Reserve an entry for the new session. + R_TRY(handle_table.Reserve(out)); + ON_RESULT_FAILURE { + handle_table.Unreserve(*out); + }; + + // Accept the session. + KAutoObject* session; + if (port->IsLight()) { + session = port->AcceptLightSession(); + } else { + session = port->AcceptSession(); + } + + // Ensure we accepted successfully. + R_UNLESS(session != nullptr, ResultNotFound); + + // Register the session. + handle_table.Register(*out, session); + session->Close(); + + R_SUCCEED(); } Result CreateSession64(Core::System& system, Handle* out_server_session_handle, diff --git a/src/core/hle/service/hid/controllers/applet_resource.cpp b/src/core/hle/service/hid/controllers/applet_resource.cpp new file mode 100644 index 000000000..ee60d8b44 --- /dev/null +++ b/src/core/hle/service/hid/controllers/applet_resource.cpp @@ -0,0 +1,199 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "core/core.h" +#include "core/hle/kernel/k_shared_memory.h" +#include "core/hle/service/hid/controllers/applet_resource.h" +#include "core/hle/service/hid/errors.h" + +namespace Service::HID { + +AppletResource::AppletResource(Core::System& system_) : system{system_} {} + +AppletResource::~AppletResource() = default; + +Result AppletResource::CreateAppletResource(u64 aruid) { + const u64 index = GetIndexFromAruid(aruid); + + if (index >= AruidIndexMax) { + return ResultAruidNotRegistered; + } + + if (data[index].flag.is_assigned) { + return ResultAruidAlreadyRegistered; + } + + // TODO: Here shared memory is created for the process we don't quite emulate this part so + // obtain this pointer from system + auto& shared_memory = system.Kernel().GetHidSharedMem(); + + data[index].shared_memory_handle = &shared_memory; + data[index].flag.is_assigned.Assign(true); + // TODO: InitializeSixAxisControllerConfig(false); + active_aruid = aruid; + return ResultSuccess; +} + +Result AppletResource::RegisterAppletResourceUserId(u64 aruid, bool enable_input) { + const u64 index = GetIndexFromAruid(aruid); + + if (index < AruidIndexMax) { + return ResultAruidAlreadyRegistered; + } + + std::size_t data_index = AruidIndexMax; + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (!data[i].flag.is_initialized) { + data_index = i; + break; + } + } + + if (data_index == AruidIndexMax) { + return ResultAruidNoAvailableEntries; + } + + AruidData& aruid_data = data[data_index]; + + aruid_data.aruid = aruid; + aruid_data.flag.is_initialized.Assign(true); + if (enable_input) { + aruid_data.flag.enable_pad_input.Assign(true); + aruid_data.flag.enable_six_axis_sensor.Assign(true); + aruid_data.flag.bit_18.Assign(true); + aruid_data.flag.enable_touchscreen.Assign(true); + } + + data_index = AruidIndexMax; + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (registration_list.flag[i] == RegistrationStatus::Initialized) { + if (registration_list.aruid[i] != aruid) { + continue; + } + data_index = i; + break; + } + if (registration_list.flag[i] == RegistrationStatus::None) { + data_index = i; + break; + } + } + + if (data_index == AruidIndexMax) { + return ResultSuccess; + } + + registration_list.flag[data_index] = RegistrationStatus::Initialized; + registration_list.aruid[data_index] = aruid; + + return ResultSuccess; +} + +void AppletResource::UnregisterAppletResourceUserId(u64 aruid) { + u64 index = GetIndexFromAruid(aruid); + + if (index < AruidIndexMax) { + if (data[index].flag.is_assigned) { + data[index].shared_memory_handle = nullptr; + data[index].flag.is_assigned.Assign(false); + } + } + + index = GetIndexFromAruid(aruid); + if (index < AruidIndexMax) { + DestroySevenSixAxisTransferMemory(); + data[index].flag.raw = 0; + data[index].aruid = 0; + + index = GetIndexFromAruid(aruid); + if (index < AruidIndexMax) { + registration_list.flag[index] = RegistrationStatus::PendingDelete; + } + } +} + +u64 AppletResource::GetActiveAruid() { + return active_aruid; +} + +Result AppletResource::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) { + u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return ResultAruidNotRegistered; + } + + *out_handle = data[index].shared_memory_handle; + return ResultSuccess; +} + +u64 AppletResource::GetIndexFromAruid(u64 aruid) { + for (std::size_t i = 0; i < AruidIndexMax; i++) { + if (registration_list.flag[i] == RegistrationStatus::Initialized && + registration_list.aruid[i] == aruid) { + return i; + } + } + return AruidIndexMax; +} + +Result AppletResource::DestroySevenSixAxisTransferMemory() { + // TODO + return ResultSuccess; +} + +void AppletResource::EnableInput(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_pad_input.Assign(is_enabled); + data[index].flag.enable_touchscreen.Assign(is_enabled); +} + +void AppletResource::EnableSixAxisSensor(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_six_axis_sensor.Assign(is_enabled); +} + +void AppletResource::EnablePadInput(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_pad_input.Assign(is_enabled); +} + +void AppletResource::EnableTouchScreen(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_touchscreen.Assign(is_enabled); +} + +void AppletResource::SetIsPalmaConnectable(u64 aruid, bool is_connectable) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.is_palma_connectable.Assign(is_connectable); +} + +void AppletResource::EnablePalmaBoostMode(u64 aruid, bool is_enabled) { + const u64 index = GetIndexFromAruid(aruid); + if (index >= AruidIndexMax) { + return; + } + + data[index].flag.enable_palma_boost_mode.Assign(is_enabled); +} + +} // namespace Service::HID diff --git a/src/core/hle/service/hid/controllers/applet_resource.h b/src/core/hle/service/hid/controllers/applet_resource.h new file mode 100644 index 000000000..3dcec2898 --- /dev/null +++ b/src/core/hle/service/hid/controllers/applet_resource.h @@ -0,0 +1,87 @@ +// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include <array> + +#include "common/bit_field.h" +#include "common/common_types.h" +#include "core/hle/result.h" + +namespace Core { +class System; +} + +namespace Kernel { +class KSharedMemory; +} + +namespace Service::HID { +class AppletResource { +public: + explicit AppletResource(Core::System& system_); + ~AppletResource(); + + Result CreateAppletResource(u64 aruid); + + Result RegisterAppletResourceUserId(u64 aruid, bool enable_input); + void UnregisterAppletResourceUserId(u64 aruid); + + u64 GetActiveAruid(); + Result GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid); + + u64 GetIndexFromAruid(u64 aruid); + + Result DestroySevenSixAxisTransferMemory(); + + void EnableInput(u64 aruid, bool is_enabled); + void EnableSixAxisSensor(u64 aruid, bool is_enabled); + void EnablePadInput(u64 aruid, bool is_enabled); + void EnableTouchScreen(u64 aruid, bool is_enabled); + void SetIsPalmaConnectable(u64 aruid, bool is_connectable); + void EnablePalmaBoostMode(u64 aruid, bool is_enabled); + +private: + static constexpr std::size_t AruidIndexMax = 0x20; + + enum RegistrationStatus : u32 { + None, + Initialized, + PendingDelete, + }; + + struct DataStatusFlag { + union { + u32 raw{}; + + BitField<0, 1, u32> is_initialized; + BitField<1, 1, u32> is_assigned; + BitField<16, 1, u32> enable_pad_input; + BitField<17, 1, u32> enable_six_axis_sensor; + BitField<18, 1, u32> bit_18; + BitField<19, 1, u32> is_palma_connectable; + BitField<20, 1, u32> enable_palma_boost_mode; + BitField<21, 1, u32> enable_touchscreen; + }; + }; + + struct AruidRegisterList { + std::array<RegistrationStatus, AruidIndexMax> flag{}; + std::array<u64, AruidIndexMax> aruid{}; + }; + static_assert(sizeof(AruidRegisterList) == 0x180, "AruidRegisterList is an invalid size"); + + struct AruidData { + DataStatusFlag flag{}; + u64 aruid{}; + Kernel::KSharedMemory* shared_memory_handle{nullptr}; + }; + + u64 active_aruid{}; + AruidRegisterList registration_list{}; + std::array<AruidData, AruidIndexMax> data{}; + + Core::System& system; +}; +} // namespace Service::HID diff --git a/src/core/hle/service/hid/errors.h b/src/core/hle/service/hid/errors.h index 9585bdaf0..f00cb831f 100644 --- a/src/core/hle/service/hid/errors.h +++ b/src/core/hle/service/hid/errors.h @@ -19,6 +19,11 @@ constexpr Result NpadIsSameType{ErrorModule::HID, 602}; constexpr Result InvalidNpadId{ErrorModule::HID, 709}; constexpr Result NpadNotConnected{ErrorModule::HID, 710}; constexpr Result InvalidArraySize{ErrorModule::HID, 715}; + +constexpr Result ResultAruidNoAvailableEntries{ErrorModule::HID, 1044}; +constexpr Result ResultAruidAlreadyRegistered{ErrorModule::HID, 1046}; +constexpr Result ResultAruidNotRegistered{ErrorModule::HID, 1047}; + constexpr Result InvalidPalmaHandle{ErrorModule::HID, 3302}; } // namespace Service::HID diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 1b7381d8d..afbcb019f 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -1,6 +1,8 @@ // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/kernel.h" #include "core/hle/service/hid/hid.h" #include "core/hle/service/hid/hid_debug_server.h" #include "core/hle/service/hid/hid_firmware_settings.h" @@ -20,6 +22,12 @@ void LoopProcess(Core::System& system) { std::shared_ptr<HidFirmwareSettings> firmware_settings = std::make_shared<HidFirmwareSettings>(); + // TODO: Remove this hack until this service is emulated properly. + const auto process_list = system.Kernel().GetProcessList(); + if (!process_list.empty()) { + resouce_manager->RegisterAppletResourceUserId(process_list[0]->GetId(), true); + } + server_manager->RegisterNamedService( "hid", std::make_shared<IHidServer>(system, resouce_manager, firmware_settings)); server_manager->RegisterNamedService( diff --git a/src/core/hle/service/hid/hid_server.cpp b/src/core/hle/service/hid/hid_server.cpp index a7d1578d9..e0f4051aa 100644 --- a/src/core/hle/service/hid/hid_server.cpp +++ b/src/core/hle/service/hid/hid_server.cpp @@ -224,8 +224,13 @@ void IHidServer::CreateAppletResource(HLERequestContext& ctx) { LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id); + Result result = GetResourceManager()->CreateAppletResource(applet_resource_user_id); + if (result.IsSuccess()) { + result = GetResourceManager()->GetNpad()->Activate(applet_resource_user_id); + } + IPC::ResponseBuilder rb{ctx, 2, 0, 1}; - rb.Push(ResultSuccess); + rb.Push(result); rb.PushIpcInterface<IAppletResource>(system, resource_manager); } diff --git a/src/core/hle/service/hid/hid_system_server.cpp b/src/core/hle/service/hid/hid_system_server.cpp index b56d0347a..4d33456a3 100644 --- a/src/core/hle/service/hid/hid_system_server.cpp +++ b/src/core/hle/service/hid/hid_system_server.cpp @@ -3,6 +3,7 @@ #include "core/hid/hid_core.h" #include "core/hle/service/hid/controllers/npad.h" +#include "core/hle/service/hid/controllers/palma.h" #include "core/hle/service/hid/controllers/touchscreen.h" #include "core/hle/service/hid/errors.h" #include "core/hle/service/hid/hid_system_server.h" @@ -63,13 +64,13 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour {329, nullptr, "DetachAbstractedPadAll"}, {330, nullptr, "CheckAbstractedPadConnection"}, {500, nullptr, "SetAppletResourceUserId"}, - {501, nullptr, "RegisterAppletResourceUserId"}, - {502, nullptr, "UnregisterAppletResourceUserId"}, - {503, nullptr, "EnableAppletToGetInput"}, + {501, &IHidSystemServer::RegisterAppletResourceUserId, "RegisterAppletResourceUserId"}, + {502, &IHidSystemServer::UnregisterAppletResourceUserId, "UnregisterAppletResourceUserId"}, + {503, &IHidSystemServer::EnableAppletToGetInput, "EnableAppletToGetInput"}, {504, nullptr, "SetAruidValidForVibration"}, - {505, nullptr, "EnableAppletToGetSixAxisSensor"}, - {506, nullptr, "EnableAppletToGetPadInput"}, - {507, nullptr, "EnableAppletToGetTouchScreen"}, + {505, &IHidSystemServer::EnableAppletToGetSixAxisSensor, "EnableAppletToGetSixAxisSensor"}, + {506, &IHidSystemServer::EnableAppletToGetPadInput, "EnableAppletToGetPadInput"}, + {507, &IHidSystemServer::EnableAppletToGetTouchScreen, "EnableAppletToGetTouchScreen"}, {510, nullptr, "SetVibrationMasterVolume"}, {511, nullptr, "GetVibrationMasterVolume"}, {512, nullptr, "BeginPermitVibrationSession"}, @@ -420,6 +421,129 @@ void IHidSystemServer::GetIrSensorState(HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); } +void IHidSystemServer::RegisterAppletResourceUserId(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool enable_input; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, enable_input={}, applet_resource_user_id={}", + parameters.enable_input, parameters.applet_resource_user_id); + + Result result = GetResourceManager()->RegisterAppletResourceUserId( + parameters.applet_resource_user_id, parameters.enable_input); + + if (result.IsSuccess()) { + // result = GetResourceManager()->GetNpad()->RegisterAppletResourceUserId( + // parameters.applet_resource_user_id); + } + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::UnregisterAppletResourceUserId(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + u64 applet_resource_user_id{rp.Pop<u64>()}; + + LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id); + + GetResourceManager()->UnregisterAppletResourceUserId(applet_resource_user_id); + // GetResourceManager()->GetNpad()->UnregisterAppletResourceUserId(applet_resource_user_id); + // GetResourceManager()->GetPalma()->UnregisterAppletResourceUserId(applet_resource_user_id); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetInput(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnableInput(parameters.applet_resource_user_id, parameters.is_enabled); + // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetSixAxisSensor(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnableTouchScreen(parameters.applet_resource_user_id, + parameters.is_enabled); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetPadInput(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnablePadInput(parameters.applet_resource_user_id, parameters.is_enabled); + // GetResourceManager()->GetNpad()->EnableInput(parameters.applet_resource_user_id); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} + +void IHidSystemServer::EnableAppletToGetTouchScreen(HLERequestContext& ctx) { + IPC::RequestParser rp{ctx}; + struct Parameters { + bool is_enabled; + INSERT_PADDING_WORDS_NOINIT(1); + u64 applet_resource_user_id; + }; + static_assert(sizeof(Parameters) == 0x10, "Parameters has incorrect size."); + + const auto parameters{rp.PopRaw<Parameters>()}; + + LOG_INFO(Service_HID, "called, is_enabled={}, applet_resource_user_id={}", + parameters.is_enabled, parameters.applet_resource_user_id); + + GetResourceManager()->EnableTouchScreen(parameters.applet_resource_user_id, + parameters.is_enabled); + + IPC::ResponseBuilder rb{ctx, 2}; + rb.Push(ResultSuccess); +} void IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx) { LOG_INFO(Service_AM, "(STUBBED) called"); diff --git a/src/core/hle/service/hid/hid_system_server.h b/src/core/hle/service/hid/hid_system_server.h index 822d5e5b9..1e623dfc2 100644 --- a/src/core/hle/service/hid/hid_system_server.h +++ b/src/core/hle/service/hid/hid_system_server.h @@ -38,6 +38,12 @@ private: void HasLeftRightBattery(HLERequestContext& ctx); void GetUniquePadsFromNpad(HLERequestContext& ctx); void GetIrSensorState(HLERequestContext& ctx); + void RegisterAppletResourceUserId(HLERequestContext& ctx); + void UnregisterAppletResourceUserId(HLERequestContext& ctx); + void EnableAppletToGetInput(HLERequestContext& ctx); + void EnableAppletToGetSixAxisSensor(HLERequestContext& ctx); + void EnableAppletToGetPadInput(HLERequestContext& ctx); + void EnableAppletToGetTouchScreen(HLERequestContext& ctx); void AcquireConnectionTriggerTimeoutEvent(HLERequestContext& ctx); void AcquireDeviceRegisteredEventForControllerSupport(HLERequestContext& ctx); void GetRegisteredDevices(HLERequestContext& ctx); diff --git a/src/core/hle/service/hid/resource_manager.cpp b/src/core/hle/service/hid/resource_manager.cpp index e76d4eea9..60d4ef71f 100644 --- a/src/core/hle/service/hid/resource_manager.cpp +++ b/src/core/hle/service/hid/resource_manager.cpp @@ -9,6 +9,7 @@ #include "core/hle/service/hid/resource_manager.h" #include "core/hle/service/ipc_helpers.h" +#include "core/hle/service/hid/controllers/applet_resource.h" #include "core/hle/service/hid/controllers/console_six_axis.h" #include "core/hle/service/hid/controllers/debug_pad.h" #include "core/hle/service/hid/controllers/gesture.h" @@ -33,7 +34,9 @@ constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 10 constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz) ResourceManager::ResourceManager(Core::System& system_) - : system{system_}, service_context{system_, "hid"} {} + : system{system_}, service_context{system_, "hid"} { + applet_resource = std::make_shared<AppletResource>(system); +} ResourceManager::~ResourceManager() = default; @@ -77,6 +80,11 @@ void ResourceManager::Initialize() { system.HIDCore().ReloadInputDevices(); is_initialized = true; } + +std::shared_ptr<AppletResource> ResourceManager::GetAppletResource() const { + return applet_resource; +} + std::shared_ptr<CaptureButton> ResourceManager::GetCaptureButton() const { return capture_button; } @@ -137,6 +145,46 @@ std::shared_ptr<UniquePad> ResourceManager::GetUniquePad() const { return unique_pad; } +Result ResourceManager::CreateAppletResource(u64 aruid) { + std::scoped_lock lock{shared_mutex}; + return applet_resource->CreateAppletResource(aruid); +} + +Result ResourceManager::RegisterAppletResourceUserId(u64 aruid, bool bool_value) { + std::scoped_lock lock{shared_mutex}; + return applet_resource->RegisterAppletResourceUserId(aruid, bool_value); +} + +void ResourceManager::UnregisterAppletResourceUserId(u64 aruid) { + std::scoped_lock lock{shared_mutex}; + applet_resource->UnregisterAppletResourceUserId(aruid); +} + +Result ResourceManager::GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid) { + std::scoped_lock lock{shared_mutex}; + return applet_resource->GetSharedMemoryHandle(out_handle, aruid); +} + +void ResourceManager::EnableInput(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnableInput(aruid, is_enabled); +} + +void ResourceManager::EnableSixAxisSensor(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnableSixAxisSensor(aruid, is_enabled); +} + +void ResourceManager::EnablePadInput(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnablePadInput(aruid, is_enabled); +} + +void ResourceManager::EnableTouchScreen(u64 aruid, bool is_enabled) { + std::scoped_lock lock{shared_mutex}; + applet_resource->EnableTouchScreen(aruid, is_enabled); +} + void ResourceManager::UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) { auto& core_timing = system.CoreTiming(); @@ -172,14 +220,12 @@ void ResourceManager::UpdateMotion(std::uintptr_t user_data, std::chrono::nanose } IAppletResource::IAppletResource(Core::System& system_, std::shared_ptr<ResourceManager> resource) - : ServiceFramework{system_, "IAppletResource"} { + : ServiceFramework{system_, "IAppletResource"}, resource_manager{resource} { static const FunctionInfo functions[] = { {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"}, }; RegisterHandlers(functions); - resource->Initialize(); - // Register update callbacks npad_update_event = Core::Timing::CreateEvent( "HID::UpdatePadCallback", @@ -233,9 +279,13 @@ IAppletResource::~IAppletResource() { void IAppletResource::GetSharedMemoryHandle(HLERequestContext& ctx) { LOG_DEBUG(Service_HID, "called"); + Kernel::KSharedMemory* handle; + const u64 applet_resource_user_id = resource_manager->GetAppletResource()->GetActiveAruid(); + const auto result = resource_manager->GetSharedMemoryHandle(&handle, applet_resource_user_id); + IPC::ResponseBuilder rb{ctx, 2, 1}; - rb.Push(ResultSuccess); - rb.PushCopyObjects(&system.Kernel().GetHidSharedMem()); + rb.Push(result); + rb.PushCopyObjects(handle); } } // namespace Service::HID diff --git a/src/core/hle/service/hid/resource_manager.h b/src/core/hle/service/hid/resource_manager.h index 2b6a9b5e6..a78e2b729 100644 --- a/src/core/hle/service/hid/resource_manager.h +++ b/src/core/hle/service/hid/resource_manager.h @@ -6,11 +6,20 @@ #include "core/hle/service/kernel_helpers.h" #include "core/hle/service/service.h" +namespace Core { +class System; +} + namespace Core::Timing { struct EventType; } +namespace Kernel { +class KSharedMemory; +} + namespace Service::HID { +class AppletResource; class Controller_Stubbed; class ConsoleSixAxis; class DebugPad; @@ -38,6 +47,7 @@ public: void Initialize(); + std::shared_ptr<AppletResource> GetAppletResource() const; std::shared_ptr<CaptureButton> GetCaptureButton() const; std::shared_ptr<ConsoleSixAxis> GetConsoleSixAxis() const; std::shared_ptr<DebugMouse> GetDebugMouse() const; @@ -54,6 +64,18 @@ public: std::shared_ptr<TouchScreen> GetTouchScreen() const; std::shared_ptr<UniquePad> GetUniquePad() const; + Result CreateAppletResource(u64 aruid); + + Result RegisterAppletResourceUserId(u64 aruid, bool bool_value); + void UnregisterAppletResourceUserId(u64 aruid); + + Result GetSharedMemoryHandle(Kernel::KSharedMemory** out_handle, u64 aruid); + + void EnableInput(u64 aruid, bool is_enabled); + void EnableSixAxisSensor(u64 aruid, bool is_enabled); + void EnablePadInput(u64 aruid, bool is_enabled); + void EnableTouchScreen(u64 aruid, bool is_enabled); + void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late); @@ -62,6 +84,9 @@ public: private: bool is_initialized{false}; + mutable std::mutex shared_mutex; + std::shared_ptr<AppletResource> applet_resource = nullptr; + std::shared_ptr<CaptureButton> capture_button = nullptr; std::shared_ptr<ConsoleSixAxis> console_six_axis = nullptr; std::shared_ptr<DebugMouse> debug_mouse = nullptr; @@ -106,6 +131,8 @@ private: std::shared_ptr<Core::Timing::EventType> default_update_event; std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event; std::shared_ptr<Core::Timing::EventType> motion_update_event; + + std::shared_ptr<ResourceManager> resource_manager; }; } // namespace Service::HID diff --git a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp index d7db24f42..75bf31e32 100644 --- a/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp +++ b/src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp @@ -171,6 +171,7 @@ void MakeGraphicBuffer(android::BufferQueueProducer& producer, u32 slot, u32 han buffer->height = SharedBufferHeight; buffer->stride = SharedBufferBlockLinearStride; buffer->format = SharedBufferBlockLinearFormat; + buffer->external_format = SharedBufferBlockLinearFormat; buffer->buffer_id = handle; buffer->offset = slot * SharedBufferSlotSize; ASSERT(producer.SetPreallocatedBuffer(slot, buffer) == android::Status::NoError); diff --git a/src/video_core/host1x/ffmpeg/ffmpeg.cpp b/src/video_core/host1x/ffmpeg/ffmpeg.cpp index dcd07e6d2..96686da59 100644 --- a/src/video_core/host1x/ffmpeg/ffmpeg.cpp +++ b/src/video_core/host1x/ffmpeg/ffmpeg.cpp @@ -233,7 +233,12 @@ std::unique_ptr<Frame> DecoderContext::ReceiveFrame(bool* out_is_interlaced) { return false; } - *out_is_interlaced = frame->interlaced_frame != 0; + *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 return true; }; diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp index 9995b6dd4..279e5a4e0 100644 --- a/src/video_core/renderer_opengl/gl_rasterizer.cpp +++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp @@ -714,7 +714,8 @@ 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(framebuffer_addr)}; + ImageView* const image_view{ + texture_cache.TryFindFramebufferImageView(config, framebuffer_addr)}; if (!image_view) { return false; } @@ -725,7 +726,6 @@ 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; } diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp index 6bfed08a1..7a4f0c5c1 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.cpp +++ b/src/video_core/renderer_opengl/renderer_opengl.cpp @@ -653,11 +653,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) { }; glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices), std::data(vertices)); - if (screen_info.display_srgb) { - glEnable(GL_FRAMEBUFFER_SRGB); - } else { - glDisable(GL_FRAMEBUFFER_SRGB); - } + glDisable(GL_FRAMEBUFFER_SRGB); glViewportIndexedf(0, 0.0f, 0.0f, static_cast<GLfloat>(layout.width), static_cast<GLfloat>(layout.height)); @@ -710,8 +706,7 @@ void RendererOpenGL::RenderScreenshot() { GLuint renderbuffer; glGenRenderbuffers(1, &renderbuffer); glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer); - glRenderbufferStorage(GL_RENDERBUFFER, screen_info.display_srgb ? GL_SRGB8 : GL_RGB8, - layout.width, layout.height); + glRenderbufferStorage(GL_RENDERBUFFER, GL_SRGB8, layout.width, layout.height); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer); DrawScreen(layout); diff --git a/src/video_core/renderer_opengl/renderer_opengl.h b/src/video_core/renderer_opengl/renderer_opengl.h index f1d5fd954..b70607635 100644 --- a/src/video_core/renderer_opengl/renderer_opengl.h +++ b/src/video_core/renderer_opengl/renderer_opengl.h @@ -53,7 +53,6 @@ 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; }; diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp index c4c30d807..100b70918 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp +++ b/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, false), + render_window.GetFramebufferLayout().height), present_manager(instance, render_window, device, memory_allocator, scheduler, swapchain, surface), blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, present_manager, @@ -131,11 +131,10 @@ 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, is_srgb); + blit_screen.DrawToSwapchain(frame, *framebuffer, use_accelerated); scheduler.Flush(*frame->render_ready); present_manager.Present(frame); @@ -205,7 +204,7 @@ void Vulkan::RendererVulkan::RenderScreenshot(const Tegra::FramebufferConfig& fr .flags = 0, .image = *staging_image, .viewType = VK_IMAGE_VIEW_TYPE_2D, - .format = screen_info.is_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM, + .format = VK_FORMAT_B8G8R8A8_UNORM, .components{ .r = VK_COMPONENT_SWIZZLE_IDENTITY, .g = VK_COMPONENT_SWIZZLE_IDENTITY, diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp index 5e461fbd0..60432f5ad 100644 --- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp +++ b/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_}, - current_srgb{swapchain.IsSrgb()}, image_view_format{swapchain.GetImageViewFormat()} { + scheduler{scheduler_}, image_count{swapchain.GetImageCount()}, screen_info{screen_info_} { resource_ticks.resize(image_count); + swapchain_view_format = swapchain.GetImageViewFormat(); CreateStaticResources(); CreateDynamicResources(); @@ -480,28 +480,22 @@ void BlitScreen::Draw(const Tegra::FramebufferConfig& framebuffer, } void BlitScreen::DrawToSwapchain(Frame* frame, const Tegra::FramebufferConfig& framebuffer, - bool use_accelerated, bool is_srgb) { - // Recreate dynamic resources if the the image count or colorspace changed + 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)); if (const std::size_t swapchain_images = swapchain.GetImageCount(); - 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 + swapchain_images != image_count || current_framebuffer_format != framebuffer_view_format) { 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 || - is_srgb != frame->is_srgb) { + if (layout.width != frame->width || layout.height != frame->height) { Recreate(); - present_manager.RecreateFrame(frame, layout.width, layout.height, is_srgb, - image_view_format, *renderpass); + present_manager.RecreateFrame(frame, layout.width, layout.height, swapchain_view_format, + *renderpass); } const VkExtent2D render_area{frame->width, frame->height}; @@ -629,7 +623,7 @@ void BlitScreen::CreateDescriptorPool() { } void BlitScreen::CreateRenderPass() { - renderpass = CreateRenderPassImpl(image_view_format); + renderpass = CreateRenderPassImpl(swapchain_view_format); } vk::RenderPass BlitScreen::CreateRenderPassImpl(VkFormat format) { @@ -1149,7 +1143,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 : GetFormat(framebuffer), + .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : framebuffer_view_format, .extent = { .width = (up_scale * framebuffer.width) >> down_shift, @@ -1174,7 +1168,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 : GetFormat(framebuffer), + .format = used_on_framebuffer ? VK_FORMAT_R16G16B16A16_SFLOAT : framebuffer_view_format, .components = { .r = VK_COMPONENT_SWIZZLE_IDENTITY, diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.h b/src/video_core/renderer_vulkan/vk_blit_screen.h index 8365b5668..16b882b6d 100644 --- a/src/video_core/renderer_vulkan/vk_blit_screen.h +++ b/src/video_core/renderer_vulkan/vk_blit_screen.h @@ -52,7 +52,6 @@ struct ScreenInfo { VkImageView image_view{}; u32 width{}; u32 height{}; - bool is_srgb{}; }; class BlitScreen { @@ -69,7 +68,7 @@ public: const Layout::FramebufferLayout layout, VkExtent2D render_area, bool use_accelerated); void DrawToSwapchain(Frame* frame, const Tegra::FramebufferConfig& framebuffer, - bool use_accelerated, bool is_srgb); + bool use_accelerated); [[nodiscard]] vk::Framebuffer CreateFramebuffer(const VkImageView& image_view, VkExtent2D extent); @@ -161,8 +160,8 @@ private: u32 raw_width = 0; u32 raw_height = 0; Service::android::PixelFormat pixel_format{}; - bool current_srgb; - VkFormat image_view_format; + VkFormat framebuffer_view_format; + VkFormat swapchain_view_format; std::unique_ptr<FSR> fsr; std::unique_ptr<SMAA> smaa; diff --git a/src/video_core/renderer_vulkan/vk_present_manager.cpp b/src/video_core/renderer_vulkan/vk_present_manager.cpp index 2ef36583b..8e4c74b5c 100644 --- a/src/video_core/renderer_vulkan/vk_present_manager.cpp +++ b/src/video_core/renderer_vulkan/vk_present_manager.cpp @@ -172,13 +172,12 @@ void PresentManager::Present(Frame* frame) { }); } -void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, bool is_srgb, - VkFormat image_view_format, VkRenderPass rd) { +void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, 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, @@ -289,7 +288,7 @@ void PresentManager::PresentThread(std::stop_token token) { } void PresentManager::RecreateSwapchain(Frame* frame) { - swapchain.Create(*surface, frame->width, frame->height, frame->is_srgb); + swapchain.Create(*surface, frame->width, frame->height); image_count = swapchain.GetImageCount(); } @@ -319,12 +318,12 @@ void PresentManager::CopyToSwapchain(Frame* frame) { void PresentManager::CopyToSwapchainImpl(Frame* frame) { MICROPROFILE_SCOPE(Vulkan_CopyToSwapchain); - // If the size or colorspace of the incoming frames has changed, recreate the swapchain + // If the size of the incoming frames has changed, recreate the swapchain // to account for that. - const bool srgb_changed = swapchain.NeedsRecreation(frame->is_srgb); + const bool is_suboptimal = swapchain.NeedsRecreation(); const bool size_changed = swapchain.GetWidth() != frame->width || swapchain.GetHeight() != frame->height; - if (srgb_changed || size_changed) { + if (is_suboptimal || size_changed) { RecreateSwapchain(frame); } diff --git a/src/video_core/renderer_vulkan/vk_present_manager.h b/src/video_core/renderer_vulkan/vk_present_manager.h index a3d825fe6..337171a09 100644 --- a/src/video_core/renderer_vulkan/vk_present_manager.h +++ b/src/video_core/renderer_vulkan/vk_present_manager.h @@ -25,7 +25,6 @@ class Swapchain; struct Frame { u32 width; u32 height; - bool is_srgb; vk::Image image; vk::ImageView image_view; vk::Framebuffer framebuffer; @@ -48,8 +47,8 @@ public: void Present(Frame* frame); /// Recreates the present frame to match the provided parameters - void RecreateFrame(Frame* frame, u32 width, u32 height, bool is_srgb, - VkFormat image_view_format, VkRenderPass rd); + void RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format, + VkRenderPass rd); /// Waits for the present thread to finish presenting all queued frames. void WaitPresent(); diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp index b6f52e017..59829c88b 100644 --- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp +++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp @@ -783,7 +783,8 @@ bool RasterizerVulkan::AccelerateDisplay(const Tegra::FramebufferConfig& config, return false; } std::scoped_lock lock{texture_cache.mutex}; - ImageView* const image_view = texture_cache.TryFindFramebufferImageView(framebuffer_addr); + ImageView* const image_view = + texture_cache.TryFindFramebufferImageView(config, framebuffer_addr); if (!image_view) { return false; } @@ -792,7 +793,6 @@ 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; } diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp index 821f44f1a..86a30dcd1 100644 --- a/src/video_core/renderer_vulkan/vk_swapchain.cpp +++ b/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_, bool srgb) + u32 width_, u32 height_) : surface{surface_}, device{device_}, scheduler{scheduler_} { - Create(surface_, width_, height_, srgb); + Create(surface_, width_, height_); } Swapchain::~Swapchain() = default; -void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_, bool srgb) { +void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_) { is_outdated = false; is_suboptimal = false; width = width_; @@ -127,7 +127,7 @@ void Swapchain::Create(VkSurfaceKHR surface_, u32 width_, u32 height_, bool srgb Destroy(); - CreateSwapchain(capabilities, srgb); + CreateSwapchain(capabilities); CreateSemaphores(); resource_ticks.clear(); @@ -196,7 +196,7 @@ void Swapchain::Present(VkSemaphore render_semaphore) { } } -void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bool srgb) { +void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities) { const auto physical_device{device.GetPhysical()}; const auto formats{physical_device.GetSurfaceFormatsKHR(surface)}; const auto present_modes = physical_device.GetSurfacePresentModesKHR(surface); @@ -274,15 +274,14 @@ void Swapchain::CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bo 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 = srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM; + image_view_format = VK_FORMAT_R8G8B8A8_UNORM; #else - image_view_format = srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM; + image_view_format = VK_FORMAT_B8G8R8A8_UNORM; #endif } diff --git a/src/video_core/renderer_vulkan/vk_swapchain.h b/src/video_core/renderer_vulkan/vk_swapchain.h index b8a1465a6..d264f06e4 100644 --- a/src/video_core/renderer_vulkan/vk_swapchain.h +++ b/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, bool srgb); + u32 height); ~Swapchain(); /// Creates (or recreates) the swapchain with a given size. - void Create(VkSurfaceKHR surface, u32 width, u32 height, bool srgb); + void Create(VkSurfaceKHR surface, u32 width, u32 height); /// Acquires the next image in the swapchain, waits as needed. bool AcquireNextImage(); @@ -33,13 +33,8 @@ public: void Present(VkSemaphore render_semaphore); /// Returns true when the swapchain needs to be recreated. - 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; + bool NeedsRecreation() const { + return IsSubOptimal() || NeedsPresentModeUpdate(); } /// Returns true when the swapchain is outdated. @@ -52,11 +47,6 @@ 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; } @@ -110,7 +100,7 @@ public: } private: - void CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities, bool srgb); + void CreateSwapchain(const VkSurfaceCapabilitiesKHR& capabilities); void CreateSemaphores(); void CreateImageViews(); @@ -144,7 +134,6 @@ private: bool has_mailbox{false}; bool has_fifo_relaxed{false}; - bool current_srgb{}; bool is_outdated{}; bool is_suboptimal{}; }; diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h index dade38b18..0d5a1709f 100644 --- a/src/video_core/texture_cache/texture_cache.h +++ b/src/video_core/texture_cache/texture_cache.h @@ -712,14 +712,15 @@ bool TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst, } template <class P> -typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_addr) { +typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView( + const Tegra::FramebufferConfig& config, 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<const ImageBase*, 4> valid_images; + boost::container::small_vector<ImageId, 4> valid_image_ids; for (const ImageMapId map_id : image_map_ids) { const ImageMapView& map = slot_map_views[map_id]; const ImageBase& image = slot_images[map.image_id]; @@ -729,18 +730,34 @@ typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_ad if (image.image_view_ids.empty()) { continue; } - valid_images.push_back(&image); + valid_image_ids.push_back(map.image_id); } - if (valid_images.size() == 1) [[likely]] { - return &slot_image_views[valid_images[0]->image_view_ids.at(0)]; + 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() > 0) [[unlikely]] { - std::ranges::sort(valid_images, [](const auto* a, const auto* b) { - return a->modification_tick > b->modification_tick; + 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; }); - return &slot_image_views[valid_images[0]->image_view_ids.at(0)]; + return GetImageViewForFramebuffer(*most_recent); } return nullptr; diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h index a40825c9f..cbe56e166 100644 --- a/src/video_core/texture_cache/texture_cache_base.h +++ b/src/video_core/texture_cache/texture_cache_base.h @@ -209,7 +209,8 @@ public: const Tegra::Engines::Fermi2D::Config& copy); /// Try to find a cached image view in the given CPU address - [[nodiscard]] ImageView* TryFindFramebufferImageView(VAddr cpu_addr); + [[nodiscard]] ImageView* TryFindFramebufferImageView(const Tegra::FramebufferConfig& config, + VAddr cpu_addr); /// Return true when there are uncommitted images to be downloaded [[nodiscard]] bool HasUncommittedFlushes() const noexcept; |