Skip to content

VERY experimental Nintendo Switch 2 emulator

C++

[core, display, overlay] Add LayerIsOverlay to separate overlay on composer, stub RequestListSummaryOverlayNotification, sync emu settings when setting language (#3123)

Maufeat1eed7efd09ce
diff --git a/src/core/hle/service/am/display_layer_manager.cpp b/src/core/hle/service/am/display_layer_manager.cpp
index a93ca5bc67..6789629310 100644
--- a/src/core/hle/service/am/display_layer_manager.cpp
+++ b/src/core/hle/service/am/display_layer_manager.cpp
@@ -36,10 +36,6 @@ void DisplayLayerManager::Initialize(Core::System& system, Kernel::KProcess* pro
m_buffer_sharing_enabled = false;
m_blending_enabled = mode == LibraryAppletMode::PartialForeground ||
mode == LibraryAppletMode::PartialForegroundIndirectDisplay;
-
- if (m_applet_id != AppletId::Application) {
- (void)this->IsSystemBufferSharingEnabled();
- }
}
void DisplayLayerManager::Finalize() {
@@ -80,11 +76,10 @@ Result DisplayLayerManager::CreateManagedDisplayLayer(u64* out_layer_id) {
if (m_applet_id != AppletId::Application) {
(void)m_manager_display_service->SetLayerBlending(m_blending_enabled, *out_layer_id);
if (m_applet_id == AppletId::OverlayDisplay) {
- static constexpr s32 kOverlayBackgroundZ = -1;
- (void)m_manager_display_service->SetLayerZIndex(kOverlayBackgroundZ, *out_layer_id);
+ (void)m_manager_display_service->SetLayerZIndex(-1, *out_layer_id);
+ (void)m_display_service->GetContainer()->SetLayerIsOverlay(*out_layer_id, true);
} else {
- static constexpr s32 kOverlayZ = 3;
- (void)m_manager_display_service->SetLayerZIndex(kOverlayZ, *out_layer_id);
+ (void)m_manager_display_service->SetLayerZIndex(1, *out_layer_id);
}
}
@@ -131,6 +126,7 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
s32 initial_z = 1;
if (m_applet_id == AppletId::OverlayDisplay) {
initial_z = -1;
+ (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
}
m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);
R_SUCCEED();
diff --git a/src/core/hle/service/am/service/overlay_functions.cpp b/src/core/hle/service/am/service/overlay_functions.cpp
index 8af037734a..41f2e5c008 100644
--- a/src/core/hle/service/am/service/overlay_functions.cpp
+++ b/src/core/hle/service/am/service/overlay_functions.cpp
@@ -24,7 +24,7 @@ namespace Service::AM {
{20, D<&IOverlayFunctions::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
{21, nullptr, "SetHandlingTouchScreenInputEnabled"},
{30, nullptr, "SetHealthWarningShowingState"},
- {31, nullptr, "IsHealthWarningRequired"},
+ {31, D<&IOverlayFunctions::IsHealthWarningRequired>, "IsHealthWarningRequired"},
{40, nullptr, "GetApplicationNintendoLogo"},
{41, nullptr, "GetApplicationStartupMovie"},
{50, nullptr, "SetGpuTimeSliceBoostForApplication"},
@@ -69,12 +69,33 @@ namespace Service::AM {
Result IOverlayFunctions::GetApplicationIdForLogo(Out<u64> out_application_id) {
LOG_DEBUG(Service_AM, "called");
- // Prefer explicit application_id if available, else fall back to program_id
+ std::shared_ptr<Applet> target_applet;
+
+ auto* window_system = system.GetAppletManager().GetWindowSystem();
+ if (window_system) {
+ target_applet = window_system->GetMainApplet();
+ if (target_applet) {
+ std::scoped_lock lk{target_applet->lock};
+ LOG_DEBUG(Service_AM, "applet_id={}, program_id={:016X}, type={}",
+ static_cast<u32>(target_applet->applet_id), target_applet->program_id,
+ static_cast<u32>(target_applet->type));
+
+ u64 id = target_applet->screen_shot_identity.application_id;
+ if (id == 0) {
+ id = target_applet->program_id;
+ }
+ LOG_DEBUG(Service_AM, "application_id={:016X}", id);
+ *out_application_id = id;
+ R_SUCCEED();
+ }
+ }
+
std::scoped_lock lk{m_applet->lock};
u64 id = m_applet->screen_shot_identity.application_id;
if (id == 0) {
id = m_applet->program_id;
}
+ LOG_DEBUG(Service_AM, "application_id={:016X} (fallback)", id);
*out_application_id = id;
R_SUCCEED();
}
@@ -86,6 +107,13 @@ namespace Service::AM {
R_SUCCEED();
}
+ Result IOverlayFunctions::IsHealthWarningRequired(Out<bool> is_required) {
+ LOG_DEBUG(Service_AM, "called");
+ std::scoped_lock lk{m_applet->lock};
+ *is_required = false;
+ R_SUCCEED();
+ }
+
Result IOverlayFunctions::SetHandlingHomeButtonShortPressedEnabled(bool enabled) {
LOG_DEBUG(Service_AM, "called, enabled={}", enabled);
std::scoped_lock lk{m_applet->lock};
diff --git a/src/core/hle/service/am/service/overlay_functions.h b/src/core/hle/service/am/service/overlay_functions.h
index 26c5cc0c88..870f5eae9c 100644
--- a/src/core/hle/service/am/service/overlay_functions.h
+++ b/src/core/hle/service/am/service/overlay_functions.h
@@ -18,6 +18,7 @@ namespace Service::AM {
Result EndToWatchShortHomeButtonMessage();
Result GetApplicationIdForLogo(Out<u64> out_application_id);
Result SetAutoSleepTimeAndDimmingTimeEnabled(bool enabled);
+ Result IsHealthWarningRequired(Out<bool> is_required);
Result SetHandlingHomeButtonShortPressedEnabled(bool enabled);
Result Unknown70();
diff --git a/src/core/hle/service/am/window_system.cpp b/src/core/hle/service/am/window_system.cpp
index c78a955f68..77ca5a76f5 100644
--- a/src/core/hle/service/am/window_system.cpp
+++ b/src/core/hle/service/am/window_system.cpp
@@ -186,8 +186,6 @@ void WindowSystem::OnSystemButtonPress(SystemButtonType type) {
if (m_overlay_display) {
std::scoped_lock lk_overlay{m_overlay_display->lock};
m_overlay_display->overlay_in_foreground = !m_overlay_display->overlay_in_foreground;
- // Tie window visibility to foreground state so hidden when not active
- m_overlay_display->window_visible = m_overlay_display->overlay_in_foreground;
LOG_INFO(Service_AM, "Overlay long-press toggle: overlay_in_foreground={} window_visible={}", m_overlay_display->overlay_in_foreground, m_overlay_display->window_visible);
}
SendButtonAppletMessageLocked(AppletMessage::DetectLongPressingHomeButton);
@@ -393,7 +391,7 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
s32 z_index = 0;
const bool now_foreground = inherited_foreground;
if (applet->applet_id == AppletId::OverlayDisplay) {
- z_index = applet->overlay_in_foreground ? 100000 : -100000;
+ z_index = applet->overlay_in_foreground ? 100000 : -1;
} else if (now_foreground && !is_obscured) {
z_index = 2;
} else if (now_foreground) {
diff --git a/src/core/hle/service/friend/friend.cpp b/src/core/hle/service/friend/friend.cpp
index 84c73e9d6f..f65e70a969 100644
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -67,7 +70,7 @@ public:
{20701, &IFriendService::GetPlayHistoryStatistics, "GetPlayHistoryStatistics"},
{20800, &IFriendService::LoadUserSetting, "LoadUserSetting"},
{20801, nullptr, "SyncUserSetting"},
- {20900, nullptr, "RequestListSummaryOverlayNotification"},
+ {20900, &IFriendService::RequestListSummaryOverlayNotification, "RequestListSummaryOverlayNotification"},
{21000, nullptr, "GetExternalApplicationCatalog"},
{22000, nullptr, "GetReceivedFriendInvitationList"},
{22001, nullptr, "GetReceivedFriendInvitationDetailedInfo"},
@@ -317,6 +320,13 @@ private:
rb.Push(ResultSuccess);
}
+ void RequestListSummaryOverlayNotification(HLERequestContext& ctx) {
+ LOG_INFO(Service_Friend, "(STUBBED) called");
+
+ IPC::ResponseBuilder rb{ctx, 2};
+ rb.Push(ResultSuccess);
+ }
+
void GetReceivedFriendInvitationCountCache(HLERequestContext& ctx) {
LOG_DEBUG(Service_Friend, "(STUBBED) called, check in out");
diff --git a/src/core/hle/service/ns/application_manager_interface.cpp b/src/core/hle/service/ns/application_manager_interface.cpp
index 6f05116853..7c4843a80a 100644
--- a/src/core/hle/service/ns/application_manager_interface.cpp
+++ b/src/core/hle/service/ns/application_manager_interface.cpp
@@ -10,6 +10,8 @@
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/filesystem/filesystem.h"
#include "core/hle/service/ns/application_manager_interface.h"
+
+#include "core/file_sys/content_archive.h"
#include "core/hle/service/ns/content_management_interface.h"
#include "core/hle/service/ns/read_only_application_control_data_interface.h"
#include "core/file_sys/patch_manager.h"
@@ -54,7 +56,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
{37, nullptr, "ListRequiredVersion"},
{38, D<&IApplicationManagerInterface::CheckApplicationLaunchVersion>, "CheckApplicationLaunchVersion"},
{39, nullptr, "CheckApplicationLaunchRights"},
- {40, nullptr, "GetApplicationLogoData"},
+ {40, D<&IApplicationManagerInterface::GetApplicationLogoData>, "GetApplicationLogoData"},
{41, nullptr, "CalculateApplicationDownloadRequiredSize"},
{42, nullptr, "CleanupSdCard"},
{43, D<&IApplicationManagerInterface::CheckSdCardMountStatus>, "CheckSdCardMountStatus"},
@@ -331,6 +333,53 @@ Result IApplicationManagerInterface::UnregisterNetworkServiceAccountWithUserSave
LOG_DEBUG(Service_NS, "called, user_id={}", user_id.FormattedString());
R_SUCCEED();
}
+
+Result IApplicationManagerInterface::GetApplicationLogoData(
+ Out<s64> out_size, OutBuffer<BufferAttr_HipcMapAlias> out_buffer, u64 application_id,
+ InBuffer<BufferAttr_HipcMapAlias> logo_path_buffer) {
+ const std::string path_view{reinterpret_cast<const char*>(logo_path_buffer.data()),
+ logo_path_buffer.size()};
+
+ // Find null terminator and trim the path
+ auto null_pos = path_view.find('\0');
+ std::string path = (null_pos != std::string::npos) ? path_view.substr(0, null_pos) : path_view;
+
+ LOG_DEBUG(Service_NS, "called, application_id={:016X}, logo_path={}", application_id, path);
+
+ auto& content_provider = system.GetContentProviderUnion();
+
+ auto program = content_provider.GetEntry(application_id, FileSys::ContentRecordType::Program);
+ if (!program) {
+ LOG_WARNING(Service_NS, "Application program not found for id={:016X}", application_id);
+ R_RETURN(ResultUnknown);
+ }
+
+ const auto logo_dir = program->GetLogoPartition();
+ if (!logo_dir) {
+ LOG_WARNING(Service_NS, "Logo partition not found for id={:016X}", application_id);
+ R_RETURN(ResultUnknown);
+ }
+
+ const auto file = logo_dir->GetFile(path);
+ if (!file) {
+ LOG_WARNING(Service_NS, "Logo path not found: {} for id={:016X}", path,
+ application_id);
+ R_RETURN(ResultUnknown);
+ }
+
+ const auto data = file->ReadAllBytes();
+ if (data.size() > out_buffer.size()) {
+ LOG_WARNING(Service_NS, "Logo buffer too small: have={}, need={}", out_buffer.size(),
+ data.size());
+ R_RETURN(ResultUnknown);
+ }
+
+ std::memcpy(out_buffer.data(), data.data(), data.size());
+ *out_size = static_cast<s64>(data.size());
+
+ R_SUCCEED();
+}
+
Result IApplicationManagerInterface::GetApplicationControlData(
OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u32> out_actual_size,
ApplicationControlSource application_control_source, u64 application_id) {
diff --git a/src/core/hle/service/ns/application_manager_interface.h b/src/core/hle/service/ns/application_manager_interface.h
index 915581172e..e7bab6dca1 100644
--- a/src/core/hle/service/ns/application_manager_interface.h
+++ b/src/core/hle/service/ns/application_manager_interface.h
@@ -60,6 +60,10 @@ public:
u64 application_id);
Result CheckApplicationLaunchVersion(u64 application_id);
Result GetApplicationTerminateResult(Out<Result> out_result, u64 application_id);
+ Result GetApplicationLogoData(Out<s64> out_size,
+ OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
+ u64 application_id,
+ InBuffer<BufferAttr_HipcMapAlias> logo_path_buffer);
Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
Result Unknown4023(Out<u64> out_result);
Result Unknown4053();
diff --git a/src/core/hle/service/ns/ns_types.h b/src/core/hle/service/ns/ns_types.h
index 8e7e4fa0dc..247f7063af 100644
--- a/src/core/hle/service/ns/ns_types.h
+++ b/src/core/hle/service/ns/ns_types.h
@@ -179,4 +179,9 @@ struct ApplicationDisplayData {
};
static_assert(sizeof(ApplicationDisplayData) == 0x300, "ApplicationDisplayData has incorrect size.");
+struct LogoPath {
+ std::array<char, 0x300> path;
+};
+static_assert(std::is_trivially_copyable_v<LogoPath>, "LogoPath must be trivially copyable.");
+
} // namespace Service::NS
diff --git a/src/core/hle/service/nvnflinger/display.h b/src/core/hle/service/nvnflinger/display.h
index 1264465079..ada302a79e 100644
--- a/src/core/hle/service/nvnflinger/display.h
+++ b/src/core/hle/service/nvnflinger/display.h
@@ -15,7 +15,7 @@ struct Layer {
explicit Layer(std::shared_ptr<android::BufferItemConsumer> buffer_item_consumer_,
s32 consumer_id_)
: buffer_item_consumer(std::move(buffer_item_consumer_)), consumer_id(consumer_id_),
- blending(LayerBlending::None), visible(true), z_index(0) {}
+ blending(LayerBlending::None), visible(true), z_index(0), is_overlay(false) {}
~Layer() {
buffer_item_consumer->Abandon();
}
@@ -25,6 +25,7 @@ struct Layer {
LayerBlending blending;
bool visible;
s32 z_index;
+ bool is_overlay;
};
struct LayerStack {
diff --git a/src/core/hle/service/nvnflinger/hardware_composer.cpp b/src/core/hle/service/nvnflinger/hardware_composer.cpp
index 4f8f5da69a..cfd999497b 100644
--- a/src/core/hle/service/nvnflinger/hardware_composer.cpp
+++ b/src/core/hle/service/nvnflinger/hardware_composer.cpp
@@ -78,8 +78,25 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
for (auto& layer : display.stack.layers) {
auto consumer_id = layer->consumer_id;
+ bool should_try_acquire = true;
+ if (!layer->is_overlay) {
+ auto fb_it = m_framebuffers.find(consumer_id);
+ if (fb_it != m_framebuffers.end() && fb_it->second.is_acquired) {
+ const u64 frames_since_last_acquire = m_frame_number - fb_it->second.last_acquire_frame;
+ const s32 expected_interval = NormalizeSwapInterval(nullptr, fb_it->second.item.swap_interval);
+
+ if (frames_since_last_acquire < static_cast<u64>(expected_interval)) {
+ should_try_acquire = false;
+ }
+ }
+ }
+
// Try to fetch the framebuffer (either new or stale).
- const auto result = this->CacheFramebufferLocked(*layer, consumer_id);
+ const auto result = should_try_acquire
+ ? this->CacheFramebufferLocked(*layer, consumer_id)
+ : (m_framebuffers.find(consumer_id) != m_framebuffers.end() && m_framebuffers[consumer_id].is_acquired
+ ? CacheStatus::CachedBufferReused
+ : CacheStatus::NoBufferAvailable);
// If we failed, skip this layer.
if (result == CacheStatus::NoBufferAvailable) {
@@ -111,6 +128,12 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
});
}
+ // Overlay layers run at their own framerate independently of the game.
+ // Skip them when calculating the swap interval for the main game.
+ if (layer->is_overlay) {
+ continue;
+ }
+
// We need to compose again either before this frame is supposed to
// be released, or exactly on the vsync period it should be released.
const s32 item_swap_interval = NormalizeSwapInterval(out_speed_scale, item.swap_interval);
@@ -138,33 +161,44 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
// Batch framebuffer releases, instead of one-into-one.
std::vector<std::pair<Layer*, Framebuffer*>> to_release;
for (auto& [layer_id, framebuffer] : m_framebuffers) {
- if (framebuffer.release_frame_number > m_frame_number || !framebuffer.is_acquired)
+ if (!framebuffer.is_acquired)
+ continue;
+
+ auto layer = display.stack.FindLayer(layer_id);
+ if (!layer)
continue;
- if (auto layer = display.stack.FindLayer(layer_id); layer)
+
+ // Overlay layers always release after every compose
+ // Non-overlay layers release based on their swap interval
+ if (layer->is_overlay || framebuffer.release_frame_number <= m_frame_number) {
to_release.emplace_back(layer.get(), &framebuffer);
+ }
}
for (auto& [layer, framebuffer] : to_release) {
layer->buffer_item_consumer->ReleaseBuffer(framebuffer->item, android::Fence::NoFence());
framebuffer->is_acquired = false;
}
- // Advance by at least one frame.
- const u32 frame_advance = swap_interval.value_or(1);
- m_frame_number += frame_advance;
+ // Advance by 1 frame (60 FPS compositing)
+ m_frame_number += 1;
- // Release any necessary framebuffers.
+ // Release any necessary framebuffers (non-overlay layers only, as overlays are already released above).
for (auto& [layer_id, framebuffer] : m_framebuffers) {
- if (framebuffer.release_frame_number > m_frame_number) {
- // Not yet ready to release this framebuffer.
+ if (!framebuffer.is_acquired) {
+ // Already released.
continue;
}
- if (!framebuffer.is_acquired) {
- // Already released.
+ if (framebuffer.release_frame_number > m_frame_number) {
continue;
}
if (const auto layer = display.stack.FindLayer(layer_id); layer != nullptr) {
+ // Skip overlay layers as they were already released above
+ if (layer->is_overlay) {
+ continue;
+ }
+
// TODO: support release fence
// This is needed to prevent screen tearing
layer->buffer_item_consumer->ReleaseBuffer(framebuffer.item, android::Fence::NoFence());
@@ -172,7 +206,7 @@ u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, Display& display,
}
}
- return frame_advance;
+ return 1;
}
void HardwareComposer::RemoveLayerLocked(Display& display, ConsumerId consumer_id) {
@@ -200,8 +234,9 @@ bool HardwareComposer::TryAcquireFramebufferLocked(Layer& layer, Framebuffer& fr
}
// We succeeded, so set the new release frame info.
- framebuffer.release_frame_number =
- NormalizeSwapInterval(nullptr, framebuffer.item.swap_interval);
+ const s32 swap_interval = layer.is_overlay ? 1 : NormalizeSwapInterval(nullptr, framebuffer.item.swap_interval);
+ framebuffer.release_frame_number = m_frame_number + swap_interval;
+ framebuffer.last_acquire_frame = m_frame_number;
framebuffer.is_acquired = true;
return true;
diff --git a/src/core/hle/service/nvnflinger/hardware_composer.h b/src/core/hle/service/nvnflinger/hardware_composer.h
index c5b8304681..e9b7194612 100644
--- a/src/core/hle/service/nvnflinger/hardware_composer.h
+++ b/src/core/hle/service/nvnflinger/hardware_composer.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
@@ -34,6 +37,7 @@ private:
struct Framebuffer {
android::BufferItem item{};
ReleaseFrameNumber release_frame_number{};
+ u64 last_acquire_frame{0};
bool is_acquired{false};
};
diff --git a/src/core/hle/service/nvnflinger/surface_flinger.cpp b/src/core/hle/service/nvnflinger/surface_flinger.cpp
index 8362b65e58..fbf70592bd 100644
--- a/src/core/hle/service/nvnflinger/surface_flinger.cpp
+++ b/src/core/hle/service/nvnflinger/surface_flinger.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@@ -101,6 +104,13 @@ void SurfaceFlinger::SetLayerBlending(s32 consumer_binder_id, LayerBlending blen
}
}
+void SurfaceFlinger::SetLayerIsOverlay(s32 consumer_binder_id, bool is_overlay) {
+ if (const auto layer = this->FindLayer(consumer_binder_id); layer != nullptr) {
+ layer->is_overlay = is_overlay;
+ LOG_DEBUG(Service_VI, "Layer {} marked as overlay: {}", consumer_binder_id, is_overlay);
+ }
+}
+
Display* SurfaceFlinger::FindDisplay(u64 display_id) {
for (auto& display : m_displays) {
if (display.id == display_id) {
diff --git a/src/core/hle/service/nvnflinger/surface_flinger.h b/src/core/hle/service/nvnflinger/surface_flinger.h
index d771909a82..05b4206c34 100644
--- a/src/core/hle/service/nvnflinger/surface_flinger.h
+++ b/src/core/hle/service/nvnflinger/surface_flinger.h
@@ -47,6 +47,7 @@ public:
void SetLayerVisibility(s32 consumer_binder_id, bool visible);
void SetLayerBlending(s32 consumer_binder_id, LayerBlending blending);
+ void SetLayerIsOverlay(s32 consumer_binder_id, bool is_overlay);
std::shared_ptr<Layer> FindLayer(s32 consumer_binder_id);
diff --git a/src/core/hle/service/set/system_settings_server.cpp b/src/core/hle/service/set/system_settings_server.cpp
index 115eaf331a..f87dd847ba 100644
--- a/src/core/hle/service/set/system_settings_server.cpp
+++ b/src/core/hle/service/set/system_settings_server.cpp
@@ -36,6 +36,29 @@ struct SettingsHeader {
u32 version;
u32 reserved;
};
+
+void SyncGlobalLanguageFromCode(LanguageCode language_code) {
+ const auto it = std::find_if(available_language_codes.begin(), available_language_codes.end(),
+ [language_code](LanguageCode code) { return code == language_code; });
+ if (it == available_language_codes.end()) {
+ return;
+ }
+
+ const std::size_t index = static_cast<std::size_t>(std::distance(available_language_codes.begin(), it));
+ if (index >= static_cast<std::size_t>(Settings::values.language_index.GetValue())) {
+ Settings::values.language_index.SetValue(static_cast<Settings::Language>(index));
+ }
+}
+
+void SyncGlobalRegionFromCode(SystemRegionCode region_code) {
+ const auto region_index = static_cast<std::size_t>(region_code);
+ if (region_index > static_cast<std::size_t>(Settings::Region::Taiwan)) {
+ return;
+ }
+
+ Settings::values.region_index.SetValue(static_cast<Settings::Region>(region_index));
+}
+
} // Anonymous namespace
Result GetFirmwareVersionImpl(FirmwareVersionFormat& out_firmware, Core::System& system,
@@ -457,6 +480,7 @@ Result ISystemSettingsServer::SetLanguageCode(LanguageCode language_code) {
LOG_INFO(Service_SET, "called, language_code={}", language_code);
m_system_settings.language_code = language_code;
+ SyncGlobalLanguageFromCode(language_code);
SetSaveNeeded();
R_SUCCEED();
}
@@ -889,6 +913,7 @@ Result ISystemSettingsServer::SetRegionCode(SystemRegionCode region_code) {
LOG_INFO(Service_SET, "called, region_code={}", region_code);
m_system_settings.region_code = region_code;
+ SyncGlobalRegionFromCode(region_code);
SetSaveNeeded();
R_SUCCEED();
}
@@ -1224,6 +1249,7 @@ Result ISystemSettingsServer::SetKeyboardLayout(KeyboardLayout keyboard_layout)
LOG_INFO(Service_SET, "called, keyboard_layout={}", keyboard_layout);
m_system_settings.keyboard_layout = keyboard_layout;
+ SetSaveNeeded();
R_SUCCEED();
}
diff --git a/src/core/hle/service/vi/conductor.cpp b/src/core/hle/service/vi/conductor.cpp
index c8ce4fca04..a271041be6 100644
--- a/src/core/hle/service/vi/conductor.cpp
+++ b/src/core/hle/service/vi/conductor.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
diff --git a/src/core/hle/service/vi/container.cpp b/src/core/hle/service/vi/container.cpp
index e7d3b4757b..e7255c2b0a 100644
--- a/src/core/hle/service/vi/container.cpp
+++ b/src/core/hle/service/vi/container.cpp
@@ -166,6 +166,16 @@ Result Container::GetLayerZIndex(u64 layer_id, s32* out_z_index) {
R_RETURN(VI::ResultNotFound);
}
+Result Container::SetLayerIsOverlay(u64 layer_id, bool is_overlay) {
+ std::scoped_lock lk{m_lock};
+
+ auto* const layer = m_layers.GetLayerById(layer_id);
+ R_UNLESS(layer != nullptr, VI::ResultNotFound);
+
+ m_surface_flinger->SetLayerIsOverlay(layer->GetConsumerBinderId(), is_overlay);
+ R_SUCCEED();
+}
+
void Container::LinkVsyncEvent(u64 display_id, Event* event) {
std::scoped_lock lk{m_lock};
m_conductor->LinkVsyncEvent(display_id, event);
diff --git a/src/core/hle/service/vi/container.h b/src/core/hle/service/vi/container.h
index 544a47889a..5d111e71ab 100644
--- a/src/core/hle/service/vi/container.h
+++ b/src/core/hle/service/vi/container.h
@@ -67,6 +67,7 @@ public:
Result SetLayerBlending(u64 layer_id, bool enabled);
Result SetLayerZIndex(u64 layer_id, s32 z_index);
Result GetLayerZIndex(u64 layer_id, s32* out_z_index);
+ Result SetLayerIsOverlay(u64 layer_id, bool is_overlay);
void LinkVsyncEvent(u64 display_id, Event* event);
void UnlinkVsyncEvent(u64 display_id, Event* event);
diff --git a/src/core/hle/service/vi/shared_buffer_manager.cpp b/src/core/hle/service/vi/shared_buffer_manager.cpp
index e1808f74ca..1568344830 100644
--- a/src/core/hle/service/vi/shared_buffer_manager.cpp
+++ b/src/core/hle/service/vi/shared_buffer_manager.cpp
@@ -46,8 +46,8 @@ Result AllocateSharedBufferMemory(std::unique_ptr<Kernel::KPageGroup>* out_page_
u32* start = system.DeviceMemory().GetPointer<u32>(block.GetAddress());
u32* end = system.DeviceMemory().GetPointer<u32>(block.GetAddress() + block.GetSize());
- for (; start < end; ++start) {
- *start = 0x00000000; // ARGB/RGBA with alpha=0
+ for (; start < end; start++) {
+ *start = 0xFF0000FF;
}
}
@@ -257,7 +257,6 @@ Result SharedBufferManager::CreateSession(Kernel::KProcess* owner_process, u64*
// Configure blending and z-index
R_ASSERT(m_container.SetLayerBlending(session.layer_id, enable_blending));
- R_ASSERT(m_container.SetLayerZIndex(session.layer_id, 100000));
// Get the producer and set preallocated buffers.
std::shared_ptr<android::BufferQueueProducer> producer;
@@ -374,11 +373,6 @@ Result SharedBufferManager::PresentSharedFrameBuffer(android::Fence fence,
android::Status::NoError,
VI::ResultOperationFailed);
- // Ensure the layer is visible when content is presented.
- // Re-assert overlay priority in case clients reset it.
- (void)m_container.SetLayerZIndex(layer_id, 100000);
- (void)m_container.SetLayerVisibility(layer_id, true);
-
// We succeeded.
R_SUCCEED();
}
@@ -415,51 +409,22 @@ Result SharedBufferManager::WriteAppletCaptureBuffer(bool* out_was_written, s32*
// TODO: this could be optimized
s64 e = -1280 * 768 * 4;
for (auto& block : *m_buffer_page_group) {
- u8* const block_start = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress());
- u8* ptr = block_start;
- u8* const block_end = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress() + block.GetSize());
+ u8* start = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress());
+ u8* end = m_system.DeviceMemory().GetPointer<u8>(block.GetAddress() + block.GetSize());
- for (; ptr < block_end; ++ptr) {
+ for (; start < end; start++) {
+ *start = 0;
if (e >= 0 && e < static_cast<s64>(capture_buffer.size())) {
- *ptr = capture_buffer[static_cast<size_t>(e)];
- } else {
- *ptr = 0;
+ *start = capture_buffer[e];
}
- ++e;
+ e++;
}
- m_system.GPU().Host1x().MemoryManager().ApplyOpOnPointer(block_start, scratch, [&](DAddr addr) {
- m_system.GPU().InvalidateRegion(addr, block_end - block_start);
+ m_system.GPU().Host1x().MemoryManager().ApplyOpOnPointer(start, scratch, [&](DAddr addr) {
+ m_system.GPU().InvalidateRegion(addr, end - start);
});
}
- // After writing, present a frame on each active shared layer so it becomes visible.
- for (auto& [aruid, session] : m_sessions) {
- std::shared_ptr<android::BufferQueueProducer> producer;
- if (R_FAILED(m_container.GetLayerProducerHandle(std::addressof(producer), session.layer_id))) {
- continue;
- }
- s32 slot = -1;
- android::Fence fence = android::Fence::NoFence();
- if (producer->DequeueBuffer(&slot, &fence, SharedBufferAsync != 0, SharedBufferWidth,
- SharedBufferHeight, SharedBufferBlockLinearFormat, 0) !=
- android::Status::NoError) {
- continue;
- }
- std::shared_ptr<android::GraphicBuffer> gb;
- if (producer->RequestBuffer(slot, &gb) != android::Status::NoError) {
- producer->CancelBuffer(slot, android::Fence::NoFence());
- continue;
- }
- android::QueueBufferInput qin{};
- android::QueueBufferOutput qout{};
- qin.crop = {0, 0, static_cast<s32>(SharedBufferWidth), static_cast<s32>(SharedBufferHeight)};
- qin.fence = android::Fence::NoFence();
- qin.transform = static_cast<android::NativeWindowTransform>(0);
- qin.swap_interval = 1;
- (void)producer->QueueBuffer(slot, qin, &qout);
- }
-
*out_was_written = true;
*out_layer_index = 1;
R_SUCCEED();