diff options
Diffstat (limited to 'Ryujinx.Graphics.Vic')
25 files changed, 1536 insertions, 0 deletions
diff --git a/Ryujinx.Graphics.Vic/Blender.cs b/Ryujinx.Graphics.Vic/Blender.cs new file mode 100644 index 00000000..f00b9093 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Blender.cs @@ -0,0 +1,157 @@ +using Ryujinx.Graphics.Vic.Image; +using Ryujinx.Graphics.Vic.Types; +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; + +namespace Ryujinx.Graphics.Vic +{ + static class Blender + { + public static void BlendOne(Surface dst, Surface src, ref SlotStruct slot) + { + if (Sse41.IsSupported && (dst.Width & 3) == 0) + { + BlendOneSse41(dst, src, ref slot); + return; + } + + for (int y = 0; y < dst.Height; y++) + { + for (int x = 0; x < dst.Width; x++) + { + int inR = src.GetR(x, y); + int inG = src.GetG(x, y); + int inB = src.GetB(x, y); + + MatrixMultiply(ref slot.ColorMatrixStruct, inR, inG, inB, out int r, out int g, out int b); + + r = Math.Clamp(r, slot.SlotConfig.SoftClampLow, slot.SlotConfig.SoftClampHigh); + g = Math.Clamp(g, slot.SlotConfig.SoftClampLow, slot.SlotConfig.SoftClampHigh); + b = Math.Clamp(b, slot.SlotConfig.SoftClampLow, slot.SlotConfig.SoftClampHigh); + + dst.SetR(x, y, (ushort)r); + dst.SetG(x, y, (ushort)g); + dst.SetB(x, y, (ushort)b); + dst.SetA(x, y, src.GetA(x, y)); + } + } + } + + private unsafe static void BlendOneSse41(Surface dst, Surface src, ref SlotStruct slot) + { + Debug.Assert((dst.Width & 3) == 0); + + ref MatrixStruct mtx = ref slot.ColorMatrixStruct; + + int one = 1 << (mtx.MatrixRShift + 8); + + Vector128<int> col1 = Vector128.Create(mtx.MatrixCoeff00, mtx.MatrixCoeff10, mtx.MatrixCoeff20, 0); + Vector128<int> col2 = Vector128.Create(mtx.MatrixCoeff01, mtx.MatrixCoeff11, mtx.MatrixCoeff21, 0); + Vector128<int> col3 = Vector128.Create(mtx.MatrixCoeff02, mtx.MatrixCoeff12, mtx.MatrixCoeff22, one); + Vector128<int> col4 = Vector128.Create(mtx.MatrixCoeff03, mtx.MatrixCoeff13, mtx.MatrixCoeff23, 0); + Vector128<int> rShift = Vector128.CreateScalar(mtx.MatrixRShift); + Vector128<ushort> clMin = Vector128.Create((ushort)slot.SlotConfig.SoftClampLow); + Vector128<ushort> clMax = Vector128.Create((ushort)slot.SlotConfig.SoftClampHigh); + + fixed (Pixel* srcPtr = src.Data, dstPtr = dst.Data) + { + Pixel* ip = srcPtr; + Pixel* op = dstPtr; + + for (int y = 0; y < dst.Height; y++, ip += src.Width, op += dst.Width) + { + for (int x = 0; x < dst.Width; x += 4) + { + Vector128<int> pixel1 = Sse41.ConvertToVector128Int32((ushort*)(ip + (uint)x)); + Vector128<int> pixel2 = Sse41.ConvertToVector128Int32((ushort*)(ip + (uint)x + 1)); + Vector128<int> pixel3 = Sse41.ConvertToVector128Int32((ushort*)(ip + (uint)x + 2)); + Vector128<int> pixel4 = Sse41.ConvertToVector128Int32((ushort*)(ip + (uint)x + 3)); + + Vector128<ushort> pixel12, pixel34; + + if (mtx.MatrixEnable) + { + pixel12 = Sse41.PackUnsignedSaturate( + MatrixMultiplySse41(pixel1, col1, col2, col3, col4, rShift), + MatrixMultiplySse41(pixel2, col1, col2, col3, col4, rShift)); + pixel34 = Sse41.PackUnsignedSaturate( + MatrixMultiplySse41(pixel3, col1, col2, col3, col4, rShift), + MatrixMultiplySse41(pixel4, col1, col2, col3, col4, rShift)); + } + else + { + pixel12 = Sse41.PackUnsignedSaturate(pixel1, pixel2); + pixel34 = Sse41.PackUnsignedSaturate(pixel3, pixel4); + } + + pixel12 = Sse41.Min(pixel12, clMax); + pixel34 = Sse41.Min(pixel34, clMax); + pixel12 = Sse41.Max(pixel12, clMin); + pixel34 = Sse41.Max(pixel34, clMin); + + Sse2.Store((ushort*)(op + (uint)x + 0), pixel12); + Sse2.Store((ushort*)(op + (uint)x + 2), pixel34); + } + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void MatrixMultiply(ref MatrixStruct mtx, int x, int y, int z, out int r, out int g, out int b) + { + if (mtx.MatrixEnable) + { + r = x * mtx.MatrixCoeff00 + y * mtx.MatrixCoeff01 + z * mtx.MatrixCoeff02; + g = x * mtx.MatrixCoeff10 + y * mtx.MatrixCoeff11 + z * mtx.MatrixCoeff12; + b = x * mtx.MatrixCoeff20 + y * mtx.MatrixCoeff21 + z * mtx.MatrixCoeff22; + + r >>= mtx.MatrixRShift; + g >>= mtx.MatrixRShift; + b >>= mtx.MatrixRShift; + + r += mtx.MatrixCoeff03; + g += mtx.MatrixCoeff13; + b += mtx.MatrixCoeff23; + + r >>= 8; + g >>= 8; + b >>= 8; + } + else + { + r = x; + g = y; + b = z; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector128<int> MatrixMultiplySse41( + Vector128<int> pixel, + Vector128<int> col1, + Vector128<int> col2, + Vector128<int> col3, + Vector128<int> col4, + Vector128<int> rShift) + { + Vector128<int> x = Sse2.Shuffle(pixel, 0); + Vector128<int> y = Sse2.Shuffle(pixel, 0x55); + Vector128<int> z = Sse2.Shuffle(pixel, 0xea); + + col1 = Sse41.MultiplyLow(col1, x); + col2 = Sse41.MultiplyLow(col2, y); + col3 = Sse41.MultiplyLow(col3, z); + + Vector128<int> res = Sse2.Add(col3, Sse2.Add(col1, col2)); + + res = Sse2.ShiftRightArithmetic(res, rShift); + res = Sse2.Add(res, col4); + res = Sse2.ShiftRightArithmetic(res, 8); + + return res; + } + } +} diff --git a/Ryujinx.Graphics.Vic/Image/BufferPool.cs b/Ryujinx.Graphics.Vic/Image/BufferPool.cs new file mode 100644 index 00000000..932d3dc9 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/BufferPool.cs @@ -0,0 +1,103 @@ +using System; + +namespace Ryujinx.Graphics.Vic.Image +{ + class BufferPool<T> + { + /// <summary> + /// Maximum number of buffers on the pool. + /// </summary> + private const int MaxBuffers = 4; + + /// <summary> + /// Maximum size of a buffer that can be added on the pool. + /// If the required buffer is larger than this, it won't be + /// added to the pool to avoid long term high memory usage. + /// </summary> + private const int MaxBufferSize = 2048 * 1280; + + private struct PoolItem + { + public bool InUse; + public T[] Buffer; + } + + private readonly PoolItem[] _pool = new PoolItem[MaxBuffers]; + + /// <summary> + /// Rents a buffer with the exact size requested. + /// </summary> + /// <param name="length">Size of the buffer</param> + /// <param name="buffer">Span of the requested size</param> + /// <returns>The index of the buffer on the pool</returns> + public int Rent(int length, out Span<T> buffer) + { + int index = RentMinimum(length, out T[] bufferArray); + + buffer = new Span<T>(bufferArray).Slice(0, length); + + return index; + } + + /// <summary> + /// Rents a buffer with a size greater than or equal to the requested size. + /// </summary> + /// <param name="length">Size of the buffer</param> + /// <param name="buffer">Array with a length greater than or equal to the requested length</param> + /// <returns>The index of the buffer on the pool</returns> + public int RentMinimum(int length, out T[] buffer) + { + if ((uint)length > MaxBufferSize) + { + buffer = new T[length]; + return -1; + } + + // Try to find a buffer that is larger or the same size of the requested one. + // This will avoid an allocation. + for (int i = 0; i < MaxBuffers; i++) + { + ref PoolItem item = ref _pool[i]; + + if (!item.InUse && item.Buffer != null && item.Buffer.Length >= length) + { + buffer = item.Buffer; + item.InUse = true; + return i; + } + } + + buffer = new T[length]; + + // Try to add the new buffer to the pool. + // We try to find a slot that is not in use, and replace the buffer in it. + for (int i = 0; i < MaxBuffers; i++) + { + ref PoolItem item = ref _pool[i]; + + if (!item.InUse) + { + item.Buffer = buffer; + item.InUse = true; + return i; + } + } + + return -1; + } + + /// <summary> + /// Returns a buffer returned from <see cref="Rent(int)"/> to the pool. + /// </summary> + /// <param name="index">Index of the buffer on the pool</param> + public void Return(int index) + { + if (index < 0) + { + return; + } + + _pool[index].InUse = false; + } + } +} diff --git a/Ryujinx.Graphics.Vic/Image/InputSurface.cs b/Ryujinx.Graphics.Vic/Image/InputSurface.cs new file mode 100644 index 00000000..de003194 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/InputSurface.cs @@ -0,0 +1,17 @@ +using System; + +namespace Ryujinx.Graphics.Vic.Image +{ + ref struct InputSurface + { + public ReadOnlySpan<byte> Buffer0; + public ReadOnlySpan<byte> Buffer1; + public ReadOnlySpan<byte> Buffer2; + + public int Width; + public int Height; + + public int UvWidth; + public int UvHeight; + } +} diff --git a/Ryujinx.Graphics.Vic/Image/Pixel.cs b/Ryujinx.Graphics.Vic/Image/Pixel.cs new file mode 100644 index 00000000..35f25d16 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/Pixel.cs @@ -0,0 +1,10 @@ +namespace Ryujinx.Graphics.Vic.Image +{ + struct Pixel + { + public ushort R; + public ushort G; + public ushort B; + public ushort A; + } +} diff --git a/Ryujinx.Graphics.Vic/Image/Surface.cs b/Ryujinx.Graphics.Vic/Image/Surface.cs new file mode 100644 index 00000000..03767f8a --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/Surface.cs @@ -0,0 +1,46 @@ +using System; +using System.Runtime.CompilerServices; + +namespace Ryujinx.Graphics.Vic.Image +{ + struct Surface : IDisposable + { + private readonly int _bufferIndex; + + private readonly BufferPool<Pixel> _pool; + + public Pixel[] Data { get; } + + public int Width { get; } + public int Height { get; } + + public Surface(BufferPool<Pixel> pool, int width, int height) + { + _bufferIndex = pool.RentMinimum(width * height, out Pixel[] data); + _pool = pool; + Data = data; + Width = width; + Height = height; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ushort GetR(int x, int y) => Data[y * Width + x].R; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ushort GetG(int x, int y) => Data[y * Width + x].G; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ushort GetB(int x, int y) => Data[y * Width + x].B; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ushort GetA(int x, int y) => Data[y * Width + x].A; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SetR(int x, int y, ushort value) => Data[y * Width + x].R = value; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SetG(int x, int y, ushort value) => Data[y * Width + x].G = value; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SetB(int x, int y, ushort value) => Data[y * Width + x].B = value; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void SetA(int x, int y, ushort value) => Data[y * Width + x].A = value; + + public void Dispose() => _pool.Return(_bufferIndex); + } +} diff --git a/Ryujinx.Graphics.Vic/Image/SurfaceCommon.cs b/Ryujinx.Graphics.Vic/Image/SurfaceCommon.cs new file mode 100644 index 00000000..10cdefe2 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/SurfaceCommon.cs @@ -0,0 +1,33 @@ +using Ryujinx.Common; +using Ryujinx.Graphics.Texture; + +namespace Ryujinx.Graphics.Vic.Image +{ + static class SurfaceCommon + { + public static int GetPitch(int width, int bytesPerPixel) + { + return BitUtils.AlignUp(width * bytesPerPixel, 256); + } + + public static int GetBlockLinearSize(int width, int height, int bytesPerPixel, int gobBlocksInY) + { + return SizeCalculator.GetBlockLinearTextureSize(width, height, 1, 1, 1, 1, 1, bytesPerPixel, gobBlocksInY, 1, 1).TotalSize; + } + + public static ulong ExtendOffset(uint offset) + { + return (ulong)offset << 8; + } + + public static ushort Upsample(byte value) + { + return (ushort)(value << 2); + } + + public static byte Downsample(ushort value) + { + return (byte)(value >> 2); + } + } +} diff --git a/Ryujinx.Graphics.Vic/Image/SurfaceReader.cs b/Ryujinx.Graphics.Vic/Image/SurfaceReader.cs new file mode 100644 index 00000000..ab591cd0 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/SurfaceReader.cs @@ -0,0 +1,253 @@ +using Ryujinx.Common.Logging; +using Ryujinx.Graphics.Gpu.Memory; +using Ryujinx.Graphics.Texture; +using Ryujinx.Graphics.Vic.Types; +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; +using static Ryujinx.Graphics.Vic.Image.SurfaceCommon; + +namespace Ryujinx.Graphics.Vic.Image +{ + static class SurfaceReader + { + public static Surface Read(ResourceManager rm, ref SlotSurfaceConfig config, ref PlaneOffsets offsets) + { + switch (config.SlotPixelFormat) + { + case PixelFormat.Y8___V8U8_N420: return ReadNv12(rm, ref config, ref offsets); + } + + Logger.PrintError(LogClass.Vic, $"Unsupported pixel format \"{config.SlotPixelFormat}\"."); + + int lw = config.SlotLumaWidth + 1; + int lh = config.SlotLumaHeight + 1; + + return new Surface(rm.SurfacePool, lw, lh); + } + + private unsafe static Surface ReadNv12(ResourceManager rm, ref SlotSurfaceConfig config, ref PlaneOffsets offsets) + { + InputSurface input = ReadSurface(rm.Gmm, ref config, ref offsets, 1, 2); + + int width = input.Width; + int height = input.Height; + + int yStride = GetPitch(width, 1); + int uvStride = GetPitch(input.UvWidth, 2); + + Surface output = new Surface(rm.SurfacePool, width, height); + + if (Sse41.IsSupported) + { + Vector128<byte> shufMask = Vector128.Create( + (byte)0, (byte)2, (byte)3, (byte)1, + (byte)4, (byte)6, (byte)7, (byte)5, + (byte)8, (byte)10, (byte)11, (byte)9, + (byte)12, (byte)14, (byte)15, (byte)13); + Vector128<short> alphaMask = Vector128.Create(0xffUL << 48).AsInt16(); + + int yStrideGap = yStride - width; + int uvStrideGap = uvStride - input.UvWidth; + + int widthTrunc = width & ~0xf; + + fixed (Pixel* dstPtr = output.Data) + { + Pixel* op = dstPtr; + + fixed (byte* src0Ptr = input.Buffer0, src1Ptr = input.Buffer1) + { + byte* i0p = src0Ptr; + + for (int y = 0; y < height; y++) + { + byte* i1p = src1Ptr + (y >> 1) * uvStride; + + int x = 0; + + for (; x < widthTrunc; x += 16, i0p += 16, i1p += 16) + { + Vector128<short> ya0 = Sse41.ConvertToVector128Int16(i0p); + Vector128<short> ya1 = Sse41.ConvertToVector128Int16(i0p + 8); + + Vector128<byte> uv = Sse2.LoadVector128(i1p); + + Vector128<short> uv0 = Sse2.UnpackLow(uv.AsInt16(), uv.AsInt16()); + Vector128<short> uv1 = Sse2.UnpackHigh(uv.AsInt16(), uv.AsInt16()); + + Vector128<short> rgba0 = Sse2.UnpackLow(ya0, uv0); + Vector128<short> rgba1 = Sse2.UnpackHigh(ya0, uv0); + Vector128<short> rgba2 = Sse2.UnpackLow(ya1, uv1); + Vector128<short> rgba3 = Sse2.UnpackHigh(ya1, uv1); + + rgba0 = Ssse3.Shuffle(rgba0.AsByte(), shufMask).AsInt16(); + rgba1 = Ssse3.Shuffle(rgba1.AsByte(), shufMask).AsInt16(); + rgba2 = Ssse3.Shuffle(rgba2.AsByte(), shufMask).AsInt16(); + rgba3 = Ssse3.Shuffle(rgba3.AsByte(), shufMask).AsInt16(); + + Vector128<short> rgba16_0 = Sse41.ConvertToVector128Int16(rgba0.AsByte()); + Vector128<short> rgba16_1 = Sse41.ConvertToVector128Int16(HighToLow(rgba0.AsByte())); + Vector128<short> rgba16_2 = Sse41.ConvertToVector128Int16(rgba1.AsByte()); + Vector128<short> rgba16_3 = Sse41.ConvertToVector128Int16(HighToLow(rgba1.AsByte())); + Vector128<short> rgba16_4 = Sse41.ConvertToVector128Int16(rgba2.AsByte()); + Vector128<short> rgba16_5 = Sse41.ConvertToVector128Int16(HighToLow(rgba2.AsByte())); + Vector128<short> rgba16_6 = Sse41.ConvertToVector128Int16(rgba3.AsByte()); + Vector128<short> rgba16_7 = Sse41.ConvertToVector128Int16(HighToLow(rgba3.AsByte())); + + rgba16_0 = Sse2.Or(rgba16_0, alphaMask); + rgba16_1 = Sse2.Or(rgba16_1, alphaMask); + rgba16_2 = Sse2.Or(rgba16_2, alphaMask); + rgba16_3 = Sse2.Or(rgba16_3, alphaMask); + rgba16_4 = Sse2.Or(rgba16_4, alphaMask); + rgba16_5 = Sse2.Or(rgba16_5, alphaMask); + rgba16_6 = Sse2.Or(rgba16_6, alphaMask); + rgba16_7 = Sse2.Or(rgba16_7, alphaMask); + + rgba16_0 = Sse2.ShiftLeftLogical(rgba16_0, 2); + rgba16_1 = Sse2.ShiftLeftLogical(rgba16_1, 2); + rgba16_2 = Sse2.ShiftLeftLogical(rgba16_2, 2); + rgba16_3 = Sse2.ShiftLeftLogical(rgba16_3, 2); + rgba16_4 = Sse2.ShiftLeftLogical(rgba16_4, 2); + rgba16_5 = Sse2.ShiftLeftLogical(rgba16_5, 2); + rgba16_6 = Sse2.ShiftLeftLogical(rgba16_6, 2); + rgba16_7 = Sse2.ShiftLeftLogical(rgba16_7, 2); + + Sse2.Store((short*)(op + (uint)x + 0), rgba16_0); + Sse2.Store((short*)(op + (uint)x + 2), rgba16_1); + Sse2.Store((short*)(op + (uint)x + 4), rgba16_2); + Sse2.Store((short*)(op + (uint)x + 6), rgba16_3); + Sse2.Store((short*)(op + (uint)x + 8), rgba16_4); + Sse2.Store((short*)(op + (uint)x + 10), rgba16_5); + Sse2.Store((short*)(op + (uint)x + 12), rgba16_6); + Sse2.Store((short*)(op + (uint)x + 14), rgba16_7); + } + + for (; x < width; x++, i1p += (x & 1) * 2) + { + Pixel* px = op + (uint)x; + + px->R = Upsample(*i0p++); + px->G = Upsample(*i1p); + px->B = Upsample(*(i1p + 1)); + px->A = 0x3ff; + } + + op += width; + i0p += yStrideGap; + i1p += uvStrideGap; + } + } + } + } + else + { + for (int y = 0; y < height; y++) + { + int uvBase = (y >> 1) * uvStride; + + for (int x = 0; x < width; x++) + { + output.SetR(x, y, Upsample(input.Buffer0[y * yStride + x])); + + int uvOffs = uvBase + (x & ~1); + + output.SetG(x, y, Upsample(input.Buffer1[uvOffs])); + output.SetB(x, y, Upsample(input.Buffer1[uvOffs + 1])); + output.SetA(x, y, 0x3ff); + } + } + } + + return output; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector128<byte> HighToLow(Vector128<byte> value) + { + return Sse.MoveHighToLow(value.AsSingle(), value.AsSingle()).AsByte(); + } + + private static InputSurface ReadSurface( + MemoryManager gmm, + ref SlotSurfaceConfig config, + ref PlaneOffsets offsets, + int bytesPerPixel, + int planes) + { + InputSurface surface = new InputSurface(); + + int gobBlocksInY = 1 << config.SlotBlkHeight; + + bool linear = config.SlotBlkKind == 0; + + int lw = config.SlotLumaWidth + 1; + int lh = config.SlotLumaHeight + 1; + + int cw = config.SlotChromaWidth + 1; + int ch = config.SlotChromaHeight + 1; + + surface.Width = lw; + surface.Height = lh; + surface.UvWidth = cw; + surface.UvHeight = ch; + + if (planes > 0) + { + surface.Buffer0 = ReadBuffer(gmm, offsets.LumaOffset, linear, lw, lh, bytesPerPixel, gobBlocksInY); + } + + if (planes > 1) + { + surface.Buffer1 = ReadBuffer(gmm, offsets.ChromaUOffset, linear, cw, ch, planes == 2 ? 2 : 1, gobBlocksInY); + } + + if (planes > 2) + { + surface.Buffer2 = ReadBuffer(gmm, offsets.ChromaVOffset, linear, cw, ch, 1, gobBlocksInY); + } + + return surface; + } + + private static ReadOnlySpan<byte> ReadBuffer( + MemoryManager gmm, + uint offset, + bool linear, + int width, + int height, + int bytesPerPixel, + int gobBlocksInY) + { + int stride = GetPitch(width, bytesPerPixel); + + if (linear) + { + return gmm.GetSpan(ExtendOffset(offset), stride * height); + } + + return ReadBuffer(gmm, offset, width, height, stride, bytesPerPixel, gobBlocksInY); + } + + private static ReadOnlySpan<byte> ReadBuffer( + MemoryManager gmm, + uint offset, + int width, + int height, + int dstStride, + int bytesPerPixel, + int gobBlocksInY) + { + int inSize = GetBlockLinearSize(width, height, bytesPerPixel, gobBlocksInY); + + ReadOnlySpan<byte> src = gmm.GetSpan(ExtendOffset(offset), inSize); + + Span<byte> dst = new byte[dstStride * height]; + + LayoutConverter.ConvertBlockLinearToLinear(dst, width, height, dstStride, bytesPerPixel, gobBlocksInY, src); + + return dst; + } + } +} diff --git a/Ryujinx.Graphics.Vic/Image/SurfaceWriter.cs b/Ryujinx.Graphics.Vic/Image/SurfaceWriter.cs new file mode 100644 index 00000000..cab1ec80 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Image/SurfaceWriter.cs @@ -0,0 +1,361 @@ +using Ryujinx.Common.Logging; +using Ryujinx.Graphics.Texture; +using Ryujinx.Graphics.Vic.Types; +using System; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.X86; +using static Ryujinx.Graphics.Vic.Image.SurfaceCommon; + +namespace Ryujinx.Graphics.Vic.Image +{ + class SurfaceWriter + { + public static void Write(ResourceManager rm, Surface input, ref OutputSurfaceConfig config, ref PlaneOffsets offsets) + { + switch (config.OutPixelFormat) + { + case PixelFormat.A8B8G8R8: + WriteA8B8G8R8(rm, input, ref config, ref offsets); + break; + case PixelFormat.Y8___V8U8_N420: + WriteNv12(rm, input, ref config, ref offsets); + break; + default: + Logger.PrintError(LogClass.Vic, $"Unsupported pixel format \"{config.OutPixelFormat}\"."); + break; + } + } + + private unsafe static void WriteA8B8G8R8(ResourceManager rm, Surface input, ref OutputSurfaceConfig config, ref PlaneOffsets offsets) + { + int width = input.Width; + int height = input.Height; + int stride = GetPitch(width, 4); + + int dstIndex = rm.BufferPool.Rent(height * stride, out Span<byte> dst); + + if (Sse2.IsSupported) + { + int widthTrunc = width & ~7; + int strideGap = stride - width * 4; + + fixed (Pixel* srcPtr = input.Data) + { + Pixel* ip = srcPtr; + + fixed (byte* dstPtr = dst) + { + byte* op = dstPtr; + + for (int y = 0; y < height; y++, ip += input.Width) + { + int x = 0; + + for (; x < widthTrunc; x += 8) + { + Vector128<ushort> pixel12 = Sse2.LoadVector128((ushort*)(ip + (uint)x)); + Vector128<ushort> pixel34 = Sse2.LoadVector128((ushort*)(ip + (uint)x + 2)); + Vector128<ushort> pixel56 = Sse2.LoadVector128((ushort*)(ip + (uint)x + 4)); + Vector128<ushort> pixel78 = Sse2.LoadVector128((ushort*)(ip + (uint)x + 6)); + + pixel12 = Sse2.ShiftRightLogical(pixel12, 2); + pixel34 = Sse2.ShiftRightLogical(pixel34, 2); + pixel56 = Sse2.ShiftRightLogical(pixel56, 2); + pixel78 = Sse2.ShiftRightLogical(pixel78, 2); + + Vector128<byte> pixel1234 = Sse2.PackUnsignedSaturate(pixel12.AsInt16(), pixel34.AsInt16()); + Vector128<byte> pixel5678 = Sse2.PackUnsignedSaturate(pixel56.AsInt16(), pixel78.AsInt16()); + + Sse2.Store(op + 0x00, pixel1234); + Sse2.Store(op + 0x10, pixel5678); + + op += 0x20; + } + + for (; x < width; x++) + { + Pixel* px = ip + (uint)x; + + *(op + 0) = Downsample(px->R); + *(op + 1) = Downsample(px->G); + *(op + 2) = Downsample(px->B); + *(op + 3) = Downsample(px->A); + + op += 4; + } + + op += strideGap; + } + } + } + } + else + { + for (int y = 0; y < height; y++) + { + int baseOffs = y * stride; + + for (int x = 0; x < width; x++) + { + int offs = baseOffs + x * 4; + + dst[offs + 0] = Downsample(input.GetR(x, y)); + dst[offs + 1] = Downsample(input.GetG(x, y)); + dst[offs + 2] = Downsample(input.GetB(x, y)); + dst[offs + 3] = Downsample(input.GetA(x, y)); + } + } + } + + bool outLinear = config.OutBlkKind == 0; + + int gobBlocksInY = 1 << config.OutBlkHeight; + + WriteBuffer(rm, dst, offsets.LumaOffset, outLinear, width, height, 4, gobBlocksInY); + + rm.BufferPool.Return(dstIndex); + } + + private unsafe static void WriteNv12(ResourceManager rm, Surface input, ref OutputSurfaceConfig config, ref PlaneOffsets offsets) + { + int gobBlocksInY = 1 << config.OutBlkHeight; + + bool outLinear = config.OutBlkKind == 0; + + int width = Math.Min(config.OutLumaWidth + 1, input.Width); + int height = Math.Min(config.OutLumaHeight + 1, input.Height); + int yStride = GetPitch(config.OutLumaWidth + 1, 1); + + int dstYIndex = rm.BufferPool.Rent((config.OutLumaHeight + 1) * yStride, out Span<byte> dstY); + + if (Sse41.IsSupported) + { + Vector128<ushort> mask = Vector128.Create(0xffffUL).AsUInt16(); + + int widthTrunc = width & ~0xf; + int strideGap = yStride - width; + + fixed (Pixel* srcPtr = input.Data) + { + Pixel* ip = srcPtr; + + fixed (byte* dstPtr = dstY) + { + byte* op = dstPtr; + + for (int y = 0; y < height; y++, ip += input.Width) + { + int x = 0; + + for (; x < widthTrunc; x += 16) + { + byte* baseOffset = (byte*)(ip + (ulong)(uint)x); + + Vector128<ushort> pixelp1 = Sse2.LoadVector128((ushort*)baseOffset); + Vector128<ushort> pixelp2 = Sse2.LoadVector128((ushort*)(baseOffset + 0x10)); + Vector128<ushort> pixelp3 = Sse2.LoadVector128((ushort*)(baseOffset + 0x20)); + Vector128<ushort> pixelp4 = Sse2.LoadVector128((ushort*)(baseOffset + 0x30)); + Vector128<ushort> pixelp5 = Sse2.LoadVector128((ushort*)(baseOffset + 0x40)); + Vector128<ushort> pixelp6 = Sse2.LoadVector128((ushort*)(baseOffset + 0x50)); + Vector128<ushort> pixelp7 = Sse2.LoadVector128((ushort*)(baseOffset + 0x60)); + Vector128<ushort> pixelp8 = Sse2.LoadVector128((ushort*)(baseOffset + 0x70)); + + pixelp1 = Sse2.And(pixelp1, mask); + pixelp2 = Sse2.And(pixelp2, mask); + pixelp3 = Sse2.And(pixelp3, mask); + pixelp4 = Sse2.And(pixelp4, mask); + pixelp5 = Sse2.And(pixelp5, mask); + pixelp6 = Sse2.And(pixelp6, mask); + pixelp7 = Sse2.And(pixelp7, mask); + pixelp8 = Sse2.And(pixelp8, mask); + + Vector128<ushort> pixelq1 = Sse41.PackUnsignedSaturate(pixelp1.AsInt32(), pixelp2.AsInt32()); + Vector128<ushort> pixelq2 = Sse41.PackUnsignedSaturate(pixelp3.AsInt32(), pixelp4.AsInt32()); + Vector128<ushort> pixelq3 = Sse41.PackUnsignedSaturate(pixelp5.AsInt32(), pixelp6.AsInt32()); + Vector128<ushort> pixelq4 = Sse41.PackUnsignedSaturate(pixelp7.AsInt32(), pixelp8.AsInt32()); + + pixelq1 = Sse41.PackUnsignedSaturate(pixelq1.AsInt32(), pixelq2.AsInt32()); + pixelq2 = Sse41.PackUnsignedSaturate(pixelq3.AsInt32(), pixelq4.AsInt32()); + + pixelq1 = Sse2.ShiftRightLogical(pixelq1, 2); + pixelq2 = Sse2.ShiftRightLogical(pixelq2, 2); + + Vector128<byte> pixel = Sse2.PackUnsignedSaturate(pixelq1.AsInt16(), pixelq2.AsInt16()); + + Sse2.Store(op, pixel); + + op += 0x10; + } + + for (; x < width; x++) + { + Pixel* px = ip + (uint)x; + + *op++ = Downsample(px->R); + } + + op += strideGap; + } + } + } + } + else + { + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + dstY[y * yStride + x] = Downsample(input.GetR(x, y)); + } + } + } + + WriteBuffer( + rm, + dstY, + offsets.LumaOffset, + outLinear, + config.OutLumaWidth + 1, + config.OutLumaHeight + 1, + 1, + gobBlocksInY); + + rm.BufferPool.Return(dstYIndex); + + int uvWidth = Math.Min(config.OutChromaWidth + 1, (width + 1) >> 1); + int uvHeight = Math.Min(config.OutChromaHeight + 1, (height + 1) >> 1); + int uvStride = GetPitch(config.OutChromaWidth + 1, 2); + + int dstUvIndex = rm.BufferPool.Rent((config.OutChromaHeight + 1) * uvStride, out Span<byte> dstUv); + + if (Sse2.IsSupported) + { + int widthTrunc = uvWidth & ~7; + int strideGap = uvStride - uvWidth * 2; + + fixed (Pixel* srcPtr = input.Data) + { + Pixel* ip = srcPtr; + + fixed (byte* dstPtr = dstUv) + { + byte* op = dstPtr; + + for (int y = 0; y < uvHeight; y++, ip += input.Width * 2) + { + int x = 0; + + for (; x < widthTrunc; x += 8) + { + byte* baseOffset = (byte*)ip + (ulong)(uint)x * 16; + + Vector128<uint> pixel1 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x02)); + Vector128<uint> pixel2 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x12)); + Vector128<uint> pixel3 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x22)); + Vector128<uint> pixel4 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x32)); + Vector128<uint> pixel5 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x42)); + Vector128<uint> pixel6 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x52)); + Vector128<uint> pixel7 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x62)); + Vector128<uint> pixel8 = Sse2.LoadScalarVector128((uint*)(baseOffset + 0x72)); + + Vector128<uint> pixel12 = Sse2.UnpackLow(pixel1, pixel2); + Vector128<uint> pixel34 = Sse2.UnpackLow(pixel3, pixel4); + Vector128<uint> pixel56 = Sse2.UnpackLow(pixel5, pixel6); + Vector128<uint> pixel78 = Sse2.UnpackLow(pixel7, pixel8); + + Vector128<ulong> pixel1234 = Sse2.UnpackLow(pixel12.AsUInt64(), pixel34.AsUInt64()); + Vector128<ulong> pixel5678 = Sse2.UnpackLow(pixel56.AsUInt64(), pixel78.AsUInt64()); + + pixel1234 = Sse2.ShiftRightLogical(pixel1234, 2); + pixel5678 = Sse2.ShiftRightLogical(pixel5678, 2); + + Vector128<byte> pixel = Sse2.PackUnsignedSaturate(pixel1234.AsInt16(), pixel5678.AsInt16()); + + Sse2.Store(op, pixel); + + op += 0x10; + } + + for (; x < uvWidth; x++) + { + Pixel* px = ip + (uint)(x << 1); + + *op++ = Downsample(px->G); + *op++ = Downsample(px->B); + } + + op += strideGap; + } + } + } + } + else + { + for (int y = 0; y < uvHeight; y++) + { + for (int x = 0; x < uvWidth; x++) + { + int xx = x << 1; + int yy = y << 1; + + int uvOffs = y * uvStride + xx; + + dstUv[uvOffs + 0] = Downsample(input.GetG(xx, yy)); + dstUv[uvOffs + 1] = Downsample(input.GetB(xx, yy)); + } + } + } + + WriteBuffer( + rm, + dstUv, + offsets.ChromaUOffset, + outLinear, + config.OutChromaWidth + 1, + config.OutChromaHeight + 1, 2, + gobBlocksInY); + + rm.BufferPool.Return(dstUvIndex); + } + + private static void WriteBuffer( + ResourceManager rm, + ReadOnlySpan<byte> src, + uint offset, + bool linear, + int width, + int height, + int bytesPerPixel, + int gobBlocksInY) + { + if (linear) + { + rm.Gmm.Write(ExtendOffset(offset), src); + return; + } + + WriteBuffer(rm, src, offset, width, height, bytesPerPixel, gobBlocksInY); + } + + private static void WriteBuffer( + ResourceManager rm, + ReadOnlySpan<byte> src, + uint offset, + int width, + int height, + int bytesPerPixel, + int gobBlocksInY) + { + int outSize = GetBlockLinearSize(width, height, bytesPerPixel, gobBlocksInY); + int dstStride = GetPitch(width, bytesPerPixel); + + int dstIndex = rm.BufferPool.Rent(outSize, out Span<byte> dst); + + LayoutConverter.ConvertLinearToBlockLinear(dst, width, height, dstStride, bytesPerPixel, gobBlocksInY, src); + + rm.Gmm.Write(ExtendOffset(offset), dst); + + rm.BufferPool.Return(dstIndex); + } + } +} diff --git a/Ryujinx.Graphics.Vic/ResourceManager.cs b/Ryujinx.Graphics.Vic/ResourceManager.cs new file mode 100644 index 00000000..036b30b6 --- /dev/null +++ b/Ryujinx.Graphics.Vic/ResourceManager.cs @@ -0,0 +1,19 @@ +using Ryujinx.Graphics.Gpu.Memory; +using Ryujinx.Graphics.Vic.Image; + +namespace Ryujinx.Graphics.Vic +{ + struct ResourceManager + { + public MemoryManager Gmm { get; } + public BufferPool<Pixel> SurfacePool { get; } + public BufferPool<byte> BufferPool { get; } + + public ResourceManager(MemoryManager gmm, BufferPool<Pixel> surfacePool, BufferPool<byte> bufferPool) + { + Gmm = gmm; + SurfacePool = surfacePool; + BufferPool = bufferPool; + } + } +} diff --git a/Ryujinx.Graphics.Vic/Ryujinx.Graphics.Vic.csproj b/Ryujinx.Graphics.Vic/Ryujinx.Graphics.Vic.csproj new file mode 100644 index 00000000..f072fa36 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Ryujinx.Graphics.Vic.csproj @@ -0,0 +1,23 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>netcoreapp3.1</TargetFramework> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'"> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + </PropertyGroup> + + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'"> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + </PropertyGroup> + + <ItemGroup> + <ProjectReference Include="..\Ryujinx.Common\Ryujinx.Common.csproj" /> + <ProjectReference Include="..\Ryujinx.Graphics.Device\Ryujinx.Graphics.Device.csproj" /> + <ProjectReference Include="..\Ryujinx.Graphics.Gpu\Ryujinx.Graphics.Gpu.csproj" /> + <ProjectReference Include="..\Ryujinx.Graphics.Host1x\Ryujinx.Graphics.Host1x.csproj" /> + <ProjectReference Include="..\Ryujinx.Graphics.Texture\Ryujinx.Graphics.Texture.csproj" /> + </ItemGroup> + +</Project> diff --git a/Ryujinx.Graphics.Vic/Types/BitfieldExtensions.cs b/Ryujinx.Graphics.Vic/Types/BitfieldExtensions.cs new file mode 100644 index 00000000..06d0f006 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/BitfieldExtensions.cs @@ -0,0 +1,39 @@ +using System.Runtime.CompilerServices; + +namespace Ryujinx.Graphics.Vic.Types +{ + static class BitfieldExtensions + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool Extract(this int value, int lsb) + { + return ((value >> (lsb & 0x1f)) & 1) != 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int Extract(this int value, int lsb, int length) + { + return (value >> (lsb & 0x1f)) & (int)(uint.MaxValue >> (32 - length)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool Extract(this long value, int lsb) + { + return ((int)(value >> (lsb & 0x3f)) & 1) != 0; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int Extract(this long value, int lsb, int length) + { + return (int)(value >> (lsb & 0x3f)) & (int)(uint.MaxValue >> (32 - length)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int ExtractSx(this long value, int lsb, int length) + { + int shift = lsb & 0x3f; + + return (int)((value << (64 - (shift + length))) >> (64 - length)); + } + } +} diff --git a/Ryujinx.Graphics.Vic/Types/BlendingSlotStruct.cs b/Ryujinx.Graphics.Vic/Types/BlendingSlotStruct.cs new file mode 100644 index 00000000..fc5d315e --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/BlendingSlotStruct.cs @@ -0,0 +1,27 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct BlendingSlotStruct + { + private long _word0; + private long _word1; + + public int AlphaK1 => _word0.Extract(0, 10); + public int AlphaK2 => _word0.Extract(16, 10); + public int SrcFactCMatchSelect => _word0.Extract(32, 3); + public int DstFactCMatchSelect => _word0.Extract(36, 3); + public int SrcFactAMatchSelect => _word0.Extract(40, 3); + public int DstFactAMatchSelect => _word0.Extract(44, 3); + public int OverrideR => _word1.Extract(66, 10); + public int OverrideG => _word1.Extract(76, 10); + public int OverrideB => _word1.Extract(86, 10); + public int OverrideA => _word1.Extract(96, 10); + public bool UseOverrideR => _word1.Extract(108); + public bool UseOverrideG => _word1.Extract(109); + public bool UseOverrideB => _word1.Extract(110); + public bool UseOverrideA => _word1.Extract(111); + public bool MaskR => _word1.Extract(112); + public bool MaskG => _word1.Extract(113); + public bool MaskB => _word1.Extract(114); + public bool MaskA => _word1.Extract(115); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/ClearRectStruct.cs b/Ryujinx.Graphics.Vic/Types/ClearRectStruct.cs new file mode 100644 index 00000000..21b7b598 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/ClearRectStruct.cs @@ -0,0 +1,17 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct ClearRectStruct + { + private long _word0; + private long _word1; + + public int ClearRect0Left => _word0.Extract(0, 14); + public int ClearRect0Right => _word0.Extract(16, 14); + public int ClearRect0Top => _word0.Extract(32, 14); + public int ClearRect0Bottom => _word0.Extract(48, 14); + public int ClearRect1Left => _word1.Extract(64, 14); + public int ClearRect1Right => _word1.Extract(80, 14); + public int ClearRect1Top => _word1.Extract(96, 14); + public int ClearRect1Bottom => _word1.Extract(112, 14); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/ConfigStruct.cs b/Ryujinx.Graphics.Vic/Types/ConfigStruct.cs new file mode 100644 index 00000000..f1e6287a --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/ConfigStruct.cs @@ -0,0 +1,14 @@ +using Ryujinx.Common.Memory; + +namespace Ryujinx.Graphics.Vic.Types +{ + struct ConfigStruct + { + public PipeConfig PipeConfig; + public OutputConfig OutputConfig; + public OutputSurfaceConfig OutputSurfaceConfig; + public MatrixStruct OutColorMatrix; + public Array4<ClearRectStruct> ClearRectStruct; + public Array8<SlotStruct> SlotStruct; + } +} diff --git a/Ryujinx.Graphics.Vic/Types/LumaKeyStruct.cs b/Ryujinx.Graphics.Vic/Types/LumaKeyStruct.cs new file mode 100644 index 00000000..df5e647e --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/LumaKeyStruct.cs @@ -0,0 +1,17 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct LumaKeyStruct + { + private long _word0; + private long _word1; + + public int LumaCoeff0 => _word0.Extract(0, 20); + public int LumaCoeff1 => _word0.Extract(20, 20); + public int LumaCoeff2 => _word0.Extract(40, 20); + public int LumaRShift => _word0.Extract(60, 4); + public int LumaCoeff3 => _word1.Extract(64, 20); + public int LumaKeyLower => _word1.Extract(84, 10); + public int LumaKeyUpper => _word1.Extract(94, 10); + public bool LumaKeyEnabled => _word1.Extract(104); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/MatrixStruct.cs b/Ryujinx.Graphics.Vic/Types/MatrixStruct.cs new file mode 100644 index 00000000..b9dcd8ff --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/MatrixStruct.cs @@ -0,0 +1,25 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct MatrixStruct + { + private long _word0; + private long _word1; + private long _word2; + private long _word3; + + public int MatrixCoeff00 => _word0.ExtractSx(0, 20); + public int MatrixCoeff10 => _word0.ExtractSx(20, 20); + public int MatrixCoeff20 => _word0.ExtractSx(40, 20); + public int MatrixRShift => _word0.Extract(60, 4); + public int MatrixCoeff01 => _word1.ExtractSx(64, 20); + public int MatrixCoeff11 => _word1.ExtractSx(84, 20); + public int MatrixCoeff21 => _word1.ExtractSx(104, 20); + public bool MatrixEnable => _word1.Extract(127); + public int MatrixCoeff02 => _word2.ExtractSx(128, 20); + public int MatrixCoeff12 => _word2.ExtractSx(148, 20); + public int MatrixCoeff22 => _word2.ExtractSx(168, 20); + public int MatrixCoeff03 => _word3.ExtractSx(192, 20); + public int MatrixCoeff13 => _word3.ExtractSx(212, 20); + public int MatrixCoeff23 => _word3.ExtractSx(232, 20); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/OutputConfig.cs b/Ryujinx.Graphics.Vic/Types/OutputConfig.cs new file mode 100644 index 00000000..8ab46fe5 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/OutputConfig.cs @@ -0,0 +1,23 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct OutputConfig + { + private long _word0; + private long _word1; + + public int AlphaFillMode => _word0.Extract(0, 3); + public int AlphaFillSlot => _word0.Extract(3, 3); + public int BackgroundAlpha => _word0.Extract(6, 10); + public int BackgroundR => _word0.Extract(16, 10); + public int BackgroundG => _word0.Extract(26, 10); + public int BackgroundB => _word0.Extract(36, 10); + public int RegammaMode => _word0.Extract(46, 2); + public bool OutputFlipX => _word0.Extract(48); + public bool OutputFlipY => _word0.Extract(49); + public bool OutputTranspose => _word0.Extract(50); + public int TargetRectLeft => _word1.Extract(64, 14); + public int TargetRectRight => _word1.Extract(80, 14); + public int TargetRectTop => _word1.Extract(96, 14); + public int TargetRectBottom => _word1.Extract(112, 14); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/OutputSurfaceConfig.cs b/Ryujinx.Graphics.Vic/Types/OutputSurfaceConfig.cs new file mode 100644 index 00000000..9068cbbe --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/OutputSurfaceConfig.cs @@ -0,0 +1,20 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct OutputSurfaceConfig + { + private long _word0; + private long _word1; + + public PixelFormat OutPixelFormat => (PixelFormat)_word0.Extract(0, 7); + public int OutChromaLocHoriz => _word0.Extract(7, 2); + public int OutChromaLocVert => _word0.Extract(9, 2); + public int OutBlkKind => _word0.Extract(11, 4); + public int OutBlkHeight => _word0.Extract(15, 4); + public int OutSurfaceWidth => _word0.Extract(32, 14); + public int OutSurfaceHeight => _word0.Extract(46, 14); + public int OutLumaWidth => _word1.Extract(64, 14); + public int OutLumaHeight => _word1.Extract(78, 14); + public int OutChromaWidth => _word1.Extract(96, 14); + public int OutChromaHeight => _word1.Extract(110, 14); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/PipeConfig.cs b/Ryujinx.Graphics.Vic/Types/PipeConfig.cs new file mode 100644 index 00000000..72d8cc99 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/PipeConfig.cs @@ -0,0 +1,11 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct PipeConfig + { + private long _word0; + private long _word1; + + public int DownsampleHoriz => _word0.Extract(0, 11); + public int DownsampleVert => _word0.Extract(16, 11); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/PixelFormat.cs b/Ryujinx.Graphics.Vic/Types/PixelFormat.cs new file mode 100644 index 00000000..72dc7899 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/PixelFormat.cs @@ -0,0 +1,81 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + enum PixelFormat + { + A8, + L8, + A4L4, + L4A4, + R8, + A8L8, + L8A8, + R8G8, + G8R8, + B5G6R5, + R5G6B5, + B6G5R5, + R5G5B6, + A1B5G5R5, + A1R5G5B5, + B5G5R5A1, + R5G5B5A1, + A5B5G5R1, + A5R1G5B5, + B5G5R1A5, + R1G5B5A5, + X1B5G5R5, + X1R5G5B5, + B5G5R5X1, + R5G5B5X1, + A4B4G4R4, + A4R4G4B4, + B4G4R4A4, + R4G4B4A4, + B8_G8_R8, + R8_G8_B8, + A8B8G8R8, + A8R8G8B8, + B8G8R8A8, + R8G8B8A8, + X8B8G8R8, + X8R8G8B8, + B8G8R8X8, + R8G8B8X8, + A2B10G10R10, + A2R10G10B10, + B10G10R10A2, + R10G10B10A2, + A4P4, + P4A4, + P8A845, + A8P8, + P8, + P1, + U8V8, + V8U8, + A8Y8U8V8, + V8U8Y8A8, + Y8_U8_V8, + Y8_V8_U8, + U8_V8_Y8, + V8_U8_Y8, + Y8_U8__Y8_V8, + Y8_V8__Y8_U8, + U8_Y8__V8_Y8, + V8_Y8__U8_Y8, + Y8___U8V8_N444, + Y8___V8U8_N444, + Y8___U8V8_N422, + Y8___V8U8_N422, + Y8___U8V8_N422R, + Y8___V8U8_N422R, + Y8___U8V8_N420, + Y8___V8U8_N420, + Y8___U8___V8_N444, + Y8___U8___V8_N422, + Y8___U8___V8_N422R, + Y8___U8___V8_N420, + U8, + V8 + } +} diff --git a/Ryujinx.Graphics.Vic/Types/SlotConfig.cs b/Ryujinx.Graphics.Vic/Types/SlotConfig.cs new file mode 100644 index 00000000..183ee4ac --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/SlotConfig.cs @@ -0,0 +1,63 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct SlotConfig + { + private long _word0; + private long _word1; + private long _word2; + private long _word3; + private long _word4; + private long _word5; + private long _word6; + private long _word7; + + public bool SlotEnable => _word0.Extract(0); + public bool DeNoise => _word0.Extract(1); + public bool AdvancedDenoise => _word0.Extract(2); + public bool CadenceDetect => _word0.Extract(3); + public bool MotionMap => _word0.Extract(4); + public bool MMapCombine => _word0.Extract(5); + public bool IsEven => _word0.Extract(6); + public bool ChromaEven => _word0.Extract(7); + public bool CurrentFieldEnable => _word0.Extract(8); + public bool PrevFieldEnable => _word0.Extract(9); + public bool NextFieldEnable => _word0.Extract(10); + public bool NextNrFieldEnable => _word0.Extract(11); + public bool CurMotionFieldEnable => _word0.Extract(12); + public bool PrevMotionFieldEnable => _word0.Extract(13); + public bool PpMotionFieldEnable => _word0.Extract(14); + public bool CombMotionFieldEnable => _word0.Extract(15); + public int FrameFormat => _word0.Extract(16, 4); + public int FilterLengthY => _word0.Extract(20, 2); + public int FilterLengthX => _word0.Extract(22, 2); + public int Panoramic => _word0.Extract(24, 12); + public int DetailFltClamp => _word0.Extract(58, 6); + public int FilterNoise => _word1.Extract(64, 10); + public int FilterDetail => _word1.Extract(74, 10); + public int ChromaNoise => _word1.Extract(84, 10); + public int ChromaDetail => _word1.Extract(94, 10); + public int DeinterlaceMode => _word1.Extract(104, 4); + public int MotionAccumWeight => _word1.Extract(108, 3); + public int NoiseIir => _word1.Extract(111, 11); + public int LightLevel => _word1.Extract(122, 4); + public int SoftClampLow => _word2.Extract(128, 10); + public int SoftClampHigh => _word2.Extract(138, 10); + public int PlanarAlpha => _word2.Extract(160, 10); + public bool ConstantAlpha => _word2.Extract(170); + public int StereoInterleave => _word2.Extract(171, 3); + public bool ClipEnabled => _word2.Extract(174); + public int ClearRectMask => _word2.Extract(175, 8); + public int DegammaMode => _word2.Extract(183, 2); + public bool DecompressEnable => _word2.Extract(186); + public int DecompressCtbCount => _word3.Extract(192, 8); + public int DecompressZbcColor => _word3.Extract(200, 32); + public int SourceRectLeft => _word4.Extract(256, 30); + public int SourceRectRight => _word4.Extract(288, 30); + public int SourceRectTop => _word5.Extract(320, 30); + public int SourceRectBottom => _word5.Extract(352, 30); + public int DstRectLeft => _word6.Extract(384, 14); + public int DstRectRight => _word6.Extract(400, 14); + public int DstRectTop => _word6.Extract(416, 14); + public int DstRectBottom => _word6.Extract(432, 14); + } +} diff --git a/Ryujinx.Graphics.Vic/Types/SlotStruct.cs b/Ryujinx.Graphics.Vic/Types/SlotStruct.cs new file mode 100644 index 00000000..96c6cce5 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/SlotStruct.cs @@ -0,0 +1,12 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct SlotStruct + { + public SlotConfig SlotConfig; + public SlotSurfaceConfig SlotSurfaceConfig; + public LumaKeyStruct LumaKeyStruct; + public MatrixStruct ColorMatrixStruct; + public MatrixStruct GamutMatrixStruct; + public BlendingSlotStruct BlendingSlotStruct; + } +} diff --git a/Ryujinx.Graphics.Vic/Types/SlotSurfaceConfig.cs b/Ryujinx.Graphics.Vic/Types/SlotSurfaceConfig.cs new file mode 100644 index 00000000..7396afa1 --- /dev/null +++ b/Ryujinx.Graphics.Vic/Types/SlotSurfaceConfig.cs @@ -0,0 +1,21 @@ +namespace Ryujinx.Graphics.Vic.Types +{ + struct SlotSurfaceConfig + { + private long _word0; + private long _word1; + + public PixelFormat SlotPixelFormat => (PixelFormat)_word0.Extract(0, 7); + public int SlotChromaLocHoriz => _word0.Extract(7, 2); + public int SlotChromaLocVert => _word0.Extract(9, 2); + public int SlotBlkKind => _word0.Extract(11, 4); + public int SlotBlkHeight => _word0.Extract(15, 4); + public int SlotCacheWidth => _word0.Extract(19, 3); + public int SlotSurfaceWidth => _word0.Extract(32, 14); + public int SlotSurfaceHeight => _word0.Extract(46, 14); + public int SlotLumaWidth => _word1.Extract(64, 14); + public int SlotLumaHeight => _word1.Extract(78, 14); + public int SlotChromaWidth => _word1.Extract(96, 14); + public int SlotChromaHeight => _word1.Extract(110, 14); + } +} diff --git a/Ryujinx.Graphics.Vic/VicDevice.cs b/Ryujinx.Graphics.Vic/VicDevice.cs new file mode 100644 index 00000000..db4fe513 --- /dev/null +++ b/Ryujinx.Graphics.Vic/VicDevice.cs @@ -0,0 +1,97 @@ +using Ryujinx.Common.Logging; +using Ryujinx.Graphics.Device; +using Ryujinx.Graphics.Gpu.Memory; +using Ryujinx.Graphics.Vic.Image; +using Ryujinx.Graphics.Vic.Types; +using System; +using System.Collections.Generic; + +namespace Ryujinx.Graphics.Vic +{ + public class VicDevice : IDeviceState + { + private readonly MemoryManager _gmm; + private readonly ResourceManager _rm; + private readonly DeviceState<VicRegisters> _state; + + private PlaneOffsets _overrideOffsets; + private bool _hasOverride; + + public VicDevice(MemoryManager gmm) + { + _gmm = gmm; + _rm = new ResourceManager(gmm, new BufferPool<Pixel>(), new BufferPool<byte>()); + _state = new DeviceState<VicRegisters>(new Dictionary<string, RwCallback> + { + { nameof(VicRegisters.Execute), new RwCallback(Execute, null) } + }); + } + + /// <summary> + /// Overrides all input surfaces with a custom surface. + /// </summary> + /// <param name="lumaOffset">Offset of the luma plane or packed data for this surface</param> + /// <param name="chromaUOffset">Offset of the U chroma plane (for planar formats) or both chroma planes (for semiplanar formats)</param> + /// <param name="chromaVOffset">Offset of the V chroma plane for planar formats</param> + public void SetSurfaceOverride(uint lumaOffset, uint chromaUOffset, uint chromaVOffset) + { + _overrideOffsets.LumaOffset = lumaOffset; + _overrideOffsets.ChromaUOffset = chromaUOffset; + _overrideOffsets.ChromaVOffset = chromaVOffset; + _hasOverride = true; + } + + /// <summary> + /// Disables overriding input surfaces. + /// </summary> + /// <remarks> + /// Surface overrides are disabled by default. + /// Call this if you previously called <see cref="SetSurfaceOverride(uint, uint, uint)"/> and which to disable it. + /// </remarks> + public void DisableSurfaceOverride() + { + _hasOverride = false; + } + + public int Read(int offset) => _state.Read(offset); + public void Write(int offset, int data) => _state.Write(offset, data); + + private void Execute(int data) + { + ConfigStruct config = ReadIndirect<ConfigStruct>(_state.State.SetConfigStructOffset); + + using Surface output = new Surface( + _rm.SurfacePool, + config.OutputSurfaceConfig.OutSurfaceWidth + 1, + config.OutputSurfaceConfig.OutSurfaceHeight + 1); + + for (int i = 0; i < config.SlotStruct.Length; i++) + { + ref SlotStruct slot = ref config.SlotStruct[i]; + + if (!slot.SlotConfig.SlotEnable) + { + continue; + } + + var offsets = _state.State.SetSurfacexSlotx[i][0]; + + if (_hasOverride) + { + offsets = _overrideOffsets; + } + + using Surface src = SurfaceReader.Read(_rm, ref slot.SlotSurfaceConfig, ref offsets); + + Blender.BlendOne(output, src, ref slot); + } + + SurfaceWriter.Write(_rm, output, ref config.OutputSurfaceConfig, ref _state.State.SetOutputSurface); + } + + private T ReadIndirect<T>(uint offset) where T : unmanaged + { + return _gmm.Read<T>((ulong)offset << 8); + } + } +} diff --git a/Ryujinx.Graphics.Vic/VicRegisters.cs b/Ryujinx.Graphics.Vic/VicRegisters.cs new file mode 100644 index 00000000..71dc9eed --- /dev/null +++ b/Ryujinx.Graphics.Vic/VicRegisters.cs @@ -0,0 +1,47 @@ +using Ryujinx.Common.Memory; + +namespace Ryujinx.Graphics.Vic +{ + struct PlaneOffsets + { + public uint LumaOffset; + public uint ChromaUOffset; + public uint ChromaVOffset; + } + + struct VicRegisters + { + public Array64<uint> Reserved0; + public uint Nop; + public Array15<uint> Reserved104; + public uint PmTrigger; + public Array47<uint> Reserved144; + public uint SetApplicationID; + public uint SetWatchdogTimer; + public Array14<uint> Reserved208; + public uint SemaphoreA; + public uint SemaphoreB; + public uint SemaphoreC; + public uint CtxSaveArea; + public uint CtxSwitch; + public Array43<uint> Reserved254; + public uint Execute; + public uint SemaphoreD; + public Array62<uint> Reserved308; + public Array8<Array8<PlaneOffsets>> SetSurfacexSlotx; + public uint SetPictureIndex; + public uint SetControlParams; + public uint SetConfigStructOffset; + public uint SetFilterStructOffset; + public uint SetPaletteOffset; + public uint SetHistOffset; + public uint SetContextId; + public uint SetFceUcodeSize; + public PlaneOffsets SetOutputSurface; + public uint SetFceUcodeOffset; + public Array4<uint> Reserved730; + public Array8<uint> SetSlotContextId; + public Array8<uint> SetCompTagBufferOffset; + public Array8<uint> SetHistoryBufferOffset; + } +} |