New NVDEC and VIC implementation (#1384)
* 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:
parent
38b26cf424
commit
4d02a2d2c0
202 changed files with 20563 additions and 2567 deletions
103
Ryujinx.Graphics.Vic/Image/BufferPool.cs
Normal file
103
Ryujinx.Graphics.Vic/Image/BufferPool.cs
Normal 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
17
Ryujinx.Graphics.Vic/Image/InputSurface.cs
Normal 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
10
Ryujinx.Graphics.Vic/Image/Pixel.cs
Normal 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
46
Ryujinx.Graphics.Vic/Image/Surface.cs
Normal 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
33
Ryujinx.Graphics.Vic/Image/SurfaceCommon.cs
Normal 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
253
Ryujinx.Graphics.Vic/Image/SurfaceReader.cs
Normal 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
361
Ryujinx.Graphics.Vic/Image/SurfaceWriter.cs
Normal 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);
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue