Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-04-10 07:38:56 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

sysconf stub cuz crash(?) + some stderrp stuff

Browse source
This commit is contained in:
lizzie 2025-12-01 09:33:59 +00:00
parent b02e0ccc76
commit a58b1e975e
14 changed files with 506 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -130,6 +130,10 @@ public:
ASSERT(!eden_path.empty());
eden_path_cache = eden_path / CACHE_DIR;
eden_path_config = eden_path / CONFIG_DIR;
#elif defined(__OPENORBIS__)
eden_path = "/data/eden";
eden_path_cache = eden_path / CACHE_DIR;
eden_path_config = eden_path / CONFIG_DIR;
#else
eden_path = GetCurrentDir() / PORTABLE_DIR;
if (!Exists(eden_path) || !IsDir(eden_path)) {

7
src/common/host_memory.cpp
View file

@ -495,9 +495,12 @@ class HostMemory::Impl {
public:
explicit Impl(size_t backing_size_, size_t virtual_size_)
: backing_size{backing_size_}, virtual_size{virtual_size_} {
#ifdef __OPENORBIS__
#else
long page_size = sysconf(_SC_PAGESIZE);
ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging",
page_size);
ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging", page_size);
#endif
// Backing memory initialization
#if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);

4
src/common/memory_detect.cpp
View file

@ -43,7 +43,9 @@ static MemoryInfo Detect() {
sysctlbyname("vm.swapusage", &vmusage, &sizeof_vmusage, nullptr, 0);
mem_info.TotalPhysicalMemory = ramsize;
mem_info.TotalSwapMemory = vmusage.xsu_total;
#elif defined(__FreeBSD__) && !defined(__OPENORBIS__)
#elif defined(__OPENORBIS__)
mem_info.TotalPhysicalMemory = mem_info.TotalSwapMemory = 0;
#elif defined(__FreeBSD__)
u_long physmem, swap_total;
std::size_t sizeof_u_long = sizeof(u_long);
// sysctlbyname(const char *, void *, size_t *, const void *, size_t);

13
src/input_common/drivers/joycon.cpp
View file

@ -23,12 +23,14 @@ Joycons::Joycons(const std::string& input_engine_) : InputEngine(input_engine_)
return;
}
LOG_INFO(Input, "Joycon driver Initialization started");
const int init_res = SDL_hid_init();
if (init_res == 0) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
int const res = SDL_hid_init();
if (res == 0) {
Setup();
} else {
LOG_ERROR(Input, "Hidapi could not be initialized. failed with error = {}", init_res);
LOG_ERROR(Input, "Hidapi could not be initialized. failed with error = {}", res);
}
#endif
}
Joycons::~Joycons() {
@ -55,7 +57,9 @@ void Joycons::Reset() {
}
device->Stop();
}
#if SDL_VERSION_ATLEAST(2, 26, 4)
SDL_hid_exit();
#endif
}
void Joycons::Setup() {
@ -80,9 +84,9 @@ void Joycons::Setup() {
}
void Joycons::ScanThread(std::stop_token stop_token) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
constexpr u16 nintendo_vendor_id = 0x057e;
Common::SetCurrentThreadName("JoyconScanThread");
do {
SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
SDL_hid_device_info* cur_dev = devs;
@ -98,6 +102,7 @@ void Joycons::ScanThread(std::stop_token stop_token) {
SDL_hid_free_enumeration(devs);
} while (Common::StoppableTimedWait(stop_token, std::chrono::seconds{5}));
#endif
}
bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {

9
src/input_common/drivers/joycon.h
View file

@ -6,7 +6,14 @@
#include <array>
#include <span>
#include <thread>
#include <SDL_hidapi.h>
#include <SDL.h>
#if SDL_VERSION_ATLEAST(2, 26, 4)
# include <SDL_hidapi.h>
#else
struct SDL_hid_device;
struct SDL_hid_device_info;
#endif
#include "input_common/input_engine.h"

39
src/input_common/drivers/sdl_driver.cpp
View file

@ -42,6 +42,7 @@ public:
}
void EnableMotion() {
#if SDL_VERSION_ATLEAST(2, 26, 4)
if (!sdl_controller) {
return;
}
@ -58,12 +59,14 @@ public:
if (has_gyro) {
SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
}
#endif
}
bool HasMotion() const {
return has_gyro || has_accel;
}
#if SDL_VERSION_ATLEAST(2, 26, 4)
bool UpdateMotion(SDL_ControllerSensorEvent event) {
constexpr float gravity_constant = 9.80665f;
std::scoped_lock lock{mutex};
@ -105,6 +108,7 @@ public:
motion.delta_timestamp = time_difference * 1000;
return true;
}
#endif
const BasicMotion& GetMotion() const {
return motion;
@ -149,13 +153,15 @@ public:
}
bool HasHDRumble() const {
#if SDL_VERSION_ATLEAST(2, 26, 4)
if (sdl_controller) {
const auto type = SDL_GameControllerGetType(sdl_controller.get());
auto const type = SDL_GameControllerGetType(sdl_controller.get());
return (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO) ||
(type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT) ||
(type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT) ||
(type == SDL_CONTROLLER_TYPE_PS5);
}
#endif
return false;
}
@ -252,26 +258,21 @@ public:
}
std::string GetControllerName() const {
#if SDL_VERSION_ATLEAST(2, 26, 4)
if (sdl_controller) {
switch (SDL_GameControllerGetType(sdl_controller.get())) {
case SDL_CONTROLLER_TYPE_XBOX360:
return "Xbox 360 Controller";
case SDL_CONTROLLER_TYPE_XBOXONE:
return "Xbox One Controller";
case SDL_CONTROLLER_TYPE_PS3:
return "DualShock 3 Controller";
case SDL_CONTROLLER_TYPE_PS4:
return "DualShock 4 Controller";
case SDL_CONTROLLER_TYPE_PS5:
return "DualSense Controller";
case SDL_CONTROLLER_TYPE_XBOX360: return "Xbox 360 Controller";
case SDL_CONTROLLER_TYPE_XBOXONE: return "Xbox One Controller";
case SDL_CONTROLLER_TYPE_PS3: return "DualShock 3 Controller";
case SDL_CONTROLLER_TYPE_PS4: return "DualShock 4 Controller";
case SDL_CONTROLLER_TYPE_PS5: return "DualSense Controller";
default:
if (auto const name = SDL_GameControllerName(sdl_controller.get()); name)
return name;
break;
}
const auto name = SDL_GameControllerName(sdl_controller.get());
if (name) {
return name;
}
}
#endif
if (sdl_joystick) {
const auto name = SDL_JoystickName(sdl_joystick.get());
@ -456,6 +457,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
}
break;
}
#if SDL_VERSION_ATLEAST(2, 26, 4)
case SDL_CONTROLLERSENSORUPDATE: {
if (auto joystick = GetSDLJoystickBySDLID(event.csensor.which)) {
if (joystick->UpdateMotion(event.csensor)) {
@ -472,6 +474,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
}
break;
}
#endif
case SDL_JOYDEVICEREMOVED:
LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
CloseJoystick(SDL_JoystickFromInstanceID(event.jdevice.which));
@ -489,6 +492,7 @@ void SDLDriver::CloseJoysticks() {
}
SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
// Set our application name. Currently passed to DBus by SDL and visible to the user through
// their desktop environment.
SDL_SetHint(SDL_HINT_APP_NAME, "Eden");
@ -529,6 +533,7 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
// Disable hidapi driver for xbox. Already default on Windows, this causes conflict with native
// driver on Linux.
SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX, "0");
#endif
// If the frontend is going to manage the event loop, then we don't start one here
start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0;
@ -833,6 +838,7 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
auto slr_button = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
auto srr_button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
#if SDL_VERSION_ATLEAST(2, 26, 4)
if (joystick->IsJoyconLeft()) {
sll_button = SDL_CONTROLLER_BUTTON_PADDLE2;
srl_button = SDL_CONTROLLER_BUTTON_PADDLE4;
@ -841,6 +847,7 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
slr_button = SDL_CONTROLLER_BUTTON_PADDLE3;
srr_button = SDL_CONTROLLER_BUTTON_PADDLE1;
}
#endif
return {
std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_B},
@ -862,7 +869,9 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
{Settings::NativeButton::SLRight, slr_button},
{Settings::NativeButton::SRRight, srr_button},
{Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
#if SDL_VERSION_ATLEAST(2, 26, 4)
{Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1},
#endif
};
}

35
src/input_common/helpers/joycon_driver.cpp
View file

@ -38,8 +38,8 @@ Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_inf
return Common::Input::DriverResult::UnsupportedControllerType;
}
hidapi_handle->handle =
SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
#if SDL_VERSION_ATLEAST(2, 26, 4)
hidapi_handle->handle = SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
std::memcpy(&handle_serial_number, device_info->serial_number, 15);
if (!hidapi_handle->handle) {
LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
@ -48,6 +48,9 @@ Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_inf
}
SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
return Common::Input::DriverResult::Success;
#else
return Common::Input::DriverResult::UnsupportedControllerType;
#endif
}
Common::Input::DriverResult JoyconDriver::InitializeDevice() {
@ -138,8 +141,6 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
Common::SetCurrentThreadName("JoyconInput");
input_thread_running = true;
// Max update rate is 5ms, ensure we are always able to read a bit faster
constexpr int ThreadDelay = 3;
std::vector<u8> buffer(MaxBufferSize);
while (!stop_token.stop_requested()) {
@ -150,14 +151,17 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
continue;
}
#if SDL_VERSION_ATLEAST(2, 26, 4)
// Max update rate is 5ms, ensure we are always able to read a bit faster
int constexpr thread_delay = 3;
// By disabling the input thread we can ensure custom commands will succeed as no package is
// skipped
if (!disable_input_thread) {
status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(),
ThreadDelay);
status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(), thread_delay);
} else {
std::this_thread::sleep_for(std::chrono::milliseconds(ThreadDelay));
std::this_thread::sleep_for(std::chrono::milliseconds(thread_delay));
}
#endif
if (IsPayloadCorrect(status, buffer)) {
OnNewData(buffer);
@ -690,19 +694,18 @@ void JoyconDriver::SetCallbacks(const JoyconCallbacks& callbacks) {
joycon_poller->SetCallbacks(callbacks);
}
Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
ControllerType& controller_type) {
Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info, ControllerType& controller_type) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
static constexpr std::array<std::pair<u32, ControllerType>, 6> supported_devices{
std::pair<u32, ControllerType>{0x2006, ControllerType::Left},
{0x2007, ControllerType::Right},
{0x2009, ControllerType::Pro},
};
constexpr u16 nintendo_vendor_id = 0x057e;
constexpr u16 nintendo_vendor_id = 0x057e;
controller_type = ControllerType::None;
if (device_info->vendor_id != nintendo_vendor_id) {
if (device_info->vendor_id != nintendo_vendor_id)
return Common::Input::DriverResult::UnsupportedControllerType;
}
for (const auto& [product_id, type] : supported_devices) {
if (device_info->product_id == static_cast<u16>(product_id)) {
@ -710,16 +713,20 @@ Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* dev
return Common::Input::DriverResult::Success;
}
}
#endif
return Common::Input::DriverResult::UnsupportedControllerType;
}
Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info,
SerialNumber& serial_number) {
Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info, SerialNumber& serial_number) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
if (device_info->serial_number == nullptr) {
return Common::Input::DriverResult::Unknown;
}
std::memcpy(&serial_number, device_info->serial_number, 15);
return Common::Input::DriverResult::Success;
#else
return Common::Input::DriverResult::Unknown;
#endif
}
} // namespace InputCommon::Joycon

52
src/input_common/helpers/joycon_protocol/common_protocol.cpp
View file

@ -15,11 +15,15 @@ u8 JoyconCommonProtocol::GetCounter() {
}
void JoyconCommonProtocol::SetBlocking() {
#if SDL_VERSION_ATLEAST(2, 26, 4)
SDL_hid_set_nonblocking(hidapi_handle->handle, 0);
#endif
}
void JoyconCommonProtocol::SetNonBlocking() {
#if SDL_VERSION_ATLEAST(2, 26, 4)
SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
#endif
}
Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type) {
@ -35,26 +39,23 @@ Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType&
return result;
}
Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(
SDL_hid_device_info* device_info) {
Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device_info) {
ControllerType controller_type{ControllerType::None};
const auto result = GetDeviceType(controller_type);
if (result != Common::Input::DriverResult::Success || controller_type == ControllerType::None) {
return Common::Input::DriverResult::UnsupportedControllerType;
}
hidapi_handle->handle =
SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
#if SDL_VERSION_ATLEAST(2, 26, 4)
hidapi_handle->handle = SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
if (!hidapi_handle->handle) {
LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
device_info->vendor_id, device_info->product_id);
LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.", device_info->vendor_id, device_info->product_id);
return Common::Input::DriverResult::HandleInUse;
}
SetNonBlocking();
return Common::Input::DriverResult::Success;
#else
return Common::Input::DriverResult::UnsupportedControllerType;
#endif
}
Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode report_mode) {
@ -63,21 +64,21 @@ Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode repor
}
Common::Input::DriverResult JoyconCommonProtocol::SendRawData(std::span<const u8> buffer) {
const auto result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
if (result == -1) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
auto const result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
if (result == -1)
return Common::Input::DriverResult::ErrorWritingData;
}
return Common::Input::DriverResult::Success;
#else
return Common::Input::DriverResult::ErrorWritingData;
#endif
}
Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(
SubCommand sc, SubCommandResponse& output) {
Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc, SubCommandResponse& output) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
constexpr int timeout_mili = 66;
constexpr int MaxTries = 10;
int tries = 0;
do {
int result = SDL_hid_read_timeout(hidapi_handle->handle, reinterpret_cast<u8*>(&output),
sizeof(SubCommandResponse), timeout_mili);
@ -88,9 +89,8 @@ Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(
if (tries++ > MaxTries) {
return Common::Input::DriverResult::Timeout;
}
} while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY &&
output.sub_command != sc);
} while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY && output.sub_command != sc);
#endif
return Common::Input::DriverResult::Success;
}
@ -218,12 +218,11 @@ Common::Input::DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig&
return result;
}
Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode,
MCUCommandResponse& output) {
Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, MCUCommandResponse& output) {
#if SDL_VERSION_ATLEAST(2, 26, 4)
constexpr int TimeoutMili = 200;
constexpr int MaxTries = 9;
int tries = 0;
do {
int result = SDL_hid_read_timeout(hidapi_handle->handle, reinterpret_cast<u8*>(&output),
sizeof(MCUCommandResponse), TimeoutMili);
@ -234,9 +233,8 @@ Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode
if (tries++ > MaxTries) {
return Common::Input::DriverResult::Timeout;
}
} while (output.input_report.report_mode != report_mode ||
output.mcu_report == MCUReport::EmptyAwaitingCmd);
} while (output.input_report.report_mode != report_mode || output.mcu_report == MCUReport::EmptyAwaitingCmd);
#endif
return Common::Input::DriverResult::Success;
}

9
src/input_common/helpers/joycon_protocol/joycon_types.h
View file

@ -10,7 +10,14 @@
#include <array>
#include <functional>
#include <SDL_hidapi.h>
#include <SDL.h>
#if SDL_VERSION_ATLEAST(2, 26, 4)
# include <SDL_hidapi.h>
#else
struct SDL_hid_device;
struct SDL_hid_device_info;
#endif
#include "common/bit_field.h"
#include "common/common_funcs.h"

3
src/yuzu_cmd/CMakeLists.txt
View file

@ -42,7 +42,8 @@ target_link_libraries(yuzu-cmd PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
create_resource("../../dist/eden.bmp" "yuzu_cmd/yuzu_icon.h" "yuzu_icon")
target_include_directories(yuzu-cmd PRIVATE ${RESOURCES_DIR})
target_link_libraries(yuzu-cmd PRIVATE SDL2::SDL2)
target_include_directories(yuzu-cmd PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
target_link_libraries(yuzu-cmd PRIVATE SDL2)
if(UNIX AND NOT APPLE)
install(TARGETS yuzu-cmd)

1
src/yuzu_cmd/yuzu.cpp
View file

@ -59,6 +59,7 @@ STUB_WEAK(ZSTD_trace_compress_begin)
STUB_WEAK(ZSTD_trace_compress_end)
STUB_WEAK(ZSTD_trace_decompress_begin)
STUB_WEAK(ZSTD_trace_decompress_end)
FILE* __stderrp = stdout;
# undef STUB_WEAK
#endif
#ifdef _WIN32