mirrors/ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

New NVDEC and VIC implementation (#1384)

Browse source 
* Initial NVDEC and VIC implementation

* Update FFmpeg.AutoGen to 4.3.0

* Add nvdec dependencies for Windows

* Unify some VP9 structures

* Rename VP9 structure fields

* Improvements to Video API

* XML docs for Common.Memory

* Remove now unused or redundant overloads from MemoryAccessor

* NVDEC UV surface read/write scalar paths

* Add FIXME comments about hacky things/stuff that will need to be fixed in the future

* Cleaned up VP9 memory allocation

* Remove some debug logs

* Rename some VP9 structs

* Remove unused struct

* No need to compile Ryujinx.Graphics.Host1x with unsafe anymore

* Name AsyncWorkQueue threads to make debugging easier

* Make Vp9PictureInfo a ref struct

* LayoutConverter no longer needs the depth argument (broken by rebase)

* Pooling of VP9 buffers, plus fix a memory leak on VP9

* Really wish VS could rename projects properly...

* Address feedback

* Remove using

* Catch OperationCanceledException

* Add licensing informations

* Add THIRDPARTY.md to release too

Co-authored-by: Thog <me@thog.eu>
This commit is contained in:
gdkchan 2020-07-12 00:07:01 -03:00 • committed by GitHub
parent 38b26cf424
commit 4d02a2d2c0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
202 changed files with 20563 additions and 2567 deletions
Download patch file Download diff file Expand all files Collapse all files

157
Ryujinx.Graphics.Vic/Blender.cs Normal file
View file

@ -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;
}
}
}

103
Ryujinx.Graphics.Vic/Image/BufferPool.cs Normal file
View file

@ -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;
}
}
}

17
Ryujinx.Graphics.Vic/Image/InputSurface.cs Normal file
View file

@ -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;
}
}

10
Ryujinx.Graphics.Vic/Image/Pixel.cs Normal file
View file

@ -0,0 +1,10 @@
namespace Ryujinx.Graphics.Vic.Image
{
struct Pixel
{
public ushort R;
public ushort G;
public ushort B;
public ushort A;
}
}

46
Ryujinx.Graphics.Vic/Image/Surface.cs Normal file
View file

@ -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);
}
}

33
Ryujinx.Graphics.Vic/Image/SurfaceCommon.cs Normal file
View file

@ -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);
}
}
}

253
Ryujinx.Graphics.Vic/Image/SurfaceReader.cs Normal file
View file

@ -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;
}
}
}

361
Ryujinx.Graphics.Vic/Image/SurfaceWriter.cs Normal file
View file

@ -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);
}
}
}

19
Ryujinx.Graphics.Vic/ResourceManager.cs Normal file
View file

@ -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;
}
}
}

23
Ryujinx.Graphics.Vic/Ryujinx.Graphics.Vic.csproj Normal file
View file

@ -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>

39
Ryujinx.Graphics.Vic/Types/BitfieldExtensions.cs Normal file
View file

@ -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));
}
}
}

27
Ryujinx.Graphics.Vic/Types/BlendingSlotStruct.cs Normal file
View file

@ -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);
}
}

17
Ryujinx.Graphics.Vic/Types/ClearRectStruct.cs Normal file
View file

@ -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);
}
}

14
Ryujinx.Graphics.Vic/Types/ConfigStruct.cs Normal file
View file

@ -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;
}
}

17
Ryujinx.Graphics.Vic/Types/LumaKeyStruct.cs Normal file
View file

@ -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);
}
}

25
Ryujinx.Graphics.Vic/Types/MatrixStruct.cs Normal file
View file

@ -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);
}
}

23
Ryujinx.Graphics.Vic/Types/OutputConfig.cs Normal file
View file

@ -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);
}
}

20
Ryujinx.Graphics.Vic/Types/OutputSurfaceConfig.cs Normal file
View file

@ -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);
}
}

11
Ryujinx.Graphics.Vic/Types/PipeConfig.cs Normal file
View file

@ -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);
}
}

81
Ryujinx.Graphics.Vic/Types/PixelFormat.cs Normal file
View file

@ -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
}
}

63
Ryujinx.Graphics.Vic/Types/SlotConfig.cs Normal file
View file

@ -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);
}
}

12
Ryujinx.Graphics.Vic/Types/SlotStruct.cs Normal file
View file

@ -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;
}
}

21
Ryujinx.Graphics.Vic/Types/SlotSurfaceConfig.cs Normal file
View file

@ -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);
}
}

97
Ryujinx.Graphics.Vic/VicDevice.cs Normal file
View file

@ -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);
}
}
}

47
Ryujinx.Graphics.Vic/VicRegisters.cs Normal file
View file

@ -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;
}
}