Refactoring HOS folder structure (#771)

* Refactoring HOS folder structure

Refactoring HOS folder structure:

- Added some subfolders when needed (Following structure decided in private).
- Added some `Types` folders when needed.
- Little cleanup here and there.
- Add services placeholders for every HOS services (close #766 and #753).

* Remove Types namespaces

7 files changed, 536 insertions, 0 deletions

diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Display.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Display.cs
new file mode 100644
index 00000000..47c7b2ae
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Display.cs
@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.HOS.Services.Vi
+{
+    class Display
+    {
+        public string Name { get; private set; }
+
+        public Display(string name)
+        {
+            Name = name;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/IHOSBinderDriver.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/IHOSBinderDriver.cs
new file mode 100644
index 00000000..3ac1c270
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/IHOSBinderDriver.cs
@@ -0,0 +1,99 @@
+using Ryujinx.Graphics.Gal;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Common;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using Ryujinx.HLE.HOS.Services.Android;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService
+{
+    class IHOSBinderDriver : IpcService, IDisposable
+    {
+        private KEvent _binderEvent;
+
+        private NvFlinger _flinger;
+
+        public IHOSBinderDriver(Horizon system, IGalRenderer renderer)
+        {
+            _binderEvent = new KEvent(system);
+
+            _binderEvent.ReadableEvent.Signal();
+
+            _flinger = new NvFlinger(renderer, _binderEvent);
+        }
+
+        [Command(0)]
+        // TransactParcel(s32, u32, u32, buffer<unknown, 5, 0>) -> buffer<unknown, 6, 0>
+        public ResultCode TransactParcel(ServiceCtx context)
+        {
+            int id   = context.RequestData.ReadInt32();
+            int code = context.RequestData.ReadInt32();
+
+            long dataPos  = context.Request.SendBuff[0].Position;
+            long dataSize = context.Request.SendBuff[0].Size;
+
+            byte[] data = context.Memory.ReadBytes(dataPos, dataSize);
+
+            data = Parcel.GetParcelData(data);
+
+            return (ResultCode)_flinger.ProcessParcelRequest(context, data, code);
+        }
+
+        [Command(1)]
+        // AdjustRefcount(s32, s32, s32)
+        public ResultCode AdjustRefcount(ServiceCtx context)
+        {
+            int id     = context.RequestData.ReadInt32();
+            int addVal = context.RequestData.ReadInt32();
+            int type   = context.RequestData.ReadInt32();
+
+            return ResultCode.Success;
+        }
+
+        [Command(2)]
+        // GetNativeHandle(s32, s32) -> handle<copy>
+        public ResultCode GetNativeHandle(ServiceCtx context)
+        {
+            int  id  = context.RequestData.ReadInt32();
+            uint unk = context.RequestData.ReadUInt32();
+
+            if (context.Process.HandleTable.GenerateHandle(_binderEvent.ReadableEvent, out int handle) != KernelResult.Success)
+            {
+                throw new InvalidOperationException("Out of handles!");
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeMove(handle);
+
+            return ResultCode.Success;
+        }
+
+        [Command(3)] // 3.0.0+
+        // TransactParcelAuto(s32, u32, u32, buffer<unknown, 21, 0>) -> buffer<unknown, 22, 0>
+        public ResultCode TransactParcelAuto(ServiceCtx context)
+        {
+            int id = context.RequestData.ReadInt32();
+            int code = context.RequestData.ReadInt32();
+
+            (long dataPos, long dataSize) = context.Request.GetBufferType0x21();
+
+            byte[] data = context.Memory.ReadBytes(dataPos, dataSize);
+
+            data = Parcel.GetParcelData(data);
+
+            return (ResultCode)_flinger.ProcessParcelRequest(context, data, code);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _flinger.Dispose();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/IManagerDisplayService.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/IManagerDisplayService.cs
new file mode 100644
index 00000000..24e73244
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/IManagerDisplayService.cs
@@ -0,0 +1,61 @@
+using Ryujinx.Common.Logging;
+
+namespace Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService
+{
+    class IManagerDisplayService : IpcService
+    {
+        private static IApplicationDisplayService _applicationDisplayService;
+
+        public IManagerDisplayService(IApplicationDisplayService applicationDisplayService)
+        {
+            _applicationDisplayService = applicationDisplayService;
+        }
+
+        [Command(2010)]
+        // CreateManagedLayer(u32, u64, nn::applet::AppletResourceUserId) -> u64
+        public ResultCode CreateManagedLayer(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            context.ResponseData.Write(0L); //LayerId
+
+            return ResultCode.Success;
+        }
+
+        [Command(2011)]
+        // DestroyManagedLayer(u64)
+        public ResultCode DestroyManagedLayer(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return ResultCode.Success;
+        }
+
+        [Command(2012)] // 7.0.0+
+        // CreateStrayLayer(u32, u64) -> (u64, u64, buffer<bytes, 6>)
+        public ResultCode CreateStrayLayer(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return _applicationDisplayService.CreateStrayLayer(context);
+        }
+
+        [Command(6000)]
+        // AddToLayerStack(u32, u64)
+        public ResultCode AddToLayerStack(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return ResultCode.Success;
+        }
+
+        [Command(6002)]
+        // SetLayerVisibility(b8, u64)
+        public ResultCode SetLayerVisibility(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return ResultCode.Success;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/ISystemDisplayService.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/ISystemDisplayService.cs
new file mode 100644
index 00000000..1e615bd2
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/ISystemDisplayService.cs
@@ -0,0 +1,54 @@
+using Ryujinx.Common.Logging;
+
+namespace Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService
+{
+    class ISystemDisplayService : IpcService
+    {
+        private static IApplicationDisplayService _applicationDisplayService;
+
+        public ISystemDisplayService(IApplicationDisplayService applicationDisplayService)
+        {
+            _applicationDisplayService = applicationDisplayService;
+        }
+
+        [Command(2205)]
+        // SetLayerZ(u64, u64)
+        public ResultCode SetLayerZ(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return ResultCode.Success;
+        }
+
+        [Command(2207)]
+        // SetLayerVisibility(b8, u64)
+        public ResultCode SetLayerVisibility(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return ResultCode.Success;
+        }
+
+        [Command(2312)] // 1.0.0-6.2.0
+        // CreateStrayLayer(u32, u64) -> (u64, u64, buffer<bytes, 6>)
+        public ResultCode CreateStrayLayer(ServiceCtx context)
+        {
+            Logger.PrintStub(LogClass.ServiceVi);
+
+            return _applicationDisplayService.CreateStrayLayer(context);
+        }
+
+        [Command(3200)]
+        // GetDisplayMode(u64) -> nn::vi::DisplayModeInfo
+        public ResultCode GetDisplayMode(ServiceCtx context)
+        {
+            // TODO: De-hardcode resolution.
+            context.ResponseData.Write(1280);
+            context.ResponseData.Write(720);
+            context.ResponseData.Write(60.0f);
+            context.ResponseData.Write(0);
+
+            return ResultCode.Success;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Types/DestinationScalingMode.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Types/DestinationScalingMode.cs
new file mode 100644
index 00000000..cf459cb2
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Types/DestinationScalingMode.cs
@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService
+{
+    enum DestinationScalingMode
+    {
+        Freeze,
+        ScaleToWindow,
+        ScaleAndCrop,
+        None,
+        PreserveAspectRatio
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Types/SourceScalingMode.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Types/SourceScalingMode.cs
new file mode 100644
index 00000000..ac8c3e02
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/ApplicationDisplayService/Types/SourceScalingMode.cs
@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService
+{
+    enum SourceScalingMode
+    {
+        None,
+        Freeze,
+        ScaleToWindow,
+        ScaleAndCrop,
+        PreserveAspectRatio 
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Vi/RootService/IApplicationDisplayService.cs b/Ryujinx.HLE/HOS/Services/Vi/RootService/IApplicationDisplayService.cs
new file mode 100644
index 00000000..fba25054
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Vi/RootService/IApplicationDisplayService.cs
@@ -0,0 +1,288 @@
+using ARMeilleure.Memory;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Common;
+using Ryujinx.HLE.HOS.Services.Vi.RootService.ApplicationDisplayService;
+using System;
+using System.IO;
+using System.Text;
+
+using static Ryujinx.HLE.HOS.Services.Android.Parcel;
+
+namespace Ryujinx.HLE.HOS.Services.Vi.RootService
+{
+    class IApplicationDisplayService : IpcService
+    {
+        private IdDictionary _displays;
+
+        public IApplicationDisplayService()
+        {
+            _displays = new IdDictionary();
+        }
+
+        [Command(100)]
+        // GetRelayService() -> object<nns::hosbinder::IHOSBinderDriver>
+        public ResultCode GetRelayService(ServiceCtx context)
+        {
+            MakeObject(context, new IHOSBinderDriver(
+                context.Device.System,
+                context.Device.Gpu.Renderer));
+
+            return ResultCode.Success;
+        }
+
+        [Command(101)]
+        // GetSystemDisplayService() -> object<nn::visrv::sf::ISystemDisplayService>
+        public ResultCode GetSystemDisplayService(ServiceCtx context)
+        {
+            MakeObject(context, new ISystemDisplayService(this));
+
+            return ResultCode.Success;
+        }
+
+        [Command(102)]
+        // GetManagerDisplayService() -> object<nn::visrv::sf::IManagerDisplayService>
+        public ResultCode GetManagerDisplayService(ServiceCtx context)
+        {
+            MakeObject(context, new IManagerDisplayService(this));
+
+            return ResultCode.Success;
+        }
+
+        [Command(103)] // 2.0.0+
+        // GetIndirectDisplayTransactionService() -> object<nns::hosbinder::IHOSBinderDriver>
+        public ResultCode GetIndirectDisplayTransactionService(ServiceCtx context)
+        {
+            MakeObject(context, new IHOSBinderDriver(
+                context.Device.System,
+                context.Device.Gpu.Renderer));
+
+            return ResultCode.Success;
+        }
+
+        [Command(1000)]
+        // ListDisplays() -> (u64, buffer<nn::vi::DisplayInfo, 6>)
+        public ResultCode ListDisplays(ServiceCtx context)
+        {
+            long recBuffPtr = context.Request.ReceiveBuff[0].Position;
+
+            MemoryHelper.FillWithZeros(context.Memory, recBuffPtr, 0x60);
+
+            // Add only the default display to buffer
+            context.Memory.WriteBytes(recBuffPtr, Encoding.ASCII.GetBytes("Default"));
+            context.Memory.WriteInt64(recBuffPtr + 0x40, 0x1L);
+            context.Memory.WriteInt64(recBuffPtr + 0x48, 0x1L);
+            context.Memory.WriteInt64(recBuffPtr + 0x50, 1920L);
+            context.Memory.WriteInt64(recBuffPtr + 0x58, 1080L);
+
+            context.ResponseData.Write(1L);
+
+            return ResultCode.Success;
+        }
+
+        [Command(1010)]
+        // OpenDisplay(nn::vi::DisplayName) -> u64
+        public ResultCode OpenDisplay(ServiceCtx context)
+        {
+            string name = GetDisplayName(context);
+
+            long displayId = _displays.Add(new Display(name));
+
+            context.ResponseData.Write(displayId);
+
+            return ResultCode.Success;
+        }
+
+        [Command(1020)]
+        // CloseDisplay(u64)
+        public ResultCode CloseDisplay(ServiceCtx context)
+        {
+            int displayId = context.RequestData.ReadInt32();
+
+            _displays.Delete(displayId);
+
+            return ResultCode.Success;
+        }
+
+        [Command(1102)]
+        // GetDisplayResolution(u64) -> (u64, u64)
+        public ResultCode GetDisplayResolution(ServiceCtx context)
+        {
+            long displayId = context.RequestData.ReadInt32();
+
+            context.ResponseData.Write(1280);
+            context.ResponseData.Write(720);
+
+            return ResultCode.Success;
+        }
+
+        [Command(2020)]
+        // OpenLayer(nn::vi::DisplayName, u64, nn::applet::AppletResourceUserId, pid) -> (u64, buffer<bytes, 6>)
+        public ResultCode OpenLayer(ServiceCtx context)
+        {
+            long layerId = context.RequestData.ReadInt64();
+            long userId  = context.RequestData.ReadInt64();
+
+            long parcelPtr = context.Request.ReceiveBuff[0].Position;
+
+            byte[] parcel = MakeIGraphicsBufferProducer(parcelPtr);
+
+            context.Memory.WriteBytes(parcelPtr, parcel);
+
+            context.ResponseData.Write((long)parcel.Length);
+
+            return ResultCode.Success;
+        }
+
+        [Command(2021)]
+        // CloseLayer(u64)
+        public ResultCode CloseLayer(ServiceCtx context)
+        {
+            long layerId = context.RequestData.ReadInt64();
+
+            return ResultCode.Success;
+        }
+
+        [Command(2030)]
+        // CreateStrayLayer(u32, u64) -> (u64, u64, buffer<bytes, 6>)
+        public ResultCode CreateStrayLayer(ServiceCtx context)
+        {
+            long layerFlags = context.RequestData.ReadInt64();
+            long displayId  = context.RequestData.ReadInt64();
+
+            long parcelPtr = context.Request.ReceiveBuff[0].Position;
+
+            Display disp = _displays.GetData<Display>((int)displayId);
+
+            byte[] parcel = MakeIGraphicsBufferProducer(parcelPtr);
+
+            context.Memory.WriteBytes(parcelPtr, parcel);
+
+            context.ResponseData.Write(0L);
+            context.ResponseData.Write((long)parcel.Length);
+
+            return ResultCode.Success;
+        }
+
+        [Command(2031)]
+        // DestroyStrayLayer(u64)
+        public ResultCode DestroyStrayLayer(ServiceCtx context)
+        {
+            return ResultCode.Success;
+        }
+
+        [Command(2101)]
+        // SetLayerScalingMode(u32, u64)
+        public ResultCode SetLayerScalingMode(ServiceCtx context)
+        {
+            int  scalingMode = context.RequestData.ReadInt32();
+            long unknown     = context.RequestData.ReadInt64();
+
+            return ResultCode.Success;
+        }
+
+        [Command(2102)] // 5.0.0+
+        // ConvertScalingMode(unknown) -> unknown
+        public ResultCode ConvertScalingMode(ServiceCtx context)
+        {
+            SourceScalingMode scalingMode = (SourceScalingMode)context.RequestData.ReadInt32();
+
+            DestinationScalingMode? convertedScalingMode = ConvertScalingMode(scalingMode);
+
+            if (!convertedScalingMode.HasValue)
+            {
+                // Scaling mode out of the range of valid values.
+                return ResultCode.InvalidArguments;
+            }
+
+            if (scalingMode != SourceScalingMode.ScaleToWindow &&
+                scalingMode != SourceScalingMode.PreserveAspectRatio)
+            {
+                // Invalid scaling mode specified.
+                return ResultCode.InvalidScalingMode;
+            }
+
+            context.ResponseData.Write((ulong)convertedScalingMode);
+
+            return ResultCode.Success;
+        }
+
+        private DestinationScalingMode? ConvertScalingMode(SourceScalingMode source)
+        {
+            switch (source)
+            {
+                case SourceScalingMode.None:                return DestinationScalingMode.None;
+                case SourceScalingMode.Freeze:              return DestinationScalingMode.Freeze;
+                case SourceScalingMode.ScaleAndCrop:        return DestinationScalingMode.ScaleAndCrop;
+                case SourceScalingMode.ScaleToWindow:       return DestinationScalingMode.ScaleToWindow;
+                case SourceScalingMode.PreserveAspectRatio: return DestinationScalingMode.PreserveAspectRatio;
+            }
+
+            return null;
+        }
+
+        [Command(5202)]
+        // GetDisplayVsyncEvent(u64) -> handle<copy>
+        public ResultCode GetDisplayVSyncEvent(ServiceCtx context)
+        {
+            string name = GetDisplayName(context);
+
+            if (context.Process.HandleTable.GenerateHandle(context.Device.System.VsyncEvent.ReadableEvent, out int handle) != KernelResult.Success)
+            {
+                throw new InvalidOperationException("Out of handles!");
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(handle);
+
+            return ResultCode.Success;
+        }
+
+        private byte[] MakeIGraphicsBufferProducer(long basePtr)
+        {
+            long id        = 0x20;
+            long cookiePtr = 0L;
+
+            using (MemoryStream ms = new MemoryStream())
+            {
+                BinaryWriter writer = new BinaryWriter(ms);
+
+                // flat_binder_object (size is 0x28)
+                writer.Write(2); //Type (BINDER_TYPE_WEAK_BINDER)
+                writer.Write(0); //Flags
+                writer.Write((int)(id >> 0));
+                writer.Write((int)(id >> 32));
+                writer.Write((int)(cookiePtr >> 0));
+                writer.Write((int)(cookiePtr >> 32));
+                writer.Write((byte)'d');
+                writer.Write((byte)'i');
+                writer.Write((byte)'s');
+                writer.Write((byte)'p');
+                writer.Write((byte)'d');
+                writer.Write((byte)'r');
+                writer.Write((byte)'v');
+                writer.Write((byte)'\0');
+                writer.Write(0L); //Pad
+
+                return MakeParcel(ms.ToArray(), new byte[] { 0, 0, 0, 0 });
+            }
+        }
+
+        private string GetDisplayName(ServiceCtx context)
+        {
+            string name = string.Empty;
+
+            for (int index = 0; index < 8 &&
+                context.RequestData.BaseStream.Position <
+                context.RequestData.BaseStream.Length; index++)
+            {
+                byte chr = context.RequestData.ReadByte();
+
+                if (chr >= 0x20 && chr < 0x7f)
+                {
+                    name += (char)chr;
+                }
+            }
+
+            return name;
+        }
+    }
+}
\ No newline at end of file