nvnflinger: fix name

src/common/logging/filter.cpp

@@ -119,7 +119,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
-    SUB(Service, NVFlinger)                                                                        \
+    SUB(Service, Nvnflinger)                                                                       \
     SUB(Service, OLSC)                                                                             \
     SUB(Service, PCIE)                                                                             \
     SUB(Service, PCTL)                                                                             \

src/common/logging/types.h

@@ -29,107 +29,107 @@ enum class Level : u8 {
  * filter.cpp.
  */
 enum class Class : u8 {
-    Log,               ///< Messages about the log system itself
-    Common,            ///< Library routines
-    Common_Filesystem, ///< Filesystem interface library
-    Common_Memory,     ///< Memory mapping and management functions
-    Core,              ///< LLE emulation core
-    Core_ARM,          ///< ARM CPU core
-    Core_Timing,       ///< CoreTiming functions
-    Config,            ///< Emulator configuration (including commandline)
-    Debug,             ///< Debugging tools
-    Debug_Emulated,    ///< Debug messages from the emulated programs
-    Debug_GPU,         ///< GPU debugging tools
-    Debug_Breakpoint,  ///< Logging breakpoints and watchpoints
-    Debug_GDBStub,     ///< GDB Stub
-    Kernel,            ///< The HLE implementation of the CTR kernel
-    Kernel_SVC,        ///< Kernel system calls
-    Service,           ///< HLE implementation of system services. Each major service
-                       ///< should have its own subclass.
-    Service_ACC,       ///< The ACC (Accounts) service
-    Service_AM,        ///< The AM (Applet manager) service
-    Service_AOC,       ///< The AOC (AddOn Content) service
-    Service_APM,       ///< The APM (Performance) service
-    Service_ARP,       ///< The ARP service
-    Service_Audio,     ///< The Audio (Audio control) service
-    Service_BCAT,      ///< The BCAT service
-    Service_BGTC,      ///< The BGTC (Background Task Controller) service
-    Service_BPC,       ///< The BPC service
-    Service_BTDRV,     ///< The Bluetooth driver service
-    Service_BTM,       ///< The BTM service
-    Service_Capture,   ///< The capture service
-    Service_ERPT,      ///< The error reporting service
-    Service_ETicket,   ///< The ETicket service
-    Service_EUPLD,     ///< The error upload service
-    Service_Fatal,     ///< The Fatal service
-    Service_FGM,       ///< The FGM service
-    Service_Friend,    ///< The friend service
-    Service_FS,        ///< The FS (Filesystem) service
-    Service_GRC,       ///< The game recording service
-    Service_HID,       ///< The HID (Human interface device) service
-    Service_IRS,       ///< The IRS service
-    Service_JIT,       ///< The JIT service
-    Service_LBL,       ///< The LBL (LCD backlight) service
-    Service_LDN,       ///< The LDN (Local domain network) service
-    Service_LDR,       ///< The loader service
-    Service_LM,        ///< The LM (Logger) service
-    Service_Migration, ///< The migration service
-    Service_Mii,       ///< The Mii service
-    Service_MM,        ///< The MM (Multimedia) service
-    Service_MNPP,      ///< The MNPP service
-    Service_NCM,       ///< The NCM service
-    Service_NFC,       ///< The NFC (Near-field communication) service
-    Service_NFP,       ///< The NFP service
-    Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
-    Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NIM,       ///< The NIM service
-    Service_NOTIF,     ///< The NOTIF (Notification) service
-    Service_NPNS,      ///< The NPNS service
-    Service_NS,        ///< The NS services
-    Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
-    Service_NVFlinger, ///< The NVFlinger service
-    Service_OLSC,      ///< The OLSC service
-    Service_PCIE,      ///< The PCIe service
-    Service_PCTL,      ///< The PCTL (Parental control) service
-    Service_PCV,       ///< The PCV service
-    Service_PM,        ///< The PM service
-    Service_PREPO,     ///< The PREPO (Play report) service
-    Service_PSC,       ///< The PSC service
-    Service_PTM,       ///< The PTM service
-    Service_SET,       ///< The SET (Settings) service
-    Service_SM,        ///< The SM (Service manager) service
-    Service_SPL,       ///< The SPL service
-    Service_SSL,       ///< The SSL service
-    Service_TCAP,      ///< The TCAP service.
-    Service_Time,      ///< The time service
-    Service_USB,       ///< The USB (Universal Serial Bus) service
-    Service_VI,        ///< The VI (Video interface) service
-    Service_WLAN,      ///< The WLAN (Wireless local area network) service
-    HW,                ///< Low-level hardware emulation
-    HW_Memory,         ///< Memory-map and address translation
-    HW_LCD,            ///< LCD register emulation
-    HW_GPU,            ///< GPU control emulation
-    HW_AES,            ///< AES engine emulation
-    IPC,               ///< IPC interface
-    Frontend,          ///< Emulator UI
-    Render,            ///< Emulator video output and hardware acceleration
-    Render_Software,   ///< Software renderer backend
-    Render_OpenGL,     ///< OpenGL backend
-    Render_Vulkan,     ///< Vulkan backend
-    Shader,            ///< Shader recompiler
-    Shader_SPIRV,      ///< Shader SPIR-V code generation
-    Shader_GLASM,      ///< Shader GLASM code generation
-    Shader_GLSL,       ///< Shader GLSL code generation
-    Audio,             ///< Audio emulation
-    Audio_DSP,         ///< The HLE implementation of the DSP
-    Audio_Sink,        ///< Emulator audio output backend
-    Loader,            ///< ROM loader
-    CheatEngine,       ///< Memory manipulation and engine VM functions
-    Crypto,            ///< Cryptographic engine/functions
-    Input,             ///< Input emulation
-    Network,           ///< Network emulation
-    WebService,        ///< Interface to yuzu Web Services
-    Count              ///< Total number of logging classes
+    Log,                ///< Messages about the log system itself
+    Common,             ///< Library routines
+    Common_Filesystem,  ///< Filesystem interface library
+    Common_Memory,      ///< Memory mapping and management functions
+    Core,               ///< LLE emulation core
+    Core_ARM,           ///< ARM CPU core
+    Core_Timing,        ///< CoreTiming functions
+    Config,             ///< Emulator configuration (including commandline)
+    Debug,              ///< Debugging tools
+    Debug_Emulated,     ///< Debug messages from the emulated programs
+    Debug_GPU,          ///< GPU debugging tools
+    Debug_Breakpoint,   ///< Logging breakpoints and watchpoints
+    Debug_GDBStub,      ///< GDB Stub
+    Kernel,             ///< The HLE implementation of the CTR kernel
+    Kernel_SVC,         ///< Kernel system calls
+    Service,            ///< HLE implementation of system services. Each major service
+                        ///< should have its own subclass.
+    Service_ACC,        ///< The ACC (Accounts) service
+    Service_AM,         ///< The AM (Applet manager) service
+    Service_AOC,        ///< The AOC (AddOn Content) service
+    Service_APM,        ///< The APM (Performance) service
+    Service_ARP,        ///< The ARP service
+    Service_Audio,      ///< The Audio (Audio control) service
+    Service_BCAT,       ///< The BCAT service
+    Service_BGTC,       ///< The BGTC (Background Task Controller) service
+    Service_BPC,        ///< The BPC service
+    Service_BTDRV,      ///< The Bluetooth driver service
+    Service_BTM,        ///< The BTM service
+    Service_Capture,    ///< The capture service
+    Service_ERPT,       ///< The error reporting service
+    Service_ETicket,    ///< The ETicket service
+    Service_EUPLD,      ///< The error upload service
+    Service_Fatal,      ///< The Fatal service
+    Service_FGM,        ///< The FGM service
+    Service_Friend,     ///< The friend service
+    Service_FS,         ///< The FS (Filesystem) service
+    Service_GRC,        ///< The game recording service
+    Service_HID,        ///< The HID (Human interface device) service
+    Service_IRS,        ///< The IRS service
+    Service_JIT,        ///< The JIT service
+    Service_LBL,        ///< The LBL (LCD backlight) service
+    Service_LDN,        ///< The LDN (Local domain network) service
+    Service_LDR,        ///< The loader service
+    Service_LM,         ///< The LM (Logger) service
+    Service_Migration,  ///< The migration service
+    Service_Mii,        ///< The Mii service
+    Service_MM,         ///< The MM (Multimedia) service
+    Service_MNPP,       ///< The MNPP service
+    Service_NCM,        ///< The NCM service
+    Service_NFC,        ///< The NFC (Near-field communication) service
+    Service_NFP,        ///< The NFP service
+    Service_NGCT,       ///< The NGCT (No Good Content for Terra) service
+    Service_NIFM,       ///< The NIFM (Network interface) service
+    Service_NIM,        ///< The NIM service
+    Service_NOTIF,      ///< The NOTIF (Notification) service
+    Service_NPNS,       ///< The NPNS service
+    Service_NS,         ///< The NS services
+    Service_NVDRV,      ///< The NVDRV (Nvidia driver) service
+    Service_Nvnflinger, ///< The Nvnflinger service
+    Service_OLSC,       ///< The OLSC service
+    Service_PCIE,       ///< The PCIe service
+    Service_PCTL,       ///< The PCTL (Parental control) service
+    Service_PCV,        ///< The PCV service
+    Service_PM,         ///< The PM service
+    Service_PREPO,      ///< The PREPO (Play report) service
+    Service_PSC,        ///< The PSC service
+    Service_PTM,        ///< The PTM service
+    Service_SET,        ///< The SET (Settings) service
+    Service_SM,         ///< The SM (Service manager) service
+    Service_SPL,        ///< The SPL service
+    Service_SSL,        ///< The SSL service
+    Service_TCAP,       ///< The TCAP service.
+    Service_Time,       ///< The time service
+    Service_USB,        ///< The USB (Universal Serial Bus) service
+    Service_VI,         ///< The VI (Video interface) service
+    Service_WLAN,       ///< The WLAN (Wireless local area network) service
+    HW,                 ///< Low-level hardware emulation
+    HW_Memory,          ///< Memory-map and address translation
+    HW_LCD,             ///< LCD register emulation
+    HW_GPU,             ///< GPU control emulation
+    HW_AES,             ///< AES engine emulation
+    IPC,                ///< IPC interface
+    Frontend,           ///< Emulator UI
+    Render,             ///< Emulator video output and hardware acceleration
+    Render_Software,    ///< Software renderer backend
+    Render_OpenGL,      ///< OpenGL backend
+    Render_Vulkan,      ///< Vulkan backend
+    Shader,             ///< Shader recompiler
+    Shader_SPIRV,       ///< Shader SPIR-V code generation
+    Shader_GLASM,       ///< Shader GLASM code generation
+    Shader_GLSL,        ///< Shader GLSL code generation
+    Audio,              ///< Audio emulation
+    Audio_DSP,          ///< The HLE implementation of the DSP
+    Audio_Sink,         ///< Emulator audio output backend
+    Loader,             ///< ROM loader
+    CheatEngine,        ///< Memory manipulation and engine VM functions
+    Crypto,             ///< Cryptographic engine/functions
+    Input,              ///< Input emulation
+    Network,            ///< Network emulation
+    WebService,         ///< Interface to yuzu Web Services
+    Count               ///< Total number of logging classes
 };
 
 } // namespace Common::Log

src/core/CMakeLists.txt

@@ -626,35 +626,35 @@ add_library(core STATIC
     hle/service/nvdrv/nvdrv_interface.h
     hle/service/nvdrv/nvmemp.cpp
     hle/service/nvdrv/nvmemp.h
-    hle/service/nvflinger/binder.h
-    hle/service/nvflinger/buffer_item.h
-    hle/service/nvflinger/buffer_item_consumer.cpp
-    hle/service/nvflinger/buffer_item_consumer.h
-    hle/service/nvflinger/buffer_queue_consumer.cpp
-    hle/service/nvflinger/buffer_queue_consumer.h
-    hle/service/nvflinger/buffer_queue_core.cpp
-    hle/service/nvflinger/buffer_queue_core.h
-    hle/service/nvflinger/buffer_queue_defs.h
-    hle/service/nvflinger/buffer_queue_producer.cpp
-    hle/service/nvflinger/buffer_queue_producer.h
-    hle/service/nvflinger/buffer_slot.h
-    hle/service/nvflinger/buffer_transform_flags.h
-    hle/service/nvflinger/consumer_base.cpp
-    hle/service/nvflinger/consumer_base.h
-    hle/service/nvflinger/consumer_listener.h
-    hle/service/nvflinger/graphic_buffer_producer.cpp
-    hle/service/nvflinger/graphic_buffer_producer.h
-    hle/service/nvflinger/hos_binder_driver_server.cpp
-    hle/service/nvflinger/hos_binder_driver_server.h
-    hle/service/nvflinger/nvflinger.cpp
-    hle/service/nvflinger/nvflinger.h
-    hle/service/nvflinger/parcel.h
-    hle/service/nvflinger/pixel_format.h
-    hle/service/nvflinger/producer_listener.h
-    hle/service/nvflinger/status.h
-    hle/service/nvflinger/ui/fence.h
-    hle/service/nvflinger/ui/graphic_buffer.h
-    hle/service/nvflinger/window.h
+    hle/service/nvnflinger/binder.h
+    hle/service/nvnflinger/buffer_item.h
+    hle/service/nvnflinger/buffer_item_consumer.cpp
+    hle/service/nvnflinger/buffer_item_consumer.h
+    hle/service/nvnflinger/buffer_queue_consumer.cpp
+    hle/service/nvnflinger/buffer_queue_consumer.h
+    hle/service/nvnflinger/buffer_queue_core.cpp
+    hle/service/nvnflinger/buffer_queue_core.h
+    hle/service/nvnflinger/buffer_queue_defs.h
+    hle/service/nvnflinger/buffer_queue_producer.cpp
+    hle/service/nvnflinger/buffer_queue_producer.h
+    hle/service/nvnflinger/buffer_slot.h
+    hle/service/nvnflinger/buffer_transform_flags.h
+    hle/service/nvnflinger/consumer_base.cpp
+    hle/service/nvnflinger/consumer_base.h
+    hle/service/nvnflinger/consumer_listener.h
+    hle/service/nvnflinger/graphic_buffer_producer.cpp
+    hle/service/nvnflinger/graphic_buffer_producer.h
+    hle/service/nvnflinger/hos_binder_driver_server.cpp
+    hle/service/nvnflinger/hos_binder_driver_server.h
+    hle/service/nvnflinger/nvnflinger.cpp
+    hle/service/nvnflinger/nvnflinger.h
+    hle/service/nvnflinger/parcel.h
+    hle/service/nvnflinger/pixel_format.h
+    hle/service/nvnflinger/producer_listener.h
+    hle/service/nvnflinger/status.h
+    hle/service/nvnflinger/ui/fence.h
+    hle/service/nvnflinger/ui/graphic_buffer.h
+    hle/service/nvnflinger/window.h
     hle/service/olsc/olsc.cpp
     hle/service/olsc/olsc.h
     hle/service/pcie/pcie.cpp

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

@@ -30,7 +30,7 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ns/ns.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/sm/sm.h"
@@ -251,10 +251,9 @@ IDebugFunctions::IDebugFunctions(Core::System& system_)
 
 IDebugFunctions::~IDebugFunctions() = default;
 
-ISelfController::ISelfController(Core::System& system_, NVFlinger::NVFlinger& nvflinger_)
-    : ServiceFramework{system_, "ISelfController"}, nvflinger{nvflinger_}, service_context{
-                                                                               system,
-                                                                               "ISelfController"} {
+ISelfController::ISelfController(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger_)
+    : ServiceFramework{system_, "ISelfController"}, nvnflinger{nvnflinger_},
+      service_context{system, "ISelfController"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ISelfController::Exit, "Exit"},
@@ -470,8 +469,8 @@ void ISelfController::CreateManagedDisplayLayer(HLERequestContext& ctx) {
 
     // TODO(Subv): Find out how AM determines the display to use, for now just
     // create the layer in the Default display.
-    const auto display_id = nvflinger.OpenDisplay("Default");
-    const auto layer_id = nvflinger.CreateLayer(*display_id);
+    const auto display_id = nvnflinger.OpenDisplay("Default");
+    const auto layer_id = nvnflinger.CreateLayer(*display_id);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -488,8 +487,8 @@ void ISelfController::CreateManagedDisplaySeparableLayer(HLERequestContext& ctx)
     // Outputting 1 layer id instead of the expected 2 has not been observed to cause any adverse
     // side effects.
     // TODO: Support multiple layers
-    const auto display_id = nvflinger.OpenDisplay("Default");
-    const auto layer_id = nvflinger.CreateLayer(*display_id);
+    const auto display_id = nvnflinger.OpenDisplay("Default");
+    const auto layer_id = nvnflinger.CreateLayer(*display_id);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
@@ -1826,7 +1825,7 @@ void IApplicationFunctions::PrepareForJit(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
-void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system) {
+void LoopProcess(Nvnflinger::Nvnflinger& nvnflinger, Core::System& system) {
     auto message_queue = std::make_shared<AppletMessageQueue>(system);
     // Needed on game boot
     message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
@@ -1834,9 +1833,9 @@ void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
     server_manager->RegisterNamedService(
-        "appletAE", std::make_shared<AppletAE>(nvflinger, message_queue, system));
+        "appletAE", std::make_shared<AppletAE>(nvnflinger, message_queue, system));
     server_manager->RegisterNamedService(
-        "appletOE", std::make_shared<AppletOE>(nvflinger, message_queue, system));
+        "appletOE", std::make_shared<AppletOE>(nvnflinger, message_queue, system));
     server_manager->RegisterNamedService("idle:sys", std::make_shared<IdleSys>(system));
     server_manager->RegisterNamedService("omm", std::make_shared<OMM>(system));
     server_manager->RegisterNamedService("spsm", std::make_shared<SPSM>(system));

src/core/hle/service/am/am.h

@@ -16,8 +16,8 @@ class KReadableEvent;
 class KTransferMemory;
 } // namespace Kernel
 
-namespace Service::NVFlinger {
-class NVFlinger;
+namespace Service::Nvnflinger {
+class Nvnflinger;
 }
 
 namespace Service::AM {
@@ -154,7 +154,7 @@ public:
 
 class ISelfController final : public ServiceFramework<ISelfController> {
 public:
-    explicit ISelfController(Core::System& system_, NVFlinger::NVFlinger& nvflinger_);
+    explicit ISelfController(Core::System& system_, Nvnflinger::Nvnflinger& nvnflinger_);
     ~ISelfController() override;
 
 private:
@@ -191,7 +191,7 @@ private:
         Disable = 2,
     };
 
-    NVFlinger::NVFlinger& nvflinger;
+    Nvnflinger::Nvnflinger& nvnflinger;
 
     KernelHelpers::ServiceContext service_context;
 
@@ -397,6 +397,6 @@ public:
     ~IProcessWindingController() override;
 };
 
-void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system);
+void LoopProcess(Nvnflinger::Nvnflinger& nvnflinger, Core::System& system);
 
 } // namespace Service::AM

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

@@ -6,17 +6,17 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
 
 namespace Service::AM {
 
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
-    explicit ILibraryAppletProxy(NVFlinger::NVFlinger& nvflinger_,
+    explicit ILibraryAppletProxy(Nvnflinger::Nvnflinger& nvnflinger_,
                                  std::shared_ptr<AppletMessageQueue> msg_queue_,
                                  Core::System& system_)
-        : ServiceFramework{system_, "ILibraryAppletProxy"}, nvflinger{nvflinger_},
-          msg_queue{std::move(msg_queue_)} {
+        : ServiceFramework{system_, "ILibraryAppletProxy"},
+          nvnflinger{nvnflinger_}, msg_queue{std::move(msg_queue_)} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
@@ -49,7 +49,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISelfController>(system, nvflinger);
+        rb.PushIpcInterface<ISelfController>(system, nvnflinger);
     }
 
     void GetWindowController(HLERequestContext& ctx) {
@@ -108,17 +108,17 @@ private:
         rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
-    NVFlinger::NVFlinger& nvflinger;
+    Nvnflinger::Nvnflinger& nvnflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
 class ISystemAppletProxy final : public ServiceFramework<ISystemAppletProxy> {
 public:
-    explicit ISystemAppletProxy(NVFlinger::NVFlinger& nvflinger_,
+    explicit ISystemAppletProxy(Nvnflinger::Nvnflinger& nvnflinger_,
                                 std::shared_ptr<AppletMessageQueue> msg_queue_,
                                 Core::System& system_)
-        : ServiceFramework{system_, "ISystemAppletProxy"}, nvflinger{nvflinger_},
-          msg_queue{std::move(msg_queue_)} {
+        : ServiceFramework{system_, "ISystemAppletProxy"},
+          nvnflinger{nvnflinger_}, msg_queue{std::move(msg_queue_)} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISystemAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
@@ -153,7 +153,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISelfController>(system, nvflinger);
+        rb.PushIpcInterface<ISelfController>(system, nvnflinger);
     }
 
     void GetWindowController(HLERequestContext& ctx) {
@@ -220,7 +220,7 @@ private:
         rb.PushIpcInterface<IApplicationCreator>(system);
     }
 
-    NVFlinger::NVFlinger& nvflinger;
+    Nvnflinger::Nvnflinger& nvnflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
@@ -229,7 +229,7 @@ void AppletAE::OpenSystemAppletProxy(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<ISystemAppletProxy>(nvnflinger, msg_queue, system);
 }
 
 void AppletAE::OpenLibraryAppletProxy(HLERequestContext& ctx) {
@@ -237,7 +237,7 @@ void AppletAE::OpenLibraryAppletProxy(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<ILibraryAppletProxy>(nvnflinger, msg_queue, system);
 }
 
 void AppletAE::OpenLibraryAppletProxyOld(HLERequestContext& ctx) {
@@ -245,13 +245,13 @@ void AppletAE::OpenLibraryAppletProxyOld(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<ILibraryAppletProxy>(nvnflinger, msg_queue, system);
 }
 
-AppletAE::AppletAE(NVFlinger::NVFlinger& nvflinger_, std::shared_ptr<AppletMessageQueue> msg_queue_,
-                   Core::System& system_)
-    : ServiceFramework{system_, "appletAE"}, nvflinger{nvflinger_}, msg_queue{
-                                                                        std::move(msg_queue_)} {
+AppletAE::AppletAE(Nvnflinger::Nvnflinger& nvnflinger_,
+                   std::shared_ptr<AppletMessageQueue> msg_queue_, Core::System& system_)
+    : ServiceFramework{system_, "appletAE"}, nvnflinger{nvnflinger_}, msg_queue{
+                                                                          std::move(msg_queue_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},

src/core/hle/service/am/applet_ae.h

@@ -12,8 +12,8 @@ namespace FileSystem {
 class FileSystemController;
 }
 
-namespace NVFlinger {
-class NVFlinger;
+namespace Nvnflinger {
+class Nvnflinger;
 }
 
 namespace AM {
@@ -22,7 +22,7 @@ class AppletMessageQueue;
 
 class AppletAE final : public ServiceFramework<AppletAE> {
 public:
-    explicit AppletAE(NVFlinger::NVFlinger& nvflinger_,
+    explicit AppletAE(Nvnflinger::Nvnflinger& nvnflinger_,
                       std::shared_ptr<AppletMessageQueue> msg_queue_, Core::System& system_);
     ~AppletAE() override;
 
@@ -33,7 +33,7 @@ private:
     void OpenLibraryAppletProxy(HLERequestContext& ctx);
     void OpenLibraryAppletProxyOld(HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nvflinger;
+    Nvnflinger::Nvnflinger& nvnflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 

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

@@ -5,17 +5,17 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
 
 namespace Service::AM {
 
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
-    explicit IApplicationProxy(NVFlinger::NVFlinger& nvflinger_,
+    explicit IApplicationProxy(Nvnflinger::Nvnflinger& nvnflinger_,
                                std::shared_ptr<AppletMessageQueue> msg_queue_,
                                Core::System& system_)
-        : ServiceFramework{system_, "IApplicationProxy"}, nvflinger{nvflinger_},
-          msg_queue{std::move(msg_queue_)} {
+        : ServiceFramework{system_, "IApplicationProxy"},
+          nvnflinger{nvnflinger_}, msg_queue{std::move(msg_queue_)} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IApplicationProxy::GetCommonStateGetter, "GetCommonStateGetter"},
@@ -71,7 +71,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);
-        rb.PushIpcInterface<ISelfController>(system, nvflinger);
+        rb.PushIpcInterface<ISelfController>(system, nvnflinger);
     }
 
     void GetCommonStateGetter(HLERequestContext& ctx) {
@@ -98,7 +98,7 @@ private:
         rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
-    NVFlinger::NVFlinger& nvflinger;
+    Nvnflinger::Nvnflinger& nvnflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
@@ -107,13 +107,13 @@ void AppletOE::OpenApplicationProxy(HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
-    rb.PushIpcInterface<IApplicationProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<IApplicationProxy>(nvnflinger, msg_queue, system);
 }
 
-AppletOE::AppletOE(NVFlinger::NVFlinger& nvflinger_, std::shared_ptr<AppletMessageQueue> msg_queue_,
-                   Core::System& system_)
-    : ServiceFramework{system_, "appletOE"}, nvflinger{nvflinger_}, msg_queue{
-                                                                        std::move(msg_queue_)} {
+AppletOE::AppletOE(Nvnflinger::Nvnflinger& nvnflinger_,
+                   std::shared_ptr<AppletMessageQueue> msg_queue_, Core::System& system_)
+    : ServiceFramework{system_, "appletOE"}, nvnflinger{nvnflinger_}, msg_queue{
+                                                                          std::move(msg_queue_)} {
     static const FunctionInfo functions[] = {
         {0, &AppletOE::OpenApplicationProxy, "OpenApplicationProxy"},
     };

src/core/hle/service/am/applet_oe.h

@@ -12,8 +12,8 @@ namespace FileSystem {
 class FileSystemController;
 }
 
-namespace NVFlinger {
-class NVFlinger;
+namespace Nvnflinger {
+class Nvnflinger;
 }
 
 namespace AM {
@@ -22,7 +22,7 @@ class AppletMessageQueue;
 
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
-    explicit AppletOE(NVFlinger::NVFlinger& nvflinger_,
+    explicit AppletOE(Nvnflinger::Nvnflinger& nvnflinger_,
                       std::shared_ptr<AppletMessageQueue> msg_queue_, Core::System& system_);
     ~AppletOE() override;
 
@@ -31,7 +31,7 @@ public:
 private:
     void OpenApplicationProxy(HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nvflinger;
+    Nvnflinger::Nvnflinger& nvnflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 

src/core/hle/service/nvdrv/devices/nvdisp_disp0.h

@@ -8,8 +8,8 @@
 #include "common/common_types.h"
 #include "common/math_util.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "core/hle/service/nvflinger/buffer_transform_flags.h"
-#include "core/hle/service/nvflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/buffer_transform_flags.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
 
 namespace Service::Nvidia::NvCore {
 class Container;

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -23,7 +23,7 @@
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvdrv/nvdrv_interface.h"
 #include "core/hle/service/nvdrv/nvmemp.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
 #include "core/hle/service/server_manager.h"
 #include "video_core/gpu.h"
 
@@ -42,7 +42,7 @@ void EventInterface::FreeEvent(Kernel::KEvent* event) {
     module.service_context.CloseEvent(event);
 }
 
-void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system) {
+void LoopProcess(Nvnflinger::Nvnflinger& nvnflinger, Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
     auto module = std::make_shared<Module>(system);
     server_manager->RegisterNamedService("nvdrv", std::make_shared<NVDRV>(system, module, "nvdrv"));
@@ -53,7 +53,7 @@ void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system) {
     server_manager->RegisterNamedService("nvdrv:t",
                                          std::make_shared<NVDRV>(system, module, "nvdrv:t"));
     server_manager->RegisterNamedService("nvmemp", std::make_shared<NVMEMP>(system));
-    nvflinger.SetNVDrvInstance(module);
+    nvnflinger.SetNVDrvInstance(module);
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/nvdrv/nvdrv.h

@@ -16,7 +16,7 @@
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nvdrv/core/container.h"
 #include "core/hle/service/nvdrv/nvdata.h"
-#include "core/hle/service/nvflinger/ui/fence.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
 #include "core/hle/service/service.h"
 
 namespace Core {
@@ -27,8 +27,8 @@ namespace Kernel {
 class KEvent;
 }
 
-namespace Service::NVFlinger {
-class NVFlinger;
+namespace Service::Nvnflinger {
+class Nvnflinger;
 }
 
 namespace Service::Nvidia {
@@ -95,7 +95,7 @@ public:
 
 private:
     friend class EventInterface;
-    friend class Service::NVFlinger::NVFlinger;
+    friend class Service::Nvnflinger::Nvnflinger;
 
     /// Manages syncpoints on the host
     NvCore::Container container;
@@ -114,6 +114,6 @@ private:
     std::unordered_map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
 };
 
-void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system);
+void LoopProcess(Nvnflinger::Nvnflinger& nvnflinger, Core::System& system);
 
 } // namespace Service::Nvidia

src/core/hle/service/nvflinger/buffer_item.h → src/core/hle/service/nvnflinger/buffer_item.h

@@ -10,8 +10,8 @@
 
 #include "common/common_types.h"
 #include "common/math_util.h"
-#include "core/hle/service/nvflinger/ui/fence.h"
-#include "core/hle/service/nvflinger/window.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
+#include "core/hle/service/nvnflinger/window.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/buffer_item_consumer.cpp → src/core/hle/service/nvnflinger/buffer_item_consumer.cpp

@@ -6,9 +6,9 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/service/nvflinger/buffer_item.h"
-#include "core/hle/service/nvflinger/buffer_item_consumer.h"
-#include "core/hle/service/nvflinger/buffer_queue_consumer.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_consumer.h"
 
 namespace Service::android {
 
@@ -25,7 +25,7 @@ Status BufferItemConsumer::AcquireBuffer(BufferItem* item, std::chrono::nanoseco
 
     if (const auto status = AcquireBufferLocked(item, present_when); status != Status::NoError) {
         if (status != Status::NoBufferAvailable) {
-            LOG_ERROR(Service_NVFlinger, "Failed to acquire buffer: {}", status);
+            LOG_ERROR(Service_Nvnflinger, "Failed to acquire buffer: {}", status);
         }
         return status;
     }
@@ -44,12 +44,12 @@ Status BufferItemConsumer::ReleaseBuffer(const BufferItem& item, const Fence& re
 
     if (const auto status = AddReleaseFenceLocked(item.buf, item.graphic_buffer, release_fence);
         status != Status::NoError) {
-        LOG_ERROR(Service_NVFlinger, "Failed to add fence: {}", status);
+        LOG_ERROR(Service_Nvnflinger, "Failed to add fence: {}", status);
     }
 
     if (const auto status = ReleaseBufferLocked(item.buf, item.graphic_buffer);
         status != Status::NoError) {
-        LOG_WARNING(Service_NVFlinger, "Failed to release buffer: {}", status);
+        LOG_WARNING(Service_Nvnflinger, "Failed to release buffer: {}", status);
         return status;
     }
 

src/core/hle/service/nvflinger/buffer_item_consumer.h → src/core/hle/service/nvnflinger/buffer_item_consumer.h

@@ -10,8 +10,8 @@
 #include <memory>
 
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/consumer_base.h"
-#include "core/hle/service/nvflinger/status.h"
+#include "core/hle/service/nvnflinger/consumer_base.h"
+#include "core/hle/service/nvnflinger/status.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/buffer_queue_consumer.cpp → src/core/hle/service/nvnflinger/buffer_queue_consumer.cpp

@@ -6,11 +6,11 @@
 
 #include "common/logging/log.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
-#include "core/hle/service/nvflinger/buffer_item.h"
-#include "core/hle/service/nvflinger/buffer_queue_consumer.h"
-#include "core/hle/service/nvflinger/buffer_queue_core.h"
-#include "core/hle/service/nvflinger/producer_listener.h"
-#include "core/hle/service/nvflinger/ui/graphic_buffer.h"
+#include "core/hle/service/nvnflinger/buffer_item.h"
+#include "core/hle/service/nvnflinger/buffer_queue_consumer.h"
+#include "core/hle/service/nvnflinger/buffer_queue_core.h"
+#include "core/hle/service/nvnflinger/producer_listener.h"
+#include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
 
 namespace Service::android {
 
@@ -31,7 +31,7 @@ Status BufferQueueConsumer::AcquireBuffer(BufferItem* out_buffer,
         }))};
 
     if (num_acquired_buffers >= core->max_acquired_buffer_count + 1) {
-        LOG_ERROR(Service_NVFlinger, "max acquired buffer count reached: {} (max {})",
+        LOG_ERROR(Service_Nvnflinger, "max acquired buffer count reached: {} (max {})",
                   num_acquired_buffers, core->max_acquired_buffer_count);
         return Status::InvalidOperation;
     }
@@ -57,12 +57,12 @@ Status BufferQueueConsumer::AcquireBuffer(BufferItem* out_buffer,
             if (desired_present < expected_present.count() - MAX_REASONABLE_NSEC ||
                 desired_present > expected_present.count()) {
                 // This buffer is set to display in the near future, or desired_present is garbage.
-                LOG_DEBUG(Service_NVFlinger, "nodrop desire={} expect={}", desired_present,
+                LOG_DEBUG(Service_Nvnflinger, "nodrop desire={} expect={}", desired_present,
                           expected_present.count());
                 break;
             }
 
-            LOG_DEBUG(Service_NVFlinger, "drop desire={} expect={} size={}", desired_present,
+            LOG_DEBUG(Service_Nvnflinger, "drop desire={} expect={} size={}", desired_present,
                       expected_present.count(), core->queue.size());
 
             if (core->StillTracking(*front)) {
@@ -78,19 +78,19 @@ Status BufferQueueConsumer::AcquireBuffer(BufferItem* out_buffer,
         const auto desired_present = front->timestamp;
         if (desired_present > expected_present.count() &&
             desired_present < expected_present.count() + MAX_REASONABLE_NSEC) {
-            LOG_DEBUG(Service_NVFlinger, "defer desire={} expect={}", desired_present,
+            LOG_DEBUG(Service_Nvnflinger, "defer desire={} expect={}", desired_present,
                       expected_present.count());
             return Status::PresentLater;
         }
 
-        LOG_DEBUG(Service_NVFlinger, "accept desire={} expect={}", desired_present,
+        LOG_DEBUG(Service_Nvnflinger, "accept desire={} expect={}", desired_present,
                   expected_present.count());
     }
 
     const auto slot = front->slot;
     *out_buffer = *front;
 
-    LOG_DEBUG(Service_NVFlinger, "acquiring slot={}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "acquiring slot={}", slot);
 
     // If the buffer has previously been acquired by the consumer, set graphic_buffer to nullptr to
     // avoid unnecessarily remapping this buffer on the consumer side.
@@ -109,7 +109,7 @@ Status BufferQueueConsumer::AcquireBuffer(BufferItem* out_buffer,
 
 Status BufferQueueConsumer::ReleaseBuffer(s32 slot, u64 frame_number, const Fence& release_fence) {
     if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
-        LOG_ERROR(Service_NVFlinger, "slot {} out of range", slot);
+        LOG_ERROR(Service_Nvnflinger, "slot {} out of range", slot);
         return Status::BadValue;
     }
 
@@ -127,7 +127,7 @@ Status BufferQueueConsumer::ReleaseBuffer(s32 slot, u64 frame_number, const Fenc
         auto current(core->queue.begin());
         while (current != core->queue.end()) {
             if (current->slot == slot) {
-                LOG_ERROR(Service_NVFlinger, "buffer slot {} pending release is currently queued",
+                LOG_ERROR(Service_Nvnflinger, "buffer slot {} pending release is currently queued",
                           slot);
                 return Status::BadValue;
             }
@@ -140,7 +140,7 @@ Status BufferQueueConsumer::ReleaseBuffer(s32 slot, u64 frame_number, const Fenc
 
         listener = core->connected_producer_listener;
 
-        LOG_DEBUG(Service_NVFlinger, "releasing slot {}", slot);
+        LOG_DEBUG(Service_Nvnflinger, "releasing slot {}", slot);
 
         core->SignalDequeueCondition();
     }
@@ -156,16 +156,16 @@ Status BufferQueueConsumer::ReleaseBuffer(s32 slot, u64 frame_number, const Fenc
 Status BufferQueueConsumer::Connect(std::shared_ptr<IConsumerListener> consumer_listener,
                                     bool controlled_by_app) {
     if (consumer_listener == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "consumer_listener may not be nullptr");
+        LOG_ERROR(Service_Nvnflinger, "consumer_listener may not be nullptr");
         return Status::BadValue;
     }
 
-    LOG_DEBUG(Service_NVFlinger, "controlled_by_app={}", controlled_by_app);
+    LOG_DEBUG(Service_Nvnflinger, "controlled_by_app={}", controlled_by_app);
 
     std::scoped_lock lock{core->mutex};
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
 
@@ -177,14 +177,14 @@ Status BufferQueueConsumer::Connect(std::shared_ptr<IConsumerListener> consumer_
 
 Status BufferQueueConsumer::GetReleasedBuffers(u64* out_slot_mask) {
     if (out_slot_mask == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "out_slot_mask may not be nullptr");
+        LOG_ERROR(Service_Nvnflinger, "out_slot_mask may not be nullptr");
         return Status::BadValue;
     }
 
     std::scoped_lock lock{core->mutex};
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
 
@@ -205,7 +205,7 @@ Status BufferQueueConsumer::GetReleasedBuffers(u64* out_slot_mask) {
         ++current;
     }
 
-    LOG_DEBUG(Service_NVFlinger, "returning mask {}", mask);
+    LOG_DEBUG(Service_Nvnflinger, "returning mask {}", mask);
     *out_slot_mask = mask;
     return Status::NoError;
 }

src/core/hle/service/nvflinger/buffer_queue_consumer.h → src/core/hle/service/nvnflinger/buffer_queue_consumer.h

@@ -10,8 +10,8 @@
 #include <memory>
 
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/buffer_queue_defs.h"
-#include "core/hle/service/nvflinger/status.h"
+#include "core/hle/service/nvnflinger/buffer_queue_defs.h"
+#include "core/hle/service/nvnflinger/status.h"
 
 namespace Service::Nvidia::NvCore {
 class NvMap;

src/core/hle/service/nvflinger/buffer_queue_core.cpp → src/core/hle/service/nvnflinger/buffer_queue_core.cpp

@@ -6,7 +6,7 @@
 
 #include "common/assert.h"
 
-#include "core/hle/service/nvflinger/buffer_queue_core.h"
+#include "core/hle/service/nvnflinger/buffer_queue_core.h"
 
 namespace Service::android {
 
@@ -82,7 +82,7 @@ s32 BufferQueueCore::GetPreallocatedBufferCountLocked() const {
 }
 
 void BufferQueueCore::FreeBufferLocked(s32 slot) {
-    LOG_DEBUG(Service_NVFlinger, "slot {}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot {}", slot);
 
     slots[slot].graphic_buffer.reset();
 

src/core/hle/service/nvflinger/buffer_queue_core.h → src/core/hle/service/nvnflinger/buffer_queue_core.h

@@ -13,11 +13,11 @@
 #include <set>
 #include <vector>
 
-#include "core/hle/service/nvflinger/buffer_item.h"
-#include "core/hle/service/nvflinger/buffer_queue_defs.h"
-#include "core/hle/service/nvflinger/pixel_format.h"
-#include "core/hle/service/nvflinger/status.h"
-#include "core/hle/service/nvflinger/window.h"
+#include "core/hle/service/nvnflinger/buffer_item.h"
+#include "core/hle/service/nvnflinger/buffer_queue_defs.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/status.h"
+#include "core/hle/service/nvnflinger/window.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/buffer_queue_defs.h → src/core/hle/service/nvnflinger/buffer_queue_defs.h

@@ -9,7 +9,7 @@
 #include <array>
 
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/buffer_slot.h"
+#include "core/hle/service/nvnflinger/buffer_slot.h"
 
 namespace Service::android::BufferQueueDefs {
 

src/core/hle/service/nvflinger/buffer_queue_producer.cpp → src/core/hle/service/nvnflinger/buffer_queue_producer.cpp

@@ -14,12 +14,12 @@
 #include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nvdrv/core/nvmap.h"
-#include "core/hle/service/nvflinger/buffer_queue_core.h"
-#include "core/hle/service/nvflinger/buffer_queue_producer.h"
-#include "core/hle/service/nvflinger/consumer_listener.h"
-#include "core/hle/service/nvflinger/parcel.h"
-#include "core/hle/service/nvflinger/ui/graphic_buffer.h"
-#include "core/hle/service/nvflinger/window.h"
+#include "core/hle/service/nvnflinger/buffer_queue_core.h"
+#include "core/hle/service/nvnflinger/buffer_queue_producer.h"
+#include "core/hle/service/nvnflinger/consumer_listener.h"
+#include "core/hle/service/nvnflinger/parcel.h"
+#include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
+#include "core/hle/service/nvnflinger/window.h"
 #include "core/hle/service/vi/vi.h"
 
 namespace Service::android {
@@ -37,20 +37,20 @@ BufferQueueProducer::~BufferQueueProducer() {
 }
 
 Status BufferQueueProducer::RequestBuffer(s32 slot, std::shared_ptr<GraphicBuffer>* buf) {
-    LOG_DEBUG(Service_NVFlinger, "slot {}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot {}", slot);
 
     std::scoped_lock lock{core->mutex};
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
     if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
-        LOG_ERROR(Service_NVFlinger, "slot index {} out of range [0, {})", slot,
+        LOG_ERROR(Service_Nvnflinger, "slot index {} out of range [0, {})", slot,
                   BufferQueueDefs::NUM_BUFFER_SLOTS);
         return Status::BadValue;
     } else if (slots[slot].buffer_state != BufferState::Dequeued) {
-        LOG_ERROR(Service_NVFlinger, "slot {} is not owned by the producer (state = {})", slot,
+        LOG_ERROR(Service_Nvnflinger, "slot {} is not owned by the producer (state = {})", slot,
                   slots[slot].buffer_state);
         return Status::BadValue;
     }
@@ -62,7 +62,7 @@ Status BufferQueueProducer::RequestBuffer(s32 slot, std::shared_ptr<GraphicBuffe
 }
 
 Status BufferQueueProducer::SetBufferCount(s32 buffer_count) {
-    LOG_DEBUG(Service_NVFlinger, "count = {}", buffer_count);
+    LOG_DEBUG(Service_Nvnflinger, "count = {}", buffer_count);
 
     std::shared_ptr<IConsumerListener> listener;
     {
@@ -70,12 +70,12 @@ Status BufferQueueProducer::SetBufferCount(s32 buffer_count) {
         core->WaitWhileAllocatingLocked();
 
         if (core->is_abandoned) {
-            LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+            LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
             return Status::NoInit;
         }
 
         if (buffer_count > BufferQueueDefs::NUM_BUFFER_SLOTS) {
-            LOG_ERROR(Service_NVFlinger, "buffer_count {} too large (max {})", buffer_count,
+            LOG_ERROR(Service_Nvnflinger, "buffer_count {} too large (max {})", buffer_count,
                       BufferQueueDefs::NUM_BUFFER_SLOTS);
             return Status::BadValue;
         }
@@ -83,7 +83,7 @@ Status BufferQueueProducer::SetBufferCount(s32 buffer_count) {
         // There must be no dequeued buffers when changing the buffer count.
         for (s32 s{}; s < BufferQueueDefs::NUM_BUFFER_SLOTS; ++s) {
             if (slots[s].buffer_state == BufferState::Dequeued) {
-                LOG_ERROR(Service_NVFlinger, "buffer owned by producer");
+                LOG_ERROR(Service_Nvnflinger, "buffer owned by producer");
                 return Status::BadValue;
             }
         }
@@ -96,7 +96,7 @@ Status BufferQueueProducer::SetBufferCount(s32 buffer_count) {
 
         const s32 min_buffer_slots = core->GetMinMaxBufferCountLocked(false);
         if (buffer_count < min_buffer_slots) {
-            LOG_ERROR(Service_NVFlinger, "requested buffer count {} is less than minimum {}",
+            LOG_ERROR(Service_Nvnflinger, "requested buffer count {} is less than minimum {}",
                       buffer_count, min_buffer_slots);
             return Status::BadValue;
         }
@@ -127,14 +127,14 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
 
     while (try_again) {
         if (core->is_abandoned) {
-            LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+            LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
             return Status::NoInit;
         }
 
         const s32 max_buffer_count = core->GetMaxBufferCountLocked(async);
         if (async && core->override_max_buffer_count) {
             if (core->override_max_buffer_count < max_buffer_count) {
-                LOG_ERROR(Service_NVFlinger, "async mode is invalid with buffer count override");
+                LOG_ERROR(Service_Nvnflinger, "async mode is invalid with buffer count override");
                 return Status::BadValue;
             }
         }
@@ -176,7 +176,7 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
         // Producers are not allowed to dequeue more than one buffer if they did not set a buffer
         // count
         if (!core->override_max_buffer_count && dequeued_count) {
-            LOG_ERROR(Service_NVFlinger,
+            LOG_ERROR(Service_Nvnflinger,
                       "can't dequeue multiple buffers without setting the buffer count");
             return Status::InvalidOperation;
         }
@@ -188,7 +188,7 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
             const s32 new_undequeued_count = max_buffer_count - (dequeued_count + 1);
             const s32 min_undequeued_count = core->GetMinUndequeuedBufferCountLocked(async);
             if (new_undequeued_count < min_undequeued_count) {
-                LOG_ERROR(Service_NVFlinger,
+                LOG_ERROR(Service_Nvnflinger,
                           "min undequeued buffer count({}) exceeded (dequeued={} undequeued={})",
                           min_undequeued_count, dequeued_count, new_undequeued_count);
                 return Status::InvalidOperation;
@@ -200,7 +200,7 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
         // outrun the consumer. Wait here if it looks like we have too many buffers queued up.
         const bool too_many_buffers = core->queue.size() > static_cast<size_t>(max_buffer_count);
         if (too_many_buffers) {
-            LOG_ERROR(Service_NVFlinger, "queue size is {}, waiting", core->queue.size());
+            LOG_ERROR(Service_Nvnflinger, "queue size is {}, waiting", core->queue.size());
         }
 
         // If no buffer is found, or if the queue has too many buffers outstanding, wait for a
@@ -226,11 +226,11 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
 
 Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool async, u32 width,
                                           u32 height, PixelFormat format, u32 usage) {
-    LOG_DEBUG(Service_NVFlinger, "async={} w={} h={} format={}, usage={}", async ? "true" : "false",
-              width, height, format, usage);
+    LOG_DEBUG(Service_Nvnflinger, "async={} w={} h={} format={}, usage={}",
+              async ? "true" : "false", width, height, format, usage);
 
     if ((width != 0 && height == 0) || (width == 0 && height != 0)) {
-        LOG_ERROR(Service_NVFlinger, "invalid size: w={} h={}", width, height);
+        LOG_ERROR(Service_Nvnflinger, "invalid size: w={} h={}", width, height);
         return Status::BadValue;
     }
 
@@ -255,7 +255,7 @@ Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool
 
         // This should not happen
         if (found == BufferQueueCore::INVALID_BUFFER_SLOT) {
-            LOG_ERROR(Service_NVFlinger, "no available buffer slots");
+            LOG_ERROR(Service_Nvnflinger, "no available buffer slots");
             return Status::Busy;
         }
 
@@ -287,11 +287,11 @@ Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool
     }
 
     if ((return_flags & Status::BufferNeedsReallocation) != Status::None) {
-        LOG_DEBUG(Service_NVFlinger, "allocating a new buffer for slot {}", *out_slot);
+        LOG_DEBUG(Service_Nvnflinger, "allocating a new buffer for slot {}", *out_slot);
 
         auto graphic_buffer = std::make_shared<GraphicBuffer>(width, height, format, usage);
         if (graphic_buffer == nullptr) {
-            LOG_ERROR(Service_NVFlinger, "creating GraphicBuffer failed");
+            LOG_ERROR(Service_Nvnflinger, "creating GraphicBuffer failed");
             return Status::NoMemory;
         }
 
@@ -299,7 +299,7 @@ Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool
             std::scoped_lock lock{core->mutex};
 
             if (core->is_abandoned) {
-                LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+                LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
                 return Status::NoInit;
             }
 
@@ -312,32 +312,32 @@ Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool
         return_flags |= Status::BufferNeedsReallocation;
     }
 
-    LOG_DEBUG(Service_NVFlinger, "returning slot={} frame={}, flags={}", *out_slot,
+    LOG_DEBUG(Service_Nvnflinger, "returning slot={} frame={}, flags={}", *out_slot,
               slots[*out_slot].frame_number, return_flags);
 
     return return_flags;
 }
 
 Status BufferQueueProducer::DetachBuffer(s32 slot) {
-    LOG_DEBUG(Service_NVFlinger, "slot {}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot {}", slot);
 
     std::scoped_lock lock{core->mutex};
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
 
     if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
-        LOG_ERROR(Service_NVFlinger, "slot {} out of range [0, {})", slot,
+        LOG_ERROR(Service_Nvnflinger, "slot {} out of range [0, {})", slot,
                   BufferQueueDefs::NUM_BUFFER_SLOTS);
         return Status::BadValue;
     } else if (slots[slot].buffer_state != BufferState::Dequeued) {
-        LOG_ERROR(Service_NVFlinger, "slot {} is not owned by the producer (state = {})", slot,
+        LOG_ERROR(Service_Nvnflinger, "slot {} is not owned by the producer (state = {})", slot,
                   slots[slot].buffer_state);
         return Status::BadValue;
     } else if (!slots[slot].request_buffer_called) {
-        LOG_ERROR(Service_NVFlinger, "buffer in slot {} has not been requested", slot);
+        LOG_ERROR(Service_Nvnflinger, "buffer in slot {} has not been requested", slot);
         return Status::BadValue;
     }
 
@@ -350,10 +350,10 @@ Status BufferQueueProducer::DetachBuffer(s32 slot) {
 Status BufferQueueProducer::DetachNextBuffer(std::shared_ptr<GraphicBuffer>* out_buffer,
                                              Fence* out_fence) {
     if (out_buffer == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "out_buffer must not be nullptr");
+        LOG_ERROR(Service_Nvnflinger, "out_buffer must not be nullptr");
         return Status::BadValue;
     } else if (out_fence == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "out_fence must not be nullptr");
+        LOG_ERROR(Service_Nvnflinger, "out_fence must not be nullptr");
         return Status::BadValue;
     }
 
@@ -361,7 +361,7 @@ Status BufferQueueProducer::DetachNextBuffer(std::shared_ptr<GraphicBuffer>* out
     core->WaitWhileAllocatingLocked();
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
 
@@ -380,7 +380,7 @@ Status BufferQueueProducer::DetachNextBuffer(std::shared_ptr<GraphicBuffer>* out
         return Status::NoMemory;
     }
 
-    LOG_DEBUG(Service_NVFlinger, "Detached slot {}", found);
+    LOG_DEBUG(Service_Nvnflinger, "Detached slot {}", found);
 
     *out_buffer = slots[found].graphic_buffer;
     *out_fence = slots[found].fence;
@@ -393,10 +393,10 @@ Status BufferQueueProducer::DetachNextBuffer(std::shared_ptr<GraphicBuffer>* out
 Status BufferQueueProducer::AttachBuffer(s32* out_slot,
                                          const std::shared_ptr<GraphicBuffer>& buffer) {
     if (out_slot == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "out_slot must not be nullptr");
+        LOG_ERROR(Service_Nvnflinger, "out_slot must not be nullptr");
         return Status::BadValue;
     } else if (buffer == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "Cannot attach nullptr buffer");
+        LOG_ERROR(Service_Nvnflinger, "Cannot attach nullptr buffer");
         return Status::BadValue;
     }
 
@@ -413,13 +413,13 @@ Status BufferQueueProducer::AttachBuffer(s32* out_slot,
 
     // This should not happen
     if (found == BufferQueueCore::INVALID_BUFFER_SLOT) {
-        LOG_ERROR(Service_NVFlinger, "No available buffer slots");
+        LOG_ERROR(Service_Nvnflinger, "No available buffer slots");
         return Status::Busy;
     }
 
     *out_slot = found;
 
-    LOG_DEBUG(Service_NVFlinger, "Returning slot {} flags={}", *out_slot, return_flags);
+    LOG_DEBUG(Service_Nvnflinger, "Returning slot {} flags={}", *out_slot, return_flags);
 
     slots[*out_slot].graphic_buffer = buffer;
     slots[*out_slot].buffer_state = BufferState::Dequeued;
@@ -451,7 +451,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
     case NativeWindowScalingMode::NoScaleCrop:
         break;
     default:
-        LOG_ERROR(Service_NVFlinger, "unknown scaling mode {}", scaling_mode);
+        LOG_ERROR(Service_Nvnflinger, "unknown scaling mode {}", scaling_mode);
         return Status::BadValue;
     }
 
@@ -464,38 +464,38 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
         std::scoped_lock lock{core->mutex};
 
         if (core->is_abandoned) {
-            LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+            LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
             return Status::NoInit;
         }
 
         const s32 max_buffer_count = core->GetMaxBufferCountLocked(async);
         if (async && core->override_max_buffer_count) {
             if (core->override_max_buffer_count < max_buffer_count) {
-                LOG_ERROR(Service_NVFlinger, "async mode is invalid with "
-                                             "buffer count override");
+                LOG_ERROR(Service_Nvnflinger, "async mode is invalid with "
+                                              "buffer count override");
                 return Status::BadValue;
             }
         }
 
         if (slot < 0 || slot >= max_buffer_count) {
-            LOG_ERROR(Service_NVFlinger, "slot index {} out of range [0, {})", slot,
+            LOG_ERROR(Service_Nvnflinger, "slot index {} out of range [0, {})", slot,
                       max_buffer_count);
             return Status::BadValue;
         } else if (slots[slot].buffer_state != BufferState::Dequeued) {
-            LOG_ERROR(Service_NVFlinger,
+            LOG_ERROR(Service_Nvnflinger,
                       "slot {} is not owned by the producer "
                       "(state = {})",
                       slot, slots[slot].buffer_state);
             return Status::BadValue;
         } else if (!slots[slot].request_buffer_called) {
-            LOG_ERROR(Service_NVFlinger,
+            LOG_ERROR(Service_Nvnflinger,
                       "slot {} was queued without requesting "
                       "a buffer",
                       slot);
             return Status::BadValue;
         }
 
-        LOG_DEBUG(Service_NVFlinger,
+        LOG_DEBUG(Service_Nvnflinger,
                   "slot={} frame={} time={} crop=[{},{},{},{}] transform={} scale={}", slot,
                   core->frame_counter + 1, timestamp, crop.Left(), crop.Top(), crop.Right(),
                   crop.Bottom(), transform, scaling_mode);
@@ -506,7 +506,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
         [[maybe_unused]] const bool unused = crop.Intersect(buffer_rect, &cropped_rect);
 
         if (cropped_rect != crop) {
-            LOG_ERROR(Service_NVFlinger, "crop rect is not contained within the buffer in slot {}",
+            LOG_ERROR(Service_Nvnflinger, "crop rect is not contained within the buffer in slot {}",
                       slot);
             return Status::BadValue;
         }
@@ -598,21 +598,21 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
 }
 
 void BufferQueueProducer::CancelBuffer(s32 slot, const Fence& fence) {
-    LOG_DEBUG(Service_NVFlinger, "slot {}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot {}", slot);
 
     std::scoped_lock lock{core->mutex};
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return;
     }
 
     if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
-        LOG_ERROR(Service_NVFlinger, "slot index {} out of range [0, {})", slot,
+        LOG_ERROR(Service_Nvnflinger, "slot index {} out of range [0, {})", slot,
                   BufferQueueDefs::NUM_BUFFER_SLOTS);
         return;
     } else if (slots[slot].buffer_state != BufferState::Dequeued) {
-        LOG_ERROR(Service_NVFlinger, "slot {} is not owned by the producer (state = {})", slot,
+        LOG_ERROR(Service_Nvnflinger, "slot {} is not owned by the producer (state = {})", slot,
                   slots[slot].buffer_state);
         return;
     }
@@ -629,12 +629,12 @@ Status BufferQueueProducer::Query(NativeWindow what, s32* out_value) {
     std::scoped_lock lock{core->mutex};
 
     if (out_value == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "outValue was nullptr");
+        LOG_ERROR(Service_Nvnflinger, "outValue was nullptr");
         return Status::BadValue;
     }
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
 
@@ -666,7 +666,7 @@ Status BufferQueueProducer::Query(NativeWindow what, s32* out_value) {
         return Status::BadValue;
     }
 
-    LOG_DEBUG(Service_NVFlinger, "what = {}, value = {}", what, value);
+    LOG_DEBUG(Service_Nvnflinger, "what = {}, value = {}", what, value);
 
     *out_value = static_cast<s32>(value);
 
@@ -678,26 +678,26 @@ Status BufferQueueProducer::Connect(const std::shared_ptr<IProducerListener>& li
                                     QueueBufferOutput* output) {
     std::scoped_lock lock{core->mutex};
 
-    LOG_DEBUG(Service_NVFlinger, "api = {} producer_controlled_by_app = {}", api,
+    LOG_DEBUG(Service_Nvnflinger, "api = {} producer_controlled_by_app = {}", api,
               producer_controlled_by_app);
 
     if (core->is_abandoned) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has been abandoned");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has been abandoned");
         return Status::NoInit;
     }
 
     if (core->consumer_listener == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "BufferQueue has no consumer");
+        LOG_ERROR(Service_Nvnflinger, "BufferQueue has no consumer");
         return Status::NoInit;
     }
 
     if (output == nullptr) {
-        LOG_ERROR(Service_NVFlinger, "output was nullptr");
+        LOG_ERROR(Service_Nvnflinger, "output was nullptr");
         return Status::BadValue;
     }
 
     if (core->connected_api != NativeWindowApi::NoConnectedApi) {
-        LOG_ERROR(Service_NVFlinger, "already connected (cur = {} req = {})", core->connected_api,
+        LOG_ERROR(Service_Nvnflinger, "already connected (cur = {} req = {})", core->connected_api,
                   api);
         return Status::BadValue;
     }
@@ -714,7 +714,7 @@ Status BufferQueueProducer::Connect(const std::shared_ptr<IProducerListener>& li
         core->connected_producer_listener = listener;
         break;
     default:
-        LOG_ERROR(Service_NVFlinger, "unknown api = {}", api);
+        LOG_ERROR(Service_Nvnflinger, "unknown api = {}", api);
         status = Status::BadValue;
         break;
     }
@@ -727,7 +727,7 @@ Status BufferQueueProducer::Connect(const std::shared_ptr<IProducerListener>& li
 }
 
 Status BufferQueueProducer::Disconnect(NativeWindowApi api) {
-    LOG_DEBUG(Service_NVFlinger, "api = {}", api);
+    LOG_DEBUG(Service_Nvnflinger, "api = {}", api);
 
     Status status = Status::NoError;
     std::shared_ptr<IConsumerListener> listener;
@@ -762,13 +762,13 @@ Status BufferQueueProducer::Disconnect(NativeWindowApi api) {
                 buffer_wait_event->Signal();
                 listener = core->consumer_listener;
             } else {
-                LOG_ERROR(Service_NVFlinger, "still connected to another api (cur = {} req = {})",
+                LOG_ERROR(Service_Nvnflinger, "still connected to another api (cur = {} req = {})",
                           core->connected_api, api);
                 status = Status::BadValue;
             }
             break;
         default:
-            LOG_ERROR(Service_NVFlinger, "unknown api = {}", api);
+            LOG_ERROR(Service_Nvnflinger, "unknown api = {}", api);
             status = Status::BadValue;
             break;
         }
@@ -784,7 +784,7 @@ Status BufferQueueProducer::Disconnect(NativeWindowApi api) {
 
 Status BufferQueueProducer::SetPreallocatedBuffer(s32 slot,
                                                   const std::shared_ptr<GraphicBuffer>& buffer) {
-    LOG_DEBUG(Service_NVFlinger, "slot {}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot {}", slot);
 
     if (slot < 0 || slot >= BufferQueueDefs::NUM_BUFFER_SLOTS) {
         return Status::BadValue;
@@ -914,7 +914,7 @@ void BufferQueueProducer::Transact(HLERequestContext& ctx, TransactionId code, u
         break;
     }
     case TransactionId::GetBufferHistory:
-        LOG_WARNING(Service_NVFlinger, "(STUBBED) called, transaction=GetBufferHistory");
+        LOG_WARNING(Service_Nvnflinger, "(STUBBED) called, transaction=GetBufferHistory");
         break;
     default:
         ASSERT_MSG(false, "Unimplemented TransactionId {}", code);

src/core/hle/service/nvflinger/buffer_queue_producer.h → src/core/hle/service/nvnflinger/buffer_queue_producer.h

@@ -12,13 +12,13 @@
 
 #include "common/common_funcs.h"
 #include "core/hle/service/nvdrv/nvdata.h"
-#include "core/hle/service/nvflinger/binder.h"
-#include "core/hle/service/nvflinger/buffer_queue_defs.h"
-#include "core/hle/service/nvflinger/buffer_slot.h"
-#include "core/hle/service/nvflinger/graphic_buffer_producer.h"
-#include "core/hle/service/nvflinger/pixel_format.h"
-#include "core/hle/service/nvflinger/status.h"
-#include "core/hle/service/nvflinger/window.h"
+#include "core/hle/service/nvnflinger/binder.h"
+#include "core/hle/service/nvnflinger/buffer_queue_defs.h"
+#include "core/hle/service/nvnflinger/buffer_slot.h"
+#include "core/hle/service/nvnflinger/graphic_buffer_producer.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/status.h"
+#include "core/hle/service/nvnflinger/window.h"
 
 namespace Kernel {
 class KernelCore;

src/core/hle/service/nvflinger/buffer_slot.h → src/core/hle/service/nvnflinger/buffer_slot.h

@@ -9,7 +9,7 @@
 #include <memory>
 
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/ui/fence.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/consumer_base.cpp → src/core/hle/service/nvnflinger/consumer_base.cpp

@@ -6,11 +6,11 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/service/nvflinger/buffer_item.h"
-#include "core/hle/service/nvflinger/buffer_queue_consumer.h"
-#include "core/hle/service/nvflinger/buffer_queue_core.h"
-#include "core/hle/service/nvflinger/consumer_base.h"
-#include "core/hle/service/nvflinger/ui/graphic_buffer.h"
+#include "core/hle/service/nvnflinger/buffer_item.h"
+#include "core/hle/service/nvnflinger/buffer_queue_consumer.h"
+#include "core/hle/service/nvnflinger/buffer_queue_core.h"
+#include "core/hle/service/nvnflinger/consumer_base.h"
+#include "core/hle/service/nvnflinger/ui/graphic_buffer.h"
 
 namespace Service::android {
 
@@ -28,7 +28,7 @@ void ConsumerBase::Connect(bool controlled_by_app) {
 }
 
 void ConsumerBase::FreeBufferLocked(s32 slot_index) {
-    LOG_DEBUG(Service_NVFlinger, "slot_index={}", slot_index);
+    LOG_DEBUG(Service_Nvnflinger, "slot_index={}", slot_index);
 
     slots[slot_index].graphic_buffer = nullptr;
     slots[slot_index].fence = Fence::NoFence();
@@ -36,17 +36,17 @@ void ConsumerBase::FreeBufferLocked(s32 slot_index) {
 }
 
 void ConsumerBase::OnFrameAvailable(const BufferItem& item) {
-    LOG_DEBUG(Service_NVFlinger, "called");
+    LOG_DEBUG(Service_Nvnflinger, "called");
 }
 
 void ConsumerBase::OnFrameReplaced(const BufferItem& item) {
-    LOG_DEBUG(Service_NVFlinger, "called");
+    LOG_DEBUG(Service_Nvnflinger, "called");
 }
 
 void ConsumerBase::OnBuffersReleased() {
     std::scoped_lock lock{mutex};
 
-    LOG_DEBUG(Service_NVFlinger, "called");
+    LOG_DEBUG(Service_Nvnflinger, "called");
 
     if (is_abandoned) {
         // Nothing to do if we're already abandoned.
@@ -77,7 +77,7 @@ Status ConsumerBase::AcquireBufferLocked(BufferItem* item, std::chrono::nanoseco
     slots[item->slot].frame_number = item->frame_number;
     slots[item->slot].fence = item->fence;
 
-    LOG_DEBUG(Service_NVFlinger, "slot={}", item->slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot={}", item->slot);
 
     return Status::NoError;
 }
@@ -85,7 +85,7 @@ Status ConsumerBase::AcquireBufferLocked(BufferItem* item, std::chrono::nanoseco
 Status ConsumerBase::AddReleaseFenceLocked(s32 slot,
                                            const std::shared_ptr<GraphicBuffer>& graphic_buffer,
                                            const Fence& fence) {
-    LOG_DEBUG(Service_NVFlinger, "slot={}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot={}", slot);
 
     // If consumer no longer tracks this graphic_buffer, we can safely
     // drop this fence, as it will never be received by the producer.
@@ -109,7 +109,7 @@ Status ConsumerBase::ReleaseBufferLocked(s32 slot,
         return Status::NoError;
     }
 
-    LOG_DEBUG(Service_NVFlinger, "slot={}", slot);
+    LOG_DEBUG(Service_Nvnflinger, "slot={}", slot);
     Status err = consumer->ReleaseBuffer(slot, slots[slot].frame_number, slots[slot].fence);
     if (err == Status::StaleBufferSlot) {
         FreeBufferLocked(slot);

src/core/hle/service/nvflinger/consumer_base.h → src/core/hle/service/nvnflinger/consumer_base.h

@@ -12,9 +12,9 @@
 #include <mutex>
 
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/buffer_queue_defs.h"
-#include "core/hle/service/nvflinger/consumer_listener.h"
-#include "core/hle/service/nvflinger/status.h"
+#include "core/hle/service/nvnflinger/buffer_queue_defs.h"
+#include "core/hle/service/nvnflinger/consumer_listener.h"
+#include "core/hle/service/nvnflinger/status.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/graphic_buffer_producer.cpp → src/core/hle/service/nvnflinger/graphic_buffer_producer.cpp

@@ -4,8 +4,8 @@
 // Parts of this implementation were based on:
 // https://cs.android.com/android/platform/superproject/+/android-5.1.1_r38:frameworks/native/libs/gui/IGraphicBufferProducer.cpp
 
-#include "core/hle/service/nvflinger/graphic_buffer_producer.h"
-#include "core/hle/service/nvflinger/parcel.h"
+#include "core/hle/service/nvnflinger/graphic_buffer_producer.h"
+#include "core/hle/service/nvnflinger/parcel.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/graphic_buffer_producer.h → src/core/hle/service/nvnflinger/graphic_buffer_producer.h

@@ -9,8 +9,8 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/math_util.h"
-#include "core/hle/service/nvflinger/ui/fence.h"
-#include "core/hle/service/nvflinger/window.h"
+#include "core/hle/service/nvnflinger/ui/fence.h"
+#include "core/hle/service/nvnflinger/window.h"
 
 namespace Service::android {
 

src/core/hle/service/nvflinger/hos_binder_driver_server.cpp → src/core/hle/service/nvnflinger/hos_binder_driver_server.cpp

@@ -4,9 +4,9 @@
 #include <mutex>
 
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/hos_binder_driver_server.h"
+#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 
 HosBinderDriverServer::HosBinderDriverServer(Core::System& system_)
     : service_context(system_, "HosBinderDriverServer") {}
@@ -33,4 +33,4 @@ android::IBinder* HosBinderDriverServer::TryGetProducer(u64 id) {
     return {};
 }
 
-} // namespace Service::NVFlinger
+} // namespace Service::Nvnflinger

src/core/hle/service/nvflinger/hos_binder_driver_server.h → src/core/hle/service/nvnflinger/hos_binder_driver_server.h

@@ -9,13 +9,13 @@
 
 #include "common/common_types.h"
 #include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/nvflinger/binder.h"
+#include "core/hle/service/nvnflinger/binder.h"
 
 namespace Core {
 class System;
 }
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 
 class HosBinderDriverServer final {
 public:
@@ -34,4 +34,4 @@ private:
     u64 last_id{};
 };
 
-} // namespace Service::NVFlinger
+} // namespace Service::Nvnflinger

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

@@ -15,11 +15,11 @@
 #include "core/hle/kernel/k_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_item_consumer.h"
-#include "core/hle/service/nvflinger/buffer_queue_core.h"
-#include "core/hle/service/nvflinger/hos_binder_driver_server.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
-#include "core/hle/service/nvflinger/ui/graphic_buffer.h"
+#include "core/hle/service/nvnflinger/buffer_item_consumer.h"
+#include "core/hle/service/nvnflinger/buffer_queue_core.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"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
 #include "core/hle/service/vi/vi_results.h"
@@ -27,11 +27,11 @@
 #include "video_core/host1x/host1x.h"
 #include "video_core/host1x/syncpoint_manager.h"
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 
 constexpr auto frame_ns = std::chrono::nanoseconds{1000000000 / 60};
 
-void NVFlinger::SplitVSync(std::stop_token stop_token) {
+void Nvnflinger::SplitVSync(std::stop_token stop_token) {
     system.RegisterHostThread();
     std::string name = "VSyncThread";
     MicroProfileOnThreadCreate(name.c_str());
@@ -54,8 +54,8 @@ void NVFlinger::SplitVSync(std::stop_token stop_token) {
     }
 }
 
-NVFlinger::NVFlinger(Core::System& system_, HosBinderDriverServer& hos_binder_driver_server_)
-    : system(system_), service_context(system_, "nvflinger"),
+Nvnflinger::Nvnflinger(Core::System& system_, HosBinderDriverServer& hos_binder_driver_server_)
+    : system(system_), service_context(system_, "nvnflinger"),
       hos_binder_driver_server(hos_binder_driver_server_) {
     displays.emplace_back(0, "Default", hos_binder_driver_server, service_context, system);
     displays.emplace_back(1, "External", hos_binder_driver_server, service_context, system);
@@ -92,7 +92,7 @@ NVFlinger::NVFlinger(Core::System& system_, HosBinderDriverServer& hos_binder_dr
     }
 }
 
-NVFlinger::~NVFlinger() {
+Nvnflinger::~Nvnflinger() {
     if (system.IsMulticore()) {
         system.CoreTiming().UnscheduleEvent(multi_composition_event, {});
         vsync_thread.request_stop();
@@ -109,7 +109,7 @@ NVFlinger::~NVFlinger() {
     }
 }
 
-void NVFlinger::ShutdownLayers() {
+void Nvnflinger::ShutdownLayers() {
     for (auto& display : displays) {
         for (size_t layer = 0; layer < display.GetNumLayers(); ++layer) {
             display.GetLayer(layer).Core().NotifyShutdown();
@@ -117,15 +117,15 @@ void NVFlinger::ShutdownLayers() {
     }
 }
 
-void NVFlinger::SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance) {
+void Nvnflinger::SetNVDrvInstance(std::shared_ptr<Nvidia::Module> instance) {
     nvdrv = std::move(instance);
     disp_fd = nvdrv->Open("/dev/nvdisp_disp0");
 }
 
-std::optional<u64> NVFlinger::OpenDisplay(std::string_view name) {
+std::optional<u64> Nvnflinger::OpenDisplay(std::string_view name) {
     const auto lock_guard = Lock();
 
-    LOG_DEBUG(Service_NVFlinger, "Opening \"{}\" display", name);
+    LOG_DEBUG(Service_Nvnflinger, "Opening \"{}\" display", name);
 
     const auto itr =
         std::find_if(displays.begin(), displays.end(),
@@ -138,7 +138,7 @@ std::optional<u64> NVFlinger::OpenDisplay(std::string_view name) {
     return itr->GetID();
 }
 
-bool NVFlinger::CloseDisplay(u64 display_id) {
+bool Nvnflinger::CloseDisplay(u64 display_id) {
     const auto lock_guard = Lock();
     auto* const display = FindDisplay(display_id);
 
@@ -151,7 +151,7 @@ bool NVFlinger::CloseDisplay(u64 display_id) {
     return true;
 }
 
-std::optional<u64> NVFlinger::CreateLayer(u64 display_id) {
+std::optional<u64> Nvnflinger::CreateLayer(u64 display_id) {
     const auto lock_guard = Lock();
     auto* const display = FindDisplay(display_id);
 
@@ -164,12 +164,12 @@ std::optional<u64> NVFlinger::CreateLayer(u64 display_id) {
     return layer_id;
 }
 
-void NVFlinger::CreateLayerAtId(VI::Display& display, u64 layer_id) {
+void Nvnflinger::CreateLayerAtId(VI::Display& display, u64 layer_id) {
     const auto buffer_id = next_buffer_queue_id++;
     display.CreateLayer(layer_id, buffer_id, nvdrv->container);
 }
 
-void NVFlinger::CloseLayer(u64 layer_id) {
+void Nvnflinger::CloseLayer(u64 layer_id) {
     const auto lock_guard = Lock();
 
     for (auto& display : displays) {
@@ -177,7 +177,7 @@ void NVFlinger::CloseLayer(u64 layer_id) {
     }
 }
 
-std::optional<u32> NVFlinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
+std::optional<u32> Nvnflinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
     const auto lock_guard = Lock();
     const auto* const layer = FindOrCreateLayer(display_id, layer_id);
 
@@ -188,7 +188,7 @@ std::optional<u32> NVFlinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
     return layer->GetBinderId();
 }
 
-ResultVal<Kernel::KReadableEvent*> NVFlinger::FindVsyncEvent(u64 display_id) {
+ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) {
     const auto lock_guard = Lock();
     auto* const display = FindDisplay(display_id);
 
@@ -199,7 +199,7 @@ ResultVal<Kernel::KReadableEvent*> NVFlinger::FindVsyncEvent(u64 display_id) {
     return display->GetVSyncEvent();
 }
 
-VI::Display* NVFlinger::FindDisplay(u64 display_id) {
+VI::Display* Nvnflinger::FindDisplay(u64 display_id) {
     const auto itr =
         std::find_if(displays.begin(), displays.end(),
                      [&](const VI::Display& display) { return display.GetID() == display_id; });
@@ -211,7 +211,7 @@ VI::Display* NVFlinger::FindDisplay(u64 display_id) {
     return &*itr;
 }
 
-const VI::Display* NVFlinger::FindDisplay(u64 display_id) const {
+const VI::Display* Nvnflinger::FindDisplay(u64 display_id) const {
     const auto itr =
         std::find_if(displays.begin(), displays.end(),
                      [&](const VI::Display& display) { return display.GetID() == display_id; });
@@ -223,7 +223,7 @@ const VI::Display* NVFlinger::FindDisplay(u64 display_id) const {
     return &*itr;
 }
 
-VI::Layer* NVFlinger::FindLayer(u64 display_id, u64 layer_id) {
+VI::Layer* Nvnflinger::FindLayer(u64 display_id, u64 layer_id) {
     auto* const display = FindDisplay(display_id);
 
     if (display == nullptr) {
@@ -233,7 +233,7 @@ VI::Layer* NVFlinger::FindLayer(u64 display_id, u64 layer_id) {
     return display->FindLayer(layer_id);
 }
 
-const VI::Layer* NVFlinger::FindLayer(u64 display_id, u64 layer_id) const {
+const VI::Layer* Nvnflinger::FindLayer(u64 display_id, u64 layer_id) const {
     const auto* const display = FindDisplay(display_id);
 
     if (display == nullptr) {
@@ -243,7 +243,7 @@ const VI::Layer* NVFlinger::FindLayer(u64 display_id, u64 layer_id) const {
     return display->FindLayer(layer_id);
 }
 
-VI::Layer* NVFlinger::FindOrCreateLayer(u64 display_id, u64 layer_id) {
+VI::Layer* Nvnflinger::FindOrCreateLayer(u64 display_id, u64 layer_id) {
     auto* const display = FindDisplay(display_id);
 
     if (display == nullptr) {
@@ -253,7 +253,7 @@ VI::Layer* NVFlinger::FindOrCreateLayer(u64 display_id, u64 layer_id) {
     auto* layer = display->FindLayer(layer_id);
 
     if (layer == nullptr) {
-        LOG_DEBUG(Service_NVFlinger, "Layer at id {} not found. Trying to create it.", layer_id);
+        LOG_DEBUG(Service_Nvnflinger, "Layer at id {} not found. Trying to create it.", layer_id);
         CreateLayerAtId(*display, layer_id);
         return display->FindLayer(layer_id);
     }
@@ -261,7 +261,7 @@ VI::Layer* NVFlinger::FindOrCreateLayer(u64 display_id, u64 layer_id) {
     return layer;
 }
 
-void NVFlinger::Compose() {
+void Nvnflinger::Compose() {
     for (auto& display : displays) {
         // Trigger vsync for this display at the end of drawing
         SCOPE_EXIT({ display.SignalVSyncEvent(); });
@@ -311,7 +311,7 @@ void NVFlinger::Compose() {
     }
 }
 
-s64 NVFlinger::GetNextTicks() const {
+s64 Nvnflinger::GetNextTicks() const {
     const auto& settings = Settings::values;
     auto speed_scale = 1.f;
     if (settings.use_multi_core.GetValue()) {
@@ -332,4 +332,4 @@ s64 NVFlinger::GetNextTicks() const {
     return static_cast<s64>(speed_scale * (1000000000.f / effective_fps));
 }
 
-} // namespace Service::NVFlinger
+} // namespace Service::Nvnflinger

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

@@ -42,12 +42,12 @@ class BufferQueueCore;
 class BufferQueueProducer;
 } // namespace Service::android
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 
-class NVFlinger final {
+class Nvnflinger final {
 public:
-    explicit NVFlinger(Core::System& system_, HosBinderDriverServer& hos_binder_driver_server_);
-    ~NVFlinger();
+    explicit Nvnflinger(Core::System& system_, HosBinderDriverServer& hos_binder_driver_server_);
+    ~Nvnflinger();
 
     void ShutdownLayers();
 
@@ -152,4 +152,4 @@ private:
     HosBinderDriverServer& hos_binder_driver_server;
 };
 
-} // namespace Service::NVFlinger
+} // namespace Service::Nvnflinger

src/core/hle/service/nvflinger/ui/graphic_buffer.h → src/core/hle/service/nvnflinger/ui/graphic_buffer.h

@@ -8,7 +8,7 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/hle/service/nvflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
 
 namespace Service::android {
 

src/core/hle/service/service.cpp

@@ -49,8 +49,8 @@
 #include "core/hle/service/npns/npns.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
-#include "core/hle/service/nvflinger/hos_binder_driver_server.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
+#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
 #include "core/hle/service/olsc/olsc.h"
 #include "core/hle/service/pcie/pcie.h"
 #include "core/hle/service/pctl/pctl_module.h"
@@ -210,12 +210,12 @@ Result ServiceFrameworkBase::HandleSyncRequest(Kernel::KServerSession& session,
 
 /// Initialize Services
 Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system)
-    : hos_binder_driver_server{std::make_unique<NVFlinger::HosBinderDriverServer>(system)},
-      nv_flinger{std::make_unique<NVFlinger::NVFlinger>(system, *hos_binder_driver_server)} {
+    : hos_binder_driver_server{std::make_unique<Nvnflinger::HosBinderDriverServer>(system)},
+      nv_flinger{std::make_unique<Nvnflinger::Nvnflinger>(system, *hos_binder_driver_server)} {
 
     auto& kernel = system.Kernel();
 
-    // NVFlinger needs to be accessed by several services like Vi and AppletOE so we instantiate it
+    // Nvnflinger needs to be accessed by several services like Vi and AppletOE so we instantiate it
     // here and pass it into the respective InstallInterfaces functions.
     system.GetFileSystemController().CreateFactories(*system.GetFilesystem(), false);
 

src/core/hle/service/service.h

@@ -28,10 +28,10 @@ namespace FileSystem {
 class FileSystemController;
 }
 
-namespace NVFlinger {
+namespace Nvnflinger {
 class HosBinderDriverServer;
-class NVFlinger;
-} // namespace NVFlinger
+class Nvnflinger;
+} // namespace Nvnflinger
 
 namespace SM {
 class ServiceManager;
@@ -228,8 +228,8 @@ public:
     void KillNVNFlinger();
 
 private:
-    std::unique_ptr<NVFlinger::HosBinderDriverServer> hos_binder_driver_server;
-    std::unique_ptr<NVFlinger::NVFlinger> nv_flinger;
+    std::unique_ptr<Nvnflinger::HosBinderDriverServer> hos_binder_driver_server;
+    std::unique_ptr<Nvnflinger::Nvnflinger> nv_flinger;
 };
 
 } // namespace Service

src/core/hle/service/vi/display/vi_display.cpp

@@ -12,11 +12,11 @@
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nvdrv/core/container.h"
-#include "core/hle/service/nvflinger/buffer_item_consumer.h"
-#include "core/hle/service/nvflinger/buffer_queue_consumer.h"
-#include "core/hle/service/nvflinger/buffer_queue_core.h"
-#include "core/hle/service/nvflinger/buffer_queue_producer.h"
-#include "core/hle/service/nvflinger/hos_binder_driver_server.h"
+#include "core/hle/service/nvnflinger/buffer_item_consumer.h"
+#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/hos_binder_driver_server.h"
 #include "core/hle/service/vi/display/vi_display.h"
 #include "core/hle/service/vi/layer/vi_layer.h"
 #include "core/hle/service/vi/vi_results.h"
@@ -39,7 +39,7 @@ static BufferQueue CreateBufferQueue(KernelHelpers::ServiceContext& service_cont
 }
 
 Display::Display(u64 id, std::string name_,
-                 NVFlinger::HosBinderDriverServer& hos_binder_driver_server_,
+                 Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_,
                  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_} {

src/core/hle/service/vi/display/vi_display.h

@@ -23,7 +23,7 @@ namespace Service::KernelHelpers {
 class ServiceContext;
 }
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 class HosBinderDriverServer;
 }
 
@@ -45,12 +45,12 @@ public:
     /// Constructs a display with a given unique ID and name.
     ///
     /// @param id The unique ID for this display.
-    /// @param hos_binder_driver_server_ NVFlinger HOSBinderDriver server instance.
+    /// @param hos_binder_driver_server_ Nvnflinger HOSBinderDriver server instance.
     /// @param service_context_ The ServiceContext for the owning service.
     /// @param name_ The name for this display.
     /// @param system_ The global system instance.
     ///
-    Display(u64 id, std::string name_, NVFlinger::HosBinderDriverServer& hos_binder_driver_server_,
+    Display(u64 id, std::string name_, Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_,
             KernelHelpers::ServiceContext& service_context_, Core::System& system_);
     ~Display();
 
@@ -133,7 +133,7 @@ public:
 private:
     u64 display_id;
     std::string name;
-    NVFlinger::HosBinderDriverServer& hos_binder_driver_server;
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
     KernelHelpers::ServiceContext& service_context;
 
     std::vector<std::unique_ptr<Layer>> layers;

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

@@ -21,11 +21,11 @@
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/nvdrv/nvdata.h"
-#include "core/hle/service/nvflinger/binder.h"
-#include "core/hle/service/nvflinger/buffer_queue_producer.h"
-#include "core/hle/service/nvflinger/hos_binder_driver_server.h"
-#include "core/hle/service/nvflinger/nvflinger.h"
-#include "core/hle/service/nvflinger/parcel.h"
+#include "core/hle/service/nvnflinger/binder.h"
+#include "core/hle/service/nvnflinger/buffer_queue_producer.h"
+#include "core/hle/service/nvnflinger/hos_binder_driver_server.h"
+#include "core/hle/service/nvnflinger/nvnflinger.h"
+#include "core/hle/service/nvnflinger/parcel.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/vi/vi.h"
@@ -73,7 +73,7 @@ static_assert(sizeof(NativeWindow) == 0x28, "NativeWindow has wrong size");
 
 class IHOSBinderDriver final : public ServiceFramework<IHOSBinderDriver> {
 public:
-    explicit IHOSBinderDriver(Core::System& system_, NVFlinger::HosBinderDriverServer& server_)
+    explicit IHOSBinderDriver(Core::System& system_, Nvnflinger::HosBinderDriverServer& server_)
         : ServiceFramework{system_, "IHOSBinderDriver"}, server(server_) {
         static const FunctionInfo functions[] = {
             {0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
@@ -126,7 +126,7 @@ private:
     }
 
 private:
-    NVFlinger::HosBinderDriverServer& server;
+    Nvnflinger::HosBinderDriverServer& server;
 };
 
 class ISystemDisplayService final : public ServiceFramework<ISystemDisplayService> {
@@ -232,7 +232,7 @@ private:
 
 class IManagerDisplayService final : public ServiceFramework<IManagerDisplayService> {
 public:
-    explicit IManagerDisplayService(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_)
+    explicit IManagerDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_)
         : ServiceFramework{system_, "IManagerDisplayService"}, nv_flinger{nv_flinger_} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -383,13 +383,13 @@ private:
         rb.Push(ResultSuccess);
     }
 
-    NVFlinger::NVFlinger& nv_flinger;
+    Nvnflinger::Nvnflinger& nv_flinger;
 };
 
 class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
 public:
-    IApplicationDisplayService(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-                               NVFlinger::HosBinderDriverServer& hos_binder_driver_server_)
+    IApplicationDisplayService(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+                               Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
         : ServiceFramework{system_, "IApplicationDisplayService"}, nv_flinger{nv_flinger_},
           hos_binder_driver_server{hos_binder_driver_server_} {
 
@@ -774,8 +774,8 @@ private:
         }
     }
 
-    NVFlinger::NVFlinger& nv_flinger;
-    NVFlinger::HosBinderDriverServer& hos_binder_driver_server;
+    Nvnflinger::Nvnflinger& nv_flinger;
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
 };
 
 static bool IsValidServiceAccess(Permission permission, Policy policy) {
@@ -791,8 +791,8 @@ static bool IsValidServiceAccess(Permission permission, Policy policy) {
 }
 
 void detail::GetDisplayServiceImpl(HLERequestContext& ctx, Core::System& system,
-                                   NVFlinger::NVFlinger& nv_flinger,
-                                   NVFlinger::HosBinderDriverServer& hos_binder_driver_server,
+                                   Nvnflinger::Nvnflinger& nv_flinger,
+                                   Nvnflinger::HosBinderDriverServer& hos_binder_driver_server,
                                    Permission permission) {
     IPC::RequestParser rp{ctx};
     const auto policy = rp.PopEnum<Policy>();
@@ -809,8 +809,8 @@ void detail::GetDisplayServiceImpl(HLERequestContext& ctx, Core::System& system,
     rb.PushIpcInterface<IApplicationDisplayService>(system, nv_flinger, hos_binder_driver_server);
 }
 
-void LoopProcess(Core::System& system, NVFlinger::NVFlinger& nv_flinger,
-                 NVFlinger::HosBinderDriverServer& hos_binder_driver_server) {
+void LoopProcess(Core::System& system, Nvnflinger::Nvnflinger& nv_flinger,
+                 Nvnflinger::HosBinderDriverServer& hos_binder_driver_server) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
     server_manager->RegisterNamedService(

src/core/hle/service/vi/vi.h

@@ -13,10 +13,10 @@ namespace Service {
 class HLERequestContext;
 }
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 class HosBinderDriverServer;
-class NVFlinger;
-} // namespace Service::NVFlinger
+class Nvnflinger;
+} // namespace Service::Nvnflinger
 
 namespace Service::VI {
 
@@ -43,12 +43,12 @@ enum class Policy {
 
 namespace detail {
 void GetDisplayServiceImpl(HLERequestContext& ctx, Core::System& system,
-                           NVFlinger::NVFlinger& nv_flinger,
-                           NVFlinger::HosBinderDriverServer& hos_binder_driver_server,
+                           Nvnflinger::Nvnflinger& nv_flinger,
+                           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server,
                            Permission permission);
 } // namespace detail
 
-void LoopProcess(Core::System& system, NVFlinger::NVFlinger& nv_flinger,
-                 NVFlinger::HosBinderDriverServer& hos_binder_driver_server);
+void LoopProcess(Core::System& system, Nvnflinger::Nvnflinger& nv_flinger,
+                 Nvnflinger::HosBinderDriverServer& hos_binder_driver_server);
 
 } // namespace Service::VI

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

@@ -7,8 +7,8 @@
 
 namespace Service::VI {
 
-VI_M::VI_M(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-           NVFlinger::HosBinderDriverServer& hos_binder_driver_server_)
+VI_M::VI_M(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
     : ServiceFramework{system_, "vi:m"}, nv_flinger{nv_flinger_}, hos_binder_driver_server{
                                                                       hos_binder_driver_server_} {
     static const FunctionInfo functions[] = {

src/core/hle/service/vi/vi_m.h

@@ -9,24 +9,24 @@ namespace Core {
 class System;
 }
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 class HosBinderDriverServer;
-class NVFlinger;
-} // namespace Service::NVFlinger
+class Nvnflinger;
+} // namespace Service::Nvnflinger
 
 namespace Service::VI {
 
 class VI_M final : public ServiceFramework<VI_M> {
 public:
-    explicit VI_M(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-                  NVFlinger::HosBinderDriverServer& hos_binder_driver_server_);
+    explicit VI_M(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_);
     ~VI_M() override;
 
 private:
     void GetDisplayService(HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nv_flinger;
-    NVFlinger::HosBinderDriverServer& hos_binder_driver_server;
+    Nvnflinger::Nvnflinger& nv_flinger;
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
 };
 
 } // namespace Service::VI

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

@@ -7,8 +7,8 @@
 
 namespace Service::VI {
 
-VI_S::VI_S(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-           NVFlinger::HosBinderDriverServer& hos_binder_driver_server_)
+VI_S::VI_S(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
     : ServiceFramework{system_, "vi:s"}, nv_flinger{nv_flinger_}, hos_binder_driver_server{
                                                                       hos_binder_driver_server_} {
     static const FunctionInfo functions[] = {

src/core/hle/service/vi/vi_s.h

@@ -9,24 +9,24 @@ namespace Core {
 class System;
 }
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 class HosBinderDriverServer;
-class NVFlinger;
-} // namespace Service::NVFlinger
+class Nvnflinger;
+} // namespace Service::Nvnflinger
 
 namespace Service::VI {
 
 class VI_S final : public ServiceFramework<VI_S> {
 public:
-    explicit VI_S(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-                  NVFlinger::HosBinderDriverServer& hos_binder_driver_server_);
+    explicit VI_S(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_);
     ~VI_S() override;
 
 private:
     void GetDisplayService(HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nv_flinger;
-    NVFlinger::HosBinderDriverServer& hos_binder_driver_server;
+    Nvnflinger::Nvnflinger& nv_flinger;
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
 };
 
 } // namespace Service::VI

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

@@ -7,8 +7,8 @@
 
 namespace Service::VI {
 
-VI_U::VI_U(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-           NVFlinger::HosBinderDriverServer& hos_binder_driver_server_)
+VI_U::VI_U(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+           Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_)
     : ServiceFramework{system_, "vi:u"}, nv_flinger{nv_flinger_}, hos_binder_driver_server{
                                                                       hos_binder_driver_server_} {
     static const FunctionInfo functions[] = {

src/core/hle/service/vi/vi_u.h

@@ -9,24 +9,24 @@ namespace Core {
 class System;
 }
 
-namespace Service::NVFlinger {
+namespace Service::Nvnflinger {
 class HosBinderDriverServer;
-class NVFlinger;
-} // namespace Service::NVFlinger
+class Nvnflinger;
+} // namespace Service::Nvnflinger
 
 namespace Service::VI {
 
 class VI_U final : public ServiceFramework<VI_U> {
 public:
-    explicit VI_U(Core::System& system_, NVFlinger::NVFlinger& nv_flinger_,
-                  NVFlinger::HosBinderDriverServer& hos_binder_driver_server_);
+    explicit VI_U(Core::System& system_, Nvnflinger::Nvnflinger& nv_flinger_,
+                  Nvnflinger::HosBinderDriverServer& hos_binder_driver_server_);
     ~VI_U() override;
 
 private:
     void GetDisplayService(HLERequestContext& ctx);
 
-    NVFlinger::NVFlinger& nv_flinger;
-    NVFlinger::HosBinderDriverServer& hos_binder_driver_server;
+    Nvnflinger::Nvnflinger& nv_flinger;
+    Nvnflinger::HosBinderDriverServer& hos_binder_driver_server;
 };
 
 } // namespace Service::VI

src/video_core/framebuffer_config.h

@@ -5,8 +5,8 @@
 
 #include "common/common_types.h"
 #include "common/math_util.h"
-#include "core/hle/service/nvflinger/buffer_transform_flags.h"
-#include "core/hle/service/nvflinger/pixel_format.h"
+#include "core/hle/service/nvnflinger/buffer_transform_flags.h"
+#include "core/hle/service/nvnflinger/pixel_format.h"
 
 namespace Tegra {