weakboson/eden
1
0
Fork 0
forked from eden-emu/eden
Code Pull requests Activity

Ran clang-format. Fixed Qt6 deprecations.

Browse source
This commit is contained in:
weakboson 2025-07-23 18:07:16 +08:00
parent a538126eb7
commit 8cd0d78269
219 changed files with 2635 additions and 2845 deletions
Download patch file Download diff file Expand all files Collapse all files

8
externals/dynarmic/src/dynarmic/ir/basic_block.cpp vendored
View file

@ -7,7 +7,6 @@
#include <algorithm>
#include <initializer_list>
#include <map>
#include <string>
#include <fmt/format.h>
@ -22,12 +21,7 @@
namespace Dynarmic::IR {
Block::Block(const LocationDescriptor& location)
: location{location},
end_location{location},
cond{Cond::AL},
instruction_alloc_pool{std::make_unique<std::remove_reference_t<decltype(*instruction_alloc_pool)>>()}
{
: location{location}, end_location{location}, cond{Cond::AL}, instruction_alloc_pool{std::make_unique<InstPool>()} {
}
/// Prepends a new instruction to this basic block before the insertion point,

4
externals/dynarmic/src/dynarmic/ir/basic_block.h vendored
View file

@ -17,7 +17,6 @@
#include "dynarmic/ir/microinstruction.h"
#include "dynarmic/ir/terminal.h"
#include "dynarmic/ir/value.h"
#include "dynarmic/ir/dense_list.h"
#include "dynarmic/common/memory_pool.h"
namespace Dynarmic::IR {
@ -171,8 +170,9 @@ private:
LocationDescriptor end_location;
/// Conditional to pass in order to execute this block
Cond cond;
using InstPool = Common::Pool<sizeof(Inst), 0x200000UL / sizeof(Inst)>;
/// Memory pool for instruction list
std::unique_ptr<Common::Pool<sizeof(Inst), 2097152UL / sizeof(Inst)>> instruction_alloc_pool;
std::unique_ptr<InstPool> instruction_alloc_pool;
/// Terminal instruction of this block.
Terminal terminal = Term::Invalid{};
/// Number of cycles this block takes to execute if the conditional fails.

12
externals/dynarmic/src/dynarmic/ir/microinstruction.h vendored
View file

@ -23,7 +23,7 @@ constexpr size_t max_arg_count = 4;
/// A representation of a microinstruction. A single ARM/Thumb instruction may be
/// converted into zero or more microinstructions.
//class Inst final {
class Inst final : public mcl::intrusive_list_node<Inst> {
class alignas(64) Inst final : public mcl::intrusive_list_node<Inst> {
public:
explicit Inst(Opcode op) : op(op) {}
@ -74,12 +74,12 @@ private:
void UndoUse(const Value& value);
// TODO: so much padding wasted with mcl::intrusive_node
// 16 + 1, 24
Opcode op; //2 (6)
// 17
Opcode op; // 20(4)
// Linked list of pseudooperations associated with this instruction.
Inst* next_pseudoop = nullptr; //8 (14)
unsigned use_count = 0; //4 (0)
unsigned name = 0; //4 (4)
Inst* next_pseudoop = nullptr; // 24(8)
unsigned use_count = 0; // 32(4)
unsigned name = 0; // 36(4)
alignas(64) std::array<Value, max_arg_count> args; //16 * 4 = 64 (1 cache line)
};
static_assert(sizeof(Inst) == 128);

357
src/android/app/src/main/jni/android_settings.h
View file

@ -8,172 +8,233 @@
#include <common/settings_common.h>
#include "common/common_types.h"
#include "common/settings_setting.h"
#include "common/settings_enums.h"
#include "common/settings_setting.h"
namespace AndroidSettings {
struct GameDir {
std::string path;
bool deep_scan = false;
};
struct GameDir {
std::string path;
bool deep_scan = false;
};
struct OverlayControlData {
std::string id;
bool enabled;
std::pair<double, double> landscape_position;
std::pair<double, double> portrait_position;
std::pair<double, double> foldable_position;
};
struct OverlayControlData {
std::string id;
bool enabled;
std::pair<double, double> landscape_position;
std::pair<double, double> portrait_position;
std::pair<double, double> foldable_position;
};
struct Values {
Settings::Linkage linkage;
struct Values {
Settings::Linkage linkage;
// Path settings
std::vector<GameDir> game_dirs;
// Path settings
std::vector<GameDir> game_dirs;
// Android
Settings::Setting<bool> picture_in_picture{linkage, false, "picture_in_picture",
Settings::Category::Android};
Settings::Setting<s32> screen_layout{linkage,
5,
"screen_layout",
Settings::Category::Android,
Settings::Specialization::Default,
true,
true};
Settings::Setting<s32> vertical_alignment{linkage,
0,
"vertical_alignment",
Settings::Category::Android,
// Android
Settings::Setting<bool> picture_in_picture{linkage, false, "picture_in_picture",
Settings::Category::Android};
Settings::Setting<s32> screen_layout{linkage,
5,
"screen_layout",
Settings::Category::Android,
Settings::Specialization::Default,
true,
true};
Settings::Setting<s32> vertical_alignment{linkage,
0,
"vertical_alignment",
Settings::Category::Android,
Settings::Specialization::Default,
true,
true};
Settings::SwitchableSetting<std::string, false> driver_path{linkage, "", "driver_path",
Settings::Category::GpuDriver};
// LRU Cache
Settings::SwitchableSetting<bool> use_lru_cache{linkage, true, "use_lru_cache",
Settings::Category::System};
Settings::Setting<s32> theme{linkage, 0, "theme", Settings::Category::Android};
Settings::Setting<s32> theme_mode{linkage, -1, "theme_mode", Settings::Category::Android};
Settings::Setting<bool> black_backgrounds{linkage, false, "black_backgrounds",
Settings::Category::Android};
// Input/performance overlay settings
std::vector<OverlayControlData> overlay_control_data;
Settings::Setting<s32> overlay_scale{linkage, 50, "control_scale", Settings::Category::Overlay};
Settings::Setting<s32> overlay_opacity{linkage, 100, "control_opacity",
Settings::Category::Overlay};
Settings::Setting<bool> joystick_rel_center{linkage, true, "joystick_rel_center",
Settings::Category::Overlay};
Settings::Setting<bool> dpad_slide{linkage, true, "dpad_slide", Settings::Category::Overlay};
Settings::Setting<bool> haptic_feedback{linkage, true, "haptic_feedback",
Settings::Category::Overlay};
Settings::Setting<bool> show_performance_overlay{linkage,
true,
"show_performance_overlay",
Settings::Category::Overlay,
Settings::Specialization::Paired,
true,
true};
Settings::Setting<bool> perf_overlay_background{linkage,
false,
"perf_overlay_background",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<s32> perf_overlay_position{linkage,
0,
"perf_overlay_position",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_fps{linkage,
true,
"show_fps",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_frame_time{linkage,
false,
"show_frame_time",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_app_ram_usage{linkage,
false,
"show_app_ram_usage",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_system_ram_usage{linkage,
false,
"show_system_ram_usage",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true};
Settings::SwitchableSetting<std::string, false> driver_path{linkage, "", "driver_path",
Settings::Category::GpuDriver};
// LRU Cache
Settings::SwitchableSetting<bool> use_lru_cache{linkage, true, "use_lru_cache",
Settings::Category::System};
Settings::Setting<s32> theme{linkage, 0, "theme", Settings::Category::Android};
Settings::Setting<s32> theme_mode{linkage, -1, "theme_mode", Settings::Category::Android};
Settings::Setting<bool> black_backgrounds{linkage, false, "black_backgrounds",
Settings::Category::Android};
// Input/performance overlay settings
std::vector<OverlayControlData> overlay_control_data;
Settings::Setting<s32> overlay_scale{linkage, 50, "control_scale",
Settings::Category::Overlay};
Settings::Setting<s32> overlay_opacity{linkage, 100, "control_opacity",
Settings::Category::Overlay};
Settings::Setting<bool> joystick_rel_center{linkage, true, "joystick_rel_center",
Settings::Category::Overlay};
Settings::Setting<bool> dpad_slide{linkage, true, "dpad_slide",
Settings::Category::Overlay};
Settings::Setting<bool> haptic_feedback{linkage, true, "haptic_feedback",
Settings::Category::Overlay};
Settings::Setting<bool> show_performance_overlay{linkage, true, "show_performance_overlay",
Settings::Category::Overlay,
Settings::Specialization::Paired, true,
true};
Settings::Setting<bool> perf_overlay_background{linkage, false, "perf_overlay_background",
Settings::Category::Overlay,
Settings::Specialization::Default, true,
true,
&show_performance_overlay};
Settings::Setting<s32> perf_overlay_position{linkage, 0, "perf_overlay_position",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_fps{linkage, true, "show_fps",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_frame_time{linkage, false, "show_frame_time",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_app_ram_usage{linkage, false, "show_app_ram_usage",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_system_ram_usage{linkage, false, "show_system_ram_usage",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_bat_temperature{linkage, false, "show_bat_temperature",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<Settings::TemperatureUnits> bat_temperature_unit{linkage,
Settings::TemperatureUnits::Celsius,
"bat_temperature_unit",
Settings::Category::Overlay,
Settings::Specialization::Default,
true, true,
&show_bat_temperature};
Settings::Setting<bool> show_power_info{linkage, false, "show_power_info",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_shaders_building{linkage, true, "show_shaders_building",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_input_overlay{linkage, true, "show_input_overlay",
Settings::Category::Overlay};
Settings::Setting<bool> touchscreen{linkage, true, "touchscreen",
Settings::Category::Overlay};
Settings::Setting<s32> lock_drawer{linkage, false, "lock_drawer",
Settings::Category::Overlay};
/// DEVICE/SOC OVERLAY
Settings::Setting<bool> show_soc_overlay{linkage, true, "show_soc_overlay",
true,
&show_performance_overlay};
Settings::Setting<bool> show_bat_temperature{linkage,
false,
"show_bat_temperature",
Settings::Category::Overlay,
Settings::Specialization::Paired, true, true};
Settings::Setting<bool> show_device_model{linkage, true, "show_device_model",
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<Settings::TemperatureUnits> bat_temperature_unit{
linkage,
Settings::TemperatureUnits::Celsius,
"bat_temperature_unit",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_bat_temperature};
Settings::Setting<bool> show_power_info{linkage,
false,
"show_power_info",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_shaders_building{linkage,
true,
"show_shaders_building",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_gpu_model{linkage, true, "show_gpu_model",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Setting<bool> show_input_overlay{linkage, true, "show_input_overlay",
Settings::Category::Overlay};
Settings::Setting<bool> touchscreen{linkage, true, "touchscreen", Settings::Category::Overlay};
Settings::Setting<s32> lock_drawer{linkage, false, "lock_drawer", Settings::Category::Overlay};
Settings::Setting<bool> show_soc_model{linkage, true, "show_soc_model",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_soc_overlay};
/// DEVICE/SOC OVERLAY
Settings::Setting<bool> show_fw_version{linkage, true, "show_firmware_version",
Settings::Setting<bool> show_soc_overlay{linkage,
true,
"show_soc_overlay",
Settings::Category::Overlay,
Settings::Specialization::Paired,
true,
true};
Settings::Setting<bool> show_device_model{linkage,
true,
"show_device_model",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_gpu_model{linkage,
true,
"show_gpu_model",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> show_soc_model{linkage,
true,
"show_soc_model",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_soc_overlay};
Settings::Setting<bool> show_fw_version{linkage,
true,
"show_firmware_version",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_performance_overlay};
Settings::Setting<bool> soc_overlay_background{linkage,
false,
"soc_overlay_background",
Settings::Category::Overlay,
Settings::Specialization::Default,
true,
true,
&show_soc_overlay};
Settings::Setting<s32> soc_overlay_position{linkage,
2,
"soc_overlay_position",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_performance_overlay};
Settings::Specialization::Default,
true,
true,
&show_soc_overlay};
Settings::Setting<bool> soc_overlay_background{linkage, false, "soc_overlay_background",
Settings::Category::Overlay,
Settings::Specialization::Default, true,
true,
&show_soc_overlay};
Settings::Setting<s32> soc_overlay_position{linkage, 2, "soc_overlay_position",
Settings::Category::Overlay,
Settings::Specialization::Default, true, true,
&show_soc_overlay};
Settings::Setting<bool> dont_show_eden_veil_warning{
linkage, false, "dont_show_eden_veil_warning", Settings::Category::Miscellaneous};
};
Settings::Setting<bool> dont_show_eden_veil_warning{linkage, false,
"dont_show_eden_veil_warning",
Settings::Category::Miscellaneous};
};
extern Values values;
extern Values values;
} // namespace AndroidSettings

114
src/android/app/src/main/jni/native.cpp
View file

@ -4,7 +4,6 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <codecvt>
#include <locale>
#include <string>
@ -24,9 +23,9 @@
#include <frontend_common/content_manager.h>
#include <jni.h>
#include "common/android/multiplayer/multiplayer.h"
#include "common/android/android_common.h"
#include "common/android/id_cache.h"
#include "common/android/multiplayer/multiplayer.h"
#include "common/detached_tasks.h"
#include "common/dynamic_library.h"
#include "common/fs/path_util.h"
@ -65,23 +64,23 @@
#include "hid_core/hid_core.h"
#include "hid_core/hid_types.h"
#include "jni/native.h"
#include "network/announce_multiplayer_session.h"
#include "video_core/renderer_base.h"
#include "video_core/renderer_vulkan/renderer_vulkan.h"
#include "video_core/shader_notify.h"
#include "video_core/vulkan_common/vulkan_instance.h"
#include "video_core/vulkan_common/vulkan_surface.h"
#include "video_core/shader_notify.h"
#include "network/announce_multiplayer_session.h"
#define jconst [[maybe_unused]] const auto
#define jauto [[maybe_unused]] auto
static EmulationSession s_instance;
//Abdroid Multiplayer which can be initialized with parameters
// Abdroid Multiplayer which can be initialized with parameters
std::unique_ptr<AndroidMultiplayer> multiplayer{nullptr};
std::shared_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session;
//Power Status default values
// Power Status default values
std::atomic<int> g_battery_percentage = {100};
std::atomic<bool> g_is_charging = {false};
std::atomic<bool> g_has_battery = {true};
@ -581,7 +580,9 @@ jobjectArray Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getSystemDriverInfo(
return j_driver_info;
}
jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv *env, jobject j_obj, jobject j_surf, jstring j_hook_lib_dir) {
jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv* env, jobject j_obj,
jobject j_surf,
jstring j_hook_lib_dir) {
const char* file_redirect_dir_{};
int featureFlags{};
std::string hook_lib_dir = Common::Android::GetJString(env, j_hook_lib_dir);
@ -590,11 +591,11 @@ jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv *env, j
auto driver_library = std::make_shared<Common::DynamicLibrary>(handle);
InputCommon::InputSubsystem input_subsystem;
auto window =
std::make_unique<EmuWindow_Android>(ANativeWindow_fromSurface(env, j_surf), driver_library);
std::make_unique<EmuWindow_Android>(ANativeWindow_fromSurface(env, j_surf), driver_library);
Vulkan::vk::InstanceDispatch dld;
Vulkan::vk::Instance vk_instance = Vulkan::CreateInstance(
*driver_library, dld, VK_API_VERSION_1_1, Core::Frontend::WindowSystemType::Android);
*driver_library, dld, VK_API_VERSION_1_1, Core::Frontend::WindowSystemType::Android);
auto surface = Vulkan::CreateSurface(vk_instance, window->GetWindowInfo());
@ -791,16 +792,19 @@ jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_firmwareVersion(JNIEnv* env, jclas
}
jint Java_org_yuzu_yuzu_1emu_NativeLibrary_verifyFirmware(JNIEnv* env, jclass clazz) {
return static_cast<int>(FirmwareManager::VerifyFirmware(EmulationSession::GetInstance().System()));
return static_cast<int>(
FirmwareManager::VerifyFirmware(EmulationSession::GetInstance().System()));
}
jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_gameRequiresFirmware(JNIEnv* env, jclass clazz, jstring jprogramId) {
jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_gameRequiresFirmware(JNIEnv* env, jclass clazz,
jstring jprogramId) {
auto program_id = EmulationSession::GetProgramId(env, jprogramId);
return FirmwareManager::GameRequiresFirmware(program_id);
}
jint Java_org_yuzu_yuzu_1emu_NativeLibrary_installKeys(JNIEnv* env, jclass clazz, jstring jpath, jstring jext) {
jint Java_org_yuzu_yuzu_1emu_NativeLibrary_installKeys(JNIEnv* env, jclass clazz, jstring jpath,
jstring jext) {
const auto path = Common::Android::GetJString(env, jpath);
const auto ext = Common::Android::GetJString(env, jext);
@ -957,105 +961,97 @@ jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_areKeysPresent(JNIEnv* env, jobje
}
JNIEXPORT void JNICALL
Java_org_yuzu_yuzu_1emu_NativeLibrary_initMultiplayer(
JNIEnv* env, [[maybe_unused]] jobject obj) {
Java_org_yuzu_yuzu_1emu_NativeLibrary_initMultiplayer(JNIEnv* env, [[maybe_unused]] jobject obj) {
if (multiplayer) {
return;
}
announce_multiplayer_session = std::make_shared<Core::AnnounceMultiplayerSession>();
multiplayer = std::make_unique<AndroidMultiplayer>(s_instance.System(), announce_multiplayer_session);
multiplayer =
std::make_unique<AndroidMultiplayer>(s_instance.System(), announce_multiplayer_session);
multiplayer->NetworkInit();
}
JNIEXPORT jobjectArray JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetPublicRooms(
JNIEnv *env, [[maybe_unused]] jobject obj) {
JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetPublicRooms(
JNIEnv* env, [[maybe_unused]] jobject obj) {
return Common::Android::ToJStringArray(env, multiplayer->NetPlayGetPublicRooms());
}
JNIEXPORT jint JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayCreateRoom(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port,
jstring username, jstring preferredGameName, jlong preferredGameId, jstring password,
jstring room_name, jint max_players, jboolean isPublic) {
return static_cast<jint>(
multiplayer->NetPlayCreateRoom(Common::Android::GetJString(env, ipaddress), port,
Common::Android::GetJString(env, username), Common::Android::GetJString(env, preferredGameName),
preferredGameId,Common::Android::GetJString(env, password),
Common::Android::GetJString(env, room_name), max_players, isPublic));
JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port, jstring username,
jstring preferredGameName, jlong preferredGameId, jstring password, jstring room_name,
jint max_players, jboolean isPublic) {
return static_cast<jint>(multiplayer->NetPlayCreateRoom(
Common::Android::GetJString(env, ipaddress), port,
Common::Android::GetJString(env, username),
Common::Android::GetJString(env, preferredGameName), preferredGameId,
Common::Android::GetJString(env, password), Common::Android::GetJString(env, room_name),
max_players, isPublic));
}
JNIEXPORT jint JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayJoinRoom(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port,
jstring username, jstring password) {
return static_cast<jint>(
multiplayer->NetPlayJoinRoom(Common::Android::GetJString(env, ipaddress), port,
Common::Android::GetJString(env, username), Common::Android::GetJString(env, password)));
JNIEnv* env, [[maybe_unused]] jobject obj, jstring ipaddress, jint port, jstring username,
jstring password) {
return static_cast<jint>(multiplayer->NetPlayJoinRoom(
Common::Android::GetJString(env, ipaddress), port,
Common::Android::GetJString(env, username), Common::Android::GetJString(env, password)));
}
JNIEXPORT jobjectArray JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayRoomInfo(
JNIEnv* env, [[maybe_unused]] jobject obj) {
JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayRoomInfo(
JNIEnv* env, [[maybe_unused]] jobject obj) {
return Common::Android::ToJStringArray(env, multiplayer->NetPlayRoomInfo());
}
JNIEXPORT jboolean JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsJoined(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsJoined(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
return multiplayer->NetPlayIsJoined();
}
JNIEXPORT jboolean JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsHostedRoom(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsHostedRoom(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
return multiplayer->NetPlayIsHostedRoom();
}
JNIEXPORT void JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlaySendMessage(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring msg) {
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlaySendMessage(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring msg) {
multiplayer->NetPlaySendMessage(Common::Android::GetJString(env, msg));
}
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayKickUser(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring username) {
JNIEnv* env, [[maybe_unused]] jobject obj, jstring username) {
multiplayer->NetPlayKickUser(Common::Android::GetJString(env, username));
}
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayLeaveRoom(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
multiplayer->NetPlayLeaveRoom();
}
JNIEXPORT jboolean JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsModerator(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayIsModerator(
[[maybe_unused]] JNIEnv* env, [[maybe_unused]] jobject obj) {
return multiplayer->NetPlayIsModerator();
}
JNIEXPORT jobjectArray JNICALL
Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetBanList(
JNIEnv* env, [[maybe_unused]] jobject obj) {
JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayGetBanList(
JNIEnv* env, [[maybe_unused]] jobject obj) {
return Common::Android::ToJStringArray(env, multiplayer->NetPlayGetBanList());
}
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayBanUser(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring username) {
JNIEnv* env, [[maybe_unused]] jobject obj, jstring username) {
multiplayer->NetPlayBanUser(Common::Android::GetJString(env, username));
}
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_network_NetPlayManager_netPlayUnbanUser(
JNIEnv* env, [[maybe_unused]] jobject obj, jstring username) {
JNIEnv* env, [[maybe_unused]] jobject obj, jstring username) {
multiplayer->NetPlayUnbanUser(Common::Android::GetJString(env, username));
}
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_updatePowerState(
JNIEnv* env,
jobject,
jint percentage,
jboolean isCharging,
jboolean hasBattery) {
JNIEXPORT void JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_updatePowerState(JNIEnv* env, jobject,
jint percentage,
jboolean isCharging,
jboolean hasBattery) {
g_battery_percentage.store(percentage, std::memory_order_relaxed);
g_is_charging.store(isCharging, std::memory_order_relaxed);

4
src/audio_core/in/audio_in.cpp
View file

@ -8,8 +8,8 @@
namespace AudioCore::AudioIn {
In::In(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
: manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
session_id_} {}
: manager{manager_}, parent_mutex{manager.mutex}, event{event_},
system{system_, event, session_id_} {}
void In::Free() {
std::scoped_lock l{parent_mutex};

4
src/audio_core/in/audio_in_system.cpp
View file

@ -14,8 +14,8 @@
namespace AudioCore::AudioIn {
System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_)
: system{system_}, buffer_event{event_},
session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
: system{system_}, buffer_event{event_}, session_id{session_id_},
session{std::make_unique<DeviceSession>(system_)} {}
System::~System() {
Finalize();

4
src/audio_core/out/audio_out.cpp
View file

@ -8,8 +8,8 @@
namespace AudioCore::AudioOut {
Out::Out(Core::System& system_, Manager& manager_, Kernel::KEvent* event_, size_t session_id_)
: manager{manager_}, parent_mutex{manager.mutex}, event{event_}, system{system_, event,
session_id_} {}
: manager{manager_}, parent_mutex{manager.mutex}, event{event_},
system{system_, event, session_id_} {}
void Out::Free() {
std::scoped_lock l{parent_mutex};

4
src/audio_core/out/audio_out_system.cpp
View file

@ -14,8 +14,8 @@
namespace AudioCore::AudioOut {
System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_)
: system{system_}, buffer_event{event_},
session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
: system{system_}, buffer_event{event_}, session_id{session_id_},
session{std::make_unique<DeviceSession>(system_)} {}
System::~System() {
Finalize();

7
src/audio_core/renderer/behavior/info_updater.cpp
View file

@ -19,10 +19,9 @@ namespace AudioCore::Renderer {
InfoUpdater::InfoUpdater(std::span<const u8> input_, std::span<u8> output_,
Kernel::KProcess* process_handle_, BehaviorInfo& behaviour_)
: input{input_.data() + sizeof(UpdateDataHeader)},
input_origin{input_}, output{output_.data() + sizeof(UpdateDataHeader)},
output_origin{output_}, in_header{reinterpret_cast<const UpdateDataHeader*>(
input_origin.data())},
: input{input_.data() + sizeof(UpdateDataHeader)}, input_origin{input_},
output{output_.data() + sizeof(UpdateDataHeader)}, output_origin{output_},
in_header{reinterpret_cast<const UpdateDataHeader*>(input_origin.data())},
out_header{reinterpret_cast<UpdateDataHeader*>(output_origin.data())},
expected_input_size{input_.size()}, expected_output_size{output_.size()},
process_handle{process_handle_}, behaviour{behaviour_} {

4
src/audio_core/renderer/memory/pool_mapper.cpp
View file

@ -13,8 +13,8 @@ PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, bool force_map_)
PoolMapper::PoolMapper(Kernel::KProcess* process_handle_, std::span<MemoryPoolInfo> pool_infos_,
u32 pool_count_, bool force_map_)
: process_handle{process_handle_}, pool_infos{pool_infos_.data()},
pool_count{pool_count_}, force_map{force_map_} {}
: process_handle{process_handle_}, pool_infos{pool_infos_.data()}, pool_count{pool_count_},
force_map{force_map_} {}
void PoolMapper::ClearUseState(std::span<MemoryPoolInfo> pools, const u32 count) {
for (u32 i = 0; i < count; i++) {

4
src/audio_core/sink/sink_stream.cpp
View file

@ -240,7 +240,9 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
// Successfully dequeued a new buffer.
queued_buffers--;
{ std::unique_lock lk{release_mutex}; }
{
std::unique_lock lk{release_mutex};
}
release_cv.notify_one();
}

3
src/common/address_space.h
View file

@ -12,8 +12,7 @@
namespace Common {
template <typename VaType, size_t AddressSpaceBits>
concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >=
AddressSpaceBits;
concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
struct EmptyStruct {};

4
src/common/android/android_common.cpp
View file

@ -38,8 +38,8 @@ jstring ToJString(JNIEnv* env, std::string_view str) {
}
jobjectArray ToJStringArray(JNIEnv* env, const std::vector<std::string>& strs) {
jobjectArray array =
env->NewObjectArray(static_cast<jsize>(strs.size()), env->FindClass("java/lang/String"), env->NewStringUTF(""));
jobjectArray array = env->NewObjectArray(
static_cast<jsize>(strs.size()), env->FindClass("java/lang/String"), env->NewStringUTF(""));
for (std::size_t i = 0; i < strs.size(); ++i) {
env->SetObjectArrayElement(array, static_cast<jsize>(i), ToJString(env, strs[i]));
}

1045
src/common/android/id_cache.cpp
View file

File diff suppressed because it is too large Load diff

1
src/common/android/id_cache.h
View file

@ -118,5 +118,4 @@ jmethodID GetYuzuDeviceHasKeys();
jmethodID GetAddNetPlayMessage();
jmethodID ClearChat();
} // namespace Common::Android

238
src/common/android/multiplayer/multiplayer.cpp
View file

@ -6,23 +6,23 @@
#include "common/android/android_common.h"
#include "android/log.h"
#include "core/core.h"
#include "network/network.h"
#include "android/log.h"
#include "common/settings.h"
#include "web_service/web_backend.h"
#include "web_service/verify_user_jwt.h"
#include "web_service/web_backend.h"
#include "web_service/web_result.h"
#include <thread>
#include <chrono>
#include <thread>
namespace IDCache = Common::Android;
AndroidMultiplayer::AndroidMultiplayer(Core::System &system_,
AndroidMultiplayer::AndroidMultiplayer(Core::System& system_,
std::shared_ptr<Core::AnnounceMultiplayerSession> session)
: system{system_}, announce_multiplayer_session(session) {}
: system{system_}, announce_multiplayer_session(session) {}
AndroidMultiplayer::~AndroidMultiplayer() = default;
@ -31,8 +31,8 @@ void AndroidMultiplayer::AddNetPlayMessage(jint type, jstring msg) {
IDCache::GetAddNetPlayMessage(), type, msg);
}
void AndroidMultiplayer::AddNetPlayMessage(int type, const std::string &msg) {
JNIEnv *env = IDCache::GetEnvForThread();
void AndroidMultiplayer::AddNetPlayMessage(int type, const std::string& msg) {
JNIEnv* env = IDCache::GetEnvForThread();
AddNetPlayMessage(type, Common::Android::ToJString(env, msg));
}
@ -50,91 +50,91 @@ bool AndroidMultiplayer::NetworkInit() {
if (auto member = Network::GetRoomMember().lock()) {
// register the network structs to use in slots and signals
member->BindOnStateChanged([this](const Network::RoomMember::State &state) {
member->BindOnStateChanged([this](const Network::RoomMember::State& state) {
if (state == Network::RoomMember::State::Joined ||
state == Network::RoomMember::State::Moderator) {
NetPlayStatus status;
std::string msg;
switch (state) {
case Network::RoomMember::State::Joined:
status = NetPlayStatus::ROOM_JOINED;
break;
case Network::RoomMember::State::Moderator:
status = NetPlayStatus::ROOM_MODERATOR;
break;
default:
return;
case Network::RoomMember::State::Joined:
status = NetPlayStatus::ROOM_JOINED;
break;
case Network::RoomMember::State::Moderator:
status = NetPlayStatus::ROOM_MODERATOR;
break;
default:
return;
}
AddNetPlayMessage(static_cast<int>(status), msg);
}
});
member->BindOnError([this](const Network::RoomMember::Error &error) {
member->BindOnError([this](const Network::RoomMember::Error& error) {
NetPlayStatus status;
std::string msg;
switch (error) {
case Network::RoomMember::Error::LostConnection:
status = NetPlayStatus::LOST_CONNECTION;
break;
case Network::RoomMember::Error::HostKicked:
status = NetPlayStatus::HOST_KICKED;
break;
case Network::RoomMember::Error::UnknownError:
status = NetPlayStatus::UNKNOWN_ERROR;
break;
case Network::RoomMember::Error::NameCollision:
status = NetPlayStatus::NAME_COLLISION;
break;
case Network::RoomMember::Error::IpCollision:
status = NetPlayStatus::MAC_COLLISION;
break;
case Network::RoomMember::Error::WrongVersion:
status = NetPlayStatus::WRONG_VERSION;
break;
case Network::RoomMember::Error::WrongPassword:
status = NetPlayStatus::WRONG_PASSWORD;
break;
case Network::RoomMember::Error::CouldNotConnect:
status = NetPlayStatus::COULD_NOT_CONNECT;
break;
case Network::RoomMember::Error::RoomIsFull:
status = NetPlayStatus::ROOM_IS_FULL;
break;
case Network::RoomMember::Error::HostBanned:
status = NetPlayStatus::HOST_BANNED;
break;
case Network::RoomMember::Error::PermissionDenied:
status = NetPlayStatus::PERMISSION_DENIED;
break;
case Network::RoomMember::Error::NoSuchUser:
status = NetPlayStatus::NO_SUCH_USER;
break;
case Network::RoomMember::Error::LostConnection:
status = NetPlayStatus::LOST_CONNECTION;
break;
case Network::RoomMember::Error::HostKicked:
status = NetPlayStatus::HOST_KICKED;
break;
case Network::RoomMember::Error::UnknownError:
status = NetPlayStatus::UNKNOWN_ERROR;
break;
case Network::RoomMember::Error::NameCollision:
status = NetPlayStatus::NAME_COLLISION;
break;
case Network::RoomMember::Error::IpCollision:
status = NetPlayStatus::MAC_COLLISION;
break;
case Network::RoomMember::Error::WrongVersion:
status = NetPlayStatus::WRONG_VERSION;
break;
case Network::RoomMember::Error::WrongPassword:
status = NetPlayStatus::WRONG_PASSWORD;
break;
case Network::RoomMember::Error::CouldNotConnect:
status = NetPlayStatus::COULD_NOT_CONNECT;
break;
case Network::RoomMember::Error::RoomIsFull:
status = NetPlayStatus::ROOM_IS_FULL;
break;
case Network::RoomMember::Error::HostBanned:
status = NetPlayStatus::HOST_BANNED;
break;
case Network::RoomMember::Error::PermissionDenied:
status = NetPlayStatus::PERMISSION_DENIED;
break;
case Network::RoomMember::Error::NoSuchUser:
status = NetPlayStatus::NO_SUCH_USER;
break;
}
AddNetPlayMessage(static_cast<int>(status), msg);
});
member->BindOnStatusMessageReceived(
[this](const Network::StatusMessageEntry &status_message) {
NetPlayStatus status = NetPlayStatus::NO_ERROR;
std::string msg(status_message.nickname);
switch (status_message.type) {
case Network::IdMemberJoin:
status = NetPlayStatus::MEMBER_JOIN;
break;
case Network::IdMemberLeave:
status = NetPlayStatus::MEMBER_LEAVE;
break;
case Network::IdMemberKicked:
status = NetPlayStatus::MEMBER_KICKED;
break;
case Network::IdMemberBanned:
status = NetPlayStatus::MEMBER_BANNED;
break;
case Network::IdAddressUnbanned:
status = NetPlayStatus::ADDRESS_UNBANNED;
break;
}
AddNetPlayMessage(static_cast<int>(status), msg);
});
member->BindOnChatMessageReceived([this](const Network::ChatEntry &chat) {
[this](const Network::StatusMessageEntry& status_message) {
NetPlayStatus status = NetPlayStatus::NO_ERROR;
std::string msg(status_message.nickname);
switch (status_message.type) {
case Network::IdMemberJoin:
status = NetPlayStatus::MEMBER_JOIN;
break;
case Network::IdMemberLeave:
status = NetPlayStatus::MEMBER_LEAVE;
break;
case Network::IdMemberKicked:
status = NetPlayStatus::MEMBER_KICKED;
break;
case Network::IdMemberBanned:
status = NetPlayStatus::MEMBER_BANNED;
break;
case Network::IdAddressUnbanned:
status = NetPlayStatus::ADDRESS_UNBANNED;
break;
}
AddNetPlayMessage(static_cast<int>(status), msg);
});
member->BindOnChatMessageReceived([this](const Network::ChatEntry& chat) {
NetPlayStatus status = NetPlayStatus::CHAT_MESSAGE;
std::string msg(chat.nickname);
msg += ": ";
@ -146,13 +146,10 @@ bool AndroidMultiplayer::NetworkInit() {
return true;
}
NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(const std::string &ipaddress, int port,
const std::string &username,
const std::string &preferredGameName,
const u64 &preferredGameId,
const std::string &password,
const std::string &room_name, int max_players,
bool isPublic) {
NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(
const std::string& ipaddress, int port, const std::string& username,
const std::string& preferredGameName, const u64& preferredGameId, const std::string& password,
const std::string& room_name, int max_players, bool isPublic) {
auto member = Network::GetRoomMember().lock();
if (!member) {
return NetPlayStatus::NETWORK_ERROR;
@ -173,8 +170,8 @@ NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(const std::string &ipaddress
// Placeholder game info
const AnnounceMultiplayerRoom::GameInfo game{
.name = preferredGameName,
.id = preferredGameId,
.name = preferredGameName,
.id = preferredGameId,
};
port = (port == 0) ? Network::DefaultRoomPort : static_cast<u16>(port);
@ -205,8 +202,8 @@ NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(const std::string &ipaddress
std::string token;
// TODO(alekpop): properly handle the compile definition, it's not working right
//#ifdef ENABLE_WEB_SERVICE
// LOG_INFO(WebService, "Web Service enabled");
// #ifdef ENABLE_WEB_SERVICE
// LOG_INFO(WebService, "Web Service enabled");
if (isPublic) {
WebService::Client client(Settings::values.web_api_url.GetValue(),
Settings::values.eden_username.GetValue(),
@ -220,9 +217,9 @@ NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(const std::string &ipaddress
LOG_INFO(WebService, "Successfully requested external JWT: size={}", token.size());
}
}
//#else
// LOG_INFO(WebService, "Web Service disabled");
//#endif
// #else
// LOG_INFO(WebService, "Web Service disabled");
// #endif
member->Join(username, ipaddress.c_str(), static_cast<u16>(port), 0, Network::NoPreferredIP,
password, token);
@ -241,17 +238,15 @@ NetPlayStatus AndroidMultiplayer::NetPlayCreateRoom(const std::string &ipaddress
return NetPlayStatus::CREATE_ROOM_ERROR;
}
NetPlayStatus AndroidMultiplayer::NetPlayJoinRoom(const std::string &ipaddress, int port,
const std::string &username,
const std::string &password) {
NetPlayStatus AndroidMultiplayer::NetPlayJoinRoom(const std::string& ipaddress, int port,
const std::string& username,
const std::string& password) {
auto member = Network::GetRoomMember().lock();
if (!member) {
return NetPlayStatus::NETWORK_ERROR;
}
port =
(port == 0) ? Network::DefaultRoomPort : static_cast<u16>(port);
port = (port == 0) ? Network::DefaultRoomPort : static_cast<u16>(port);
if (member->GetState() == Network::RoomMember::State::Joining || member->IsConnected()) {
return NetPlayStatus::ALREADY_IN_ROOM;
@ -275,7 +270,7 @@ NetPlayStatus AndroidMultiplayer::NetPlayJoinRoom(const std::string &ipaddress,
return NetPlayStatus::WRONG_PASSWORD;
}
void AndroidMultiplayer::NetPlaySendMessage(const std::string &msg) {
void AndroidMultiplayer::NetPlaySendMessage(const std::string& msg) {
if (auto room = Network::GetRoomMember().lock()) {
if (room->GetState() != Network::RoomMember::State::Joined &&
room->GetState() != Network::RoomMember::State::Moderator) {
@ -286,11 +281,11 @@ void AndroidMultiplayer::NetPlaySendMessage(const std::string &msg) {
}
}
void AndroidMultiplayer::NetPlayKickUser(const std::string &username) {
void AndroidMultiplayer::NetPlayKickUser(const std::string& username) {
if (auto room = Network::GetRoomMember().lock()) {
auto members = room->GetMemberInformation();
auto it = std::find_if(members.begin(), members.end(),
[&username](const Network::RoomMember::MemberInformation &member) {
[&username](const Network::RoomMember::MemberInformation& member) {
return member.nickname == username;
});
if (it != members.end()) {
@ -299,11 +294,11 @@ void AndroidMultiplayer::NetPlayKickUser(const std::string &username) {
}
}
void AndroidMultiplayer::NetPlayBanUser(const std::string &username) {
void AndroidMultiplayer::NetPlayBanUser(const std::string& username) {
if (auto room = Network::GetRoomMember().lock()) {
auto members = room->GetMemberInformation();
auto it = std::find_if(members.begin(), members.end(),
[&username](const Network::RoomMember::MemberInformation &member) {
[&username](const Network::RoomMember::MemberInformation& member) {
return member.nickname == username;
});
if (it != members.end()) {
@ -312,7 +307,7 @@ void AndroidMultiplayer::NetPlayBanUser(const std::string &username) {
}
}
void AndroidMultiplayer::NetPlayUnbanUser(const std::string &username) {
void AndroidMultiplayer::NetPlayUnbanUser(const std::string& username) {
if (auto room = Network::GetRoomMember().lock()) {
room->SendModerationRequest(Network::RoomMessageTypes::IdModUnban, username);
}
@ -327,7 +322,7 @@ std::vector<std::string> AndroidMultiplayer::NetPlayRoomInfo() {
auto room_info = room->GetRoomInformation();
info_list.push_back(room_info.name + "|" + std::to_string(room_info.member_slots));
// all members
for (const auto &member: members) {
for (const auto& member : members) {
info_list.push_back(member.nickname);
}
}
@ -385,30 +380,24 @@ std::vector<std::string> AndroidMultiplayer::NetPlayGetPublicRooms() {
if (auto session = announce_multiplayer_session.lock()) {
auto rooms = session->GetRoomList();
for (const auto &room: rooms) {
room_list.push_back(room.information.name + "|" +
(room.has_password ? "1" : "0") + "|" +
std::to_string(room.information.member_slots) + "|" +
room.ip + "|" +
std::to_string(room.information.port) + "|" +
for (const auto& room : rooms) {
room_list.push_back(room.information.name + "|" + (room.has_password ? "1" : "0") +
"|" + std::to_string(room.information.member_slots) + "|" +
room.ip + "|" + std::to_string(room.information.port) + "|" +
room.information.description + "|" +
room.information.host_username + "|" +
std::to_string(room.information.preferred_game.id) + "|" +
room.information.preferred_game.name + "|" +
room.information.preferred_game.version);
for (const auto &member: room.members) {
room_list.push_back("MEMBER|" + room.information.name + "|" +
member.username + "|" +
member.nickname + "|" +
std::to_string(member.game.id) + "|" +
member.game.name);
for (const auto& member : room.members) {
room_list.push_back("MEMBER|" + room.information.name + "|" + member.username +
"|" + member.nickname + "|" + std::to_string(member.game.id) +
"|" + member.game.name);
}
}
}
return room_list;
}
std::vector<std::string> AndroidMultiplayer::NetPlayGetBanList() {
@ -417,27 +406,28 @@ std::vector<std::string> AndroidMultiplayer::NetPlayGetBanList() {
auto [username_bans, ip_bans] = room->GetBanList();
// Add username bans
for (const auto &username: username_bans) {
for (const auto& username : username_bans) {
ban_list.push_back(username);
}
// Add IP bans
for (const auto &ip: ip_bans) {
for (const auto& ip : ip_bans) {
ban_list.push_back(ip);
}
}
return ban_list;
}
std::unique_ptr<Network::VerifyUser::Backend> AndroidMultiplayer::CreateVerifyBackend(bool use_validation) {
std::unique_ptr<Network::VerifyUser::Backend> AndroidMultiplayer::CreateVerifyBackend(
bool use_validation) {
std::unique_ptr<Network::VerifyUser::Backend> verify_backend;
if (use_validation) {
//#ifdef ENABLE_WEB_SERVICE
// #ifdef ENABLE_WEB_SERVICE
verify_backend =
std::make_unique<WebService::VerifyUserJWT>(Settings::values.web_api_url.GetValue());
//#else
// verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
//#endif
// #else
// verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
// #endif
} else {
verify_backend = std::make_unique<Network::VerifyUser::NullBackend>();
}

31
src/common/android/multiplayer/multiplayer.h
View file

@ -7,13 +7,13 @@
#include <vector>
#include <common/common_types.h>
#include <network/network.h>
#include <network/announce_multiplayer_session.h>
#include <network/network.h>
namespace Core {
class System;
class AnnounceMultiplayerSession;
}
class System;
class AnnounceMultiplayerSession;
} // namespace Core
enum class NetPlayStatus : s32 {
NO_ERROR,
@ -63,13 +63,14 @@ public:
void ClearChat();
NetPlayStatus NetPlayCreateRoom(const std::string &ipaddress, int port,
const std::string &username, const std::string &preferredGameName,
const u64 &preferredGameId, const std::string &password,
const std::string &room_name, int max_players, bool isPublic);
NetPlayStatus NetPlayCreateRoom(const std::string& ipaddress, int port,
const std::string& username,
const std::string& preferredGameName,
const u64& preferredGameId, const std::string& password,
const std::string& room_name, int max_players, bool isPublic);
NetPlayStatus NetPlayJoinRoom(const std::string &ipaddress, int port,
const std::string &username, const std::string &password);
NetPlayStatus NetPlayJoinRoom(const std::string& ipaddress, int port,
const std::string& username, const std::string& password);
std::vector<std::string> NetPlayRoomInfo();
@ -79,11 +80,11 @@ public:
bool NetPlayIsModerator();
void NetPlaySendMessage(const std::string &msg);
void NetPlaySendMessage(const std::string& msg);
void NetPlayKickUser(const std::string &username);
void NetPlayKickUser(const std::string& username);
void NetPlayBanUser(const std::string &username);
void NetPlayBanUser(const std::string& username);
void NetPlayLeaveRoom();
@ -91,12 +92,12 @@ public:
std::vector<std::string> NetPlayGetBanList();
void NetPlayUnbanUser(const std::string &username);
void NetPlayUnbanUser(const std::string& username);
std::vector<std::string> NetPlayGetPublicRooms();
private:
Core::System& system;
static std::unique_ptr<Network::VerifyUser::Backend> CreateVerifyBackend(bool use_validation) ;
static std::unique_ptr<Network::VerifyUser::Backend> CreateVerifyBackend(bool use_validation);
std::weak_ptr<Core::AnnounceMultiplayerSession> announce_multiplayer_session;
};

6
src/common/concepts.h
View file

@ -16,9 +16,9 @@ concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
// is available on all supported platforms.
template <typename Derived, typename Base>
concept DerivedFrom = requires {
std::is_base_of_v<Base, Derived>;
std::is_convertible_v<const volatile Derived*, const volatile Base*>;
};
std::is_base_of_v<Base, Derived>;
std::is_convertible_v<const volatile Derived*, const volatile Base*>;
};
// TODO: Replace with std::convertible_to when libc++ implements it.
template <typename From, typename To>

107
src/common/device_power_state.cpp
View file

@ -27,76 +27,73 @@ extern std::atomic<bool> g_has_battery;
namespace Common {
PowerStatus GetPowerStatus()
{
PowerStatus info;
PowerStatus GetPowerStatus() {
PowerStatus info;
#if defined(_WIN32)
SYSTEM_POWER_STATUS status;
if (GetSystemPowerStatus(&status)) {
if (status.BatteryFlag == 128) {
info.has_battery = false;
} else {
info.percentage = status.BatteryLifePercent;
info.charging = (status.BatteryFlag & 8) != 0;
}
} else {
SYSTEM_POWER_STATUS status;
if (GetSystemPowerStatus(&status)) {
if (status.BatteryFlag == 128) {
info.has_battery = false;
} else {
info.percentage = status.BatteryLifePercent;
info.charging = (status.BatteryFlag & 8) != 0;
}
} else {
info.has_battery = false;
}
#elif defined(__ANDROID__)
info.percentage = g_battery_percentage.load(std::memory_order_relaxed);
info.charging = g_is_charging.load(std::memory_order_relaxed);
info.has_battery = g_has_battery.load(std::memory_order_relaxed);
info.percentage = g_battery_percentage.load(std::memory_order_relaxed);
info.charging = g_is_charging.load(std::memory_order_relaxed);
info.has_battery = g_has_battery.load(std::memory_order_relaxed);
#elif defined(__APPLE__) && TARGET_OS_MAC
CFTypeRef info_ref = IOPSCopyPowerSourcesInfo();
CFArrayRef sources = IOPSCopyPowerSourcesList(info_ref);
if (CFArrayGetCount(sources) > 0) {
CFDictionaryRef battery =
IOPSGetPowerSourceDescription(info_ref, CFArrayGetValueAtIndex(sources, 0));
CFTypeRef info_ref = IOPSCopyPowerSourcesInfo();
CFArrayRef sources = IOPSCopyPowerSourcesList(info_ref);
if (CFArrayGetCount(sources) > 0) {
CFDictionaryRef battery =
IOPSGetPowerSourceDescription(info_ref, CFArrayGetValueAtIndex(sources, 0));
CFNumberRef curNum =
(CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSCurrentCapacityKey));
CFNumberRef maxNum =
(CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSMaxCapacityKey));
int cur = 0, max = 0;
CFNumberGetValue(curNum, kCFNumberIntType, &cur);
CFNumberGetValue(maxNum, kCFNumberIntType, &max);
CFNumberRef curNum =
(CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSCurrentCapacityKey));
CFNumberRef maxNum = (CFNumberRef)CFDictionaryGetValue(battery, CFSTR(kIOPSMaxCapacityKey));
int cur = 0, max = 0;
CFNumberGetValue(curNum, kCFNumberIntType, &cur);
CFNumberGetValue(maxNum, kCFNumberIntType, &max);
if (max > 0)
info.percentage = (cur * 100) / max;
if (max > 0)
info.percentage = (cur * 100) / max;
CFBooleanRef isCharging =
(CFBooleanRef)CFDictionaryGetValue(battery, CFSTR(kIOPSIsChargingKey));
info.charging = CFBooleanGetValue(isCharging);
} else {
info.has_battery = false;
}
CFRelease(sources);
CFRelease(info_ref);
CFBooleanRef isCharging =
(CFBooleanRef)CFDictionaryGetValue(battery, CFSTR(kIOPSIsChargingKey));
info.charging = CFBooleanGetValue(isCharging);
} else {
info.has_battery = false;
}
CFRelease(sources);
CFRelease(info_ref);
#elif defined(__linux__)
const char* battery_path = "/sys/class/power_supply/BAT0/";
const char* battery_path = "/sys/class/power_supply/BAT0/";
std::ifstream capFile(std::string(battery_path) + "capacity");
if (capFile) {
capFile >> info.percentage;
}
else {
info.has_battery = false;
}
std::ifstream statFile(std::string(battery_path) + "status");
if (statFile) {
std::string status;
std::getline(statFile, status);
info.charging = (status == "Charging");
}
#else
std::ifstream capFile(std::string(battery_path) + "capacity");
if (capFile) {
capFile >> info.percentage;
} else {
info.has_battery = false;
}
std::ifstream statFile(std::string(battery_path) + "status");
if (statFile) {
std::string status;
std::getline(statFile, status);
info.charging = (status == "Charging");
}
#else
info.has_battery = false;
#endif
return info;
}
return info;
}
} // namespace Common

8
src/common/expected.h
View file

@ -598,14 +598,14 @@ public:
template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
: impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
detail::default_constructor_tag{}} {}
: impl_base{unexpect_t{}, std::move(e.value())},
ctor_base{detail::default_constructor_tag{}} {}
template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
: impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
detail::default_constructor_tag{}} {}
: impl_base{unexpect_t{}, std::move(e.value())},
ctor_base{detail::default_constructor_tag{}} {}
template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
constexpr explicit Expected(unexpect_t, Args&&... args)

28
src/common/fs/path_util.cpp
View file

@ -88,9 +88,8 @@ public:
}
void CreateEdenPaths() {
std::for_each(eden_paths.begin(), eden_paths.end(), [](auto &path) {
void(FS::CreateDir(path.second));
});
std::for_each(eden_paths.begin(), eden_paths.end(),
[](auto& path) { void(FS::CreateDir(path.second)); });
}
void SetEdenPathImpl(EdenPath eden_path, const fs::path& new_path) {
@ -116,9 +115,13 @@ public:
eden_path_cache = eden_path / CACHE_DIR;
eden_path_config = eden_path / CONFIG_DIR;
#define LEGACY_PATH(titleName, upperName) GenerateLegacyPath(LegacyPath::titleName##Dir, GetAppDataRoamingDirectory() / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, GetAppDataRoamingDirectory() / upperName##_DIR / CONFIG_DIR); \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, GetAppDataRoamingDirectory() / upperName##_DIR / CACHE_DIR);
#define LEGACY_PATH(titleName, upperName) \
GenerateLegacyPath(LegacyPath::titleName##Dir, \
GetAppDataRoamingDirectory() / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, \
GetAppDataRoamingDirectory() / upperName##_DIR / CONFIG_DIR); \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, \
GetAppDataRoamingDirectory() / upperName##_DIR / CACHE_DIR);
LEGACY_PATH(Citron, CITRON)
LEGACY_PATH(Sudachi, SUDACHI)
@ -143,9 +146,13 @@ public:
eden_path_config = GetDataDirectory("XDG_CONFIG_HOME") / EDEN_DIR;
}
#define LEGACY_PATH(titleName, upperName) GenerateLegacyPath(LegacyPath::titleName##Dir, GetDataDirectory("XDG_DATA_HOME") / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, GetDataDirectory("XDG_CONFIG_HOME") / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, GetDataDirectory("XDG_CACHE_HOME") / upperName##_DIR);
#define LEGACY_PATH(titleName, upperName) \
GenerateLegacyPath(LegacyPath::titleName##Dir, \
GetDataDirectory("XDG_DATA_HOME") / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##ConfigDir, \
GetDataDirectory("XDG_CONFIG_HOME") / upperName##_DIR); \
GenerateLegacyPath(LegacyPath::titleName##CacheDir, \
GetDataDirectory("XDG_CACHE_HOME") / upperName##_DIR);
LEGACY_PATH(Citron, CITRON)
LEGACY_PATH(Sudachi, SUDACHI)
@ -301,8 +308,7 @@ void SetEdenPath(EdenPath eden_path, const fs::path& new_path) {
PathManagerImpl::GetInstance().SetEdenPathImpl(eden_path, new_path);
}
void CreateEdenPaths()
{
void CreateEdenPaths() {
PathManagerImpl::GetInstance().CreateEdenPaths();
}

4
src/common/intrusive_list.h
View file

@ -538,7 +538,7 @@ public:
template <auto T, class Derived = Common::impl::GetParentType<T>>
class IntrusiveListMemberTraits;
template <class Parent, IntrusiveListNode Parent::*Member, class Derived>
template <class Parent, IntrusiveListNode Parent::* Member, class Derived>
class IntrusiveListMemberTraits<Member, Derived> {
public:
using ListType = IntrusiveList<Derived, IntrusiveListMemberTraits>;
@ -566,7 +566,7 @@ private:
template <auto T, class Derived = Common::impl::GetParentType<T>>
class IntrusiveListMemberTraitsByNonConstexprOffsetOf;
template <class Parent, IntrusiveListNode Parent::*Member, class Derived>
template <class Parent, IntrusiveListNode Parent::* Member, class Derived>
class IntrusiveListMemberTraitsByNonConstexprOffsetOf<Member, Derived> {
public:
using ListType = IntrusiveList<Derived, IntrusiveListMemberTraitsByNonConstexprOffsetOf>;

10
src/common/intrusive_red_black_tree.h
View file

@ -238,10 +238,8 @@ public:
template <typename T>
concept HasRedBlackKeyType = requires {
{
std::is_same<typename T::RedBlackKeyType, void>::value
} -> std::convertible_to<bool>;
};
{ std::is_same<typename T::RedBlackKeyType, void>::value } -> std::convertible_to<bool>;
};
namespace impl {
@ -497,7 +495,7 @@ public:
template <auto T, class Derived = Common::impl::GetParentType<T>>
class IntrusiveRedBlackTreeMemberTraits;
template <class Parent, IntrusiveRedBlackTreeNode Parent::*Member, class Derived>
template <class Parent, IntrusiveRedBlackTreeNode Parent::* Member, class Derived>
class IntrusiveRedBlackTreeMemberTraits<Member, Derived> {
public:
template <class Comparator>
@ -530,7 +528,7 @@ private:
template <auto T, class Derived = Common::impl::GetParentType<T>>
class IntrusiveRedBlackTreeMemberTraitsDeferredAssert;
template <class Parent, IntrusiveRedBlackTreeNode Parent::*Member, class Derived>
template <class Parent, IntrusiveRedBlackTreeNode Parent::* Member, class Derived>
class IntrusiveRedBlackTreeMemberTraitsDeferredAssert<Member, Derived> {
public:
template <class Comparator>

4
src/common/logging/backend.cpp
View file

@ -90,8 +90,8 @@ public:
auto old_filename = filename;
old_filename += ".old.txt";
// Existence checks are done within the functions themselves.
// We don't particularly care if these succeed or not.
// Existence checks are done within the functions themselves.
// We don't particularly care if these succeed or not.
static_cast<void>(FS::RemoveFile(old_filename));
static_cast<void>(FS::RenameFile(filename, old_filename));

8
src/common/multi_level_page_table.h
View file

@ -25,12 +25,12 @@ public:
MultiLevelPageTable(MultiLevelPageTable&& other) noexcept
: address_space_bits{std::exchange(other.address_space_bits, 0)},
first_level_bits{std::exchange(other.first_level_bits, 0)}, page_bits{std::exchange(
other.page_bits, 0)},
first_level_bits{std::exchange(other.first_level_bits, 0)},
page_bits{std::exchange(other.page_bits, 0)},
first_level_shift{std::exchange(other.first_level_shift, 0)},
first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)},
first_level_map{std::move(other.first_level_map)}, base_ptr{std::exchange(other.base_ptr,
nullptr)} {}
first_level_map{std::move(other.first_level_map)},
base_ptr{std::exchange(other.base_ptr, nullptr)} {}
MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept {
address_space_bits = std::exchange(other.address_space_bits, 0);

4
src/common/parent_of_member.h
View file

@ -92,7 +92,7 @@ struct OffsetOfCalculator {
}
template <typename CurUnion>
static constexpr std::ptrdiff_t OffsetOfImpl(MemberType ParentType::*member,
static constexpr std::ptrdiff_t OffsetOfImpl(MemberType ParentType::* member,
CurUnion& cur_union) {
constexpr size_t Offset = CurUnion::GetOffset();
const auto target = std::addressof(GetPointer(U.parent)->*member);
@ -111,7 +111,7 @@ struct OffsetOfCalculator {
Offset);
}
static constexpr std::ptrdiff_t OffsetOf(MemberType ParentType::*member) {
static constexpr std::ptrdiff_t OffsetOf(MemberType ParentType::* member) {
return OffsetOfImpl(member, U.first_union);
}
};

4
src/common/point.h
View file

@ -34,12 +34,12 @@ struct Point {
.y = static_cast<T>(value op rhs.y), \
}; \
} \
friend constexpr Point& operator compound_op(Point& lhs, const Point& rhs) noexcept { \
friend constexpr Point& operator compound_op(Point & lhs, const Point & rhs) noexcept { \
lhs.x = static_cast<T>(lhs.x op rhs.x); \
lhs.y = static_cast<T>(lhs.y op rhs.y); \
return lhs; \
} \
friend constexpr Point& operator compound_op(Point& lhs, T value) noexcept { \
friend constexpr Point& operator compound_op(Point & lhs, T value) noexcept { \
lhs.x = static_cast<T>(lhs.x op value); \
lhs.y = static_cast<T>(lhs.y op value); \
return lhs; \

6
src/common/polyfill_ranges.h
View file

@ -18,9 +18,9 @@ namespace ranges {
template <typename T>
concept range = requires(T& t) {
begin(t);
end(t);
};
begin(t);
end(t);
};
template <typename T>
concept input_range = range<T>;

4
src/common/polyfill_thread.h
View file

@ -339,7 +339,9 @@ void CondvarWait(Condvar& cv, std::unique_lock<Lock>& lk, std::stop_token token,
}
std::stop_callback callback(token, [&] {
{ std::scoped_lock lk2{*lk.mutex()}; }
{
std::scoped_lock lk2{*lk.mutex()};
}
cv.notify_all();
});

170
src/common/settings.h
View file

@ -150,7 +150,7 @@ struct Values {
Setting<AppletMode> net_connect_applet_mode{linkage, AppletMode::LLE, "net_connect_applet_mode",
Category::LibraryApplet};
Setting<AppletMode> player_select_applet_mode{
linkage, AppletMode::LLE, "player_select_applet_mode", Category::LibraryApplet};
linkage, AppletMode::LLE, "player_select_applet_mode", Category::LibraryApplet};
Setting<AppletMode> swkbd_applet_mode{linkage, AppletMode::HLE, "swkbd_applet_mode",
Category::LibraryApplet};
Setting<AppletMode> mii_edit_applet_mode{linkage, AppletMode::LLE, "mii_edit_applet_mode",
@ -160,13 +160,13 @@ struct Values {
Setting<AppletMode> shop_applet_mode{linkage, AppletMode::HLE, "shop_applet_mode",
Category::LibraryApplet};
Setting<AppletMode> photo_viewer_applet_mode{
linkage, AppletMode::LLE, "photo_viewer_applet_mode", Category::LibraryApplet};
linkage, AppletMode::LLE, "photo_viewer_applet_mode", Category::LibraryApplet};
Setting<AppletMode> offline_web_applet_mode{linkage, AppletMode::LLE, "offline_web_applet_mode",
Category::LibraryApplet};
Setting<AppletMode> login_share_applet_mode{linkage, AppletMode::HLE, "login_share_applet_mode",
Category::LibraryApplet};
Setting<AppletMode> wifi_web_auth_applet_mode{
linkage, AppletMode::HLE, "wifi_web_auth_applet_mode", Category::LibraryApplet};
linkage, AppletMode::HLE, "wifi_web_auth_applet_mode", Category::LibraryApplet};
Setting<AppletMode> my_page_applet_mode{linkage, AppletMode::LLE, "my_page_applet_mode",
Category::LibraryApplet};
@ -174,13 +174,13 @@ struct Values {
SwitchableSetting<AudioEngine> sink_id{linkage, AudioEngine::Auto, "output_engine",
Category::Audio, Specialization::RuntimeList};
SwitchableSetting<std::string> audio_output_device_id{
linkage, "auto", "output_device", Category::Audio, Specialization::RuntimeList};
linkage, "auto", "output_device", Category::Audio, Specialization::RuntimeList};
SwitchableSetting<std::string> audio_input_device_id{
linkage, "auto", "input_device", Category::Audio, Specialization::RuntimeList};
linkage, "auto", "input_device", Category::Audio, Specialization::RuntimeList};
SwitchableSetting<AudioMode, true> sound_index{
linkage, AudioMode::Stereo, AudioMode::Mono, AudioMode::Surround,
"sound_index", Category::SystemAudio, Specialization::Default, true,
true};
linkage, AudioMode::Stereo, AudioMode::Mono, AudioMode::Surround,
"sound_index", Category::SystemAudio, Specialization::Default, true,
true};
SwitchableSetting<u8, true> volume{linkage,
100,
0,
@ -191,9 +191,9 @@ struct Values {
true,
true};
Setting<bool, false> audio_muted{
linkage, false, "audio_muted", Category::Audio, Specialization::Default, true, true};
linkage, false, "audio_muted", Category::Audio, Specialization::Default, true, true};
Setting<bool, false> dump_audio_commands{
linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};
linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};
// Core
SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
@ -206,7 +206,7 @@ struct Values {
Specialization::Default,
true};
SwitchableSetting<bool> use_speed_limit{
linkage, true, "use_speed_limit", Category::Core, Specialization::Paired, true, true};
linkage, true, "use_speed_limit", Category::Core, Specialization::Paired, true, true};
SwitchableSetting<u16, true> speed_limit{linkage,
100,
0,
@ -217,7 +217,8 @@ struct Values {
true,
true,
&use_speed_limit};
SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core, Specialization::Default};
SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core,
Specialization::Default};
// Memory
#ifdef HAS_NCE
@ -243,29 +244,14 @@ struct Values {
CpuAccuracy::Auto, CpuAccuracy::Paranoid,
"cpu_accuracy", Category::Cpu};
SwitchableSetting<bool> use_fast_cpu_time{linkage,
false,
"use_fast_cpu_time",
Category::Cpu,
Specialization::Paired,
true,
true};
SwitchableSetting<CpuClock> fast_cpu_time{linkage,
CpuClock::Boost,
"fast_cpu_time",
Category::Cpu,
Specialization::Default,
true,
true,
&use_fast_cpu_time};
SwitchableSetting<bool> use_fast_cpu_time{
linkage, false, "use_fast_cpu_time", Category::Cpu, Specialization::Paired, true, true};
SwitchableSetting<CpuClock> fast_cpu_time{
linkage, CpuClock::Boost, "fast_cpu_time", Category::Cpu, Specialization::Default, true,
true, &use_fast_cpu_time};
SwitchableSetting<bool> use_custom_cpu_ticks{linkage,
false,
"use_custom_cpu_ticks",
Category::Cpu,
Specialization::Paired,
true,
true};
SwitchableSetting<bool> use_custom_cpu_ticks{
linkage, false, "use_custom_cpu_ticks", Category::Cpu, Specialization::Paired, true, true};
SwitchableSetting<u32, true> cpu_ticks{linkage,
16000,
@ -302,29 +288,29 @@ struct Values {
SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{linkage, true, "cpuopt_unsafe_unfuse_fma",
Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{
linkage, true, "cpuopt_unsafe_reduce_fp_error", Category::CpuUnsafe};
linkage, true, "cpuopt_unsafe_reduce_fp_error", Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
linkage, true, "cpuopt_unsafe_ignore_standard_fpcr", Category::CpuUnsafe};
linkage, true, "cpuopt_unsafe_ignore_standard_fpcr", Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{
linkage, true, "cpuopt_unsafe_inaccurate_nan", Category::CpuUnsafe};
linkage, true, "cpuopt_unsafe_inaccurate_nan", Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{
linkage, true, "cpuopt_unsafe_fastmem_check", Category::CpuUnsafe};
linkage, true, "cpuopt_unsafe_fastmem_check", Category::CpuUnsafe};
SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
linkage, true, "cpuopt_unsafe_ignore_global_monitor", Category::CpuUnsafe};
linkage, true, "cpuopt_unsafe_ignore_global_monitor", Category::CpuUnsafe};
// Renderer
SwitchableSetting<RendererBackend, true> renderer_backend{
linkage, RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
"backend", Category::Renderer};
linkage, RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
"backend", Category::Renderer};
SwitchableSetting<ShaderBackend, true> shader_backend{
linkage, ShaderBackend::SpirV, ShaderBackend::Glsl, ShaderBackend::SpirV,
"shader_backend", Category::Renderer, Specialization::RuntimeList};
linkage, ShaderBackend::SpirV, ShaderBackend::Glsl, ShaderBackend::SpirV,
"shader_backend", Category::Renderer, Specialization::RuntimeList};
SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer,
Specialization::RuntimeList};
SwitchableSetting<bool> enable_raii{linkage, false, "enable_raii", Category::Renderer};
#ifdef __ANDROID__
SwitchableSetting<bool> frame_interpolation{linkage, true, "frame_interpolation", Category::Renderer,
Specialization::RuntimeList};
SwitchableSetting<bool> frame_interpolation{linkage, true, "frame_interpolation",
Category::Renderer, Specialization::RuntimeList};
SwitchableSetting<bool> frame_skipping{linkage, false, "frame_skipping", Category::Renderer,
Specialization::RuntimeList};
#endif
@ -337,7 +323,7 @@ struct Values {
"optimize_spirv_output",
Category::Renderer};
SwitchableSetting<bool> use_asynchronous_gpu_emulation{
linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
linkage, true, "use_asynchronous_gpu_emulation", Category::Renderer};
SwitchableSetting<AstcDecodeMode, true> accelerate_astc{linkage,
#ifdef ANDROID
AstcDecodeMode::Cpu,
@ -349,9 +335,9 @@ struct Values {
"accelerate_astc",
Category::Renderer};
SwitchableSetting<VSyncMode, true> vsync_mode{
linkage, VSyncMode::Fifo, VSyncMode::Immediate, VSyncMode::FifoRelaxed,
"use_vsync", Category::Renderer, Specialization::RuntimeList, true,
true};
linkage, VSyncMode::Fifo, VSyncMode::Immediate, VSyncMode::FifoRelaxed,
"use_vsync", Category::Renderer, Specialization::RuntimeList, true,
true};
SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::Gpu,
"nvdec_emulation", Category::Renderer};
// *nix platforms may have issues with the borderless windowed fullscreen mode.
@ -408,11 +394,11 @@ struct Values {
true};
SwitchableSetting<u8, false> bg_red{
linkage, 0, "bg_red", Category::Renderer, Specialization::Default, true, true};
linkage, 0, "bg_red", Category::Renderer, Specialization::Default, true, true};
SwitchableSetting<u8, false> bg_green{
linkage, 0, "bg_green", Category::Renderer, Specialization::Default, true, true};
linkage, 0, "bg_green", Category::Renderer, Specialization::Default, true, true};
SwitchableSetting<u8, false> bg_blue{
linkage, 0, "bg_blue", Category::Renderer, Specialization::Default, true, true};
linkage, 0, "bg_blue", Category::Renderer, Specialization::Default, true, true};
SwitchableSetting<GpuAccuracy, true> gpu_accuracy{linkage,
#ifdef ANDROID
@ -476,13 +462,9 @@ struct Values {
Category::RendererAdvanced};
SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
Category::RendererAdvanced};
SwitchableSetting<bool> use_fast_gpu_time{linkage,
true,
"use_fast_gpu_time",
Category::RendererAdvanced,
Specialization::Paired,
true,
true};
SwitchableSetting<bool> use_fast_gpu_time{
linkage, true, "use_fast_gpu_time", Category::RendererAdvanced, Specialization::Paired,
true, true};
SwitchableSetting<GpuOverclock> fast_gpu_time{linkage,
GpuOverclock::Low,
@ -507,17 +489,15 @@ struct Values {
SwitchableSetting<bool> barrier_feedback_loops{linkage, true, "barrier_feedback_loops",
Category::RendererAdvanced};
SwitchableSetting<u8, true> dyna_state{linkage,
0,
0,
3,
"dyna_state",
Category::RendererExtensions,
Specialization::Scalar};
SwitchableSetting<u8, true> dyna_state{
linkage, 0, 0, 3, "dyna_state", Category::RendererExtensions, Specialization::Scalar};
SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex", Category::RendererExtensions};
SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing", Category::RendererExtensions};
SwitchableSetting<bool> sample_shading{linkage, false, "sample_shading", Category::RendererExtensions};
SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex",
Category::RendererExtensions};
SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing",
Category::RendererExtensions};
SwitchableSetting<bool> sample_shading{linkage, false, "sample_shading",
Category::RendererExtensions};
Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
@ -525,19 +505,16 @@ struct Values {
Setting<bool> enable_nsight_aftermath{linkage, false, "nsight_aftermath",
Category::RendererDebug};
Setting<bool> disable_shader_loop_safety_checks{
linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
Category::RendererDebug};
Setting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
Category::RendererDebug};
// System
SwitchableSetting<Language, true> language_index{linkage,
Language::EnglishAmerican,
Language::Japanese,
Language::Serbian,
"language_index",
Category::System};
SwitchableSetting<Language, true> language_index{
linkage, Language::EnglishAmerican, Language::Japanese,
Language::Serbian, "language_index", Category::System};
SwitchableSetting<Region, true> region_index{linkage, Region::Usa, Region::Japan,
Region::Taiwan, "region_index", Category::System};
SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto,
@ -545,10 +522,10 @@ struct Values {
"time_zone_index", Category::System};
// Measured in seconds since epoch
SwitchableSetting<bool> custom_rtc_enabled{
linkage, false, "custom_rtc_enabled", Category::System, Specialization::Paired, true, true};
linkage, false, "custom_rtc_enabled", Category::System, Specialization::Paired, true, true};
SwitchableSetting<s64> custom_rtc{
linkage, 0, "custom_rtc", Category::System, Specialization::Time,
false, true, &custom_rtc_enabled};
linkage, 0, "custom_rtc", Category::System, Specialization::Time,
false, true, &custom_rtc_enabled};
SwitchableSetting<s64, true> custom_rtc_offset{linkage,
0,
std::numeric_limits<int>::min(),
@ -559,12 +536,12 @@ struct Values {
true,
true};
SwitchableSetting<bool> rng_seed_enabled{
linkage, false, "rng_seed_enabled", Category::System, Specialization::Paired, true, true};
linkage, false, "rng_seed_enabled", Category::System, Specialization::Paired, true, true};
SwitchableSetting<u32> rng_seed{
linkage, 0, "rng_seed", Category::System, Specialization::Hex,
true, true, &rng_seed_enabled};
linkage, 0, "rng_seed", Category::System, Specialization::Hex,
true, true, &rng_seed_enabled};
Setting<std::string> device_name{
linkage, "eden", "device_name", Category::System, Specialization::Default, true, true};
linkage, "eden", "device_name", Category::System, Specialization::Default, true, true};
Setting<s32> current_user{linkage, 0, "current_user", Category::System};
@ -615,21 +592,21 @@ struct Values {
Setting<bool> tas_loop{linkage, false, "tas_loop", Category::Controls};
Setting<bool> mouse_panning{
linkage, false, "mouse_panning", Category::Controls, Specialization::Default, false};
linkage, false, "mouse_panning", Category::Controls, Specialization::Default, false};
Setting<u8, true> mouse_panning_sensitivity{
linkage, 50, 1, 100, "mouse_panning_sensitivity", Category::Controls};
linkage, 50, 1, 100, "mouse_panning_sensitivity", Category::Controls};
Setting<bool> mouse_enabled{linkage, false, "mouse_enabled", Category::Controls};
Setting<u8, true> mouse_panning_x_sensitivity{
linkage, 50, 1, 100, "mouse_panning_x_sensitivity", Category::Controls};
linkage, 50, 1, 100, "mouse_panning_x_sensitivity", Category::Controls};
Setting<u8, true> mouse_panning_y_sensitivity{
linkage, 50, 1, 100, "mouse_panning_y_sensitivity", Category::Controls};
linkage, 50, 1, 100, "mouse_panning_y_sensitivity", Category::Controls};
Setting<u8, true> mouse_panning_deadzone_counterweight{
linkage, 20, 0, 100, "mouse_panning_deadzone_counterweight", Category::Controls};
linkage, 20, 0, 100, "mouse_panning_deadzone_counterweight", Category::Controls};
Setting<u8, true> mouse_panning_decay_strength{
linkage, 18, 0, 100, "mouse_panning_decay_strength", Category::Controls};
linkage, 18, 0, 100, "mouse_panning_decay_strength", Category::Controls};
Setting<u8, true> mouse_panning_min_decay{
linkage, 6, 0, 100, "mouse_panning_min_decay", Category::Controls};
linkage, 6, 0, 100, "mouse_panning_min_decay", Category::Controls};
Setting<bool> emulate_analog_keyboard{linkage, false, "emulate_analog_keyboard",
Category::Controls};
@ -672,23 +649,22 @@ struct Values {
Setting<bool> dump_exefs{linkage, false, "dump_exefs", Category::Debugging};
Setting<bool> dump_nso{linkage, false, "dump_nso", Category::Debugging};
Setting<bool> dump_shaders{
linkage, false, "dump_shaders", Category::DebuggingGraphics, Specialization::Default,
false};
linkage, false, "dump_shaders", Category::DebuggingGraphics, Specialization::Default,
false};
Setting<bool> dump_macros{
linkage, false, "dump_macros", Category::DebuggingGraphics, Specialization::Default, false};
linkage, false, "dump_macros", Category::DebuggingGraphics, Specialization::Default, false};
Setting<bool> enable_fs_access_log{linkage, false, "enable_fs_access_log", Category::Debugging};
Setting<bool> reporting_services{
linkage, false, "reporting_services", Category::Debugging, Specialization::Default, false};
linkage, false, "reporting_services", Category::Debugging, Specialization::Default, false};
Setting<bool> quest_flag{linkage, false, "quest_flag", Category::Debugging};
Setting<bool> disable_macro_jit{linkage, false, "disable_macro_jit",
Category::DebuggingGraphics};
Setting<bool> disable_macro_hle{linkage, false, "disable_macro_hle",
Category::DebuggingGraphics};
Setting<bool> extended_logging{
linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false};
linkage, false, "extended_logging", Category::Debugging, Specialization::Default, false};
Setting<bool> use_debug_asserts{linkage, false, "use_debug_asserts", Category::Debugging};
Setting<bool> use_auto_stub{
linkage, false, "use_auto_stub", Category::Debugging};
Setting<bool> use_auto_stub{linkage, false, "use_auto_stub", Category::Debugging};
Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
Category::Debugging};
Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};

15
src/common/settings_enums.h
View file

@ -150,19 +150,8 @@ ENUM(FullscreenMode, Borderless, Exclusive);
ENUM(NvdecEmulation, Off, Cpu, Gpu);
ENUM(ResolutionSetup,
Res1_4X,
Res1_2X,
Res3_4X,
Res1X,
Res3_2X,
Res2X,
Res3X,
Res4X,
Res5X,
Res6X,
Res7X,
Res8X);
ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X,
Res7X, Res8X);
ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, ScaleForce, Fsr, Area, MaxEnum);

12
src/common/string_util.cpp
View file

@ -4,9 +4,8 @@
#include <algorithm>
#include <cctype>
#include <codecvt>
#include <locale>
#include <sstream>
#include <boost/locale.hpp>
#include "common/string_util.h"
@ -142,18 +141,15 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
}
std::string UTF16ToUTF8(std::u16string_view input) {
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
return convert.to_bytes(input.data(), input.data() + input.size());
return boost::locale::conv::utf_to_utf<char>(input.data(), input.data() + input.size());
}
std::u16string UTF8ToUTF16(std::string_view input) {
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
return convert.from_bytes(input.data(), input.data() + input.size());
return boost::locale::conv::utf_to_utf<char16_t>(input.data(), input.data() + input.size());
}
std::u32string UTF8ToUTF32(std::string_view input) {
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
return convert.from_bytes(input.data(), input.data() + input.size());
return boost::locale::conv::utf_to_utf<char32_t>(input.data(), input.data() + input.size());
}
#ifdef _WIN32

6
src/common/tree.h
View file

@ -103,9 +103,9 @@ concept IsRBEntry = CheckRBEntry<T>::value;
template <typename T>
concept HasRBEntry = requires(T& t, const T& ct) {
{ t.GetRBEntry() } -> std::same_as<RBEntry<T>&>;
{ ct.GetRBEntry() } -> std::same_as<const RBEntry<T>&>;
};
{ t.GetRBEntry() } -> std::same_as<RBEntry<T>&>;
{ ct.GetRBEntry() } -> std::same_as<const RBEntry<T>&>;
};
template <typename T>
requires HasRBEntry<T>

12
src/common/vector_math.h
View file

@ -362,7 +362,9 @@ public:
// _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
// component names (x<->r) and permutations (xy<->yx)
#define _DEFINE_SWIZZLER2(a, b, name) \
[[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
[[nodiscard]] constexpr Vec2<T> name() const { \
return Vec2<T>(a, b); \
}
#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \
_DEFINE_SWIZZLER2(a, b, a##b); \
_DEFINE_SWIZZLER2(a, b, a2##b2); \
@ -555,7 +557,9 @@ public:
// DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
// permutations (xy<->yx)
#define _DEFINE_SWIZZLER2(a, b, name) \
[[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
[[nodiscard]] constexpr Vec2<T> name() const { \
return Vec2<T>(a, b); \
}
#define DEFINE_SWIZZLER2_COMP1(a, a2) \
_DEFINE_SWIZZLER2(a, a, a##a); \
_DEFINE_SWIZZLER2(a, a, a2##a2)
@ -580,7 +584,9 @@ public:
#undef _DEFINE_SWIZZLER2
#define _DEFINE_SWIZZLER3(a, b, c, name) \
[[nodiscard]] constexpr Vec3<T> name() const { return Vec3<T>(a, b, c); }
[[nodiscard]] constexpr Vec3<T> name() const { \
return Vec3<T>(a, b, c); \
}
#define DEFINE_SWIZZLER3_COMP1(a, a2) \
_DEFINE_SWIZZLER3(a, a, a, a##a##a); \
_DEFINE_SWIZZLER3(a, a, a, a2##a2##a2)

4
src/common/virtual_buffer.h
View file

@ -33,8 +33,8 @@ public:
VirtualBuffer& operator=(const VirtualBuffer&) = delete;
VirtualBuffer(VirtualBuffer&& other) noexcept
: alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
nullptr} {}
: alloc_size{std::exchange(other.alloc_size, 0)},
base_ptr{std::exchange(other.base_ptr), nullptr} {}
VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
alloc_size = std::exchange(other.alloc_size, 0);

4
src/common/x64/native_clock.cpp
View file

@ -8,8 +8,8 @@
namespace Common::X64 {
NativeClock::NativeClock(u64 rdtsc_frequency_)
: rdtsc_frequency{rdtsc_frequency_}, ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den,
rdtsc_frequency)},
: rdtsc_frequency{rdtsc_frequency_},
ns_rdtsc_factor{GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency)},
us_rdtsc_factor{GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency)},
ms_rdtsc_factor{GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency)},
cntpct_rdtsc_factor{GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency)},

3
src/core/arm/arm_interface.cpp
View file

@ -14,7 +14,8 @@ void ArmInterface::LogBacktrace(Kernel::KProcess* process) const {
this->GetContext(ctx);
LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", ctx.sp, ctx.pc);
LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address", "Offset", "Symbol");
LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address",
"Offset", "Symbol");
LOG_ERROR(Core_ARM, "");
const auto backtrace = GetBacktraceFromContext(process, ctx);

4
src/core/arm/dynarmic/arm_dynarmic.cpp
View file

@ -15,7 +15,7 @@ namespace {
thread_local Core::Memory::Memory* g_current_memory{};
std::once_flag g_registered{};
struct sigaction g_old_segv {};
struct sigaction g_old_segv{};
void HandleSigSegv(int sig, siginfo_t* info, void* ctx) {
if (g_current_memory && g_current_memory->InvalidateSeparateHeap(info->si_addr)) {
@ -37,7 +37,7 @@ ScopedJitExecution::~ScopedJitExecution() {
void ScopedJitExecution::RegisterHandler() {
std::call_once(g_registered, [] {
struct sigaction sa {};
struct sigaction sa{};
sa.sa_sigaction = &HandleSigSegv;
sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
Common::SigAction(SIGSEGV, std::addressof(sa), std::addressof(g_old_segv));

13
src/core/arm/dynarmic/arm_dynarmic_32.cpp
View file

@ -19,8 +19,8 @@ using namespace Common::Literals;
class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
public:
explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process)
: m_parent{parent}, m_memory(process->GetMemory()),
m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
: m_parent{parent}, m_memory(process->GetMemory()), m_process(process),
m_debugger_enabled{parent.m_system.DebuggerEnabled()},
m_check_memory_access{m_debugger_enabled ||
!Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
@ -195,11 +195,12 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
config.only_detect_misalignment_via_page_table_on_page_boundary = true;
config.fastmem_pointer = page_table->fastmem_arena ?
std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)} :
std::nullopt;
config.fastmem_pointer =
page_table->fastmem_arena
? std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)}
: std::nullopt;
config.fastmem_exclusive_access = config.fastmem_pointer != std::nullopt;
config.fastmem_exclusive_access = config.fastmem_pointer != std::nullopt;
config.recompile_on_exclusive_fastmem_failure = true;
}

11
src/core/arm/dynarmic/arm_dynarmic_64.cpp
View file

@ -19,8 +19,8 @@ using namespace Common::Literals;
class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
public:
explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process)
: m_parent{parent}, m_memory(process->GetMemory()),
m_process(process), m_debugger_enabled{parent.m_system.DebuggerEnabled()},
: m_parent{parent}, m_memory(process->GetMemory()), m_process(process),
m_debugger_enabled{parent.m_system.DebuggerEnabled()},
m_check_memory_access{m_debugger_enabled ||
!Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
@ -242,9 +242,10 @@ std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* pa
config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
config.only_detect_misalignment_via_page_table_on_page_boundary = true;
config.fastmem_pointer = page_table->fastmem_arena ?
std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)} :
std::nullopt;
config.fastmem_pointer =
page_table->fastmem_arena
? std::optional<uintptr_t>{reinterpret_cast<uintptr_t>(page_table->fastmem_arena)}
: std::nullopt;
config.fastmem_address_space_bits = std::uint32_t(address_space_bits);
config.silently_mirror_fastmem = false;

30
src/core/arm/nce/arm_nce.cpp
View file

@ -302,7 +302,7 @@ void ArmNce::Initialize() {
sigaddset(&signal_mask, GuestAlignmentFaultSignal);
sigaddset(&signal_mask, GuestAccessFaultSignal);
struct sigaction return_to_run_code_action {};
struct sigaction return_to_run_code_action{};
return_to_run_code_action.sa_flags = SA_SIGINFO | SA_ONSTACK;
return_to_run_code_action.sa_sigaction = reinterpret_cast<HandlerType>(
&ArmNce::ReturnToRunCodeByExceptionLevelChangeSignalHandler);
@ -310,21 +310,21 @@ void ArmNce::Initialize() {
Common::SigAction(ReturnToRunCodeByExceptionLevelChangeSignal, &return_to_run_code_action,
nullptr);
struct sigaction break_from_run_code_action {};
struct sigaction break_from_run_code_action{};
break_from_run_code_action.sa_flags = SA_SIGINFO | SA_ONSTACK;
break_from_run_code_action.sa_sigaction =
reinterpret_cast<HandlerType>(&ArmNce::BreakFromRunCodeSignalHandler);
break_from_run_code_action.sa_mask = signal_mask;
Common::SigAction(BreakFromRunCodeSignal, &break_from_run_code_action, nullptr);
struct sigaction alignment_fault_action {};
struct sigaction alignment_fault_action{};
alignment_fault_action.sa_flags = SA_SIGINFO | SA_ONSTACK;
alignment_fault_action.sa_sigaction =
reinterpret_cast<HandlerType>(&ArmNce::GuestAlignmentFaultSignalHandler);
alignment_fault_action.sa_mask = signal_mask;
Common::SigAction(GuestAlignmentFaultSignal, &alignment_fault_action, nullptr);
struct sigaction access_fault_action {};
struct sigaction access_fault_action{};
access_fault_action.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESTART;
access_fault_action.sa_sigaction =
reinterpret_cast<HandlerType>(&ArmNce::GuestAccessFaultSignalHandler);
@ -405,19 +405,19 @@ void ArmNce::ClearInstructionCache() {
}
void ArmNce::InvalidateCacheRange(u64 addr, std::size_t size) {
#if defined(__GNUC__) || defined(__clang__)
// Align the start address to cache line boundary for better performance
const size_t CACHE_LINE_SIZE = 64;
addr &= ~(CACHE_LINE_SIZE - 1);
#if defined(__GNUC__) || defined(__clang__)
// Align the start address to cache line boundary for better performance
const size_t CACHE_LINE_SIZE = 64;
addr &= ~(CACHE_LINE_SIZE - 1);
// Round up size to nearest cache line
size = (size + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1);
// Round up size to nearest cache line
size = (size + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1);
// Prefetch the range to be invalidated
for (size_t offset = 0; offset < size; offset += CACHE_LINE_SIZE) {
__builtin_prefetch((void*)(addr + offset), 1, 3);
}
#endif
// Prefetch the range to be invalidated
for (size_t offset = 0; offset < size; offset += CACHE_LINE_SIZE) {
__builtin_prefetch((void*)(addr + offset), 1, 3);
}
#endif
this->ClearInstructionCache();
}

2
src/core/arm/nce/interpreter_visitor.cpp
View file

@ -10,7 +10,7 @@ namespace Core {
namespace {
// Prefetch tuning parameters
constexpr size_t CACHE_LINE_SIZE = 64;
constexpr size_t PREFETCH_STRIDE = 128; // 2 cache lines ahead
constexpr size_t PREFETCH_STRIDE = 128; // 2 cache lines ahead
constexpr size_t SIMD_PREFETCH_THRESHOLD = 32; // Bytes
} // namespace

63
src/core/arm/nce/lru_cache.h
View file

@ -13,28 +13,34 @@
template <typename KeyType, typename ValueType>
class LRUCache {
public:
using key_type = KeyType;
using key_type = KeyType;
using value_type = ValueType;
using size_type = std::size_t;
using size_type = std::size_t;
struct Statistics {
size_type hits = 0;
size_type hits = 0;
size_type misses = 0;
void reset() noexcept { hits = misses = 0; }
void reset() noexcept {
hits = misses = 0;
}
};
explicit LRUCache(size_type capacity, bool enabled = true)
: enabled_{enabled}, capacity_{capacity} {
cache_map_.reserve(capacity_);
LOG_WARNING(Core, "LRU Cache initialised (state: {} | capacity: {})", enabled_ ? "enabled" : "disabled", capacity_);
LOG_WARNING(Core, "LRU Cache initialised (state: {} | capacity: {})",
enabled_ ? "enabled" : "disabled", capacity_);
}
// Non-movable copy semantics
LRUCache(const LRUCache&) = delete;
LRUCache(const LRUCache&) = delete;
LRUCache& operator=(const LRUCache&) = delete;
LRUCache(LRUCache&& other) noexcept { *this = std::move(other); }
LRUCache(LRUCache&& other) noexcept {
*this = std::move(other);
}
LRUCache& operator=(LRUCache&& other) noexcept {
if (this == &other) return *this;
if (this == &other)
return *this;
std::unique_lock this_lock(mutex_, std::defer_lock);
std::unique_lock other_lock(other.mutex_, std::defer_lock);
std::lock(this_lock, other_lock);
@ -48,7 +54,8 @@ public:
~LRUCache() = default;
[[nodiscard]] value_type* get(const key_type& key) {
if (!enabled_) [[unlikely]] return nullptr;
if (!enabled_) [[unlikely]]
return nullptr;
std::unique_lock lock(mutex_);
auto it = cache_map_.find(key);
if (it == cache_map_.end()) {
@ -61,7 +68,8 @@ public:
}
[[nodiscard]] value_type* peek(const key_type& key) const {
if (!enabled_) [[unlikely]] return nullptr;
if (!enabled_) [[unlikely]]
return nullptr;
std::shared_lock lock(mutex_);
auto it = cache_map_.find(key);
return it == cache_map_.end() ? nullptr : &it->second.second;
@ -69,7 +77,8 @@ public:
template <typename V>
void put(const key_type& key, V&& value) {
if (!enabled_) [[unlikely]] return;
if (!enabled_) [[unlikely]]
return;
std::unique_lock lock(mutex_);
insert_or_update(key, std::forward<V>(value));
}
@ -88,16 +97,19 @@ public:
}
[[nodiscard]] bool contains(const key_type& key) const {
if (!enabled_) return false;
if (!enabled_)
return false;
std::shared_lock lock(mutex_);
return cache_map_.find(key) != cache_map_.end();
}
bool erase(const key_type& key) {
if (!enabled_) return false;
if (!enabled_)
return false;
std::unique_lock lock(mutex_);
auto it = cache_map_.find(key);
if (it == cache_map_.end()) return false;
if (it == cache_map_.end())
return false;
cache_list_.erase(it->second.first);
cache_map_.erase(it);
return true;
@ -111,15 +123,19 @@ public:
}
[[nodiscard]] size_type size() const {
if (!enabled_) return 0;
if (!enabled_)
return 0;
std::shared_lock lock(mutex_);
return cache_map_.size();
}
[[nodiscard]] size_type get_capacity() const { return capacity_; }
[[nodiscard]] size_type get_capacity() const {
return capacity_;
}
void resize(size_type new_capacity) {
if (!enabled_) return;
if (!enabled_)
return;
std::unique_lock lock(mutex_);
capacity_ = new_capacity;
shrink_if_needed();
@ -130,10 +146,13 @@ public:
std::unique_lock lock(mutex_);
enabled_ = state;
LOG_WARNING(Core, "LRU Cache state changed to: {}", state ? "enabled" : "disabled");
if (!enabled_) clear();
if (!enabled_)
clear();
}
[[nodiscard]] bool isEnabled() const { return enabled_; }
[[nodiscard]] bool isEnabled() const {
return enabled_;
}
[[nodiscard]] Statistics stats() const {
std::shared_lock lock(mutex_);
@ -141,10 +160,10 @@ public:
}
private:
using list_type = std::list<key_type>;
using list_iterator = typename list_type::iterator;
using list_type = std::list<key_type>;
using list_iterator = typename list_type::iterator;
using map_value_type = std::pair<list_iterator, value_type>;
using map_type = std::unordered_map<key_type, map_value_type>;
using map_type = std::unordered_map<key_type, map_value_type>;
template <typename V>
void insert_or_update(const key_type& key, V&& value) {

13
src/core/arm/nce/patcher.cpp
View file

@ -16,21 +16,16 @@ namespace Core::NCE {
Patcher::Patcher(Patcher&& other) noexcept
: patch_cache(std::move(other.patch_cache)),
m_patch_instructions(std::move(other.m_patch_instructions)),
c(m_patch_instructions),
m_save_context(other.m_save_context),
m_load_context(other.m_load_context),
mode(other.mode),
m_patch_instructions(std::move(other.m_patch_instructions)), c(m_patch_instructions),
m_save_context(other.m_save_context), m_load_context(other.m_load_context), mode(other.mode),
total_program_size(other.total_program_size),
m_relocate_module_index(other.m_relocate_module_index),
modules(std::move(other.modules)),
m_relocate_module_index(other.m_relocate_module_index), modules(std::move(other.modules)),
curr_patch(nullptr) {
if (!modules.empty()) {
curr_patch = &modules.back();
}
}
using namespace Common::Literals;
using namespace oaknut::util;
@ -41,7 +36,7 @@ constexpr u32 ModuleCodeIndex = 0x24 / sizeof(u32);
Patcher::Patcher() : c(m_patch_instructions) {
LOG_WARNING(Core_ARM, "Patcher initialized with LRU cache {}",
patch_cache.isEnabled() ? "enabled" : "disabled");
patch_cache.isEnabled() ? "enabled" : "disabled");
// The first word of the patch section is always a branch to the first instruction of the
// module.
c.dw(0);

13
src/core/arm/nce/patcher.h
View file

@ -9,13 +9,13 @@
#include <oaknut/code_block.hpp>
#include <oaknut/oaknut.hpp>
#include <utility>
#include "common/common_types.h"
#include "common/settings.h"
#include "core/hle/kernel/code_set.h"
#include "core/hle/kernel/k_typed_address.h"
#include "core/hle/kernel/physical_memory.h"
#include "lru_cache.h"
#include <utility>
namespace Core::NCE {
@ -67,8 +67,9 @@ private:
void WriteCntpctHandler(ModuleDestLabel module_dest, oaknut::XReg dest_reg);
private:
static constexpr size_t CACHE_SIZE = 16384; // Cache size for patch entries
LRUCache<uintptr_t, PatchTextAddress> patch_cache{CACHE_SIZE, Settings::values.lru_cache_enabled.GetValue()};
static constexpr size_t CACHE_SIZE = 16384; // Cache size for patch entries
LRUCache<uintptr_t, PatchTextAddress> patch_cache{
CACHE_SIZE, Settings::values.lru_cache_enabled.GetValue()};
void BranchToPatch(uintptr_t module_dest) {
if (patch_cache.isEnabled()) {
@ -79,14 +80,16 @@ private:
curr_patch->m_branch_to_patch_relocations.push_back({c.offset(), *cached_patch});
return;
}
LOG_DEBUG(Core_ARM, "LRU cache miss for address {:#x}, creating new patch", module_dest);
LOG_DEBUG(Core_ARM, "LRU cache miss for address {:#x}, creating new patch",
module_dest);
// If not in cache, create new entry and cache it
const auto patch_addr = c.offset();
curr_patch->m_branch_to_patch_relocations.push_back({patch_addr, module_dest});
patch_cache.put(module_dest, patch_addr);
} else {
LOG_DEBUG(Core_ARM, "LRU cache disabled - creating direct patch for address {:#x}", module_dest);
LOG_DEBUG(Core_ARM, "LRU cache disabled - creating direct patch for address {:#x}",
module_dest);
// LRU disabled - use pre-LRU approach
curr_patch->m_branch_to_patch_relocations.push_back({c.offset(), module_dest});
}

34
src/core/core_timing.cpp
View file

@ -17,8 +17,8 @@
#include "common/x64/cpu_wait.h"
#endif
#include "common/settings.h"
#include "common/microprofile.h"
#include "common/settings.h"
#include "core/core_timing.h"
#include "core/hardware_properties.h"
@ -176,8 +176,8 @@ void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
void CoreTiming::AddTicks(u64 ticks_to_add) {
cpu_ticks = Settings::values.use_custom_cpu_ticks.GetValue()
? Settings::values.cpu_ticks.GetValue()
: cpu_ticks + ticks_to_add;
? Settings::values.cpu_ticks.GetValue()
: cpu_ticks + ticks_to_add;
downcount -= static_cast<s64>(cpu_ticks);
}
@ -193,22 +193,22 @@ u64 CoreTiming::GetClockTicks() const {
u64 fres;
if (is_multicore) [[likely]] {
fres = clock->GetCNTPCT();
} else {
fres = Common::WallClock::CPUTickToCNTPCT(cpu_ticks);
}
} else {
fres = Common::WallClock::CPUTickToCNTPCT(cpu_ticks);
}
if (Settings::values.use_fast_cpu_time) {
fres = (u64) ((double) fres
* (1.7 + 0.3 * (u32) Settings::values.fast_cpu_time.GetValue()));
}
if (Settings::values.use_fast_cpu_time) {
fres = (u64)((double)fres * (1.7 + 0.3 * (u32)Settings::values.fast_cpu_time.GetValue()));
}
if (Settings::values.sync_core_speed.GetValue()) {
const double ticks = static_cast<double>(fres);
const double speed_limit = static_cast<double>(Settings::values.speed_limit.GetValue())*0.01;
return static_cast<u64>(ticks/speed_limit);
} else {
return fres;
}
if (Settings::values.sync_core_speed.GetValue()) {
const double ticks = static_cast<double>(fres);
const double speed_limit =
static_cast<double>(Settings::values.speed_limit.GetValue()) * 0.01;
return static_cast<u64>(ticks / speed_limit);
} else {
return fres;
}
}
u64 CoreTiming::GetGPUTicks() const {

4
src/core/file_sys/card_image.cpp
View file

@ -29,8 +29,8 @@ constexpr std::array partition_names{
XCI::XCI(VirtualFile file_, u64 program_id, size_t program_index)
: file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
partitions(partition_names.size()),
partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
partitions(partition_names.size()), partitions_raw(partition_names.size()),
keys{Core::Crypto::KeyManager::Instance()} {
const auto header_status = TryReadHeader();
if (header_status != Loader::ResultStatus::Success) {
status = header_status;

11
src/core/file_sys/fs_path_utility.h
View file

@ -87,12 +87,15 @@ private:
u32 m_value;
public:
constexpr PathFlags() : m_value(0) { /* ... */
}
constexpr PathFlags() : m_value(0) { /* ... */ }
#define DECLARE_PATH_FLAG_HANDLER(__WHICH__) \
constexpr bool Is##__WHICH__##Allowed() const { return (m_value & __WHICH__##Flag) != 0; } \
constexpr void Allow##__WHICH__() { m_value |= __WHICH__##Flag; }
constexpr bool Is##__WHICH__##Allowed() const { \
return (m_value & __WHICH__##Flag) != 0; \
} \
constexpr void Allow##__WHICH__() { \
m_value |= __WHICH__##Flag; \
}
DECLARE_PATH_FLAG_HANDLER(WindowsPath)
DECLARE_PATH_FLAG_HANDLER(RelativePath)

22
src/core/file_sys/fssystem/fssystem_integrity_verification_storage.cpp
View file

@ -4,23 +4,18 @@
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "core/file_sys/fssystem/fssystem_integrity_verification_storage.h"
#include "common/alignment.h"
#include "core/file_sys/fssystem/fssystem_integrity_verification_storage.h"
namespace FileSys {
constexpr inline u32 ILog2(u32 val)
{
constexpr inline u32 ILog2(u32 val) {
ASSERT(val > 0);
return static_cast<u32>((sizeof(u32) * 8) - 1 - std::countl_zero<u32>(val));
}
void IntegrityVerificationStorage::Initialize(VirtualFile hs,
VirtualFile ds,
s64 verif_block_size,
s64 upper_layer_verif_block_size,
bool is_real_data)
{
void IntegrityVerificationStorage::Initialize(VirtualFile hs, VirtualFile ds, s64 verif_block_size,
s64 upper_layer_verif_block_size, bool is_real_data) {
// Validate preconditions.
ASSERT(verif_block_size >= HashSize);
@ -54,14 +49,12 @@ void IntegrityVerificationStorage::Initialize(VirtualFile hs,
m_is_real_data = is_real_data;
}
void IntegrityVerificationStorage::Finalize()
{
void IntegrityVerificationStorage::Finalize() {
m_hash_storage = VirtualFile();
m_data_storage = VirtualFile();
}
size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset) const
{
size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset) const {
// Succeed if zero size.
if (size == 0) {
return size;
@ -104,8 +97,7 @@ size_t IntegrityVerificationStorage::Read(u8* buffer, size_t size, size_t offset
return m_data_storage->Read(buffer, read_size, offset);
}
size_t IntegrityVerificationStorage::GetSize() const
{
size_t IntegrityVerificationStorage::GetSize() const {
return m_data_storage->GetSize();
}

4
src/core/file_sys/registered_cache.cpp
View file

@ -790,7 +790,9 @@ InstallResult RegisteredCache::RawInstallNCA(const NCA& nca, const VfsCopyFuncti
if (GetFileAtID(id) != nullptr) {
LOG_WARNING(Loader, "Overwriting existing NCA...");
VirtualDir c_dir;
{ c_dir = dir->GetFileRelative(path)->GetContainingDirectory(); }
{
c_dir = dir->GetFileRelative(path)->GetContainingDirectory();
}
c_dir->DeleteFile(Common::FS::GetFilename(path));
}

4
src/core/file_sys/sdmc_factory.cpp
View file

@ -15,9 +15,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
: sd_dir(std::move(sd_dir_)), sd_mod_dir(std::move(sd_mod_dir_)),
contents(std::make_unique<RegisteredCache>(
GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/registered"),
[](const VirtualFile& file, const NcaID& id) {
return NAX{file, id}.GetDecrypted();
})),
[](const VirtualFile& file, const NcaID& id) { return NAX{file, id}.GetDecrypted(); })),
placeholder(std::make_unique<PlaceholderCache>(
GetOrCreateDirectoryRelative(sd_dir, "/Nintendo/Contents/placehld"))) {}

6
src/core/file_sys/submission_package.cpp
View file

@ -19,9 +19,9 @@
namespace FileSys {
NSP::NSP(VirtualFile file_, u64 title_id_, std::size_t program_index_)
: file(std::move(file_)), expected_program_id(title_id_),
program_index(program_index_), status{Loader::ResultStatus::Success},
pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
: file(std::move(file_)), expected_program_id(title_id_), program_index(program_index_),
status{Loader::ResultStatus::Success}, pfs(std::make_shared<PartitionFilesystem>(file)),
keys{Core::Crypto::KeyManager::Instance()} {
if (pfs->GetStatus() != Loader::ResultStatus::Success) {
status = pfs->GetStatus();
return;

8
src/core/file_sys/xts_archive.cpp
View file

@ -44,8 +44,8 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
}
NAX::NAX(VirtualFile file_)
: header(std::make_unique<NAXHeader>()),
file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
: header(std::make_unique<NAXHeader>()), file(std::move(file_)),
keys{Core::Crypto::KeyManager::Instance()} {
std::string path = Common::FS::SanitizePath(file->GetFullPath());
static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
std::regex_constants::ECMAScript |
@ -62,8 +62,8 @@ NAX::NAX(VirtualFile file_)
}
NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
: header(std::make_unique<NAXHeader>()),
file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
: header(std::make_unique<NAXHeader>()), file(std::move(file_)),
keys{Core::Crypto::KeyManager::Instance()} {
Core::Crypto::SHA256Hash hash{};
mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0);
status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],

16
src/core/hle/kernel/k_auto_object.h
View file

@ -24,7 +24,9 @@ private:
friend class ::Kernel::KClassTokenGenerator; \
static constexpr inline auto ObjectType = ::Kernel::KClassTokenGenerator::ObjectType::CLASS; \
static constexpr inline const char* const TypeName = #CLASS; \
static constexpr inline ClassTokenType ClassToken() { return ::Kernel::ClassToken<CLASS>; } \
static constexpr inline ClassTokenType ClassToken() { \
return ::Kernel::ClassToken<CLASS>; \
} \
\
public: \
YUZU_NON_COPYABLE(CLASS); \
@ -35,9 +37,15 @@ public:
constexpr ClassTokenType Token = ClassToken(); \
return TypeObj(TypeName, Token); \
} \
static constexpr const char* GetStaticTypeName() { return TypeName; } \
virtual TypeObj GetTypeObj() ATTRIBUTE { return GetStaticTypeObj(); } \
virtual const char* GetTypeName() ATTRIBUTE { return GetStaticTypeName(); } \
static constexpr const char* GetStaticTypeName() { \
return TypeName; \
} \
virtual TypeObj GetTypeObj() ATTRIBUTE { \
return GetStaticTypeObj(); \
} \
virtual const char* GetTypeName() ATTRIBUTE { \
return GetStaticTypeName(); \
} \
\
private: \
constexpr bool operator!=(const TypeObj& rhs)

4
src/core/hle/kernel/k_memory_layout.cpp
View file

@ -128,8 +128,8 @@ KVirtualAddress KMemoryRegionTree::GetRandomAlignedRegion(size_t size, size_t al
KMemoryLayout::KMemoryLayout()
: m_virtual_tree{m_memory_region_allocator}, m_physical_tree{m_memory_region_allocator},
m_virtual_linear_tree{m_memory_region_allocator}, m_physical_linear_tree{
m_memory_region_allocator} {}
m_virtual_linear_tree{m_memory_region_allocator},
m_physical_linear_tree{m_memory_region_allocator} {}
void KMemoryLayout::InitializeLinearMemoryRegionTrees(KPhysicalAddress aligned_linear_phys_start,
KVirtualAddress linear_virtual_start) {

48
src/core/hle/kernel/k_priority_queue.h
View file

@ -17,38 +17,32 @@ namespace Kernel {
class KThread;
template <typename T>
concept KPriorityQueueAffinityMask = !
std::is_reference_v<T>&& requires(T& t) {
{ t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
{ t.SetAffinityMask(0) };
concept KPriorityQueueAffinityMask = !std::is_reference_v<T> && requires(T& t) {
{ t.GetAffinityMask() } -> Common::ConvertibleTo<u64>;
{ t.SetAffinityMask(0) };
{ t.GetAffinity(0) } -> std::same_as<bool>;
{ t.SetAffinity(0, false) };
{ t.SetAll() };
};
{ t.GetAffinity(0) } -> std::same_as<bool>;
{ t.SetAffinity(0, false) };
{ t.SetAll() };
};
template <typename T>
concept KPriorityQueueMember = !
std::is_reference_v<T>&& requires(T& t) {
{ typename T::QueueEntry() };
{ (typename T::QueueEntry()).Initialize() };
{ (typename T::QueueEntry()).SetPrev(std::addressof(t)) };
{ (typename T::QueueEntry()).SetNext(std::addressof(t)) };
{ (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
{ (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
{
t.GetPriorityQueueEntry(0)
} -> std::same_as<typename T::QueueEntry&>;
concept KPriorityQueueMember = !std::is_reference_v<T> && requires(T& t) {
{ typename T::QueueEntry() };
{ (typename T::QueueEntry()).Initialize() };
{ (typename T::QueueEntry()).SetPrev(std::addressof(t)) };
{ (typename T::QueueEntry()).SetNext(std::addressof(t)) };
{ (typename T::QueueEntry()).GetNext() } -> std::same_as<T*>;
{ (typename T::QueueEntry()).GetPrev() } -> std::same_as<T*>;
{ t.GetPriorityQueueEntry(0) } -> std::same_as<typename T::QueueEntry&>;
{ t.GetAffinityMask() };
{
std::remove_cvref_t<decltype(t.GetAffinityMask())>()
} -> KPriorityQueueAffinityMask;
{ t.GetAffinityMask() };
{ std::remove_cvref_t<decltype(t.GetAffinityMask())>() } -> KPriorityQueueAffinityMask;
{ t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
{ t.GetPriority() } -> Common::ConvertibleTo<s32>;
{ t.IsDummyThread() } -> Common::ConvertibleTo<bool>;
};
{ t.GetActiveCore() } -> Common::ConvertibleTo<s32>;
{ t.GetPriority() } -> Common::ConvertibleTo<s32>;
{ t.IsDummyThread() } -> Common::ConvertibleTo<bool>;
};
template <typename Member, size_t NumCores_, int LowestPriority, int HighestPriority>
requires KPriorityQueueMember<Member>

2
src/core/hle/kernel/k_process.h
View file

@ -84,7 +84,7 @@ private:
std::array<u64, 4> m_entropy{};
bool m_is_signaled{};
bool m_is_initialized{};
u32 m_pointer_buffer_size = 0x8000; // Default pointer buffer size (can be game-specific later)
u32 m_pointer_buffer_size = 0x8000; // Default pointer buffer size (can be game-specific later)
bool m_is_application{};
bool m_is_default_application_system_resource{};
bool m_is_hbl{};

9
src/core/hle/kernel/k_scoped_lock.h
View file

@ -10,11 +10,10 @@
namespace Kernel {
template <typename T>
concept KLockable = !
std::is_reference_v<T>&& requires(T& t) {
{ t.Lock() } -> std::same_as<void>;
{ t.Unlock() } -> std::same_as<void>;
};
concept KLockable = !std::is_reference_v<T> && requires(T& t) {
{ t.Lock() } -> std::same_as<void>;
{ t.Unlock() } -> std::same_as<void>;
};
template <typename T>
requires KLockable<T>

8
src/core/hle/result.h
View file

@ -458,9 +458,13 @@ constexpr inline Result __TmpCurrentResultReference = ResultSuccess;
if (true)
#define R_CONVERT(catch_type, convert_type) \
R_CATCH(catch_type) { R_THROW(static_cast<Result>(convert_type)); }
R_CATCH(catch_type) { \
R_THROW(static_cast<Result>(convert_type)); \
}
#define R_CONVERT_ALL(convert_type) \
R_CATCH_ALL() { R_THROW(static_cast<Result>(convert_type)); }
R_CATCH_ALL() { \
R_THROW(static_cast<Result>(convert_type)); \
}
#define R_ASSERT(res_expr) ASSERT(R_SUCCEEDED(res_expr))

1
src/core/hle/service/acc/profile_manager.cpp
View file

@ -496,5 +496,4 @@ void ProfileManager::SetUserPosition(u64 position, Common::UUID uuid) {
WriteUserSaveFile();
}
}; // namespace Service::Account

4
src/core/hle/service/am/applet.cpp
View file

@ -26,7 +26,7 @@ void Applet::UpdateSuspensionStateLocked(bool force_message) {
// Remove any forced resumption.
lifecycle_manager.RemoveForceResumeIfPossible();
const bool update_requested_focus_state = lifecycle_manager.UpdateRequestedFocusState();
const bool update_requested_focus_state = lifecycle_manager.UpdateRequestedFocusState();
const bool curr_activity_runnable = lifecycle_manager.IsRunnable();
const bool prev_activity_runnable = is_activity_runnable;
const bool was_changed = curr_activity_runnable != prev_activity_runnable;
@ -36,7 +36,7 @@ void Applet::UpdateSuspensionStateLocked(bool force_message) {
process->Suspend(false);
} else {
process->Suspend(true);
lifecycle_manager.RequestResumeNotification();
lifecycle_manager.RequestResumeNotification();
}
is_activity_runnable = curr_activity_runnable;

5
src/core/hle/service/am/frontend/applet_cabinet.cpp
View file

@ -18,9 +18,8 @@ namespace Service::AM::Frontend {
Cabinet::Cabinet(Core::System& system_, std::shared_ptr<Applet> applet_,
LibraryAppletMode applet_mode_, const Core::Frontend::CabinetApplet& frontend_)
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_}, service_context{
system_,
"CabinetApplet"} {
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_},
service_context{system_, "CabinetApplet"} {
availability_change_event =
service_context.CreateEvent("CabinetApplet:AvailabilityChangeEvent");

4
src/core/hle/service/am/frontend/applet_net_connect.cpp
View file

@ -15,7 +15,9 @@
namespace Service::AM::Frontend {
NetConnect::NetConnect(Core::System& system_, std::shared_ptr<Applet> applet_, LibraryAppletMode applet_mode_, const Core::Frontend::NetConnectApplet& frontend_)
NetConnect::NetConnect(Core::System& system_, std::shared_ptr<Applet> applet_,
LibraryAppletMode applet_mode_,
const Core::Frontend::NetConnectApplet& frontend_)
: FrontendApplet{system_, applet_, applet_mode_}, frontend{frontend_} {}
NetConnect::~NetConnect() = default;

4
src/core/hle/service/am/frontend/applet_net_connect.h
View file

@ -14,8 +14,8 @@ namespace Service::AM::Frontend {
class NetConnect final : public FrontendApplet {
public:
explicit NetConnect(Core::System& system_, std::shared_ptr<Applet> applet_,
LibraryAppletMode applet_mode_,
const Core::Frontend::NetConnectApplet& frontend_);
LibraryAppletMode applet_mode_,
const Core::Frontend::NetConnectApplet& frontend_);
~NetConnect() override;
void Initialize() override;

3
src/core/hle/service/am/frontend/applets.cpp
View file

@ -85,7 +85,8 @@ FrontendAppletSet::FrontendAppletSet(CabinetApplet cabinet_applet,
MiiEdit mii_edit_,
ParentalControlsApplet parental_controls_applet,
PhotoViewer photo_viewer_, ProfileSelect profile_select_,
SoftwareKeyboard software_keyboard_, WebBrowser web_browser_, NetConnect net_connect_)
SoftwareKeyboard software_keyboard_, WebBrowser web_browser_,
NetConnect net_connect_)
: cabinet{std::move(cabinet_applet)}, controller{std::move(controller_applet)},
error{std::move(error_applet)}, mii_edit{std::move(mii_edit_)},
parental_controls{std::move(parental_controls_applet)},

2
src/core/hle/service/am/frontend/applets.h
View file

@ -10,8 +10,8 @@
#include <queue>
#include "common/swap.h"
#include "core/hle/service/am/applet.h"
#include "core/frontend/applets/net_connect.h"
#include "core/hle/service/am/applet.h"
union Result;

2
src/core/hle/service/am/process_creation.cpp
View file

@ -106,7 +106,7 @@ std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control,
out_control = nacp.GetRawBytes();
} else {
out_control.resize(sizeof(FileSys::RawNACP));
std::fill(out_control.begin(), out_control.end(), (u8) 0);
std::fill(out_control.begin(), out_control.end(), (u8)0);
}
auto& storage = system.GetContentProviderUnion();

4
src/core/hle/service/am/service/application_proxy.cpp
View file

@ -18,8 +18,8 @@ namespace Service::AM {
IApplicationProxy::IApplicationProxy(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process, WindowSystem& window_system)
: ServiceFramework{system_, "IApplicationProxy"},
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
: ServiceFramework{system_, "IApplicationProxy"}, m_window_system{window_system},
m_process{process}, m_applet{std::move(applet)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IApplicationProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

2
src/core/hle/service/am/service/display_controller.h
View file

@ -20,7 +20,7 @@ public:
private:
Result GetLastForegroundCaptureImageEx(Out<bool> out_was_written,
OutBuffer<BufferAttr_HipcMapAlias> out_image_data);
OutBuffer<BufferAttr_HipcMapAlias> out_image_data);
Result GetCallerAppletCaptureImageEx(Out<bool> out_was_written,
OutBuffer<BufferAttr_HipcMapAlias> out_image_data);
Result TakeScreenShotOfOwnLayer(bool unknown0, s32 fbshare_layer_index);

12
src/core/hle/service/am/service/library_applet_accessor.cpp
View file

@ -101,12 +101,12 @@ Result ILibraryAppletAccessor::PushInData(SharedPointer<IStorage> storage) {
Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_storage) {
LOG_DEBUG(Service_AM, "called");
if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
Event m_system_event = caller_applet->lifecycle_manager.GetSystemEvent();
m_system_event.Signal();
caller_applet->lifecycle_manager.RequestResumeNotification();
m_system_event.Clear();
}
if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
Event m_system_event = caller_applet->lifecycle_manager.GetSystemEvent();
m_system_event.Signal();
caller_applet->lifecycle_manager.RequestResumeNotification();
m_system_event.Clear();
}
R_RETURN(m_broker->GetOutData().Pop(out_storage.Get()));
}

4
src/core/hle/service/am/service/library_applet_creator.cpp
View file

@ -167,8 +167,8 @@ std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& syste
ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_ptr<Applet> applet,
WindowSystem& window_system)
: ServiceFramework{system_, "ILibraryAppletCreator"},
m_window_system{window_system}, m_applet{std::move(applet)} {
: ServiceFramework{system_, "ILibraryAppletCreator"}, m_window_system{window_system},
m_applet{std::move(applet)} {
static const FunctionInfo functions[] = {
{0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
{1, nullptr, "TerminateAllLibraryApplets"},

4
src/core/hle/service/am/service/library_applet_proxy.cpp
View file

@ -20,8 +20,8 @@ namespace Service::AM {
ILibraryAppletProxy::ILibraryAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process, WindowSystem& window_system)
: ServiceFramework{system_, "ILibraryAppletProxy"},
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
: ServiceFramework{system_, "ILibraryAppletProxy"}, m_window_system{window_system},
m_process{process}, m_applet{std::move(applet)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&ILibraryAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

4
src/core/hle/service/am/service/self_controller.cpp
View file

@ -16,8 +16,8 @@ namespace Service::AM {
ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process)
: ServiceFramework{system_, "ISelfController"}, m_process{process}, m_applet{
std::move(applet)} {
: ServiceFramework{system_, "ISelfController"}, m_process{process},
m_applet{std::move(applet)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&ISelfController::Exit>, "Exit"},

4
src/core/hle/service/am/service/system_applet_proxy.cpp
View file

@ -20,8 +20,8 @@ namespace Service::AM {
ISystemAppletProxy::ISystemAppletProxy(Core::System& system_, std::shared_ptr<Applet> applet,
Kernel::KProcess* process, WindowSystem& window_system)
: ServiceFramework{system_, "ISystemAppletProxy"},
m_window_system{window_system}, m_process{process}, m_applet{std::move(applet)} {
: ServiceFramework{system_, "ISystemAppletProxy"}, m_window_system{window_system},
m_process{process}, m_applet{std::move(applet)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&ISystemAppletProxy::GetCommonStateGetter>, "GetCommonStateGetter"},

4
src/core/hle/service/am/service/window_controller.cpp
View file

@ -11,8 +11,8 @@ namespace Service::AM {
IWindowController::IWindowController(Core::System& system_, std::shared_ptr<Applet> applet,
WindowSystem& window_system)
: ServiceFramework{system_, "IWindowController"},
m_window_system{window_system}, m_applet{std::move(applet)} {
: ServiceFramework{system_, "IWindowController"}, m_window_system{window_system},
m_applet{std::move(applet)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, nullptr, "CreateWindow"},

4
src/core/hle/service/aoc/purchase_event_manager.cpp
View file

@ -9,8 +9,8 @@ namespace Service::AOC {
constexpr Result ResultNoPurchasedProductInfoAvailable{ErrorModule::NIMShop, 400};
IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
: ServiceFramework{system_, "IPurchaseEventManager"}, service_context{system,
"IPurchaseEventManager"} {
: ServiceFramework{system_, "IPurchaseEventManager"},
service_context{system, "IPurchaseEventManager"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},

5
src/core/hle/service/audio/audio_in.cpp
View file

@ -12,9 +12,8 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
const std::string& device_name, const AudioInParameter& in_params,
Kernel::KProcess* handle, u64 applet_resource_user_id)
: ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
manager, event,
session_id)} {
event{service_context.CreateEvent("AudioInEvent")},
impl{std::make_shared<In>(system_, manager, event, session_id)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IAudioIn::GetAudioInState>, "GetAudioInState"},

4
src/core/hle/service/audio/audio_in_manager.cpp
View file

@ -10,8 +10,8 @@ namespace Service::Audio {
using namespace AudioCore::AudioIn;
IAudioInManager::IAudioInManager(Core::System& system_)
: ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
system_)} {
: ServiceFramework{system_, "audin:u"},
impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IAudioInManager::ListAudioIns>, "ListAudioIns"},

4
src/core/hle/service/audio/audio_renderer.cpp
View file

@ -14,8 +14,8 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
s32 session_id)
: ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
process_handle_} {
impl{std::make_unique<Renderer>(system_, manager, rendered_event)},
process_handle{process_handle_} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},

5
src/core/hle/service/bcat/news/newly_arrived_event_holder.cpp
View file

@ -7,9 +7,8 @@
namespace Service::News {
INewlyArrivedEventHolder::INewlyArrivedEventHolder(Core::System& system_)
: ServiceFramework{system_, "INewlyArrivedEventHolder"}, service_context{
system_,
"INewlyArrivedEventHolder"} {
: ServiceFramework{system_, "INewlyArrivedEventHolder"},
service_context{system_, "INewlyArrivedEventHolder"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&INewlyArrivedEventHolder::Get>, "Get"},

4
src/core/hle/service/bcat/news/overwrite_event_holder.cpp
View file

@ -7,8 +7,8 @@
namespace Service::News {
IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
: ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
"IOverwriteEventHolder"} {
: ServiceFramework{system_, "IOverwriteEventHolder"},
service_context{system_, "IOverwriteEventHolder"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IOverwriteEventHolder::Get>, "Get"},

4
src/core/hle/service/filesystem/fsp/fs_i_filesystem.cpp
View file

@ -11,8 +11,8 @@
namespace Service::FileSystem {
IFileSystem::IFileSystem(Core::System& system_, FileSys::VirtualDir dir_, SizeGetter size_getter_)
: ServiceFramework{system_, "IFileSystem"}, backend{std::make_unique<FileSys::Fsa::IFileSystem>(
dir_)},
: ServiceFramework{system_, "IFileSystem"},
backend{std::make_unique<FileSys::Fsa::IFileSystem>(dir_)},
size_getter{std::move(size_getter_)} {
static const FunctionInfo functions[] = {
{0, D<&IFileSystem::CreateFile>, "CreateFile"},

4
src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp
View file

@ -12,8 +12,8 @@ namespace Service::FileSystem {
ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
std::shared_ptr<SaveDataController> save_data_controller_,
FileSys::SaveDataSpaceId space)
: ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
save_data_controller_} {
: ServiceFramework{system_, "ISaveDataInfoReader"},
save_data_controller{save_data_controller_} {
static const FunctionInfo functions[] = {
{0, D<&ISaveDataInfoReader::ReadSaveDataInfo>, "ReadSaveDataInfo"},
};

4
src/core/hle/service/glue/time/alarm_worker.cpp
View file

@ -11,8 +11,8 @@
namespace Service::Glue::Time {
AlarmWorker::AlarmWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource)
: m_system{system}, m_ctx{system, "Glue:AlarmWorker"}, m_steady_clock_resource{
steady_clock_resource} {}
: m_system{system}, m_ctx{system, "Glue:AlarmWorker"},
m_steady_clock_resource{steady_clock_resource} {}
AlarmWorker::~AlarmWorker() {
m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);

6
src/core/hle/service/glue/time/manager.cpp
View file

@ -87,10 +87,8 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
}
TimeManager::TimeManager(Core::System& system)
: m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
system,
m_steady_clock_resource,
m_file_timestamp_worker} {
: m_steady_clock_resource{system}, m_time_zone_binary{system},
m_worker{system, m_steady_clock_resource, m_file_timestamp_worker} {
m_time_m =
system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);

6
src/core/hle/service/glue/time/time_zone.cpp
View file

@ -22,9 +22,9 @@ TimeZoneService::TimeZoneService(
std::shared_ptr<Service::PSC::Time::TimeZoneService> time_zone_service)
: ServiceFramework{system_, "ITimeZoneService"}, m_system{system},
m_can_write_timezone_device_location{can_write_timezone_device_location},
m_file_timestamp_worker{file_timestamp_worker}, m_wrapped_service{std::move(
time_zone_service)},
m_operation_event{m_system}, m_time_zone_binary{time_zone_binary} {
m_file_timestamp_worker{file_timestamp_worker},
m_wrapped_service{std::move(time_zone_service)}, m_operation_event{m_system},
m_time_zone_binary{time_zone_binary} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&TimeZoneService::GetDeviceLocationName>, "GetDeviceLocationName"},

8
src/core/hle/service/glue/time/worker.cpp
View file

@ -19,11 +19,11 @@ namespace Service::Glue::Time {
TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
FileTimestampWorker& file_timestamp_worker)
: m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
"Glue:TimeWorker:Event")},
: m_system{system}, m_ctx{m_system, "Glue:TimeWorker"},
m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")},
m_steady_clock_resource{steady_clock_resource},
m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
"Glue:TimeWorker:SteadyClockTimerEvent")},
m_file_timestamp_worker{file_timestamp_worker},
m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")},
m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(

4
src/core/hle/service/hid/hid_debug_server.cpp
View file

@ -17,8 +17,8 @@ namespace Service::HID {
IHidDebugServer::IHidDebugServer(Core::System& system_, std::shared_ptr<ResourceManager> resource,
std::shared_ptr<HidFirmwareSettings> settings)
: ServiceFramework{system_, "hid:dbg"}, resource_manager{resource}, firmware_settings{
settings} {
: ServiceFramework{system_, "hid:dbg"}, resource_manager{resource},
firmware_settings{settings} {
// clang-format off
static const FunctionInfo functions[] = {
{0, nullptr, "DeactivateDebugPad"},

6
src/core/hle/service/hid/hid_server.cpp
View file

@ -587,10 +587,8 @@ Result IHidServer::ActivateGesture(u32 basic_gesture_id, ClientAppletResourceUse
Result IHidServer::SetGestureOutputRanges(u32 param1, u32 param2, u32 param3, u32 param4) {
// https://switchbrew.org/wiki/HID_services , Undocumented. 92 [18.0.0+] SetGestureOutputRanges
LOG_WARNING(
Service_HID,
"(STUBBED) called, param1={}, param2={}, param3={}, param4={}",
param1, param2, param3, param4);
LOG_WARNING(Service_HID, "(STUBBED) called, param1={}, param2={}, param3={}, param4={}", param1,
param2, param3, param4);
R_SUCCEED();
}

4
src/core/hle/service/ipc_helpers.h
View file

@ -72,8 +72,8 @@ public:
u32 num_handles_to_copy_ = 0, u32 num_objects_to_move_ = 0,
Flags flags = Flags::None)
: RequestHelperBase(ctx), normal_params_size(normal_params_size_),
num_handles_to_copy(num_handles_to_copy_),
num_objects_to_move(num_objects_to_move_), kernel{ctx.kernel} {
num_handles_to_copy(num_handles_to_copy_), num_objects_to_move(num_objects_to_move_),
kernel{ctx.kernel} {
memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);

4
src/core/hle/service/jit/jit_context.cpp
View file

@ -40,8 +40,8 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
public:
explicit DynarmicCallbacks64(Core::Memory::Memory& memory_, std::vector<u8>& local_memory_,
IntervalSet& mapped_ranges_, JITContextImpl& parent_)
: memory{memory_}, local_memory{local_memory_},
mapped_ranges{mapped_ranges_}, parent{parent_} {}
: memory{memory_}, local_memory{local_memory_}, mapped_ranges{mapped_ranges_},
parent{parent_} {}
u8 MemoryRead8(u64 vaddr) override {
return ReadMemory<u8>(vaddr);

2
src/core/hle/service/ldn/lan_discovery.cpp
View file

@ -37,7 +37,7 @@ void LanStation::OverrideInfo() {
}
LANDiscovery::LANDiscovery()
: stations({{{1, this}, {2, this}, {3, this}, {4, this}, {5, this}, {6, this}, {7, this}}}){}
: stations({{{1, this}, {2, this}, {3, this}, {4, this}, {5, this}, {6, this}, {7, this}}}) {}
LANDiscovery::~LANDiscovery() {
if (inited) {

3
src/core/hle/service/ldn/user_local_communication_service.cpp
View file

@ -24,8 +24,7 @@ namespace Service::LDN {
IUserLocalCommunicationService::IUserLocalCommunicationService(Core::System& system_)
: ServiceFramework{system_, "IUserLocalCommunicationService"},
service_context{system, "IUserLocalCommunicationService"},
lan_discovery{} {
service_context{system, "IUserLocalCommunicationService"}, lan_discovery{} {
// clang-format off
static const FunctionInfo functions[] = {
{0, C<&IUserLocalCommunicationService::GetState>, "GetState"},

4
src/core/hle/service/mii/mii.cpp
View file

@ -23,8 +23,8 @@ class IDatabaseService final : public ServiceFramework<IDatabaseService> {
public:
explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager,
bool is_system_)
: ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager}, is_system{
is_system_} {
: ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager},
is_system{is_system_} {
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IDatabaseService::IsUpdated>, "IsUpdated"},

26
src/core/hle/service/nifm/nifm.cpp
View file

@ -67,7 +67,6 @@ static u128 MakeUuidFromName(std::string_view name) {
return {h1, h2};
}
// This is nn::nifm::RequestState
enum class RequestState : u32 {
NotSubmitted = 1,
@ -217,7 +216,6 @@ struct PendingProfile {
std::array<char, 0x41> passphrase{};
};
constexpr Result ResultPendingConnection{ErrorModule::NIFM, 111};
constexpr Result ResultInvalidInput{ErrorModule::NIFM, 112};
constexpr Result ResultNetworkCommunicationDisabled{ErrorModule::NIFM, 1111};
@ -278,8 +276,7 @@ private:
IPC::ResponseBuilder{ctx, 2}.Push(ResultSuccess);
}
void IsProcessing(HLERequestContext& ctx)
{
void IsProcessing(HLERequestContext& ctx) {
const bool processing = state.load() == State::Processing;
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess);
@ -306,7 +303,7 @@ private:
enum class State { Idle, Processing, Finished };
void WorkerThread() {
void WorkerThread() {
using namespace std::chrono_literals;
scan_results = Network::ScanWifiNetworks(3s);
@ -321,7 +318,6 @@ private:
Finish(ok ? ResultSuccess : ResultPendingConnection);
}
void Finish(Result rc) {
worker_result.store(rc);
state.store(State::Finished);
@ -665,8 +661,9 @@ void IGeneralService::GetNetworkProfile(HLERequestContext& ctx) {
std::memcpy(net_name.data(), net_state.ssid, ssid_len);
SfWirelessSettingData wifi{};
wifi.ssid_length = static_cast<u8>(std::min<size_t>(std::strlen(net_state.ssid), net_name.size()));
wifi.is_secured = !net_state.secure; //somehow reversed
wifi.ssid_length =
static_cast<u8>(std::min<size_t>(std::strlen(net_state.ssid), net_name.size()));
wifi.is_secured = !net_state.secure; // somehow reversed
wifi.passphrase = {"password"};
std::memcpy(wifi.ssid.data(), net_state.ssid, wifi.ssid_length);
@ -693,11 +690,10 @@ void IGeneralService::GetNetworkProfile(HLERequestContext& ctx) {
.uuid{MakeUuidFromName(net_state.ssid)},
.network_name{net_name},
.profile_type = static_cast<u8>(NetworkProfileType::User),
.interface_type =
static_cast<u8>(net_iface->kind ==
Network::HostAdapterKind::Wifi ? NetworkInterfaceType::WiFi_Ieee80211 : NetworkInterfaceType::Ethernet),
.wireless_setting_data{wifi}
};
.interface_type = static_cast<u8>(net_iface->kind == Network::HostAdapterKind::Wifi
? NetworkInterfaceType::WiFi_Ieee80211
: NetworkInterfaceType::Ethernet),
.wireless_setting_data{wifi}};
}();
ctx.WriteBuffer(profile);
@ -732,7 +728,6 @@ void IGeneralService::SetNetworkProfile(HLERequestContext& ctx) {
IPC::ResponseBuilder{ctx, 2}.Push(ResultSuccess);
}
void IGeneralService::RemoveNetworkProfile(HLERequestContext& ctx) {
LOG_WARNING(Service_NIFM, "(STUBBED) called");
@ -759,7 +754,6 @@ void IGeneralService::GetScanDataV2(HLERequestContext& ctx) {
const std::size_t max_rows = guest_bytes / sizeof(AccessPointDataV3);
const std::size_t rows_copy = std::min<std::size_t>(scans.size(), max_rows);
std::vector<AccessPointDataV3> rows;
rows.resize(rows_copy);
@ -776,7 +770,7 @@ void IGeneralService::GetScanDataV2(HLERequestContext& ctx) {
ap.strength = to_bars(s.quality);
bool is_connected = std::strncmp(net_state.ssid, ap.ssid, ap.ssid_len) == 0 &&
net_state.ssid[ap.ssid_len] == '\0';
net_state.ssid[ap.ssid_len] == '\0';
ap.visible = (is_connected) ? 0 : 1;
ap.has_password = (s.flags & 2) ? 2 : 1;

3
src/core/hle/service/ns/application_manager_interface.cpp
View file

@ -315,7 +315,8 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
IApplicationManagerInterface::~IApplicationManagerInterface() = default;
Result IApplicationManagerInterface::UnregisterNetworkServiceAccountWithUserSaveDataDeletion(Common::UUID user_id) {
Result IApplicationManagerInterface::UnregisterNetworkServiceAccountWithUserSaveDataDeletion(
Common::UUID user_id) {
LOG_DEBUG(Service_NS, "called, user_id={}", user_id.FormattedString());
R_SUCCEED();
}

4
src/core/hle/service/ns/dynamic_rights_interface.cpp
View file

@ -63,8 +63,8 @@ Result IDynamicRightsInterface::VerifyActivatedRightsOwners(u64 rights_handle) {
R_SUCCEED();
}
Result IDynamicRightsInterface::HasAccountRestrictedRightsInRunningApplications(
Out<u32> out_status, u64 rights_handle) {
Result IDynamicRightsInterface::HasAccountRestrictedRightsInRunningApplications(Out<u32> out_status,
u64 rights_handle) {
LOG_WARNING(Service_NS, "(STUBBED) called, rights_handle={:#x}", rights_handle);
*out_status = 0;
R_SUCCEED();

3
src/core/hle/service/ns/dynamic_rights_interface.h
View file

@ -20,8 +20,7 @@ private:
Result NotifyApplicationRightsCheckStart();
Result GetRunningApplicationStatus(Out<u32> out_status, u64 rights_handle);
Result VerifyActivatedRightsOwners(u64 rights_handle);
Result HasAccountRestrictedRightsInRunningApplications(Out<u32> out_status,
u64 rights_handle);
Result HasAccountRestrictedRightsInRunningApplications(Out<u32> out_status, u64 rights_handle);
};
} // namespace Service::NS

2
src/core/hle/service/nvdrv/core/syncpoint_manager.h
View file

@ -97,7 +97,7 @@ public:
0x0, // `Display` is unimplemented
0x37, // `NvJpg`
0x0, // `TSec` is unimplemented
}; //!< Maps each channel ID to a constant syncpoint
}; //!< Maps each channel ID to a constant syncpoint
private:
/**

Some files were not shown because too many files have changed in this diff Show more