2026-09-12 01:12:32

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/common/error.cpp

@@ -24,7 +24,7 @@ std::string NativeErrorToString(int e) {
     DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                    FORMAT_MESSAGE_IGNORE_INSERTS,
                                nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               LPSTR(&err_str), 1, nullptr);
+                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
     if (!res) {
         return "(FormatMessageA failed to format error)";
     }
@@ -32,10 +32,9 @@ std::string NativeErrorToString(int e) {
     LocalFree(err_str);
     return ret;
 #else
-    char err_str[256];
-    // See https://github.com/llvm/llvm-project/blob/c8fdb5f8b93c3e1da5e2ff3ba8b18627d6147b51/openmp/runtime/src/kmp_i18n.cpp#L711
-    // musl doesn't provide a macro gate but defines strerror_r() even if _GNU_SOURCE is defined
-#if defined(__managarm__) || (defined(__GLIBC__) || defined(__BIONIC__)) || defined(_GNU_SOURCE)
+    char err_str[255];
+#if defined(__ANDROID__) ||                                                                            \
+    (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600)))
     // Thread safe (GNU-specific)
     const char* str = strerror_r(e, err_str, sizeof(err_str));
     return std::string(str);

src/core/CMakeLists.txt

@@ -796,8 +796,6 @@ add_library(core STATIC
     hle/service/ns/application_manager_interface.h
     hle/service/ns/application_version_interface.cpp
     hle/service/ns/application_version_interface.h
-    hle/service/ns/async_result.cpp
-    hle/service/ns/async_result.h
     hle/service/ns/content_management_interface.cpp
     hle/service/ns/content_management_interface.h
     hle/service/ns/develop_interface.cpp
@@ -812,6 +810,8 @@ add_library(core STATIC
     hle/service/ns/ecommerce_interface.h
     hle/service/ns/factory_reset_interface.cpp
     hle/service/ns/factory_reset_interface.h
+    hle/service/ns/i_async_result.cpp
+    hle/service/ns/i_async_result.h
     hle/service/ns/language.cpp
     hle/service/ns/language.h
     hle/service/ns/ns.cpp

src/core/frontend/applets/controller.cpp

@@ -12,7 +12,6 @@
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
-#include <array>
 
 namespace Core::Frontend {
 
@@ -30,39 +29,23 @@ void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callbac
 
     const std::size_t min_supported_players =
         parameters.enable_single_mode ? 1 : parameters.min_players;
-    using Core::HID::NpadStyleIndex;
-    const std::size_t max_supported_players = parameters.enable_single_mode ? 1 : parameters.max_players;
-    std::size_t num_selected_players = 0;
-    std::array<bool, HID::HIDCore::available_controllers> keep_connected{};
 
-    // reserve existing AND valid players before filling slots. include Handheld, but not other
-    for (std::size_t index = 0; index < hid_core.available_controllers - 1; ++index) {
-        const auto* controller = hid_core.GetEmulatedControllerByIndex(index);
-        if (!parameters.keep_controllers_connected || !controller->IsConnected() || num_selected_players >= max_supported_players) continue;
-
-        const auto style = controller->GetNpadStyleIndex();
-        keep_connected[index] =
-            (style == NpadStyleIndex::Fullkey && parameters.allow_pro_controller) ||
-            (style == NpadStyleIndex::JoyconDual && parameters.allow_dual_joycons) ||
-            (style == NpadStyleIndex::JoyconLeft && parameters.allow_left_joycon) ||
-            (style == NpadStyleIndex::JoyconRight && parameters.allow_right_joycon) ||
-            (style == NpadStyleIndex::Handheld && parameters.enable_single_mode && parameters.allow_handheld && !Settings::IsDockedMode()) ||
-            (style == NpadStyleIndex::GameCube && parameters.allow_gamecube_controller);
-        num_selected_players += keep_connected[index];
-    }
+    // Disconnect Handheld first.
     auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
-    if (!keep_connected[hid_core.available_controllers - 2]) handheld->Disconnect();
+    handheld->Disconnect();
 
     // Deduce the best configuration based on the input parameters.
     for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
         auto* controller = hid_core.GetEmulatedControllerByIndex(index);
 
-        if (keep_connected[index]) continue;
+        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
+        // This makes it easy to connect the desired controllers.
         controller->Disconnect();
 
-        // only add players still needed to reach the minimum
-        if (num_selected_players >= min_supported_players) continue;
-        ++num_selected_players;
+        // Only connect the minimum number of required players.
+        if (index >= min_supported_players) {
+            continue;
+        }
 
         // Connect controllers based on the following priority list from highest to lowest priority:
         // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld

src/core/hle/service/ns/application_manager_interface.h

@@ -7,7 +7,7 @@
 #pragma once
 
 #include "core/hle/service/cmif_types.h"
-#include "core/hle/service/ns/async_result.h"
+#include "core/hle/service/ns/i_async_result.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/os/event.h"

src/core/hle/service/ns/i_async_result.cpp

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ns/async_result.h"
+#include "core/hle/service/ns/i_async_result.h"
 
 #include <cstring>
 
@@ -32,4 +32,4 @@ Result IAsyncResult::Cancel() {
     R_SUCCEED();
 }
 
-} // namespace Service::NS
+} // namespace Service::NS

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -311,30 +311,27 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
         // u64 - app count
         memory.WriteBlock(t_mem_address + out_length, &app_count, sizeof(u64));
         out_length += sizeof(u64);
-        ASSERT(out_length <= t_mem->GetSize());
         // [list of u64] - size of icons
         for (size_t i = 0; i < app_count; ++i) {
             const u64 app_id = app_ids_buffer[i];
             const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                u64 full_size = control.second->GetSize();
-                memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
-            }
+            const auto control = pm.GetControlMetadata();
+            u64 full_size = control.second->GetSize();
+            memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
             out_length += sizeof(u64);
-            ASSERT(out_length <= t_mem->GetSize());
         }
         // [list of raw icon data]
+        std::vector<u8> full_icon_data;
         for (size_t i = 0; i < app_count; ++i) {
             const u64 app_id = app_ids_buffer[i];
             const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                if (auto const full_size = control.second->GetSize(); full_size > 0) {
-                    std::vector<u8> full_icon_data(full_size);
-                    control.second->Read(full_icon_data.data(), full_size, 0);
-                    memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
-                    out_length += full_size;
-                    ASSERT(out_length <= t_mem->GetSize());
-                }
+            const auto control = pm.GetControlMetadata();
+            auto const full_size = control.second->GetSize();
+            if (full_size > 0) {
+                full_icon_data.resize(full_size);
+                control.second->Read(full_icon_data.data(), full_size, 0);
+                memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
+                out_length += full_size;
             }
         }
     }
@@ -348,12 +345,6 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
 void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
     const auto app_ids_buffer = ctx.ReadBuffer();
     const size_t app_count = app_ids_buffer.size() / sizeof(u64);
-
-    std::vector<u64> application_ids(app_count);
-    if (app_count > 0) {
-        std::memcpy(application_ids.data(), app_ids_buffer.data(), app_count * sizeof(u64));
-    }
-
     auto t_mem_obj = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(ctx.GetCopyHandle(0));
     auto* t_mem = t_mem_obj.GetPointerUnsafe();
     constexpr size_t title_entry_size = sizeof(FileSys::LanguageEntry);
@@ -363,9 +354,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo
         auto& memory = system.ApplicationMemory();
         const auto t_mem_address = t_mem->GetSourceAddress();
         for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = application_ids[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(),
-                                           system.GetContentProvider()};
+            const u64 app_id = app_ids_buffer[i];
+            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
             const auto control = pm.GetControlMetadata();
             FileSys::LanguageEntry entry{};
             if (control.first != nullptr) {

src/input_common/helpers/joycon_driver.cpp

@@ -28,8 +28,10 @@ JoyconDriver::~JoyconDriver() {
 }
 
 void JoyconDriver::Stop() {
-    is_connected = false;
-    input_thread = {};
+    if (input_thread.joinable()) {
+        input_thread.request_stop();
+        input_thread.join();
+    }
 }
 
 Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_info* device_info) {
@@ -58,7 +60,6 @@ Common::Input::DriverResult JoyconDriver::InitializeDevice() {
         return Common::Input::DriverResult::InvalidHandle;
     }
     std::scoped_lock lock{mutex};
-    disable_input_thread = true;
 
     // Reset Counters
     error_counter = 0;
@@ -126,62 +127,44 @@ Common::Input::DriverResult JoyconDriver::InitializeDevice() {
                                                    right_stick_calibration, motion_calibration);
 
     // Start polling for data
-    is_connected = true;
-    if (!input_thread_running) {
-        input_thread =
-            std::jthread([this](std::stop_token stop_token) { InputThread(stop_token); });
+    if (!input_thread.joinable()) {
+        input_thread = std::jthread([this](std::stop_token stop_token) {
+            InputThread(stop_token);
+        });
     }
-
-    disable_input_thread = false;
     return Common::Input::DriverResult::Success;
 }
 
 void JoyconDriver::InputThread(std::stop_token stop_token) {
     LOG_INFO(Input, "Joycon Adapter input thread started");
     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()) {
+        // Max update rate is 5ms, so just (timeout) at 300ms
+        constexpr int READ_TIMEOUT_MS = 300;
+        constexpr size_t MAX_VIBRATIONS = 4;
+        std::array<u8, MaxBufferSize> buffer; // Filled by SDL, don't zero-init
         int status = 0;
-
-        if (!IsInputThreadValid()) {
-            input_thread.request_stop();
-            continue;
-        }
-
-        // 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);
+        if (IsInputThreadValid()) {
+            // By disabling the input thread we can ensure custom commands will succeed as no package is
+            // skipped
+            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(), READ_TIMEOUT_MS);
+            if (IsPayloadCorrect(status, buffer)) {
+                OnNewData(buffer);
+            }
+            if (!vibration_queue.Empty()) {
+                VibrationValue vibration_value;
+                vibration_queue.Pop(vibration_value);
+                last_vibration_result = rumble_protocol->SendVibration(vibration_value);
+            }
+            // We can't keep up with vibrations. Start skipping.
+            while (vibration_queue.Size() >= MAX_VIBRATIONS) {
+                vibration_queue.Pop();
+            }
         } else {
-            std::this_thread::sleep_for(std::chrono::milliseconds(ThreadDelay));
+            input_thread.request_stop();
         }
-
-        if (IsPayloadCorrect(status, buffer)) {
-            OnNewData(buffer);
-        }
-
-        if (!vibration_queue.Empty()) {
-            VibrationValue vibration_value;
-            vibration_queue.Pop(vibration_value);
-            last_vibration_result = rumble_protocol->SendVibration(vibration_value);
-        }
-
-        // We can't keep up with vibrations. Start skipping.
-        while (vibration_queue.Size() > 6) {
-            vibration_queue.Pop();
-        }
-
-        std::this_thread::yield();
     }
-
-    is_connected = false;
-    input_thread_running = false;
     LOG_INFO(Input, "Joycon Adapter input thread stopped");
 }
 
@@ -271,11 +254,6 @@ void JoyconDriver::OnNewData(std::span<u8> buffer) {
 }
 
 Common::Input::DriverResult JoyconDriver::SetPollingMode() {
-    SCOPE_EXIT {
-        disable_input_thread = false;
-    };
-    disable_input_thread = true;
-
     rumble_protocol->EnableRumble(vibration_enabled && supported_features.vibration);
 
     if (motion_enabled && supported_features.motion) {
@@ -382,17 +360,12 @@ JoyconDriver::SupportedFeatures JoyconDriver::GetSupportedFeatures() {
 }
 
 bool JoyconDriver::IsInputThreadValid() const {
-    if (!is_connected.load()) {
+    if (hidapi_handle == nullptr || hidapi_handle->handle == nullptr)
         return false;
-    }
-    if (hidapi_handle->handle == nullptr) {
-        return false;
-    }
     // Controller is not responding. Terminate connection
-    if (error_counter > MaxErrorCount) {
+    if (error_counter > MaxErrorCount)
         return false;
-    }
-    return true;
+    return input_thread.joinable();
 }
 
 bool JoyconDriver::IsPayloadCorrect(int status, std::span<const u8> buffer) {
@@ -415,30 +388,18 @@ bool JoyconDriver::IsPayloadCorrect(int status, std::span<const u8> buffer) {
 
 Common::Input::DriverResult JoyconDriver::SetVibration(const VibrationValue& vibration) {
     std::scoped_lock lock{mutex};
-    if (disable_input_thread) {
-        return Common::Input::DriverResult::HandleInUse;
-    }
     vibration_queue.Push(vibration);
     return last_vibration_result;
 }
 
 Common::Input::DriverResult JoyconDriver::SetLedConfig(u8 led_pattern) {
     std::scoped_lock lock{mutex};
-    if (disable_input_thread) {
-        return Common::Input::DriverResult::HandleInUse;
-    }
     return generic_protocol->SetLedPattern(led_pattern);
 }
 
 Common::Input::DriverResult JoyconDriver::SetIrsConfig(IrsMode mode_, IrsResolution format_) {
     std::scoped_lock lock{mutex};
-    if (disable_input_thread) {
-        return Common::Input::DriverResult::HandleInUse;
-    }
-    disable_input_thread = true;
-    const auto result = irs_protocol->SetIrsConfig(mode_, format_);
-    disable_input_thread = false;
-    return result;
+    return irs_protocol->SetIrsConfig(mode_, format_);
 }
 
 Common::Input::DriverResult JoyconDriver::SetPassiveMode() {
@@ -532,12 +493,7 @@ Common::Input::DriverResult JoyconDriver::StartNfcPolling() {
     if (!nfc_protocol->IsEnabled()) {
         return Common::Input::DriverResult::Disabled;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->StartNFCPollingMode();
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->StartNFCPollingMode();
 }
 
 Common::Input::DriverResult JoyconDriver::StopNfcPolling() {
@@ -550,10 +506,7 @@ Common::Input::DriverResult JoyconDriver::StopNfcPolling() {
         return Common::Input::DriverResult::Disabled;
     }
 
-    disable_input_thread = true;
     const auto result = nfc_protocol->StopNFCPollingMode();
-    disable_input_thread = false;
-
     if (amiibo_detected) {
         amiibo_detected = false;
         joycon_poller->UpdateAmiibo({});
@@ -576,11 +529,7 @@ Common::Input::DriverResult JoyconDriver::ReadAmiiboData(std::vector<u8>& out_da
     }
 
     out_data.resize(0x21C);
-    disable_input_thread = true;
-    const auto result = nfc_protocol->ReadAmiibo(out_data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->ReadAmiibo(out_data);
 }
 
 Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) {
@@ -595,12 +544,7 @@ Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data)
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->WriteAmiibo(data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->WriteAmiibo(data);
 }
 
 Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareReadChunk> data,
@@ -616,12 +560,7 @@ Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareR
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->ReadMifare(data, out_data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->ReadMifare(data, out_data);
 }
 
 Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const MifareWriteChunk> data) {
@@ -636,17 +575,11 @@ Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const Mifare
     if (!amiibo_detected) {
         return Common::Input::DriverResult::ErrorWritingData;
     }
-
-    disable_input_thread = true;
-    const auto result = nfc_protocol->WriteMifare(data);
-    disable_input_thread = false;
-
-    return result;
+    return nfc_protocol->WriteMifare(data);
 }
 
 bool JoyconDriver::IsConnected() const {
-    std::scoped_lock lock{mutex};
-    return is_connected.load();
+    return input_thread.joinable();
 }
 
 bool JoyconDriver::IsVibrationEnabled() const {

src/input_common/helpers/joycon_driver.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -160,8 +163,6 @@ private:
     // Thread related
     mutable std::mutex mutex;
     std::jthread input_thread;
-    bool input_thread_running{};
-    bool disable_input_thread{};
 };
 
 } // namespace InputCommon::Joycon

src/input_common/helpers/joycon_protocol/poller.cpp

@@ -22,7 +22,7 @@ void JoyconPoller::SetCallbacks(const JoyconCallbacks& callbacks_) {
 void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& motion_status,
                                   const RingStatus& ring_status) {
     InputReportActive data{};
-    memcpy(&data, buffer.data(), sizeof(InputReportActive));
+    std::memcpy(&data, buffer.data(), sizeof(InputReportActive));
 
     switch (device_type) {
     case ControllerType::Left:
@@ -47,7 +47,7 @@ void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& moti
 
 void JoyconPoller::ReadPassiveMode(std::span<u8> buffer) {
     InputReportPassive data{};
-    memcpy(&data, buffer.data(), sizeof(InputReportPassive));
+    std::memcpy(&data, buffer.data(), sizeof(InputReportPassive));
 
     switch (device_type) {
     case ControllerType::Left:

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -2850,6 +2850,8 @@ Sampler::VariantKey Sampler::MakeKey(const ImageView& image_view, bool is_depth)
     VariantKey key{};
     key.reduce_anisotropy = has_added_anisotropy && !image_view.SupportsAnisotropy();
     key.force_nearest = has_linear_filtering && IsPixelFormatInteger(image_view.format);
+    key.drop_depth_comparison =
+        is_depth && has_depth_comparison && !image_view.SupportsDepthComparison();
     key.drop_reduction = has_minmax_reduction && !image_view.SupportsMinmaxFilter();
     key.drop_custom_border = has_custom_border_colors && image_view.RequiresBorderColorFormat();
     key.srgb_border = has_srgb_border_color && IsPixelFormatSRGB(image_view.format);
@@ -2927,6 +2929,9 @@ VkSampler Sampler::Emplace(VariantKey key) {
         create_info.anisotropyEnable = static_cast<VkBool32>(default_anisotropy > 1.0f);
         create_info.maxAnisotropy = default_anisotropy;
     }
+    if (key.drop_depth_comparison) {
+        create_info.compareEnable = VK_FALSE;
+    }
     if (!custom_border) {
         create_info.borderColor = ConvertBorderColor(color);
     }

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -536,6 +536,7 @@ private:
     struct VariantKey {
         bool reduce_anisotropy;
         bool force_nearest;
+        bool drop_depth_comparison;
         bool drop_reduction;
         bool drop_custom_border;
         bool srgb_border;