tacosukoneko/suyu
1
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity

Service/vi: convert services to module

Browse source
This commit is contained in:
mailwl 2018-03-21 13:09:40 +03:00
parent 0b3ab30762
commit 6673ed1274
8 changed files with 158 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

242
src/core/hle/service/vi/vi.cpp
View file

@ -4,10 +4,13 @@
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <memory>
#include <boost/optional.hpp>
#include "common/alignment.h" #include "common/alignment.h"
#include "common/scope_exit.h" #include "common/scope_exit.h"
#include "core/core_timing.h" #include "core/core_timing.h"
#include "core/hle/ipc_helpers.h" #include "core/hle/ipc_helpers.h"
#include "core/hle/kernel/event.h"
#include "core/hle/service/nvdrv/nvdrv.h" #include "core/hle/service/nvdrv/nvdrv.h"
#include "core/hle/service/nvflinger/buffer_queue.h" #include "core/hle/service/nvflinger/buffer_queue.h"
#include "core/hle/service/vi/vi.h" #include "core/hle/service/vi/vi.h"
@ -646,144 +649,152 @@ private:
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger; std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
}; };
void IApplicationDisplayService::GetRelayService(Kernel::HLERequestContext& ctx) { class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
LOG_WARNING(Service_VI, "(STUBBED) called"); public:
IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
~IApplicationDisplayService() = default;
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; private:
rb.Push(RESULT_SUCCESS); void GetRelayService(Kernel::HLERequestContext& ctx) {
rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger); LOG_WARNING(Service_VI, "(STUBBED) called");
}
void IApplicationDisplayService::GetSystemDisplayService(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 2, 0, 1};
LOG_WARNING(Service_VI, "(STUBBED) called"); rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
}
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; void GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
rb.Push(RESULT_SUCCESS); LOG_WARNING(Service_VI, "(STUBBED) called");
rb.PushIpcInterface<ISystemDisplayService>();
}
void IApplicationDisplayService::GetManagerDisplayService(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 2, 0, 1};
LOG_WARNING(Service_VI, "(STUBBED) called"); rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<ISystemDisplayService>();
}
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; void GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
rb.Push(RESULT_SUCCESS); LOG_WARNING(Service_VI, "(STUBBED) called");
rb.PushIpcInterface<IManagerDisplayService>(nv_flinger);
}
void IApplicationDisplayService::GetIndirectDisplayTransactionService( IPC::ResponseBuilder rb{ctx, 2, 0, 1};
Kernel::HLERequestContext& ctx) { rb.Push(RESULT_SUCCESS);
LOG_WARNING(Service_VI, "(STUBBED) called"); rb.PushIpcInterface<IManagerDisplayService>(nv_flinger);
}
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx) {
rb.Push(RESULT_SUCCESS); LOG_WARNING(Service_VI, "(STUBBED) called");
rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
}
void IApplicationDisplayService::OpenDisplay(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb{ctx, 2, 0, 1};
LOG_WARNING(Service_VI, "(STUBBED) called"); rb.Push(RESULT_SUCCESS);
IPC::RequestParser rp{ctx}; rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
auto name_buf = rp.PopRaw<std::array<u8, 0x40>>(); }
auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
std::string name(name_buf.begin(), end); void OpenDisplay(Kernel::HLERequestContext& ctx) {
LOG_WARNING(Service_VI, "(STUBBED) called");
IPC::RequestParser rp{ctx};
auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet"); std::string name(name_buf.begin(), end);
IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0); ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
rb.Push(RESULT_SUCCESS);
rb.Push<u64>(nv_flinger->OpenDisplay(name));
}
void IApplicationDisplayService::CloseDisplay(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
LOG_WARNING(Service_VI, "(STUBBED) called"); rb.Push(RESULT_SUCCESS);
IPC::RequestParser rp{ctx}; rb.Push<u64>(nv_flinger->OpenDisplay(name));
u64 display_id = rp.Pop<u64>(); }
IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0); void CloseDisplay(Kernel::HLERequestContext& ctx) {
rb.Push(RESULT_SUCCESS); LOG_WARNING(Service_VI, "(STUBBED) called");
} IPC::RequestParser rp{ctx};
u64 display_id = rp.Pop<u64>();
void IApplicationDisplayService::OpenLayer(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
LOG_DEBUG(Service_VI, "called"); rb.Push(RESULT_SUCCESS);
IPC::RequestParser rp{ctx}; }
auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
std::string display_name(name_buf.begin(), end); void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
LOG_WARNING(Service_VI, "(STUBBED) called");
IPC::RequestParser rp{ctx};
u32 scaling_mode = rp.Pop<u32>();
u64 unknown = rp.Pop<u64>();
u64 layer_id = rp.Pop<u64>(); IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
u64 aruid = rp.Pop<u64>(); rb.Push(RESULT_SUCCESS);
}
u64 display_id = nv_flinger->OpenDisplay(display_name); void ListDisplays(Kernel::HLERequestContext& ctx) {
u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id); IPC::RequestParser rp{ctx};
DisplayInfo display_info;
ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
rb.Push(RESULT_SUCCESS);
rb.Push<u64>(1);
LOG_WARNING(Service_VI, "(STUBBED) called");
}
NativeWindow native_window{buffer_queue_id}; void OpenLayer(Kernel::HLERequestContext& ctx) {
IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0); LOG_DEBUG(Service_VI, "called");
rb.Push(RESULT_SUCCESS); IPC::RequestParser rp{ctx};
rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize())); auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
} auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
void IApplicationDisplayService::CreateStrayLayer(Kernel::HLERequestContext& ctx) { std::string display_name(name_buf.begin(), end);
LOG_DEBUG(Service_VI, "called");
IPC::RequestParser rp{ctx}; u64 layer_id = rp.Pop<u64>();
u32 flags = rp.Pop<u32>(); u64 aruid = rp.Pop<u64>();
rp.Pop<u32>(); // padding
u64 display_id = rp.Pop<u64>();
// TODO(Subv): What's the difference between a Stray and a Managed layer? u64 display_id = nv_flinger->OpenDisplay(display_name);
u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
u64 layer_id = nv_flinger->CreateLayer(display_id); NativeWindow native_window{buffer_queue_id};
u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id); IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
rb.Push(RESULT_SUCCESS);
rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
}
NativeWindow native_window{buffer_queue_id}; void CreateStrayLayer(Kernel::HLERequestContext& ctx) {
IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0); LOG_DEBUG(Service_VI, "called");
rb.Push(RESULT_SUCCESS);
rb.Push(layer_id);
rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
}
void IApplicationDisplayService::DestroyStrayLayer(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp{ctx};
LOG_WARNING(Service_VI, "(STUBBED) called"); u32 flags = rp.Pop<u32>();
rp.Pop<u32>(); // padding
u64 display_id = rp.Pop<u64>();
IPC::RequestParser rp{ctx}; // TODO(Subv): What's the difference between a Stray and a Managed layer?
u64 layer_id = rp.Pop<u64>();
IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0); u64 layer_id = nv_flinger->CreateLayer(display_id);
rb.Push(RESULT_SUCCESS); u32 buffer_queue_id = nv_flinger->GetBufferQueueId(display_id, layer_id);
}
void IApplicationDisplayService::SetLayerScalingMode(Kernel::HLERequestContext& ctx) { NativeWindow native_window{buffer_queue_id};
LOG_WARNING(Service_VI, "(STUBBED) called"); IPC::ResponseBuilder rb = rp.MakeBuilder(6, 0, 0);
IPC::RequestParser rp{ctx}; rb.Push(RESULT_SUCCESS);
u32 scaling_mode = rp.Pop<u32>(); rb.Push(layer_id);
u64 unknown = rp.Pop<u64>(); rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
}
IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0); void DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
rb.Push(RESULT_SUCCESS); LOG_WARNING(Service_VI, "(STUBBED) called");
}
void IApplicationDisplayService::ListDisplays(Kernel::HLERequestContext& ctx) { IPC::RequestParser rp{ctx};
IPC::RequestParser rp{ctx}; u64 layer_id = rp.Pop<u64>();
DisplayInfo display_info;
ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
IPC::ResponseBuilder rb = rp.MakeBuilder(4, 0, 0);
rb.Push(RESULT_SUCCESS);
rb.Push<u64>(1);
LOG_WARNING(Service_VI, "(STUBBED) called");
}
void IApplicationDisplayService::GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) { IPC::ResponseBuilder rb = rp.MakeBuilder(2, 0, 0);
LOG_WARNING(Service_VI, "(STUBBED) called"); rb.Push(RESULT_SUCCESS);
IPC::RequestParser rp{ctx}; }
u64 display_id = rp.Pop<u64>();
auto vsync_event = nv_flinger->GetVsyncEvent(display_id); void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
LOG_WARNING(Service_VI, "(STUBBED) called");
IPC::RequestParser rp{ctx};
u64 display_id = rp.Pop<u64>();
IPC::ResponseBuilder rb = rp.MakeBuilder(2, 1, 0); auto vsync_event = nv_flinger->GetVsyncEvent(display_id);
rb.Push(RESULT_SUCCESS);
rb.PushCopyObjects(vsync_event); IPC::ResponseBuilder rb = rp.MakeBuilder(2, 1, 0);
} rb.Push(RESULT_SUCCESS);
rb.PushCopyObjects(vsync_event);
}
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
};
IApplicationDisplayService::IApplicationDisplayService( IApplicationDisplayService::IApplicationDisplayService(
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
@ -806,11 +817,24 @@ IApplicationDisplayService::IApplicationDisplayService(
RegisterHandlers(functions); RegisterHandlers(functions);
} }
Module::Interface::Interface(std::shared_ptr<Module> module, const char* name,
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
: ServiceFramework(name), module(std::move(module)), nv_flinger(std::move(nv_flinger)) {}
void Module::Interface::GetDisplayService(Kernel::HLERequestContext& ctx) {
LOG_WARNING(Service_VI, "(STUBBED) called");
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
}
void InstallInterfaces(SM::ServiceManager& service_manager, void InstallInterfaces(SM::ServiceManager& service_manager,
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) { std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) {
std::make_shared<VI_M>(nv_flinger)->InstallAsService(service_manager); auto module = std::make_shared<Module>();
std::make_shared<VI_S>(nv_flinger)->InstallAsService(service_manager); std::make_shared<VI_M>(module, nv_flinger)->InstallAsService(service_manager);
std::make_shared<VI_U>(nv_flinger)->InstallAsService(service_manager); std::make_shared<VI_S>(module, nv_flinger)->InstallAsService(service_manager);
std::make_shared<VI_U>(module, nv_flinger)->InstallAsService(service_manager);
} }
} // namespace VI } // namespace VI

30
src/core/hle/service/vi/vi.h
View file

@ -4,9 +4,6 @@
#pragma once #pragma once
#include <memory>
#include <boost/optional.hpp>
#include "core/hle/kernel/event.h"
#include "core/hle/service/nvflinger/nvflinger.h" #include "core/hle/service/nvflinger/nvflinger.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
@ -17,26 +14,19 @@ struct EventType;
namespace Service { namespace Service {
namespace VI { namespace VI {
class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> { class Module final {
public: public:
IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger); class Interface : public ServiceFramework<Interface> {
~IApplicationDisplayService() = default; public:
Interface(std::shared_ptr<Module> module, const char* name,
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
private: void GetDisplayService(Kernel::HLERequestContext& ctx);
void GetRelayService(Kernel::HLERequestContext& ctx);
void GetSystemDisplayService(Kernel::HLERequestContext& ctx);
void GetManagerDisplayService(Kernel::HLERequestContext& ctx);
void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx);
void OpenDisplay(Kernel::HLERequestContext& ctx);
void CloseDisplay(Kernel::HLERequestContext& ctx);
void SetLayerScalingMode(Kernel::HLERequestContext& ctx);
void ListDisplays(Kernel::HLERequestContext& ctx);
void OpenLayer(Kernel::HLERequestContext& ctx);
void CreateStrayLayer(Kernel::HLERequestContext& ctx);
void DestroyStrayLayer(Kernel::HLERequestContext& ctx);
void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx);
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger; protected:
std::shared_ptr<Module> module;
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
};
}; };
/// Registers all VI services with the specified service manager. /// Registers all VI services with the specified service manager.

15
src/core/hle/service/vi/vi_m.cpp
View file

@ -2,24 +2,13 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "common/logging/log.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/service/vi/vi.h"
#include "core/hle/service/vi/vi_m.h" #include "core/hle/service/vi/vi_m.h"
namespace Service { namespace Service {
namespace VI { namespace VI {
void VI_M::GetDisplayService(Kernel::HLERequestContext& ctx) { VI_M::VI_M(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
LOG_WARNING(Service_VI, "(STUBBED) called"); : Module::Interface(std::move(module), "vi:m", std::move(nv_flinger)) {
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
}
VI_M::VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
: ServiceFramework("vi:m"), nv_flinger(std::move(nv_flinger)) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{2, &VI_M::GetDisplayService, "GetDisplayService"}, {2, &VI_M::GetDisplayService, "GetDisplayService"},
{3, nullptr, "GetDisplayServiceWithProxyNameExchange"}, {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

17
src/core/hle/service/vi/vi_m.h
View file

@ -4,25 +4,14 @@
#pragma once #pragma once
#include <memory> #include "core/hle/service/vi/vi.h"
#include "core/hle/service/service.h"
namespace Service { namespace Service {
namespace NVFlinger {
class NVFlinger;
}
namespace VI { namespace VI {
class VI_M final : public ServiceFramework<VI_M> { class VI_M final : public Module::Interface {
public: public:
VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger); explicit VI_M(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
~VI_M() = default;
private:
void GetDisplayService(Kernel::HLERequestContext& ctx);
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
}; };
} // namespace VI } // namespace VI

15
src/core/hle/service/vi/vi_s.cpp
View file

@ -2,24 +2,13 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "common/logging/log.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/service/vi/vi.h"
#include "core/hle/service/vi/vi_s.h" #include "core/hle/service/vi/vi_s.h"
namespace Service { namespace Service {
namespace VI { namespace VI {
void VI_S::GetDisplayService(Kernel::HLERequestContext& ctx) { VI_S::VI_S(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
LOG_WARNING(Service_VI, "(STUBBED) called"); : Module::Interface(std::move(module), "vi:s", std::move(nv_flinger)) {
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
}
VI_S::VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
: ServiceFramework("vi:s"), nv_flinger(std::move(nv_flinger)) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{1, &VI_S::GetDisplayService, "GetDisplayService"}, {1, &VI_S::GetDisplayService, "GetDisplayService"},
{3, nullptr, "GetDisplayServiceWithProxyNameExchange"}, {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

17
src/core/hle/service/vi/vi_s.h
View file

@ -4,25 +4,14 @@
#pragma once #pragma once
#include <memory> #include "core/hle/service/vi/vi.h"
#include "core/hle/service/service.h"
namespace Service { namespace Service {
namespace NVFlinger {
class NVFlinger;
}
namespace VI { namespace VI {
class VI_S final : public ServiceFramework<VI_S> { class VI_S final : public Module::Interface {
public: public:
VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger); explicit VI_S(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
~VI_S() = default;
private:
void GetDisplayService(Kernel::HLERequestContext& ctx);
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
}; };
} // namespace VI } // namespace VI

15
src/core/hle/service/vi/vi_u.cpp
View file

@ -2,24 +2,13 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include "common/logging/log.h"
#include "core/hle/ipc_helpers.h"
#include "core/hle/service/vi/vi.h"
#include "core/hle/service/vi/vi_u.h" #include "core/hle/service/vi/vi_u.h"
namespace Service { namespace Service {
namespace VI { namespace VI {
void VI_U::GetDisplayService(Kernel::HLERequestContext& ctx) { VI_U::VI_U(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
LOG_WARNING(Service_VI, "(STUBBED) called"); : Module::Interface(std::move(module), "vi:u", std::move(nv_flinger)) {
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
}
VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
: ServiceFramework("vi:u"), nv_flinger(std::move(nv_flinger)) {
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &VI_U::GetDisplayService, "GetDisplayService"}, {0, &VI_U::GetDisplayService, "GetDisplayService"},
{3, nullptr, "GetDisplayServiceWithProxyNameExchange"}, {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

17
src/core/hle/service/vi/vi_u.h
View file

@ -4,25 +4,14 @@
#pragma once #pragma once
#include <memory> #include "core/hle/service/vi/vi.h"
#include "core/hle/service/service.h"
namespace Service { namespace Service {
namespace NVFlinger {
class NVFlinger;
}
namespace VI { namespace VI {
class VI_U final : public ServiceFramework<VI_U> { class VI_U final : public Module::Interface {
public: public:
VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger); explicit VI_U(std::shared_ptr<Module> module, std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
~VI_U() = default;
private:
void GetDisplayService(Kernel::HLERequestContext& ctx);
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
}; };
} // namespace VI } // namespace VI