Somewhat better NvFlinger (I guess) (fixes #30)

3 files changed, 510 insertions, 0 deletions

diff --git a/Ryujinx.Core/OsHle/Objects/Android/GbpBuffer.cs b/Ryujinx.Core/OsHle/Objects/Android/GbpBuffer.cs
new file mode 100644
index 00000000..edd11523
--- /dev/null
+++ b/Ryujinx.Core/OsHle/Objects/Android/GbpBuffer.cs
@@ -0,0 +1,60 @@
+using System.IO;
+
+namespace Ryujinx.Core.OsHle.Objects.Android
+{
+    struct GbpBuffer
+    {
+        public int Magic  { get; private set; }
+        public int Width  { get; private set; }
+        public int Height { get; private set; }
+        public int Stride { get; private set; }
+        public int Format { get; private set; }
+        public int Usage  { get; private set; }
+
+        public int Pid      { get; private set; }
+        public int RefCount { get; private set; }
+
+        public int FdsCount  { get; private set; }
+        public int IntsCount { get; private set; }
+
+        public byte[] RawData { get; private set; }
+
+        public int Size => RawData.Length + 10 * 4;
+
+        public GbpBuffer(BinaryReader Reader)
+        {
+            Magic  = Reader.ReadInt32();
+            Width  = Reader.ReadInt32();
+            Height = Reader.ReadInt32();
+            Stride = Reader.ReadInt32();
+            Format = Reader.ReadInt32();
+            Usage  = Reader.ReadInt32();
+
+            Pid      = Reader.ReadInt32();
+            RefCount = Reader.ReadInt32();
+
+            FdsCount  = Reader.ReadInt32();
+            IntsCount = Reader.ReadInt32();
+
+            RawData = Reader.ReadBytes((FdsCount + IntsCount) * 4);
+        }
+
+        public void Write(BinaryWriter Writer)
+        {
+            Writer.Write(Magic);
+            Writer.Write(Width);
+            Writer.Write(Height);
+            Writer.Write(Stride);
+            Writer.Write(Format);
+            Writer.Write(Usage);
+
+            Writer.Write(Pid);
+            Writer.Write(RefCount);
+
+            Writer.Write(FdsCount);
+            Writer.Write(IntsCount);
+
+            Writer.Write(RawData);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.Core/OsHle/Objects/Android/NvFlinger.cs b/Ryujinx.Core/OsHle/Objects/Android/NvFlinger.cs
new file mode 100644
index 00000000..23863099
--- /dev/null
+++ b/Ryujinx.Core/OsHle/Objects/Android/NvFlinger.cs
@@ -0,0 +1,392 @@
+using ChocolArm64.Memory;
+using Ryujinx.Core.OsHle.Handles;
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+using static Ryujinx.Core.OsHle.Objects.Android.Parcel;
+
+namespace Ryujinx.Core.OsHle.Objects.Android
+{
+    class NvFlinger : IDisposable
+    {
+        private delegate long ServiceProcessParcel(ServiceCtx Context, BinaryReader ParcelReader);
+
+        private Dictionary<(string, int), ServiceProcessParcel> Commands;
+
+        private const int BufferQueueCount = 0x40;
+        private const int BufferQueueMask  = BufferQueueCount - 1;
+
+        [Flags]
+        private enum HalTransform
+        {
+            FlipX     = 1 << 0,
+            FlipY     = 1 << 1,
+            Rotate90  = 1 << 2
+        }
+
+        private enum BufferState
+        {
+            Free,
+            Dequeued,
+            Queued,
+            Acquired
+        }
+
+        private struct BufferEntry
+        {
+            public BufferState State;
+
+            public HalTransform Transform;
+
+            public GbpBuffer Data;
+        }
+
+        private BufferEntry[] BufferQueue;
+
+        private ManualResetEvent WaitBufferFree;
+
+        private bool KeepRunning;
+
+        public NvFlinger()
+        {
+            Commands = new Dictionary<(string, int), ServiceProcessParcel>()
+            {
+                { ("android.gui.IGraphicBufferProducer", 0x1), GbpRequestBuffer  },
+                { ("android.gui.IGraphicBufferProducer", 0x3), GbpDequeueBuffer  },
+                { ("android.gui.IGraphicBufferProducer", 0x7), GbpQueueBuffer    },
+                { ("android.gui.IGraphicBufferProducer", 0x8), GbpCancelBuffer   },
+                { ("android.gui.IGraphicBufferProducer", 0x9), GbpQuery          },
+                { ("android.gui.IGraphicBufferProducer", 0xa), GbpConnect        },
+                { ("android.gui.IGraphicBufferProducer", 0xe), GbpPreallocBuffer }
+            };
+
+            BufferQueue = new BufferEntry[0x40];
+
+            WaitBufferFree = new ManualResetEvent(false);
+
+            KeepRunning = true;
+        }
+
+        public long ProcessParcelRequest(ServiceCtx Context, byte[] ParcelData, int Code)
+        {
+            using (MemoryStream MS = new MemoryStream(ParcelData))
+            {
+                BinaryReader Reader = new BinaryReader(MS);
+
+                MS.Seek(4, SeekOrigin.Current);
+
+                int StrSize = Reader.ReadInt32();
+
+                string InterfaceName = Encoding.Unicode.GetString(Reader.ReadBytes(StrSize * 2));
+
+                long Remainder = MS.Position & 0xf;
+
+                if (Remainder != 0)
+                {
+                    MS.Seek(0x10 - Remainder, SeekOrigin.Current);
+                }
+
+                MS.Seek(0x50, SeekOrigin.Begin);
+
+                if (Commands.TryGetValue((InterfaceName, Code), out ServiceProcessParcel ProcReq))
+                {
+                    Logging.Debug($"{InterfaceName} {ProcReq.Method.Name}");
+
+                    return ProcReq(Context, Reader);
+                }
+                else
+                {
+                    throw new NotImplementedException($"{InterfaceName} {Code}");
+                }
+            }
+        }
+
+        private long GbpRequestBuffer(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            int Slot = ParcelReader.ReadInt32();
+
+            using (MemoryStream MS = new MemoryStream())
+            {
+                BinaryWriter Writer = new BinaryWriter(MS);
+                
+                BufferEntry Entry = BufferQueue[Slot];
+
+                int  BufferCount = 1; //?
+                long BufferSize  = Entry.Data.Size;
+
+                Writer.Write(BufferCount);
+                Writer.Write(BufferSize);
+
+                Entry.Data.Write(Writer);
+
+                Writer.Write(0);
+
+                return MakeReplyParcel(Context, MS.ToArray());
+            }
+        }
+
+        private long GbpDequeueBuffer(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            //TODO: Errors.
+            int Format        = ParcelReader.ReadInt32();
+            int Width         = ParcelReader.ReadInt32();
+            int Height        = ParcelReader.ReadInt32();
+            int GetTimestamps = ParcelReader.ReadInt32();
+            int Usage         = ParcelReader.ReadInt32();
+
+            int Slot = GetFreeSlotBlocking(Width, Height);
+
+            return MakeReplyParcel(Context, Slot, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+        }
+
+        private long GbpQueueBuffer(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            //TODO: Errors.
+            int Slot            = ParcelReader.ReadInt32();
+            int Unknown4        = ParcelReader.ReadInt32();
+            int Unknown8        = ParcelReader.ReadInt32();
+            int Unknownc        = ParcelReader.ReadInt32();
+            int Timestamp       = ParcelReader.ReadInt32();
+            int IsAutoTimestamp = ParcelReader.ReadInt32();
+            int CropTop         = ParcelReader.ReadInt32();
+            int CropLeft        = ParcelReader.ReadInt32();
+            int CropRight       = ParcelReader.ReadInt32();
+            int CropBottom      = ParcelReader.ReadInt32();
+            int ScalingMode     = ParcelReader.ReadInt32();
+            int Transform       = ParcelReader.ReadInt32();
+            int StickyTransform = ParcelReader.ReadInt32();
+            int Unknown34       = ParcelReader.ReadInt32();
+            int Unknown38       = ParcelReader.ReadInt32();
+            int IsFenceValid    = ParcelReader.ReadInt32();
+            int Fence0Id        = ParcelReader.ReadInt32();
+            int Fence0Value     = ParcelReader.ReadInt32();
+            int Fence1Id        = ParcelReader.ReadInt32();
+            int Fence1Value     = ParcelReader.ReadInt32();
+
+            BufferQueue[Slot].Transform = (HalTransform)Transform;
+
+            BufferQueue[Slot].State = BufferState.Queued;
+
+            SendFrameBuffer(Context, Slot);
+
+            return MakeReplyParcel(Context, 1280, 720, 0, 0, 0);
+        }
+
+        private long GbpCancelBuffer(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            //TODO: Errors.
+            int Slot = ParcelReader.ReadInt32();
+
+            BufferQueue[Slot].State = BufferState.Free;
+
+            return MakeReplyParcel(Context, 0);
+        }
+
+        private long GbpQuery(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            return MakeReplyParcel(Context, 0, 0);
+        }
+
+        private long GbpConnect(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            return MakeReplyParcel(Context, 1280, 720, 0, 0, 0);
+        }
+
+        private long GbpPreallocBuffer(ServiceCtx Context, BinaryReader ParcelReader)
+        {
+            int Slot = ParcelReader.ReadInt32();
+            
+            int  BufferCount = ParcelReader.ReadInt32();
+            long BufferSize  = ParcelReader.ReadInt64();
+
+            BufferQueue[Slot].State = BufferState.Free;
+
+            BufferQueue[Slot].Data = new GbpBuffer(ParcelReader);
+
+            return MakeReplyParcel(Context, 0);
+        }
+
+        private long MakeReplyParcel(ServiceCtx Context, params int[] Ints)
+        {
+            using (MemoryStream MS = new MemoryStream())
+            {
+                BinaryWriter Writer = new BinaryWriter(MS);
+
+                foreach (int Int in Ints)
+                {
+                    Writer.Write(Int);
+                }
+
+                return MakeReplyParcel(Context, MS.ToArray());
+            }
+        }
+
+        private long MakeReplyParcel(ServiceCtx Context, byte[] Data)
+        {
+            long ReplyPos  = Context.Request.ReceiveBuff[0].Position;
+            long ReplySize = Context.Request.ReceiveBuff[0].Size;
+
+            byte[] Reply = MakeParcel(Data, new byte[0]);
+
+            AMemoryHelper.WriteBytes(Context.Memory, ReplyPos, Reply);
+
+            return 0;
+        }
+
+        private unsafe void SendFrameBuffer(ServiceCtx Context, int Slot)
+        {
+            int FbWidth  = BufferQueue[Slot].Data.Width;
+            int FbHeight = BufferQueue[Slot].Data.Height;
+
+            int FbSize = FbWidth * FbHeight * 4;
+
+            HNvMap NvMap = GetNvMap(Context, Slot);
+
+            if (NvMap.Address < 0 || NvMap.Address + FbSize > AMemoryMgr.AddrSize)
+            {
+                Logging.Error($"Frame buffer address {NvMap.Address:x16} is invalid!");
+
+                BufferQueue[Slot].State = BufferState.Free;
+
+                WaitBufferFree.Set();
+
+                return;
+            }
+
+            BufferQueue[Slot].State = BufferState.Acquired; 
+
+            float ScaleX = 1;
+            float ScaleY = 1;
+            float Rotate = 0;
+
+            if (BufferQueue[Slot].Transform.HasFlag(HalTransform.FlipX))
+            {
+                ScaleX = -1;
+            }
+
+            if (BufferQueue[Slot].Transform.HasFlag(HalTransform.FlipY))
+            {
+                ScaleY = -1;
+            }
+
+            if (BufferQueue[Slot].Transform.HasFlag(HalTransform.Rotate90))
+            {
+                Rotate = MathF.PI * 0.5f;
+            }
+
+            byte* Fb = (byte*)Context.Ns.Ram + NvMap.Address;
+
+            Context.Ns.Gpu.Renderer.QueueAction(delegate()
+            {
+                Context.Ns.Gpu.Renderer.SetFrameBuffer(
+                    Fb,
+                    FbWidth,
+                    FbHeight,
+                    ScaleX,
+                    ScaleY,
+                    Rotate);
+
+                BufferQueue[Slot].State = BufferState.Free;
+
+                WaitBufferFree.Set();
+            });
+        }
+
+        private HNvMap GetNvMap(ServiceCtx Context, int Slot)
+        {
+            int NvMapHandle = BitConverter.ToInt32(BufferQueue[Slot].Data.RawData, 0x4c);
+
+            if (!BitConverter.IsLittleEndian)
+            {
+                byte[] RawValue = BitConverter.GetBytes(NvMapHandle);
+
+                Array.Reverse(RawValue);
+
+                NvMapHandle = BitConverter.ToInt32(RawValue, 0);
+            }
+
+            return Context.Ns.Os.Handles.GetData<HNvMap>(NvMapHandle);
+        }
+
+        private int GetFreeSlotBlocking(int Width, int Height)
+        {
+            int Slot;
+
+            do
+            {
+                if ((Slot = GetFreeSlot(Width, Height)) != -1)
+                {
+                    break;
+                }
+
+                Logging.Debug("Waiting for a free BufferQueue slot...");
+
+                lock (WaitBufferFree)
+                {
+                    if (!KeepRunning)
+                    {
+                        break;
+                    }
+
+                    WaitBufferFree.Reset();
+                }
+
+                WaitBufferFree.WaitOne();
+            }
+            while (KeepRunning);
+
+            Logging.Debug($"Found free BufferQueue slot {Slot}!");
+
+            return Slot;
+        }
+
+        private int GetFreeSlot(int Width, int Height)
+        {
+            lock (BufferQueue)
+            {
+                for (int Slot = 0; Slot < BufferQueue.Length; Slot++)
+                {
+                    if (BufferQueue[Slot].State != BufferState.Free)
+                    {
+                        continue;
+                    }
+
+                    GbpBuffer Data = BufferQueue[Slot].Data;
+
+                    if (Data.Width  == Width &&
+                        Data.Height == Height)
+                    {
+                        BufferQueue[Slot].State = BufferState.Dequeued;
+
+                        return Slot;
+                    }
+                }
+            }
+
+            return -1;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                lock (WaitBufferFree)
+                {
+                    KeepRunning = false;
+
+                    WaitBufferFree.Set();
+                }
+
+                WaitBufferFree.Dispose();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Ryujinx.Core/OsHle/Objects/Android/Parcel.cs b/Ryujinx.Core/OsHle/Objects/Android/Parcel.cs
new file mode 100644
index 00000000..cd7179e1
--- /dev/null
+++ b/Ryujinx.Core/OsHle/Objects/Android/Parcel.cs
@@ -0,0 +1,58 @@
+using System;
+using System.IO;
+
+namespace Ryujinx.Core.OsHle.Objects.Android
+{
+    static class Parcel
+    {
+        public static byte[] GetParcelData(byte[] Parcel)
+        {
+            if (Parcel == null)
+            {
+                throw new ArgumentNullException(nameof(Parcel));
+            }
+
+            using (MemoryStream MS = new MemoryStream(Parcel))
+            {
+                BinaryReader Reader = new BinaryReader(MS);
+
+                int DataSize   = Reader.ReadInt32();
+                int DataOffset = Reader.ReadInt32();
+                int ObjsSize   = Reader.ReadInt32();
+                int ObjsOffset = Reader.ReadInt32();
+
+                MS.Seek(DataOffset - 0x10, SeekOrigin.Current);
+
+                return Reader.ReadBytes(DataSize);
+            }
+        }
+
+        public static byte[] MakeParcel(byte[] Data, byte[] Objs)
+        {
+            if (Data == null)
+            {
+                throw new ArgumentNullException(nameof(Data));
+            }
+
+            if (Objs == null)
+            {
+                throw new ArgumentNullException(nameof(Objs));
+            }
+
+            using (MemoryStream MS = new MemoryStream())
+            {
+                BinaryWriter Writer = new BinaryWriter(MS);
+
+                Writer.Write(Data.Length);
+                Writer.Write(0x10);
+                Writer.Write(Objs.Length);
+                Writer.Write(Data.Length + 0x10);
+
+                Writer.Write(Data);
+                Writer.Write(Objs);
+
+                return MS.ToArray();
+            }
+        }
+    }
+}
\ No newline at end of file