summaryrefslogtreecommitdiffstats
path: root/src/core/hle/service
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/hle/service')
-rw-r--r--src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp35
-rw-r--r--src/core/hle/service/nvdrv/devices/nvdisp_disp0.h10
-rw-r--r--src/core/hle/service/nvnflinger/hardware_composer.cpp215
-rw-r--r--src/core/hle/service/nvnflinger/hardware_composer.h59
-rw-r--r--src/core/hle/service/nvnflinger/hwc_layer.h27
-rw-r--r--src/core/hle/service/nvnflinger/nvnflinger.cpp42
-rw-r--r--src/core/hle/service/nvnflinger/nvnflinger.h2
-rw-r--r--src/core/hle/service/vi/display/vi_display.cpp4
-rw-r--r--src/core/hle/service/vi/display/vi_display.h15
-rw-r--r--src/core/hle/service/vi/vi.cpp5
10 files changed, 357 insertions, 57 deletions
diff --git a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
index c1ebbd62d..abe95303e 100644
--- a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp
@@ -1,6 +1,8 @@
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
+#include <boost/container/small_vector.hpp>
+
#include "common/assert.h"
#include "common/logging/log.h"
#include "core/core.h"
@@ -38,19 +40,30 @@ NvResult nvdisp_disp0::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
void nvdisp_disp0::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {}
void nvdisp_disp0::OnClose(DeviceFD fd) {}
-void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, android::PixelFormat format, u32 width,
- u32 height, u32 stride, android::BufferTransformFlags transform,
- const Common::Rectangle<int>& crop_rect,
- std::array<Service::Nvidia::NvFence, 4>& fences, u32 num_fences) {
- const DAddr addr = nvmap.GetHandleAddress(buffer_handle);
- LOG_TRACE(Service,
- "Drawing from address {:X} offset {:08X} Width {} Height {} Stride {} Format {}",
- addr, offset, width, height, stride, format);
+void nvdisp_disp0::Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers) {
+ std::vector<Tegra::FramebufferConfig> output_layers;
+ std::vector<Service::Nvidia::NvFence> output_fences;
+ output_layers.reserve(sorted_layers.size());
+ output_fences.reserve(sorted_layers.size());
+
+ for (auto& layer : sorted_layers) {
+ output_layers.emplace_back(Tegra::FramebufferConfig{
+ .address = nvmap.GetHandleAddress(layer.buffer_handle),
+ .offset = layer.offset,
+ .width = layer.width,
+ .height = layer.height,
+ .stride = layer.stride,
+ .pixel_format = layer.format,
+ .transform_flags = layer.transform,
+ .crop_rect = layer.crop_rect,
+ });
- const Tegra::FramebufferConfig framebuffer{addr, offset, width, height,
- stride, format, transform, crop_rect};
+ for (size_t i = 0; i < layer.acquire_fence.num_fences; i++) {
+ output_fences.push_back(layer.acquire_fence.fences[i]);
+ }
+ }
- system.GPU().RequestSwapBuffers(&framebuffer, fences, num_fences);
+ system.GPU().RequestComposite(std::move(output_layers), std::move(output_fences));
system.SpeedLimiter().DoSpeedLimiting(system.CoreTiming().GetGlobalTimeUs());
system.GetPerfStats().EndSystemFrame();
system.GetPerfStats().BeginSystemFrame();
diff --git a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h
index 5f13a50a2..1082b85c2 100644
--- a/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h
+++ b/src/core/hle/service/nvdrv/devices/nvdisp_disp0.h
@@ -8,8 +8,7 @@
#include "common/common_types.h"
#include "common/math_util.h"
#include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "core/hle/service/nvnflinger/buffer_transform_flags.h"
-#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
namespace Service::Nvidia::NvCore {
class Container;
@@ -35,11 +34,8 @@ public:
void OnOpen(NvCore::SessionId session_id, DeviceFD fd) override;
void OnClose(DeviceFD fd) override;
- /// Performs a screen flip, drawing the buffer pointed to by the handle.
- void flip(u32 buffer_handle, u32 offset, android::PixelFormat format, u32 width, u32 height,
- u32 stride, android::BufferTransformFlags transform,
- const Common::Rectangle<int>& crop_rect,
- std::array<Service::Nvidia::NvFence, 4>& fences, u32 num_fences);
+ /// Performs a screen flip, compositing each buffer.
+ void Composite(std::span<const Nvnflinger::HwcLayer> sorted_layers);
Kernel::KEvent* QueryEvent(u32 event_id) override;
diff --git a/src/core/hle/service/nvnflinger/hardware_composer.cpp b/src/core/hle/service/nvnflinger/hardware_composer.cpp
new file mode 100644
index 000000000..c720dd1f8
--- /dev/null
+++ b/src/core/hle/service/nvnflinger/hardware_composer.cpp
@@ -0,0 +1,215 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <boost/container/small_vector.hpp>
+
+#include "common/microprofile.h"
+#include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
+#include "core/hle/service/nvnflinger/buffer_item.h"
+#include "core/hle/service/nvnflinger/buffer_item_consumer.h"
+#include "core/hle/service/nvnflinger/buffer_queue_producer.h"
+#include "core/hle/service/nvnflinger/hardware_composer.h"
+#include "core/hle/service/nvnflinger/hwc_layer.h"
+#include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
+#include "core/hle/service/vi/display/vi_display.h"
+#include "core/hle/service/vi/layer/vi_layer.h"
+
+namespace Service::Nvnflinger {
+
+namespace {
+
+s32 NormalizeSwapInterval(f32* out_speed_scale, s32 swap_interval) {
+ if (swap_interval <= 0) {
+ // As an extension, treat nonpositive swap interval as speed multiplier.
+ if (out_speed_scale) {
+ *out_speed_scale = 2.f * static_cast<f32>(1 - swap_interval);
+ }
+
+ swap_interval = 1;
+ }
+
+ if (swap_interval >= 5) {
+ // As an extension, treat high swap interval as precise speed control.
+ if (out_speed_scale) {
+ *out_speed_scale = static_cast<f32>(swap_interval) / 100.f;
+ }
+
+ swap_interval = 1;
+ }
+
+ return swap_interval;
+}
+
+} // namespace
+
+HardwareComposer::HardwareComposer() = default;
+HardwareComposer::~HardwareComposer() = default;
+
+u32 HardwareComposer::ComposeLocked(f32* out_speed_scale, VI::Display& display,
+ Nvidia::Devices::nvdisp_disp0& nvdisp, u32 frame_advance) {
+ boost::container::small_vector<HwcLayer, 2> composition_stack;
+
+ m_frame_number += frame_advance;
+
+ // Release any necessary framebuffers.
+ for (auto& [layer_id, framebuffer] : m_framebuffers) {
+ if (framebuffer.release_frame_number > m_frame_number) {
+ // Not yet ready to release this framebuffer.
+ continue;
+ }
+
+ if (!framebuffer.is_acquired) {
+ // Already released.
+ continue;
+ }
+
+ if (auto* layer = display.FindLayer(layer_id); layer != nullptr) {
+ // TODO: support release fence
+ // This is needed to prevent screen tearing
+ layer->GetConsumer().ReleaseBuffer(framebuffer.item, android::Fence::NoFence());
+ framebuffer.is_acquired = false;
+ }
+ }
+
+ // Set default speed limit to 100%.
+ *out_speed_scale = 1.0f;
+
+ // Determine the number of vsync periods to wait before composing again.
+ std::optional<s32> swap_interval{};
+ bool has_acquired_buffer{};
+
+ // Acquire all necessary framebuffers.
+ for (size_t i = 0; i < display.GetNumLayers(); i++) {
+ auto& layer = display.GetLayer(i);
+ auto layer_id = layer.GetLayerId();
+
+ // Try to fetch the framebuffer (either new or stale).
+ const auto result = this->CacheFramebufferLocked(layer, layer_id);
+
+ // If we failed, skip this layer.
+ if (result == CacheStatus::NoBufferAvailable) {
+ continue;
+ }
+
+ // If we acquired a new buffer, we need to present.
+ if (result == CacheStatus::BufferAcquired) {
+ has_acquired_buffer = true;
+ }
+
+ const auto& buffer = m_framebuffers[layer_id];
+ const auto& item = buffer.item;
+ const auto& igbp_buffer = *item.graphic_buffer;
+
+ // TODO: get proper Z-index from layer
+ composition_stack.emplace_back(HwcLayer{
+ .buffer_handle = igbp_buffer.BufferId(),
+ .offset = igbp_buffer.Offset(),
+ .format = igbp_buffer.ExternalFormat(),
+ .width = igbp_buffer.Width(),
+ .height = igbp_buffer.Height(),
+ .stride = igbp_buffer.Stride(),
+ .z_index = 0,
+ .transform = static_cast<android::BufferTransformFlags>(item.transform),
+ .crop_rect = item.crop,
+ .acquire_fence = item.fence,
+ });
+
+ // 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);
+
+ // TODO: handle cases where swap intervals are relatively prime. So far,
+ // only swap intervals of 0, 1 and 2 have been observed, but if 3 were
+ // to be introduced, this would cause an issue.
+ if (swap_interval) {
+ swap_interval = std::min(*swap_interval, item_swap_interval);
+ } else {
+ swap_interval = item_swap_interval;
+ }
+ }
+
+ // If any new buffers were acquired, we can present.
+ if (has_acquired_buffer) {
+ // Sort by Z-index.
+ std::stable_sort(composition_stack.begin(), composition_stack.end(),
+ [&](auto& l, auto& r) { return l.z_index < r.z_index; });
+
+ // Composite.
+ nvdisp.Composite(composition_stack);
+ }
+
+ // Render MicroProfile.
+ MicroProfileFlip();
+
+ // Advance by at least one frame.
+ return swap_interval.value_or(1);
+}
+
+void HardwareComposer::RemoveLayerLocked(VI::Display& display, LayerId layer_id) {
+ // Check if we are tracking a slot with this layer_id.
+ const auto it = m_framebuffers.find(layer_id);
+ if (it == m_framebuffers.end()) {
+ return;
+ }
+
+ // Try to release the buffer item.
+ auto* const layer = display.FindLayer(layer_id);
+ if (layer && it->second.is_acquired) {
+ layer->GetConsumer().ReleaseBuffer(it->second.item, android::Fence::NoFence());
+ }
+
+ // Erase the slot.
+ m_framebuffers.erase(it);
+}
+
+bool HardwareComposer::TryAcquireFramebufferLocked(VI::Layer& layer, Framebuffer& framebuffer) {
+ // Attempt the update.
+ const auto status = layer.GetConsumer().AcquireBuffer(&framebuffer.item, {}, false);
+ if (status != android::Status::NoError) {
+ return false;
+ }
+
+ // We succeeded, so set the new release frame info.
+ framebuffer.release_frame_number =
+ NormalizeSwapInterval(nullptr, framebuffer.item.swap_interval);
+ framebuffer.is_acquired = true;
+
+ return true;
+}
+
+HardwareComposer::CacheStatus HardwareComposer::CacheFramebufferLocked(VI::Layer& layer,
+ LayerId layer_id) {
+ // Check if this framebuffer is already present.
+ const auto it = m_framebuffers.find(layer_id);
+ if (it != m_framebuffers.end()) {
+ // If it's currently still acquired, we are done.
+ if (it->second.is_acquired) {
+ return CacheStatus::CachedBufferReused;
+ }
+
+ // Try to acquire a new item.
+ if (this->TryAcquireFramebufferLocked(layer, it->second)) {
+ // We got a new item.
+ return CacheStatus::BufferAcquired;
+ } else {
+ // We didn't acquire a new item, but we can reuse the slot.
+ return CacheStatus::CachedBufferReused;
+ }
+ }
+
+ // Framebuffer is not present, so try to create it.
+ Framebuffer framebuffer{};
+
+ if (this->TryAcquireFramebufferLocked(layer, framebuffer)) {
+ // Move the buffer item into a new slot.
+ m_framebuffers.emplace(layer_id, std::move(framebuffer));
+
+ // We succeeded.
+ return CacheStatus::BufferAcquired;
+ }
+
+ // We couldn't acquire the buffer item, so don't create a slot.
+ return CacheStatus::NoBufferAvailable;
+}
+
+} // namespace Service::Nvnflinger
diff --git a/src/core/hle/service/nvnflinger/hardware_composer.h b/src/core/hle/service/nvnflinger/hardware_composer.h
new file mode 100644
index 000000000..ddab94ac9
--- /dev/null
+++ b/src/core/hle/service/nvnflinger/hardware_composer.h
@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <boost/container/flat_map.hpp>
+
+#include "core/hle/service/nvnflinger/buffer_item.h"
+
+namespace Service::Nvidia::Devices {
+class nvdisp_disp0;
+}
+
+namespace Service::VI {
+class Display;
+class Layer;
+} // namespace Service::VI
+
+namespace Service::Nvnflinger {
+
+using LayerId = u64;
+
+class HardwareComposer {
+public:
+ explicit HardwareComposer();
+ ~HardwareComposer();
+
+ u32 ComposeLocked(f32* out_speed_scale, VI::Display& display,
+ Nvidia::Devices::nvdisp_disp0& nvdisp, u32 frame_advance);
+ void RemoveLayerLocked(VI::Display& display, LayerId layer_id);
+
+private:
+ // TODO: do we want to track frame number in vi instead?
+ u64 m_frame_number{0};
+
+private:
+ using ReleaseFrameNumber = u64;
+
+ struct Framebuffer {
+ android::BufferItem item{};
+ ReleaseFrameNumber release_frame_number{};
+ bool is_acquired{false};
+ };
+
+ enum class CacheStatus : u32 {
+ NoBufferAvailable,
+ BufferAcquired,
+ CachedBufferReused,
+ };
+
+ boost::container::flat_map<LayerId, Framebuffer> m_framebuffers{};
+
+private:
+ bool TryAcquireFramebufferLocked(VI::Layer& layer, Framebuffer& framebuffer);
+ CacheStatus CacheFramebufferLocked(VI::Layer& layer, LayerId layer_id);
+};
+
+} // namespace Service::Nvnflinger
diff --git a/src/core/hle/service/nvnflinger/hwc_layer.h b/src/core/hle/service/nvnflinger/hwc_layer.h
new file mode 100644
index 000000000..3af668a25
--- /dev/null
+++ b/src/core/hle/service/nvnflinger/hwc_layer.h
@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/math_util.h"
+#include "core/hle/service/nvdrv/nvdata.h"
+#include "core/hle/service/nvnflinger/buffer_transform_flags.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
+
+namespace Service::Nvnflinger {
+
+struct HwcLayer {
+ u32 buffer_handle;
+ u32 offset;
+ android::PixelFormat format;
+ u32 width;
+ u32 height;
+ u32 stride;
+ s32 z_index;
+ android::BufferTransformFlags transform;
+ Common::Rectangle<int> crop_rect;
+ android::Fence acquire_fence;
+};
+
+} // namespace Service::Nvnflinger
diff --git a/src/core/hle/service/nvnflinger/nvnflinger.cpp b/src/core/hle/service/nvnflinger/nvnflinger.cpp
index 51133853c..a4e848882 100644
--- a/src/core/hle/service/nvnflinger/nvnflinger.cpp
+++ b/src/core/hle/service/nvnflinger/nvnflinger.cpp
@@ -18,6 +18,7 @@
#include "core/hle/service/nvnflinger/buffer_item_consumer.h"
#include "core/hle/service/nvnflinger/buffer_queue_core.h"
#include "core/hle/service/nvnflinger/fb_share_buffer_manager.h"
+#include "core/hle/service/nvnflinger/hardware_composer.h"
#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
#include "core/hle/service/nvnflinger/nvnflinger.h"
#include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
@@ -279,45 +280,19 @@ void Nvnflinger::Compose() {
SCOPE_EXIT({ display.SignalVSyncEvent(); });
// Don't do anything for displays without layers.
- if (!display.HasLayers())
- continue;
-
- // TODO(Subv): Support more than 1 layer.
- VI::Layer& layer = display.GetLayer(0);
-
- android::BufferItem buffer{};
- const auto status = layer.GetConsumer().AcquireBuffer(&buffer, {}, false);
-
- if (status != android::Status::NoError) {
+ if (!display.HasLayers()) {
continue;
}
- const auto& igbp_buffer = *buffer.graphic_buffer;
-
if (!system.IsPoweredOn()) {
return; // We are likely shutting down
}
- // Now send the buffer to the GPU for drawing.
- // TODO(Subv): Support more than just disp0. The display device selection is probably based
- // on which display we're drawing (Default, Internal, External, etc)
auto nvdisp = nvdrv->GetDevice<Nvidia::Devices::nvdisp_disp0>(disp_fd);
ASSERT(nvdisp);
- Common::Rectangle<int> crop_rect{
- static_cast<int>(buffer.crop.Left()), static_cast<int>(buffer.crop.Top()),
- static_cast<int>(buffer.crop.Right()), static_cast<int>(buffer.crop.Bottom())};
-
- nvdisp->flip(igbp_buffer.BufferId(), igbp_buffer.Offset(), igbp_buffer.ExternalFormat(),
- igbp_buffer.Width(), igbp_buffer.Height(), igbp_buffer.Stride(),
- static_cast<android::BufferTransformFlags>(buffer.transform), crop_rect,
- buffer.fence.fences, buffer.fence.num_fences);
-
- MicroProfileFlip();
-
- swap_interval = buffer.swap_interval;
-
- layer.GetConsumer().ReleaseBuffer(buffer, android::Fence::NoFence());
+ swap_interval = display.GetComposer().ComposeLocked(&compose_speed_scale, display, *nvdisp,
+ swap_interval);
}
}
@@ -334,15 +309,16 @@ s64 Nvnflinger::GetNextTicks() const {
speed_scale = 0.01f;
}
}
+
+ // Adjust by speed limit determined during composition.
+ speed_scale /= compose_speed_scale;
+
if (system.GetNVDECActive() && settings.use_video_framerate.GetValue()) {
// Run at intended presentation rate during video playback.
speed_scale = 1.f;
}
- // As an extension, treat nonpositive swap interval as framerate multiplier.
- const f32 effective_fps = swap_interval <= 0 ? 120.f * static_cast<f32>(1 - swap_interval)
- : 60.f / static_cast<f32>(swap_interval);
-
+ const f32 effective_fps = 60.f / static_cast<f32>(swap_interval);
return static_cast<s64>(speed_scale * (1000000000.f / effective_fps));
}
diff --git a/src/core/hle/service/nvnflinger/nvnflinger.h b/src/core/hle/service/nvnflinger/nvnflinger.h
index 369439142..c984d55a0 100644
--- a/src/core/hle/service/nvnflinger/nvnflinger.h
+++ b/src/core/hle/service/nvnflinger/nvnflinger.h
@@ -46,6 +46,7 @@ class BufferQueueProducer;
namespace Service::Nvnflinger {
class FbShareBufferManager;
+class HardwareComposer;
class HosBinderDriverServer;
class Nvnflinger final {
@@ -143,6 +144,7 @@ private:
u32 next_buffer_queue_id = 1;
s32 swap_interval = 1;
+ f32 compose_speed_scale = 1.0f;
bool is_abandoned = false;
diff --git a/src/core/hle/service/vi/display/vi_display.cpp b/src/core/hle/service/vi/display/vi_display.cpp
index dab1905cc..7f2af9acc 100644
--- a/src/core/hle/service/vi/display/vi_display.cpp
+++ b/src/core/hle/service/vi/display/vi_display.cpp
@@ -16,6 +16,7 @@
#include "core/hle/service/nvnflinger/buffer_queue_consumer.h"
#include "core/hle/service/nvnflinger/buffer_queue_core.h"
#include "core/hle/service/nvnflinger/buffer_queue_producer.h"
+#include "core/hle/service/nvnflinger/hardware_composer.h"
#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
#include "core/hle/service/vi/display/vi_display.h"
#include "core/hle/service/vi/layer/vi_layer.h"
@@ -43,6 +44,7 @@ Display::Display(u64 id, std::string name_,
KernelHelpers::ServiceContext& service_context_, Core::System& system_)
: display_id{id}, name{std::move(name_)}, hos_binder_driver_server{hos_binder_driver_server_},
service_context{service_context_} {
+ hardware_composer = std::make_unique<Nvnflinger::HardwareComposer>();
vsync_event = service_context.CreateEvent(fmt::format("Display VSync Event {}", id));
}
@@ -81,8 +83,6 @@ void Display::SignalVSyncEvent() {
void Display::CreateLayer(u64 layer_id, u32 binder_id,
Service::Nvidia::NvCore::Container& nv_core) {
- ASSERT_MSG(layers.empty(), "Only one layer is supported per display at the moment");
-
auto [core, producer, consumer] = CreateBufferQueue(service_context, nv_core.GetNvMapFile());
auto buffer_item_consumer = std::make_shared<android::BufferItemConsumer>(std::move(consumer));
diff --git a/src/core/hle/service/vi/display/vi_display.h b/src/core/hle/service/vi/display/vi_display.h
index 8eb8a5155..220292cff 100644
--- a/src/core/hle/service/vi/display/vi_display.h
+++ b/src/core/hle/service/vi/display/vi_display.h
@@ -11,9 +11,14 @@
#include "common/common_types.h"
#include "core/hle/result.h"
+namespace Core {
+class System;
+}
+
namespace Kernel {
class KEvent;
-}
+class KReadableEvent;
+} // namespace Kernel
namespace Service::android {
class BufferQueueProducer;
@@ -24,8 +29,9 @@ class ServiceContext;
}
namespace Service::Nvnflinger {
+class HardwareComposer;
class HosBinderDriverServer;
-}
+} // namespace Service::Nvnflinger
namespace Service::Nvidia::NvCore {
class Container;
@@ -118,6 +124,10 @@ public:
///
const Layer* FindLayer(u64 layer_id) const;
+ Nvnflinger::HardwareComposer& GetComposer() const {
+ return *hardware_composer;
+ }
+
private:
u64 display_id;
std::string name;
@@ -125,6 +135,7 @@ private:
KernelHelpers::ServiceContext& service_context;
std::vector<std::unique_ptr<Layer>> layers;
+ std::unique_ptr<Nvnflinger::HardwareComposer> hardware_composer;
Kernel::KEvent* vsync_event{};
bool is_abandoned{};
};
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index 73058db9a..d508ed28c 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -195,8 +195,9 @@ private:
void GetSharedBufferMemoryHandleId(HLERequestContext& ctx) {
IPC::RequestParser rp{ctx};
const u64 buffer_id = rp.PopRaw<u64>();
+ const u64 aruid = ctx.GetPID();
- LOG_INFO(Service_VI, "called. buffer_id={:#x}", buffer_id);
+ LOG_INFO(Service_VI, "called. buffer_id={:#x}, aruid={:#x}", buffer_id, aruid);
struct OutputParameters {
s32 nvmap_handle;
@@ -206,7 +207,7 @@ private:
OutputParameters out{};
Nvnflinger::SharedMemoryPoolLayout layout{};
const auto result = nvnflinger.GetSystemBufferManager().GetSharedBufferMemoryHandleId(
- &out.size, &out.nvmap_handle, &layout, buffer_id, 0);
+ &out.size, &out.nvmap_handle, &layout, buffer_id, aruid);
ctx.WriteBuffer(&layout, sizeof(layout));