summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--dist/72-yuzu-input.rules19
-rw-r--r--src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/AddGameFolderDialogFragment.kt3
-rw-r--r--src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt28
-rw-r--r--src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt2
-rw-r--r--src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt8
-rw-r--r--src/common/settings.cpp8
-rw-r--r--src/common/settings.h14
-rw-r--r--src/core/CMakeLists.txt8
-rw-r--r--src/core/arm/debug.cpp5
-rw-r--r--src/core/file_sys/fsmitm_romfsbuild.cpp134
-rw-r--r--src/core/file_sys/fsmitm_romfsbuild.h6
-rw-r--r--src/core/file_sys/romfs.cpp83
-rw-r--r--src/core/file_sys/vfs_concat.cpp4
-rw-r--r--src/core/file_sys/vfs_concat.h2
-rw-r--r--src/core/file_sys/vfs_layered.cpp21
-rw-r--r--src/core/hle/kernel/k_client_port.cpp69
-rw-r--r--src/core/hle/kernel/k_client_port.h2
-rw-r--r--src/core/hle/kernel/k_light_client_session.cpp31
-rw-r--r--src/core/hle/kernel/k_light_client_session.h39
-rw-r--r--src/core/hle/kernel/k_light_server_session.cpp247
-rw-r--r--src/core/hle/kernel/k_light_server_session.h49
-rw-r--r--src/core/hle/kernel/k_light_session.cpp81
-rw-r--r--src/core/hle/kernel/k_light_session.h86
-rw-r--r--src/core/hle/kernel/k_port.cpp9
-rw-r--r--src/core/hle/kernel/k_port.h2
-rw-r--r--src/core/hle/kernel/k_server_port.cpp56
-rw-r--r--src/core/hle/kernel/k_server_port.h5
-rw-r--r--src/core/hle/kernel/k_thread.h7
-rw-r--r--src/core/hle/kernel/kernel.cpp4
-rw-r--r--src/core/hle/kernel/svc/svc_light_ipc.cpp29
-rw-r--r--src/core/hle/kernel/svc/svc_port.cpp71
-rw-r--r--src/core/hle/kernel/svc/svc_session.cpp40
-rw-r--r--src/core/hle/service/hid/controllers/applet_resource.cpp199
-rw-r--r--src/core/hle/service/hid/controllers/applet_resource.h87
-rw-r--r--src/core/hle/service/hid/errors.h5
-rw-r--r--src/core/hle/service/hid/hid.cpp8
-rw-r--r--src/core/hle/service/hid/hid_server.cpp7
-rw-r--r--src/core/hle/service/hid/hid_system_server.cpp136
-rw-r--r--src/core/hle/service/hid/hid_system_server.h6
-rw-r--r--src/core/hle/service/hid/resource_manager.cpp62
-rw-r--r--src/core/hle/service/hid/resource_manager.h27
-rw-r--r--src/core/hle/service/nvnflinger/fb_share_buffer_manager.cpp1
-rw-r--r--src/video_core/host1x/ffmpeg/ffmpeg.cpp7
-rw-r--r--src/video_core/renderer_opengl/gl_rasterizer.cpp4
-rw-r--r--src/video_core/renderer_opengl/renderer_opengl.cpp9
-rw-r--r--src/video_core/renderer_opengl/renderer_opengl.h1
-rw-r--r--src/video_core/renderer_vulkan/renderer_vulkan.cpp7
-rw-r--r--src/video_core/renderer_vulkan/vk_blit_screen.cpp32
-rw-r--r--src/video_core/renderer_vulkan/vk_blit_screen.h7
-rw-r--r--src/video_core/renderer_vulkan/vk_present_manager.cpp13
-rw-r--r--src/video_core/renderer_vulkan/vk_present_manager.h5
-rw-r--r--src/video_core/renderer_vulkan/vk_rasterizer.cpp4
-rw-r--r--src/video_core/renderer_vulkan/vk_swapchain.cpp15
-rw-r--r--src/video_core/renderer_vulkan/vk_swapchain.h21
-rw-r--r--src/video_core/texture_cache/texture_cache.h35
-rw-r--r--src/video_core/texture_cache/texture_cache_base.h3
56 files changed, 1628 insertions, 245 deletions
diff --git a/dist/72-yuzu-input.rules b/dist/72-yuzu-input.rules
new file mode 100644
index 000000000..d64f8b28d
--- /dev/null
+++ b/dist/72-yuzu-input.rules
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# Allow systemd-logind to manage user access to hidraw with this file
+# On most systems, this file should be installed to /etc/udev/rules.d/72-yuzu-input.rules
+# Consult your distro if this is not the case
+
+# Switch Pro Controller (USB/Bluetooth)
+KERNEL=="hidraw*", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="2009", MODE="0660", TAG+="uaccess"
+KERNEL=="hidraw*", KERNELS=="*057e:2009*", MODE="0660", TAG+="uaccess"
+
+# Joy-Con L (Bluetooth)
+KERNEL=="hidraw*", KERNELS=="*057e:2006*", MODE="0660", TAG+="uaccess"
+
+# Joy-Con R (Bluetooth)
+KERNEL=="hidraw*", KERNELS=="*057e:2007*", MODE="0660", TAG+="uaccess"
+
+# Joy-Con Charging Grip (USB)
+KERNEL=="hidraw*", ATTRS{idVendor}=="057e", ATTRS{idProduct}=="200e", MODE="0660", TAG+="uaccess"
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;