early-access version 1255

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -0,0 +1,193 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/readable_event.h"
+#include "core/hle/kernel/writable_event.h"
+#include "core/hle/service/nvflinger/buffer_queue.h"
+
+namespace Service::NVFlinger {
+
+BufferQueue::BufferQueue(Kernel::KernelCore& kernel, u32 id, u64 layer_id)
+    : id(id), layer_id(layer_id) {
+    buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, "BufferQueue NativeHandle");
+}
+
+BufferQueue::~BufferQueue() = default;
+
+void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) {
+    ASSERT(slot < buffer_slots);
+    LOG_WARNING(Service, "Adding graphics buffer {}", slot);
+
+    {
+        std::unique_lock lock{queue_mutex};
+        free_buffers.push_back(slot);
+    }
+    condition.notify_one();
+
+    buffers[slot] = {
+        .slot = slot,
+        .status = Buffer::Status::Free,
+        .igbp_buffer = igbp_buffer,
+        .transform = {},
+        .crop_rect = {},
+        .swap_interval = 0,
+        .multi_fence = {},
+    };
+
+    buffer_wait_event.writable->Signal();
+}
+
+std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::DequeueBuffer(u32 width,
+                                                                                       u32 height) {
+    // Wait for first request before trying to dequeue
+    {
+        std::unique_lock lock{queue_mutex};
+        condition.wait(lock, [this] { return !free_buffers.empty() || !is_connect; });
+    }
+
+    if (!is_connect) {
+        // Buffer was disconnected while the thread was blocked, this is most likely due to
+        // emulation being stopped
+        return std::nullopt;
+    }
+
+    std::unique_lock lock{queue_mutex};
+
+    auto f_itr = free_buffers.begin();
+    auto slot = buffers.size();
+
+    while (f_itr != free_buffers.end()) {
+        const Buffer& buffer = buffers[*f_itr];
+        if (buffer.status == Buffer::Status::Free && buffer.igbp_buffer.width == width &&
+            buffer.igbp_buffer.height == height) {
+            slot = *f_itr;
+            free_buffers.erase(f_itr);
+            break;
+        }
+        ++f_itr;
+    }
+    if (slot == buffers.size()) {
+        return std::nullopt;
+    }
+    buffers[slot].status = Buffer::Status::Dequeued;
+    return {{buffers[slot].slot, &buffers[slot].multi_fence}};
+}
+
+const IGBPBuffer& BufferQueue::RequestBuffer(u32 slot) const {
+    ASSERT(slot < buffers.size());
+    ASSERT(buffers[slot].status == Buffer::Status::Dequeued);
+    ASSERT(buffers[slot].slot == slot);
+
+    return buffers[slot].igbp_buffer;
+}
+
+void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
+                              const Common::Rectangle<int>& crop_rect, u32 swap_interval,
+                              Service::Nvidia::MultiFence& multi_fence) {
+    ASSERT(slot < buffers.size());
+    ASSERT(buffers[slot].status == Buffer::Status::Dequeued);
+    ASSERT(buffers[slot].slot == slot);
+
+    buffers[slot].status = Buffer::Status::Queued;
+    buffers[slot].transform = transform;
+    buffers[slot].crop_rect = crop_rect;
+    buffers[slot].swap_interval = swap_interval;
+    buffers[slot].multi_fence = multi_fence;
+    queue_sequence.push_back(slot);
+}
+
+void BufferQueue::CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& multi_fence) {
+    ASSERT(slot < buffers.size());
+    ASSERT(buffers[slot].status != Buffer::Status::Free);
+    ASSERT(buffers[slot].slot == slot);
+
+    buffers[slot].status = Buffer::Status::Free;
+    buffers[slot].multi_fence = multi_fence;
+    buffers[slot].swap_interval = 0;
+
+    {
+        std::unique_lock lock{queue_mutex};
+        free_buffers.push_back(slot);
+    }
+    condition.notify_one();
+
+    buffer_wait_event.writable->Signal();
+}
+
+std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
+    std::size_t buffer_slot = buffers.size();
+    // Iterate to find a queued buffer matching the requested slot.
+    while (buffer_slot == buffers.size() && !queue_sequence.empty()) {
+        const auto slot = static_cast<std::size_t>(queue_sequence.front());
+        ASSERT(slot < buffers.size());
+        if (buffers[slot].status == Buffer::Status::Queued) {
+            ASSERT(buffers[slot].slot == slot);
+            buffer_slot = slot;
+        }
+        queue_sequence.pop_front();
+    }
+    if (buffer_slot == buffers.size()) {
+        return std::nullopt;
+    }
+    buffers[buffer_slot].status = Buffer::Status::Acquired;
+    return {{buffers[buffer_slot]}};
+}
+
+void BufferQueue::ReleaseBuffer(u32 slot) {
+    ASSERT(slot < buffers.size());
+    ASSERT(buffers[slot].status == Buffer::Status::Acquired);
+    ASSERT(buffers[slot].slot == slot);
+
+    buffers[slot].status = Buffer::Status::Free;
+    {
+        std::unique_lock lock{queue_mutex};
+        free_buffers.push_back(slot);
+    }
+    condition.notify_one();
+
+    buffer_wait_event.writable->Signal();
+}
+
+void BufferQueue::Connect() {
+    queue_sequence.clear();
+    id = 1;
+    layer_id = 1;
+    is_connect = true;
+}
+
+void BufferQueue::Disconnect() {
+    buffers.fill({});
+    queue_sequence.clear();
+    buffer_wait_event.writable->Signal();
+    is_connect = false;
+    condition.notify_one();
+}
+
+u32 BufferQueue::Query(QueryType type) {
+    LOG_WARNING(Service, "(STUBBED) called type={}", type);
+
+    switch (type) {
+    case QueryType::NativeWindowFormat:
+        return static_cast<u32>(PixelFormat::RGBA8888);
+    }
+
+    UNIMPLEMENTED();
+    return 0;
+}
+
+std::shared_ptr<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
+    return buffer_wait_event.writable;
+}
+
+std::shared_ptr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
+    return buffer_wait_event.readable;
+}
+
+} // namespace Service::NVFlinger

src/core/hle/service/nvflinger/buffer_queue.h

@@ -0,0 +1,136 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <condition_variable>
+#include <list>
+#include <mutex>
+#include <optional>
+#include <vector>
+
+#include "common/common_funcs.h"
+#include "common/math_util.h"
+#include "common/swap.h"
+#include "core/hle/kernel/object.h"
+#include "core/hle/kernel/writable_event.h"
+#include "core/hle/service/nvdrv/nvdata.h"
+
+namespace Kernel {
+class KernelCore;
+}
+
+namespace Service::NVFlinger {
+
+constexpr u32 buffer_slots = 0x40;
+struct IGBPBuffer {
+    u32_le magic;
+    u32_le width;
+    u32_le height;
+    u32_le stride;
+    u32_le format;
+    u32_le usage;
+    INSERT_PADDING_WORDS(1);
+    u32_le index;
+    INSERT_PADDING_WORDS(3);
+    u32_le gpu_buffer_id;
+    INSERT_PADDING_WORDS(17);
+    u32_le nvmap_handle;
+    u32_le offset;
+    INSERT_PADDING_WORDS(60);
+};
+
+static_assert(sizeof(IGBPBuffer) == 0x16C, "IGBPBuffer has wrong size");
+
+class BufferQueue final {
+public:
+    enum class QueryType {
+        NativeWindowWidth = 0,
+        NativeWindowHeight = 1,
+        NativeWindowFormat = 2,
+    };
+
+    explicit BufferQueue(Kernel::KernelCore& kernel, u32 id, u64 layer_id);
+    ~BufferQueue();
+
+    enum class BufferTransformFlags : u32 {
+        /// No transform flags are set
+        Unset = 0x00,
+        /// Flip source image horizontally (around the vertical axis)
+        FlipH = 0x01,
+        /// Flip source image vertically (around the horizontal axis)
+        FlipV = 0x02,
+        /// Rotate source image 90 degrees clockwise
+        Rotate90 = 0x04,
+        /// Rotate source image 180 degrees
+        Rotate180 = 0x03,
+        /// Rotate source image 270 degrees clockwise
+        Rotate270 = 0x07,
+    };
+
+    enum class PixelFormat : u32 {
+        RGBA8888 = 1,
+        RGBX8888 = 2,
+        RGB888 = 3,
+        RGB565 = 4,
+        BGRA8888 = 5,
+        RGBA5551 = 6,
+        RRGBA4444 = 7,
+    };
+
+    struct Buffer {
+        enum class Status { Free = 0, Queued = 1, Dequeued = 2, Acquired = 3 };
+
+        u32 slot;
+        Status status = Status::Free;
+        IGBPBuffer igbp_buffer;
+        BufferTransformFlags transform;
+        Common::Rectangle<int> crop_rect;
+        u32 swap_interval;
+        Service::Nvidia::MultiFence multi_fence;
+    };
+
+    void SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer);
+    std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> DequeueBuffer(u32 width,
+                                                                              u32 height);
+    const IGBPBuffer& RequestBuffer(u32 slot) const;
+    void QueueBuffer(u32 slot, BufferTransformFlags transform,
+                     const Common::Rectangle<int>& crop_rect, u32 swap_interval,
+                     Service::Nvidia::MultiFence& multi_fence);
+    void CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& multi_fence);
+    std::optional<std::reference_wrapper<const Buffer>> AcquireBuffer();
+    void ReleaseBuffer(u32 slot);
+    void Connect();
+    void Disconnect();
+    u32 Query(QueryType type);
+
+    u32 GetId() const {
+        return id;
+    }
+
+    bool IsConnected() const {
+        return is_connect;
+    }
+
+    std::shared_ptr<Kernel::WritableEvent> GetWritableBufferWaitEvent() const;
+
+    std::shared_ptr<Kernel::ReadableEvent> GetBufferWaitEvent() const;
+
+private:
+    BufferQueue(const BufferQueue&) = delete;
+
+    u32 id{};
+    u64 layer_id{};
+    std::atomic_bool is_connect{};
+
+    std::list<u32> free_buffers;
+    std::array<Buffer, buffer_slots> buffers;
+    std::list<u32> queue_sequence;
+    Kernel::EventPair buffer_wait_event;
+
+    std::mutex queue_mutex;
+    std::condition_variable condition;
+};
+
+} // namespace Service::NVFlinger

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -0,0 +1,288 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <optional>
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "common/microprofile.h"
+#include "common/scope_exit.h"
+#include "common/thread.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/core_timing_util.h"
+#include "core/hardware_properties.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/readable_event.h"
+#include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
+#include "core/hle/service/nvdrv/nvdrv.h"
+#include "core/hle/service/nvflinger/buffer_queue.h"
+#include "core/hle/service/nvflinger/nvflinger.h"
+#include "core/hle/service/vi/display/vi_display.h"
+#include "core/hle/service/vi/layer/vi_layer.h"
+#include "core/perf_stats.h"
+#include "core/settings.h"
+#include "video_core/renderer_base.h"
+
+namespace Service::NVFlinger {
+
+constexpr auto frame_ns = std::chrono::nanoseconds{1000000000 / 60};
+
+void NVFlinger::VSyncThread(NVFlinger& nv_flinger) {
+    nv_flinger.SplitVSync();
+}
+
+void NVFlinger::SplitVSync() {
+    system.RegisterHostThread();
+    std::string name = "yuzu:VSyncThread";
+    MicroProfileOnThreadCreate(name.c_str());
+    Common::SetCurrentThreadName(name.c_str());
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+    s64 delay = 0;
+    while (is_running) {
+        guard->lock();
+        const s64 time_start = system.CoreTiming().GetGlobalTimeNs().count();
+        Compose();
+        const auto ticks = GetNextTicks();
+        const s64 time_end = system.CoreTiming().GetGlobalTimeNs().count();
+        const s64 time_passed = time_end - time_start;
+        const s64 next_time = std::max<s64>(0, ticks - time_passed - delay);
+        guard->unlock();
+        if (next_time > 0) {
+            wait_event->WaitFor(std::chrono::nanoseconds{next_time});
+        }
+        delay = (system.CoreTiming().GetGlobalTimeNs().count() - time_end) - next_time;
+    }
+}
+
+NVFlinger::NVFlinger(Core::System& system) : system(system) {
+    displays.emplace_back(0, "Default", system);
+    displays.emplace_back(1, "External", system);
+    displays.emplace_back(2, "Edid", system);
+    displays.emplace_back(3, "Internal", system);
+    displays.emplace_back(4, "Null", system);
+    guard = std::make_shared<std::mutex>();
+
+    // Schedule the screen composition events
+    composition_event = Core::Timing::CreateEvent(
+        "ScreenComposition", [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
+            const auto guard = Lock();
+            Compose();
+
+            const auto ticks = std::chrono::nanoseconds{GetNextTicks()};
+            const auto ticks_delta = ticks - ns_late;
+            const auto future_ns = std::max(std::chrono::nanoseconds::zero(), ticks_delta);
+
+            this->system.CoreTiming().ScheduleEvent(future_ns, composition_event);
+        });
+
+    if (system.IsMulticore()) {
+        is_running = true;
+        wait_event = std::make_unique<Common::Event>();
+        vsync_thread = std::make_unique<std::thread>(VSyncThread, std::ref(*this));
+    } else {
+        system.CoreTiming().ScheduleEvent(frame_ns, composition_event);
+    }
+}
+
+NVFlinger::~NVFlinger() {
+    for (auto& buffer_queue : buffer_queues) {
+        buffer_queue->Disconnect();
+    }
+
+    if (system.IsMulticore()) {
+        is_running = false;
+        wait_event->Set();
+        vsync_thread->join();
+        vsync_thread.reset();
+        wait_event.reset();
+    } else {
+        system.CoreTiming().UnscheduleEvent(composition_event, 0);
+    }
+}
+
+void NVFlinger::SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance) {
+    nvdrv = std::move(instance);
+}
+
+std::optional<u64> NVFlinger::OpenDisplay(std::string_view name) {
+    const auto guard = Lock();
+
+    LOG_DEBUG(Service, "Opening \"{}\" display", name);
+
+    // TODO(Subv): Currently we only support the Default display.
+    ASSERT(name == "Default");
+
+    const auto itr =
+        std::find_if(displays.begin(), displays.end(),
+                     [&](const VI::Display& display) { return display.GetName() == name; });
+
+    if (itr == displays.end()) {
+        return std::nullopt;
+    }
+
+    return itr->GetID();
+}
+
+std::optional<u64> NVFlinger::CreateLayer(u64 display_id) {
+    const auto guard = Lock();
+    auto* const display = FindDisplay(display_id);
+
+    if (display == nullptr) {
+        return std::nullopt;
+    }
+
+    const u64 layer_id = next_layer_id++;
+    const u32 buffer_queue_id = next_buffer_queue_id++;
+    buffer_queues.emplace_back(
+        std::make_unique<BufferQueue>(system.Kernel(), buffer_queue_id, layer_id));
+    display->CreateLayer(layer_id, *buffer_queues.back());
+    return layer_id;
+}
+
+void NVFlinger::CloseLayer(u64 layer_id) {
+    const auto guard = Lock();
+
+    for (auto& display : displays) {
+        display.CloseLayer(layer_id);
+    }
+}
+
+std::optional<u32> NVFlinger::FindBufferQueueId(u64 display_id, u64 layer_id) const {
+    const auto guard = Lock();
+    const auto* const layer = FindLayer(display_id, layer_id);
+
+    if (layer == nullptr) {
+        return std::nullopt;
+    }
+
+    return layer->GetBufferQueue().GetId();
+}
+
+std::shared_ptr<Kernel::ReadableEvent> NVFlinger::FindVsyncEvent(u64 display_id) const {
+    const auto guard = Lock();
+    auto* const display = FindDisplay(display_id);
+
+    if (display == nullptr) {
+        return nullptr;
+    }
+
+    return display->GetVSyncEvent();
+}
+
+BufferQueue* NVFlinger::FindBufferQueue(u32 id) {
+    const auto guard = Lock();
+    const auto itr = std::find_if(buffer_queues.begin(), buffer_queues.end(),
+                                  [id](const auto& queue) { return queue->GetId() == id; });
+
+    if (itr == buffer_queues.end()) {
+        return nullptr;
+    }
+
+    return itr->get();
+}
+
+VI::Display* NVFlinger::FindDisplay(u64 display_id) {
+    const auto itr =
+        std::find_if(displays.begin(), displays.end(),
+                     [&](const VI::Display& display) { return display.GetID() == display_id; });
+
+    if (itr == displays.end()) {
+        return nullptr;
+    }
+
+    return &*itr;
+}
+
+const VI::Display* NVFlinger::FindDisplay(u64 display_id) const {
+    const auto itr =
+        std::find_if(displays.begin(), displays.end(),
+                     [&](const VI::Display& display) { return display.GetID() == display_id; });
+
+    if (itr == displays.end()) {
+        return nullptr;
+    }
+
+    return &*itr;
+}
+
+VI::Layer* NVFlinger::FindLayer(u64 display_id, u64 layer_id) {
+    auto* const display = FindDisplay(display_id);
+
+    if (display == nullptr) {
+        return nullptr;
+    }
+
+    return display->FindLayer(layer_id);
+}
+
+const VI::Layer* NVFlinger::FindLayer(u64 display_id, u64 layer_id) const {
+    const auto* const display = FindDisplay(display_id);
+
+    if (display == nullptr) {
+        return nullptr;
+    }
+
+    return display->FindLayer(layer_id);
+}
+
+void NVFlinger::Compose() {
+    for (auto& display : displays) {
+        // Trigger vsync for this display at the end of drawing
+        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);
+        auto& buffer_queue = layer.GetBufferQueue();
+
+        // Search for a queued buffer and acquire it
+        auto buffer = buffer_queue.AcquireBuffer();
+
+        if (!buffer) {
+            continue;
+        }
+
+        const auto& igbp_buffer = buffer->get().igbp_buffer;
+
+        if (!system.IsPoweredOn()) {
+            return; // We are likely shutting down
+        }
+
+        auto& gpu = system.GPU();
+        const auto& multi_fence = buffer->get().multi_fence;
+        guard->unlock();
+        for (u32 fence_id = 0; fence_id < multi_fence.num_fences; fence_id++) {
+            const auto& fence = multi_fence.fences[fence_id];
+            gpu.WaitFence(fence.id, fence.value);
+        }
+        guard->lock();
+
+        MicroProfileFlip();
+
+        // 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>("/dev/nvdisp_disp0");
+        ASSERT(nvdisp);
+
+        nvdisp->flip(igbp_buffer.gpu_buffer_id, igbp_buffer.offset, igbp_buffer.format,
+                     igbp_buffer.width, igbp_buffer.height, igbp_buffer.stride,
+                     buffer->get().transform, buffer->get().crop_rect);
+
+        swap_interval = buffer->get().swap_interval;
+        buffer_queue.ReleaseBuffer(buffer->get().slot);
+    }
+}
+
+s64 NVFlinger::GetNextTicks() const {
+    constexpr s64 max_hertz = 120LL;
+    return (1000000000 * (1LL << swap_interval)) / max_hertz;
+}
+
+} // namespace Service::NVFlinger

src/core/hle/service/nvflinger/nvflinger.h

@@ -0,0 +1,132 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <vector>
+
+#include "common/common_types.h"
+#include "core/hle/kernel/object.h"
+
+namespace Common {
+class Event;
+} // namespace Common
+
+namespace Core::Timing {
+class CoreTiming;
+struct EventType;
+} // namespace Core::Timing
+
+namespace Kernel {
+class ReadableEvent;
+class WritableEvent;
+} // namespace Kernel
+
+namespace Service::Nvidia {
+class Module;
+} // namespace Service::Nvidia
+
+namespace Service::VI {
+class Display;
+class Layer;
+} // namespace Service::VI
+
+namespace Service::NVFlinger {
+
+class BufferQueue;
+
+class NVFlinger final {
+public:
+    explicit NVFlinger(Core::System& system);
+    ~NVFlinger();
+
+    /// Sets the NVDrv module instance to use to send buffers to the GPU.
+    void SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance);
+
+    /// Opens the specified display and returns the ID.
+    ///
+    /// If an invalid display name is provided, then an empty optional is returned.
+    [[nodiscard]] std::optional<u64> OpenDisplay(std::string_view name);
+
+    /// Creates a layer on the specified display and returns the layer ID.
+    ///
+    /// If an invalid display ID is specified, then an empty optional is returned.
+    [[nodiscard]] std::optional<u64> CreateLayer(u64 display_id);
+
+    /// Closes a layer on all displays for the given layer ID.
+    void CloseLayer(u64 layer_id);
+
+    /// Finds the buffer queue ID of the specified layer in the specified display.
+    ///
+    /// If an invalid display ID or layer ID is provided, then an empty optional is returned.
+    [[nodiscard]] std::optional<u32> FindBufferQueueId(u64 display_id, u64 layer_id) const;
+
+    /// Gets the vsync event for the specified display.
+    ///
+    /// If an invalid display ID is provided, then nullptr is returned.
+    [[nodiscard]] std::shared_ptr<Kernel::ReadableEvent> FindVsyncEvent(u64 display_id) const;
+
+    /// Obtains a buffer queue identified by the ID.
+    [[nodiscard]] BufferQueue* FindBufferQueue(u32 id);
+
+    /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
+    /// finished.
+    void Compose();
+
+    [[nodiscard]] s64 GetNextTicks() const;
+
+private:
+    [[nodiscard]] std::unique_lock<std::mutex> Lock() const {
+        return std::unique_lock{*guard};
+    }
+
+    /// Finds the display identified by the specified ID.
+    [[nodiscard]] VI::Display* FindDisplay(u64 display_id);
+
+    /// Finds the display identified by the specified ID.
+    [[nodiscard]] const VI::Display* FindDisplay(u64 display_id) const;
+
+    /// Finds the layer identified by the specified ID in the desired display.
+    [[nodiscard]] VI::Layer* FindLayer(u64 display_id, u64 layer_id);
+
+    /// Finds the layer identified by the specified ID in the desired display.
+    [[nodiscard]] const VI::Layer* FindLayer(u64 display_id, u64 layer_id) const;
+
+    static void VSyncThread(NVFlinger& nv_flinger);
+
+    void SplitVSync();
+
+    std::shared_ptr<Nvidia::Module> nvdrv;
+
+    std::vector<VI::Display> displays;
+    std::vector<std::unique_ptr<BufferQueue>> buffer_queues;
+
+    /// Id to use for the next layer that is created, this counter is shared among all displays.
+    u64 next_layer_id = 1;
+    /// Id to use for the next buffer queue that is created, this counter is shared among all
+    /// layers.
+    u32 next_buffer_queue_id = 1;
+
+    u32 swap_interval = 1;
+
+    /// Event that handles screen composition.
+    std::shared_ptr<Core::Timing::EventType> composition_event;
+
+    std::shared_ptr<std::mutex> guard;
+
+    Core::System& system;
+
+    std::unique_ptr<std::thread> vsync_thread;
+    std::unique_ptr<Common::Event> wait_event;
+    std::atomic<bool> is_running{};
+};
+
+} // namespace Service::NVFlinger