2026-09-06 21:41:03

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

src/core/hle/service/am/display_layer_manager.cpp

@@ -73,16 +73,20 @@ Result DisplayLayerManager::CreateManagedDisplayLayer(u64* out_layer_id) {
     R_TRY(m_manager_display_service->CreateManagedLayer(
         out_layer_id, 0, display_id, Service::AppletResourceUserId{m_process->GetProcessId()}));
 
+    m_manager_display_service->SetLayerVisibility(m_visible, *out_layer_id);
+    (void)m_display_service->GetContainer()->SetLayerStackMask(*out_layer_id,
+                                                              this->GetLayerStackMask());
+
     if (m_applet_id != AppletId::Application) {
         (void)m_manager_display_service->SetLayerBlending(m_blending_enabled, *out_layer_id);
         if (m_applet_id == AppletId::OverlayDisplay) {
-            (void)m_manager_display_service->SetLayerZIndex(-1, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(Overlay, *out_layer_id);
             (void)m_display_service->GetContainer()->SetLayerIsOverlay(*out_layer_id, true);
         } else {
-            (void)m_manager_display_service->SetLayerZIndex(1, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(Foreground, *out_layer_id);
         }
     }
-    (void)m_display_service->GetContainer()->SetLayerZIndex(*out_layer_id, true);
+
     m_managed_display_layers.emplace(*out_layer_id);
 
     R_SUCCEED();
@@ -122,11 +126,12 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
 
     // Ensure the overlay layer is visible
     m_manager_display_service->SetLayerVisibility(m_visible, m_system_shared_layer_id);
+    (void)m_display_service->GetContainer()->SetLayerStackMask(m_system_shared_layer_id,
+                                                              this->GetLayerStackMask());
     m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
-    s32 initial_z = 1;
+    s32 initial_z = Foreground;
-    (void)m_display_service->GetContainer()->SetLayerZIndex(m_system_shared_layer_id, true);
     if (m_applet_id == AppletId::OverlayDisplay) {
-        initial_z = -1;
+        initial_z = Overlay;
         (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
     }
     m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);

src/core/hle/service/vi/shared_buffer_manager.cpp

@@ -300,6 +300,28 @@ Result SharedBufferManager::CreateSession(Kernel::KProcess* owner_process, u64*
             }
         }
 
+        // Claim a presentation slot range.
+        u32 slot_base = 0;
+
+        std::array<bool, SharedBufferMaxSessions> in_use{};
+        for (const auto& [existing_aruid, existing] : m_sessions) {
+            const u32 index = existing.presentation_slot_base / SharedBufferSlotsPerSession;
+
+            if (index < in_use.size())
+                in_use[index] = true;
+        }
+
+        u32 index = 0;
+        while (index < in_use.size() && in_use[index])
+            index++;
+
+        if (index >= in_use.size()) {
+            LOG_ERROR(Service_VI, "Out of shared buffer presentation slots ({} sessions)", SharedBufferMaxSessions);
+            R_THROW(VI::ResultOperationFailed);
+        }
+
+        slot_base = index * SharedBufferSlotsPerSession;
+
         // Map into process.
         Common::ProcessAddress map_address{};
         R_TRY(MapSharedBufferIntoProcessAddressSpace(std::addressof(map_address), m_buffer_page_group,
@@ -308,6 +330,7 @@ Result SharedBufferManager::CreateSession(Kernel::KProcess* owner_process, u64*
         // Create new session.
         auto [it, was_emplaced] = m_sessions.emplace(aruid, SharedBufferSession{});
         auto& session = it->second;
+        session.presentation_slot_base = slot_base;
 
         auto& container = m_nvdrv->GetContainer();
         session.session_id = container.OpenSession(owner_process);

src/video_core/gpu.cpp

@@ -55,11 +55,11 @@ constexpr u64 GpuClockMultiplier(Settings::GpuClock clock) {
 
 struct GPU::Impl {
     explicit Impl(Core::System& system_, bool is_async_, bool use_nvdec_)
-        : system{system_}
+        : gpu_thread{system_}
+        , system{system_}
         , use_nvdec{use_nvdec_}
         , shader_notify()
         , is_async{is_async_}
-        , gpu_thread{system_}
     {}
 
     ~Impl() = default;
@@ -301,6 +301,10 @@ struct GPU::Impl {
         return out;
     }
 
+    // Destruction of thread must be done before all (non trivial)
+    // previous members has been destroyed
+    VideoCommon::GPUThread::ThreadManager gpu_thread;
+
     Core::System& system;
 
     std::unique_ptr<VideoCore::RendererBase> renderer;
@@ -329,7 +333,6 @@ struct GPU::Impl {
 
     const bool is_async;
 
-    VideoCommon::GPUThread::ThreadManager gpu_thread;
     std::unique_ptr<Core::Frontend::GraphicsContext> cpu_context;
 
     Tegra::Control::Scheduler scheduler;