GPU: Add fallback when 16-bit formats are not supported (#4108)

* Add conversion for 16 bit RGBA formats (not supported in Rosetta)

* Rebase fix

Rebase fix

* Forgot to remove this

* Fix RGBA16 format conversion

* Add RGBA4 -> RGBA8 conversion

* Handle host stride alignment

* Address Feedback Part 1

* Can't count

* Don't zero out rgb when alpha is 0

* Separate RGBA4 and 5-bit component formats

Not sure of a better way to name them...

* Add A1B5G5R5 conversion

* Put this in the right place.

* Make format naming consistent for capabilities

* Change method names

Ryujinx.Audio/Renderer/Common/WorkBufferAllocator.cs

@@ -23,7 +23,7 @@ namespace Ryujinx.Audio.Renderer.Common
 
             if (size != 0)
             {
-                ulong alignedOffset = BitUtils.AlignUp(Offset, align);
+                ulong alignedOffset = BitUtils.AlignUp<ulong>(Offset, (ulong)align);
 
                 if (alignedOffset + size <= (ulong)BackingMemory.Length)
                 {
@@ -55,7 +55,7 @@ namespace Ryujinx.Audio.Renderer.Common
 
         public static ulong GetTargetSize<T>(ulong currentSize, ulong count, int align) where T : unmanaged
         {
-            return BitUtils.AlignUp(currentSize, align) + (ulong)Unsafe.SizeOf<T>() * count;
+            return BitUtils.AlignUp<ulong>(currentSize, (ulong)align) + (ulong)Unsafe.SizeOf<T>() * count;
         }
     }
 }

Ryujinx.Audio/Renderer/Server/AudioRenderSystem.cs

@@ -167,7 +167,7 @@ namespace Ryujinx.Audio.Renderer.Server
                 return ResultCode.WorkBufferTooSmall;
             }
 
-            _depopBuffer = workBufferAllocator.Allocate<float>((ulong)BitUtils.AlignUp(parameter.MixBufferCount, Constants.BufferAlignment), Constants.BufferAlignment);
+            _depopBuffer = workBufferAllocator.Allocate<float>(BitUtils.AlignUp<ulong>(parameter.MixBufferCount, Constants.BufferAlignment), Constants.BufferAlignment);
 
             if (_depopBuffer.IsEmpty)
             {
@@ -772,7 +772,7 @@ namespace Ryujinx.Audio.Renderer.Server
             size = WorkBufferAllocator.GetTargetSize<float>(size, Constants.TargetSampleCount * (Constants.VoiceChannelCountMax + parameter.MixBufferCount) * (parameter.SinkCount + parameter.SubMixBufferCount), 0x10);
 
             // Depop buffer
-            size = WorkBufferAllocator.GetTargetSize<float>(size, (ulong)BitUtils.AlignUp(parameter.MixBufferCount, Constants.BufferAlignment), Constants.BufferAlignment);
+            size = WorkBufferAllocator.GetTargetSize<float>(size, BitUtils.AlignUp<ulong>(parameter.MixBufferCount, Constants.BufferAlignment), Constants.BufferAlignment);
 
             // Voice
             size = WorkBufferAllocator.GetTargetSize<VoiceState>(size, parameter.VoiceCount, VoiceState.Alignment);
@@ -804,10 +804,10 @@ namespace Ryujinx.Audio.Renderer.Server
             {
                 ulong performanceMetricsPerFramesSize = PerformanceManager.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter, ref behaviourContext) * (parameter.PerformanceMetricFramesCount + 1) + 0xC;
 
-                size += BitUtils.AlignUp(performanceMetricsPerFramesSize, Constants.PerformanceMetricsPerFramesSizeAlignment);
+                size += BitUtils.AlignUp<ulong>(performanceMetricsPerFramesSize, Constants.PerformanceMetricsPerFramesSizeAlignment);
             }
 
-            return BitUtils.AlignUp(size, Constants.WorkBufferAlignment);
+            return BitUtils.AlignUp<ulong>(size, Constants.WorkBufferAlignment);
         }
 
         public ResultCode QuerySystemEvent(out IWritableEvent systemEvent)

Ryujinx.Common/Utilities/BitUtils.cs

@@ -1,82 +1,26 @@
+using System;
 using System.Numerics;
 
 namespace Ryujinx.Common
 {
     public static class BitUtils
     {
-        public static uint AlignUp(uint value, int size)
+        public static T AlignUp<T>(T value, T size)
+            where T : IBinaryInteger<T>
         {
-            return (uint)AlignUp((int)value, size);
+            return (value + (size - T.One)) & -size;
         }
 
-        public static int AlignUp(int value, int size)
-        {
-            return (value + (size - 1)) & -size;
-        }
-
-        public static ulong AlignUp(ulong value, int size)
-        {
-            return (ulong)AlignUp((long)value, size);
-        }
-
-        public static long AlignUp(long value, int size)
-        {
-            return AlignUp(value, (long)size);
-        }
-
-        public static ulong AlignUp(ulong value, ulong size)
-        {
-            return (ulong)AlignUp((long)value, (long)size);
-        }
-
-        public static long AlignUp(long value, long size)
-        {
-            return (value + (size - 1)) & -size;
-        }
-
-        public static uint AlignDown(uint value, int size)
-        {
-            return (uint)AlignDown((int)value, size);
-        }
-
-        public static int AlignDown(int value, int size)
+        public static T AlignDown<T>(T value, T size)
+            where T : IBinaryInteger<T>
         {
             return value & -size;
         }
 
-        public static ulong AlignDown(ulong value, int size)
+        public static T DivRoundUp<T>(T value, T dividend)
+            where T : IBinaryInteger<T>
         {
-            return (ulong)AlignDown((long)value, size);
-        }
-
-        public static long AlignDown(long value, int size)
-        {
-            return AlignDown(value, (long)size);
-        }
-
-        public static ulong AlignDown(ulong value, ulong size)
-        {
-            return (ulong)AlignDown((long)value, (long)size);
-        }
-
-        public static long AlignDown(long value, long size)
-        {
-            return value & -size;
-        }
-
-        public static int DivRoundUp(int value, int dividend)
-        {
-            return (value + dividend - 1) / dividend;
-        }
-
-        public static ulong DivRoundUp(ulong value, uint dividend)
-        {
-            return (value + dividend - 1) / dividend;
-        }
-
-        public static long DivRoundUp(long value, int dividend)
-        {
-            return (value + dividend - 1) / dividend;
+            return (value + (dividend - T.One)) / dividend;
         }
 
         public static int Pow2RoundUp(int value)

Ryujinx.Graphics.GAL/Capabilities.cs

@@ -18,7 +18,9 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool Supports3DTextureCompression;
         public readonly bool SupportsBgraFormat;
         public readonly bool SupportsR4G4Format;
+        public readonly bool SupportsR4G4B4A4Format;
         public readonly bool SupportsSnormBufferTextureFormat;
+        public readonly bool Supports5BitComponentFormat;
         public readonly bool SupportsFragmentShaderInterlock;
         public readonly bool SupportsFragmentShaderOrderingIntel;
         public readonly bool SupportsGeometryShaderPassthrough;
@@ -55,7 +57,9 @@ namespace Ryujinx.Graphics.GAL
             bool supports3DTextureCompression,
             bool supportsBgraFormat,
             bool supportsR4G4Format,
+            bool supportsR4G4B4A4Format,
             bool supportsSnormBufferTextureFormat,
+            bool supports5BitComponentFormat,
             bool supportsFragmentShaderInterlock,
             bool supportsFragmentShaderOrderingIntel,
             bool supportsGeometryShaderPassthrough,
@@ -89,7 +93,9 @@ namespace Ryujinx.Graphics.GAL
             Supports3DTextureCompression = supports3DTextureCompression;
             SupportsBgraFormat = supportsBgraFormat;
             SupportsR4G4Format = supportsR4G4Format;
+            SupportsR4G4B4A4Format = supportsR4G4B4A4Format;
             SupportsSnormBufferTextureFormat = supportsSnormBufferTextureFormat;
+            Supports5BitComponentFormat = supports5BitComponentFormat;
             SupportsFragmentShaderInterlock = supportsFragmentShaderInterlock;
             SupportsFragmentShaderOrderingIntel = supportsFragmentShaderOrderingIntel;
             SupportsGeometryShaderPassthrough = supportsGeometryShaderPassthrough;

Ryujinx.Graphics.GAL/Format.cs

@@ -448,6 +448,27 @@ namespace Ryujinx.Graphics.GAL
             return false;
         }
 
+        /// <summary>
+        /// Checks if the texture format is 16 bit packed.
+        /// </summary>
+        /// <param name="format">Texture format</param>
+        /// <returns>True if the texture format is 16 bit packed, false otherwise</returns>
+        public static bool Is16BitPacked(this Format format)
+        {
+            switch (format)
+            {
+                case Format.B5G6R5Unorm:
+                case Format.B5G5R5A1Unorm:
+                case Format.R5G5B5X1Unorm:
+                case Format.R5G5B5A1Unorm:
+                case Format.R5G6B5Unorm:
+                case Format.R4G4B4A4Unorm:
+                    return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Checks if the texture format is an ASTC format.
         /// </summary>

Ryujinx.Graphics.Gpu/Engine/InlineToMemory/InlineToMemoryClass.cs

@@ -100,7 +100,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.InlineToMemory
             _isLinear = (argument & 1) != 0;
 
             _offset = 0;
-            _size = (int)(BitUtils.AlignUp(state.LineLengthIn, 4) * state.LineCount);
+            _size = (int)(BitUtils.AlignUp<uint>(state.LineLengthIn, 4) * state.LineCount);
 
             int count = _size / 4;
 

Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -911,7 +911,40 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
             else if (!_context.Capabilities.SupportsR4G4Format && Format == Format.R4G4Unorm)
             {
-                result = PixelConverter.ConvertR4G4ToR4G4B4A4(result);
+                result = PixelConverter.ConvertR4G4ToR4G4B4A4(result, width);
+
+                if (!_context.Capabilities.SupportsR4G4B4A4Format)
+                {
+                    result = PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result, width);
+                }
+            }
+            else if (Format == Format.R4G4B4A4Unorm)
+            {
+                if (!_context.Capabilities.SupportsR4G4B4A4Format)
+                {
+                    result = PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result, width);
+                }
+            }
+            else if (!_context.Capabilities.Supports5BitComponentFormat && Format.Is16BitPacked())
+            {
+                switch (Format)
+                {
+                    case Format.B5G6R5Unorm:
+                    case Format.R5G6B5Unorm:
+                        result = PixelConverter.ConvertR5G6B5ToR8G8B8A8(result, width);
+                        break;
+                    case Format.B5G5R5A1Unorm:
+                    case Format.R5G5B5X1Unorm:
+                    case Format.R5G5B5A1Unorm:
+                        result = PixelConverter.ConvertR5G5B5ToR8G8B8A8(result, width, Format == Format.R5G5B5X1Unorm);
+                        break;
+                    case Format.A1B5G5R5Unorm:
+                        result = PixelConverter.ConvertA1B5G5R5ToR8G8B8A8(result, width);
+                        break;
+                    case Format.R4G4B4A4Unorm:
+                        result = PixelConverter.ConvertR4G4B4A4ToR8G8B8A8(result, width);
+                        break;
+                }
             }
 
             return result;

Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs

@@ -132,7 +132,26 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             if (!caps.SupportsR4G4Format && info.FormatInfo.Format == Format.R4G4Unorm)
             {
-                return new FormatInfo(Format.R4G4B4A4Unorm, 1, 1, 2, 4);
+                if (caps.SupportsR4G4B4A4Format)
+                {
+                    return new FormatInfo(Format.R4G4B4A4Unorm, 1, 1, 2, 4);
+                }
+                else
+                {
+                    return new FormatInfo(Format.R8G8B8A8Unorm, 1, 1, 4, 4);
+                }
+            }
+
+            if (info.FormatInfo.Format == Format.R4G4B4A4Unorm)
+            {
+                if (!caps.SupportsR4G4B4A4Format)
+                {
+                    return new FormatInfo(Format.R8G8B8A8Unorm, 1, 1, 4, 4);
+                }
+            }
+            else if (!caps.Supports5BitComponentFormat && info.FormatInfo.Format.Is16BitPacked())
+            {
+                return new FormatInfo(info.FormatInfo.Format.IsBgr() ? Format.B8G8R8A8Unorm : Format.R8G8B8A8Unorm, 1, 1, 4, 4);
             }
 
             return info.FormatInfo;

Ryujinx.Graphics.Gpu/Memory/BufferManager.cs

@@ -252,7 +252,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
             RecordStorageAlignment(_cpStorageBuffers, index, gpuVa);
 
-            gpuVa = BitUtils.AlignDown(gpuVa, _context.Capabilities.StorageBufferOffsetAlignment);
+            gpuVa = BitUtils.AlignDown<ulong>(gpuVa, (ulong)_context.Capabilities.StorageBufferOffsetAlignment);
 
             ulong address = _channel.MemoryManager.Physical.BufferCache.TranslateAndCreateBuffer(_channel.MemoryManager, gpuVa, size);
 
@@ -276,7 +276,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
 
             RecordStorageAlignment(buffers, index, gpuVa);
 
-            gpuVa = BitUtils.AlignDown(gpuVa, _context.Capabilities.StorageBufferOffsetAlignment);
+            gpuVa = BitUtils.AlignDown<ulong>(gpuVa, (ulong)_context.Capabilities.StorageBufferOffsetAlignment);
 
             ulong address = _channel.MemoryManager.Physical.BufferCache.TranslateAndCreateBuffer(_channel.MemoryManager, gpuVa, size);
 

Ryujinx.Graphics.OpenGL/OpenGLRenderer.cs

@@ -114,7 +114,9 @@ namespace Ryujinx.Graphics.OpenGL
                 supports3DTextureCompression: false,
                 supportsBgraFormat: false,
                 supportsR4G4Format: false,
+                supportsR4G4B4A4Format: true,
                 supportsSnormBufferTextureFormat: false,
+                supports5BitComponentFormat: true,
                 supportsFragmentShaderInterlock: HwCapabilities.SupportsFragmentShaderInterlock,
                 supportsFragmentShaderOrderingIntel: HwCapabilities.SupportsFragmentShaderOrdering,
                 supportsGeometryShaderPassthrough: HwCapabilities.SupportsGeometryShaderPassthrough,

Ryujinx.Graphics.Texture/LayoutConverter.cs

@@ -7,7 +7,7 @@ namespace Ryujinx.Graphics.Texture
 {
     public static class LayoutConverter
     {
-        private const int HostStrideAlignment = 4;
+        public const int HostStrideAlignment = 4;
 
         public static void ConvertBlockLinearToLinear(
             Span<byte> dst,

Ryujinx.Graphics.Texture/PixelConverter.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common;
 using System;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
@@ -7,30 +8,206 @@ namespace Ryujinx.Graphics.Texture
 {
     public static class PixelConverter
     {
-        public unsafe static byte[] ConvertR4G4ToR4G4B4A4(ReadOnlySpan<byte> data)
+        private static (int remainder, int outRemainder, int height) GetLineRemainders(int length, int width, int bpp, int outBpp)
+        {
+            int stride = BitUtils.AlignUp(width * bpp, LayoutConverter.HostStrideAlignment);
+            int remainder = stride / bpp - width;
+
+            int outStride = BitUtils.AlignUp(width * outBpp, LayoutConverter.HostStrideAlignment);
+            int outRemainder = outStride / outBpp - width;
+
+            return (remainder, outRemainder, length / stride);
+        }
+
+        public unsafe static byte[] ConvertR4G4ToR4G4B4A4(ReadOnlySpan<byte> data, int width)
         {
             byte[] output = new byte[data.Length * 2];
-            int start = 0;
 
-            if (Sse41.IsSupported)
-            {
-                int sizeTrunc = data.Length & ~7;
-                start = sizeTrunc;
-
-                fixed (byte* inputPtr = data, outputPtr = output)
-                {
-                    for (ulong offset = 0; offset < (ulong)sizeTrunc; offset += 8)
-                    {
-                        Sse2.Store(outputPtr + offset * 2, Sse41.ConvertToVector128Int16(inputPtr + offset).AsByte());
-                    }
-                }
-            }
+            (int remainder, int outRemainder, int height) = GetLineRemainders(data.Length, width, 1, 2);
 
             Span<ushort> outputSpan = MemoryMarshal.Cast<byte, ushort>(output);
 
-            for (int i = start; i < data.Length; i++)
+            if (remainder == 0)
             {
-                outputSpan[i] = (ushort)data[i];
+                int start = 0;
+
+                if (Sse41.IsSupported)
+                {
+                    int sizeTrunc = data.Length & ~7;
+                    start = sizeTrunc;
+
+                    fixed (byte* inputPtr = data, outputPtr = output)
+                    {
+                        for (ulong offset = 0; offset < (ulong)sizeTrunc; offset += 8)
+                        {
+                            Sse2.Store(outputPtr + offset * 2, Sse41.ConvertToVector128Int16(inputPtr + offset).AsByte());
+                        }
+                    }
+                }
+
+                for (int i = start; i < data.Length; i++)
+                {
+                    outputSpan[i] = (ushort)data[i];
+                }
+            }
+            else
+            {
+                int offset = 0;
+                int outOffset = 0;
+
+                for (int y = 0; y < height; y++)
+                {
+                    for (int x = 0; x < width; x++)
+                    {
+                        outputSpan[outOffset++] = data[offset++];
+                    }
+
+                    offset += remainder;
+                    outOffset += outRemainder;
+                }
+            }
+
+            return output;
+        }
+
+        public unsafe static byte[] ConvertR5G6B5ToR8G8B8A8(ReadOnlySpan<byte> data, int width)
+        {
+            byte[] output = new byte[data.Length * 2];
+            int offset = 0;
+            int outOffset = 0;
+
+            (int remainder, int outRemainder, int height) = GetLineRemainders(data.Length, width, 2, 4);
+
+            ReadOnlySpan<ushort> inputSpan = MemoryMarshal.Cast<byte, ushort>(data);
+            Span<uint> outputSpan = MemoryMarshal.Cast<byte, uint>(output);
+
+            for (int y = 0; y < height; y++)
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    uint packed = inputSpan[offset++];
+
+                    uint outputPacked =  0xff000000;
+                         outputPacked |= (packed << 3) & 0x000000f8;
+                         outputPacked |= (packed << 8) & 0x00f80000;
+
+                    // Replicate 5 bit components.
+                    outputPacked |= (outputPacked >> 5) & 0x00070007;
+
+                    // Include and replicate 6 bit component.
+                    outputPacked |= ((packed << 5) & 0x0000fc00) | ((packed >> 1) & 0x00000300);
+
+                    outputSpan[outOffset++] = outputPacked;
+                }
+
+                offset += remainder;
+                outOffset += outRemainder;
+            }
+
+            return output;
+        }
+
+        public unsafe static byte[] ConvertR5G5B5ToR8G8B8A8(ReadOnlySpan<byte> data, int width, bool forceAlpha)
+        {
+            byte[] output = new byte[data.Length * 2];
+            int offset = 0;
+            int outOffset = 0;
+
+            (int remainder, int outRemainder, int height) = GetLineRemainders(data.Length, width, 2, 4);
+
+            ReadOnlySpan<ushort> inputSpan = MemoryMarshal.Cast<byte, ushort>(data);
+            Span<uint> outputSpan = MemoryMarshal.Cast<byte, uint>(output);
+
+            for (int y = 0; y < height; y++)
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    uint packed = inputSpan[offset++];
+
+                    uint a = forceAlpha ? 1 : (packed >> 15);
+
+                    uint outputPacked =  a * 0xff000000;
+                         outputPacked |= (packed << 3) & 0x000000f8;
+                         outputPacked |= (packed << 6) & 0x0000f800;
+                         outputPacked |= (packed << 9) & 0x00f80000;
+
+                    // Replicate 5 bit components.
+                    outputPacked |= (outputPacked >> 5) & 0x00070707;
+
+                    outputSpan[outOffset++] = outputPacked;
+                }
+
+                offset += remainder;
+                outOffset += outRemainder;
+            }
+
+            return output;
+        }
+
+        public unsafe static byte[] ConvertA1B5G5R5ToR8G8B8A8(ReadOnlySpan<byte> data, int width)
+        {
+            byte[] output = new byte[data.Length * 2];
+            int offset = 0;
+            int outOffset = 0;
+
+            (int remainder, int outRemainder, int height) = GetLineRemainders(data.Length, width, 2, 4);
+
+            ReadOnlySpan<ushort> inputSpan = MemoryMarshal.Cast<byte, ushort>(data);
+            Span<uint> outputSpan = MemoryMarshal.Cast<byte, uint>(output);
+
+            for (int y = 0; y < height; y++)
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    uint packed = inputSpan[offset++];
+
+                    uint a = packed >> 15;
+
+                    uint outputPacked = a * 0xff000000;
+                    outputPacked |= (packed >> 8) & 0x000000f8;
+                    outputPacked |= (packed << 5) & 0x0000f800;
+                    outputPacked |= (packed << 18) & 0x00f80000;
+
+                    // Replicate 5 bit components.
+                    outputPacked |= (outputPacked >> 5) & 0x00070707;
+
+                    outputSpan[outOffset++] = outputPacked;
+                }
+
+                offset += remainder;
+                outOffset += outRemainder;
+            }
+
+            return output;
+        }
+
+        public unsafe static byte[] ConvertR4G4B4A4ToR8G8B8A8(ReadOnlySpan<byte> data, int width)
+        {
+            byte[] output = new byte[data.Length * 2];
+            int offset = 0;
+            int outOffset = 0;
+
+            (int remainder, int outRemainder, int height) = GetLineRemainders(data.Length, width, 2, 4);
+
+            ReadOnlySpan<ushort> inputSpan = MemoryMarshal.Cast<byte, ushort>(data);
+            Span<uint> outputSpan = MemoryMarshal.Cast<byte, uint>(output);
+
+            for (int y = 0; y < height; y++)
+            {
+                for (int x = 0; x < width; x++)
+                {
+                    uint packed = inputSpan[offset++];
+
+                    uint outputPacked =  packed         & 0x0000000f;
+                         outputPacked |= (packed << 4)  & 0x00000f00;
+                         outputPacked |= (packed << 8)  & 0x000f0000;
+                         outputPacked |= (packed << 12) & 0x0f000000;
+
+                    outputSpan[outOffset++] = outputPacked * 0x11;
+                }
+
+                offset += remainder;
+                outOffset += outRemainder;
             }
 
             return output;

Ryujinx.Graphics.Vulkan/MemoryAllocatorBlockList.cs

@@ -53,7 +53,7 @@ namespace Ryujinx.Graphics.Vulkan
                 {
                     var range = _freeRanges[i];
 
-                    ulong alignedOffset = BitUtils.AlignUp(range.Offset, (int)alignment);
+                    ulong alignedOffset = BitUtils.AlignUp<ulong>(range.Offset, alignment);
                     ulong sizeDelta = alignedOffset - range.Offset;
                     ulong usableSize = range.Size - sizeDelta;
 
@@ -196,7 +196,7 @@ namespace Ryujinx.Graphics.Vulkan
                 }
             }
 
-            ulong blockAlignedSize = BitUtils.AlignUp(size, _blockAlignment);
+            ulong blockAlignedSize = BitUtils.AlignUp<ulong>(size, (ulong)_blockAlignment);
 
             var memoryAllocateInfo = new MemoryAllocateInfo()
             {

Ryujinx.Graphics.Vulkan/VulkanRenderer.cs

@@ -396,6 +396,17 @@ namespace Ryujinx.Graphics.Vulkan
                 GAL.Format.Etc2RgbSrgb,
                 GAL.Format.Etc2RgbUnorm);
 
+            bool supports5BitComponentFormat = FormatCapabilities.OptimalFormatsSupport(compressedFormatFeatureFlags,
+                GAL.Format.R5G6B5Unorm,
+                GAL.Format.R5G5B5A1Unorm,
+                GAL.Format.R5G5B5X1Unorm,
+                GAL.Format.B5G6R5Unorm,
+                GAL.Format.B5G5R5A1Unorm,
+                GAL.Format.A1B5G5R5Unorm);
+
+            bool supportsR4G4B4A4Format = FormatCapabilities.OptimalFormatsSupport(compressedFormatFeatureFlags,
+                GAL.Format.R4G4B4A4Unorm);
+
             PhysicalDeviceVulkan12Features featuresVk12 = new PhysicalDeviceVulkan12Features()
             {
                 SType = StructureType.PhysicalDeviceVulkan12Features
@@ -425,7 +436,9 @@ namespace Ryujinx.Graphics.Vulkan
                 supports3DTextureCompression: true,
                 supportsBgraFormat: true,
                 supportsR4G4Format: false,
+                supportsR4G4B4A4Format: supportsR4G4B4A4Format,
                 supportsSnormBufferTextureFormat: true,
+                supports5BitComponentFormat: supports5BitComponentFormat,
                 supportsFragmentShaderInterlock: Capabilities.SupportsFragmentShaderInterlock,
                 supportsFragmentShaderOrderingIntel: false,
                 supportsGeometryShaderPassthrough: Capabilities.SupportsGeometryShaderPassthrough,

Ryujinx.HLE/HOS/Kernel/Ipc/KBufferDescriptorTable.cs

@@ -81,8 +81,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Ipc
                     attributeMask |= MemoryAttribute.DeviceMapped;
                 }
 
-                ulong clientAddrTruncated = BitUtils.AlignDown(desc.ClientAddress, KPageTableBase.PageSize);
-                ulong clientAddrRounded   = BitUtils.AlignUp  (desc.ClientAddress, KPageTableBase.PageSize);
+                ulong clientAddrTruncated = BitUtils.AlignDown<ulong>(desc.ClientAddress, KPageTableBase.PageSize);
+                ulong clientAddrRounded   = BitUtils.AlignUp<ulong>(desc.ClientAddress, KPageTableBase.PageSize);
 
                 // Check if address is not aligned, in this case we need to perform 2 copies.
                 if (clientAddrTruncated != clientAddrRounded)
@@ -113,9 +113,9 @@ namespace Ryujinx.HLE.HOS.Kernel.Ipc
                 ulong clientEndAddr = desc.ClientAddress + desc.Size;
                 ulong serverEndAddr = desc.ServerAddress + desc.Size;
 
-                ulong clientEndAddrTruncated = BitUtils.AlignDown(clientEndAddr, KPageTableBase.PageSize);
-                ulong clientEndAddrRounded   = BitUtils.AlignUp  (clientEndAddr, KPageTableBase.PageSize);
-                ulong serverEndAddrTruncated = BitUtils.AlignDown(serverEndAddr, KPageTableBase.PageSize);
+                ulong clientEndAddrTruncated = BitUtils.AlignDown<ulong>(clientEndAddr, (ulong)KPageTableBase.PageSize);
+                ulong clientEndAddrRounded   = BitUtils.AlignUp<ulong>(clientEndAddr, KPageTableBase.PageSize);
+                ulong serverEndAddrTruncated = BitUtils.AlignDown<ulong>(serverEndAddr, (ulong)KPageTableBase.PageSize);
 
                 if (clientEndAddrTruncated < clientEndAddrRounded &&
                     (clientAddrTruncated == clientAddrRounded || clientAddrTruncated < clientEndAddrTruncated))

Ryujinx.HLE/HOS/Kernel/Ipc/KServerSession.cs

@@ -1005,7 +1005,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Ipc
                     recvListEndAddr = recvListBaseAddr + size;
                 }
 
-                recvListBufferAddress = BitUtils.AlignUp(recvListBaseAddr + dstOffset, 0x10);
+                recvListBufferAddress = BitUtils.AlignUp<ulong>(recvListBaseAddr + dstOffset, 0x10);
 
                 ulong endAddress = recvListBufferAddress + descriptor.BufferSize;
 

Ryujinx.HLE/HOS/Kernel/Memory/KCodeMemory.cs

@@ -44,7 +44,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
         public KernelResult Map(ulong address, ulong size, KMemoryPermission perm)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, (ulong)KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }
@@ -73,7 +73,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
         public KernelResult MapToOwner(ulong address, ulong size, KMemoryPermission permission)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, (ulong)KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }
@@ -102,7 +102,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
         public KernelResult Unmap(ulong address, ulong size)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, (ulong)KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }
@@ -128,7 +128,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
         public KernelResult UnmapFromOwner(ulong address, ulong size)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }

Ryujinx.HLE/HOS/Kernel/Memory/KPageBitmap.cs

@@ -101,7 +101,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
             for (int depth = HighestDepthIndex; depth >= 0; depth--)
             {
                 _bitStorages[depth] = storage;
-                size = BitUtils.DivRoundUp(size, UInt64BitSize);
+                size = BitUtils.DivRoundUp<ulong>(size, (ulong)UInt64BitSize);
                 storage = storage.Slice((int)size);
             }
 
@@ -288,7 +288,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
             for (int depth = GetRequiredDepth(regionSize) - 1; depth >= 0; depth--)
             {
-                regionSize = BitUtils.DivRoundUp(regionSize, UInt64BitSize);
+                regionSize = BitUtils.DivRoundUp<ulong>(regionSize, UInt64BitSize);
                 overheadBits += (int)regionSize;
             }
 

Ryujinx.HLE/HOS/Kernel/Memory/KPageHeap.cs

@@ -48,7 +48,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                 {
                     int diff = 1 << (NextShift - Shift);
 
-                    offset = BitUtils.AlignDown(offset, diff);
+                    offset = BitUtils.AlignDown(offset, (ulong)diff);
 
                     if (_bitmap.ClearRange(offset, diff))
                     {

Ryujinx.HLE/HOS/Kernel/Memory/KPageTableBase.cs

@@ -203,8 +203,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                     heapRegion.Size = 0x180000000;
                     stackRegion.Size = 0x80000000;
                     tlsIoRegion.Size = 0x1000000000;
-                    CodeRegionStart = BitUtils.AlignDown(address, 0x200000);
-                    codeRegionSize = BitUtils.AlignUp(endAddr, 0x200000) - CodeRegionStart;
+                    CodeRegionStart = BitUtils.AlignDown<ulong>(address, 0x200000);
+                    codeRegionSize = BitUtils.AlignUp<ulong>(endAddr, 0x200000) - CodeRegionStart;
                     stackAndTlsIoStart = 0;
                     stackAndTlsIoEnd = 0;
                     baseAddress = 0x8000000;
@@ -1584,8 +1584,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                         return KernelResult.OutOfResource;
                     }
 
-                    ulong srcMapAddress = BitUtils.AlignUp(src, PageSize);
-                    ulong srcMapEndAddr = BitUtils.AlignDown(src + size, PageSize);
+                    ulong srcMapAddress = BitUtils.AlignUp<ulong>(src, PageSize);
+                    ulong srcMapEndAddr = BitUtils.AlignDown<ulong>(src + size, PageSize);
                     ulong srcMapSize = srcMapEndAddr - srcMapAddress;
 
                     result = MapPagesFromClientProcess(size, src, permission, state, srcPageTable, send, out ulong va);
@@ -1659,10 +1659,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                 attributeMask |= MemoryAttribute.DeviceMapped;
             }
 
-            ulong addressRounded = BitUtils.AlignUp(address, PageSize);
-            ulong addressTruncated = BitUtils.AlignDown(address, PageSize);
-            ulong endAddrRounded = BitUtils.AlignUp(endAddr, PageSize);
-            ulong endAddrTruncated = BitUtils.AlignDown(endAddr, PageSize);
+            ulong addressRounded = BitUtils.AlignUp<ulong>(address, PageSize);
+            ulong addressTruncated = BitUtils.AlignDown<ulong>(address, PageSize);
+            ulong endAddrRounded = BitUtils.AlignUp<ulong>(endAddr, PageSize);
+            ulong endAddrTruncated = BitUtils.AlignDown<ulong>(endAddr, PageSize);
 
             if (!_slabManager.CanAllocate(MaxBlocksNeededForInsertion))
             {
@@ -1769,10 +1769,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
             ulong endAddr = address + size;
 
-            ulong addressTruncated = BitUtils.AlignDown(address, PageSize);
-            ulong addressRounded = BitUtils.AlignUp(address, PageSize);
-            ulong endAddrTruncated = BitUtils.AlignDown(endAddr, PageSize);
-            ulong endAddrRounded = BitUtils.AlignUp(endAddr, PageSize);
+            ulong addressTruncated = BitUtils.AlignDown<ulong>(address, PageSize);
+            ulong addressRounded = BitUtils.AlignUp<ulong>(address, PageSize);
+            ulong endAddrTruncated = BitUtils.AlignDown<ulong>(endAddr, PageSize);
+            ulong endAddrRounded = BitUtils.AlignUp<ulong>(endAddr, PageSize);
 
             ulong neededSize = endAddrRounded - addressTruncated;
 
@@ -1983,10 +1983,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
                         return KernelResult.OutOfResource;
                     }
 
-                    ulong addressTruncated = BitUtils.AlignDown(address, PageSize);
-                    ulong addressRounded = BitUtils.AlignUp(address, PageSize);
-                    ulong endAddrTruncated = BitUtils.AlignDown(endAddr, PageSize);
-                    ulong endAddrRounded = BitUtils.AlignUp(endAddr, PageSize);
+                    ulong addressTruncated = BitUtils.AlignDown<ulong>(address, PageSize);
+                    ulong addressRounded = BitUtils.AlignUp<ulong>(address, PageSize);
+                    ulong endAddrTruncated = BitUtils.AlignDown<ulong>(endAddr, PageSize);
+                    ulong endAddrRounded = BitUtils.AlignUp<ulong>(endAddr, PageSize);
 
                     ulong pagesCount = (endAddrRounded - addressTruncated) / PageSize;
 
@@ -2010,10 +2010,10 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
         {
             ulong endAddr = address + size;
 
-            ulong addressRounded = BitUtils.AlignUp(address, PageSize);
-            ulong addressTruncated = BitUtils.AlignDown(address, PageSize);
-            ulong endAddrRounded = BitUtils.AlignUp(endAddr, PageSize);
-            ulong endAddrTruncated = BitUtils.AlignDown(endAddr, PageSize);
+            ulong addressRounded = BitUtils.AlignUp<ulong>(address, PageSize);
+            ulong addressTruncated = BitUtils.AlignDown<ulong>(address, PageSize);
+            ulong endAddrRounded = BitUtils.AlignUp<ulong>(endAddr, PageSize);
+            ulong endAddrTruncated = BitUtils.AlignDown<ulong>(endAddr, PageSize);
 
             ulong pagesCount = addressRounded < endAddrTruncated ? (endAddrTruncated - addressRounded) / PageSize : 0;
 
@@ -2540,7 +2540,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
                 for (int attempt = 0; attempt < 8; attempt++)
                 {
-                    ulong aslrAddress = BitUtils.AlignDown(regionStart + GetRandomValue(0, aslrMaxOffset) * (ulong)alignment, alignment);
+                    ulong aslrAddress = BitUtils.AlignDown(regionStart + GetRandomValue(0, aslrMaxOffset) * (ulong)alignment, (ulong)alignment);
                     ulong aslrEndAddr = aslrAddress + totalNeededSize;
 
                     KMemoryInfo info = _blockManager.FindBlock(aslrAddress).GetInfo();
@@ -2618,7 +2618,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
                     currBaseAddr += reservedSize;
 
-                    ulong address = BitUtils.AlignDown(currBaseAddr, alignment) + reservedStart;
+                    ulong address = BitUtils.AlignDown<ulong>(currBaseAddr, (ulong)alignment) + reservedStart;
 
                     if (currBaseAddr > address)
                     {
@@ -2834,7 +2834,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
         {
             lock (_blockManager)
             {
-                return BitUtils.DivRoundUp(GetMmUsedSize(), PageSize);
+                return BitUtils.DivRoundUp<ulong>(GetMmUsedSize(), PageSize);
             }
         }
 

Ryujinx.HLE/HOS/Kernel/Memory/KSharedMemory.cs

@@ -33,7 +33,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
             KProcess process,
             KMemoryPermission permission)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }
@@ -52,7 +52,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
         public KernelResult UnmapFromProcess(KPageTableBase memoryManager, ulong address, ulong size, KProcess process)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }

Ryujinx.HLE/HOS/Kernel/Memory/KTransferMemory.cs

@@ -67,7 +67,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
             KProcess process,
             KMemoryPermission permission)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }
@@ -95,7 +95,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
             ulong size,
             KProcess process)
         {
-            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize))
+            if (_pageList.GetPagesCount() != BitUtils.DivRoundUp<ulong>(size, (ulong)KPageTableBase.PageSize))
             {
                 return KernelResult.InvalidSize;
             }

Ryujinx.HLE/HOS/Kernel/Process/KProcess.cs

@@ -472,7 +472,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
 
         public KernelResult FreeThreadLocalStorage(ulong tlsSlotAddr)
         {
-            ulong tlsPageAddr = BitUtils.AlignDown(tlsSlotAddr, KPageTableBase.PageSize);
+            ulong tlsPageAddr = BitUtils.AlignDown<ulong>(tlsSlotAddr, KPageTableBase.PageSize);
 
             KernelContext.CriticalSection.Enter();
 
@@ -554,7 +554,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Process
                     throw new InvalidOperationException("Trying to start a process with a invalid state!");
                 }
 
-                ulong stackSizeRounded = BitUtils.AlignUp(stackSize, KPageTableBase.PageSize);
+                ulong stackSizeRounded = BitUtils.AlignUp<ulong>(stackSize, KPageTableBase.PageSize);
 
                 ulong neededSize = stackSizeRounded + _imageSize;
 

Ryujinx.HLE/HOS/ProgramLoader.cs

@@ -47,7 +47,7 @@ namespace Ryujinx.HLE.HOS
                 endOffset = kip.BssOffset + kip.BssSize;
             }
 
-            uint codeSize = BitUtils.AlignUp(kip.TextOffset + endOffset, KPageTableBase.PageSize);
+            uint codeSize = BitUtils.AlignUp<uint>(kip.TextOffset + endOffset, KPageTableBase.PageSize);
 
             int codePagesCount = (int)(codeSize / KPageTableBase.PageSize);
 
@@ -195,7 +195,7 @@ namespace Ryujinx.HLE.HOS
                     nsoSize = dataEnd;
                 }
 
-                nsoSize = BitUtils.AlignUp(nsoSize, KPageTableBase.PageSize);
+                nsoSize = BitUtils.AlignUp<uint>(nsoSize, KPageTableBase.PageSize);
 
                 nsoBase[index] = codeStart + (ulong)codeSize;
 
@@ -349,7 +349,7 @@ namespace Ryujinx.HLE.HOS
                     return KernelResult.Success;
                 }
 
-                size = BitUtils.AlignUp(size, KPageTableBase.PageSize);
+                size = BitUtils.AlignUp<ulong>(size, KPageTableBase.PageSize);
 
                 return process.MemoryManager.SetProcessMemoryPermission(address, size, permission);
             }

Ryujinx.HLE/HOS/Services/Ro/IRoInterface.cs

@@ -321,7 +321,7 @@ namespace Ryujinx.HLE.HOS.Services.Ro
 
             ulong bssStart = dataStart + (ulong)relocatableObject.Data.Length;
 
-            ulong bssEnd = BitUtils.AlignUp(bssStart + (ulong)relocatableObject.BssSize, KPageTableBase.PageSize);
+            ulong bssEnd = BitUtils.AlignUp<ulong>(bssStart + relocatableObject.BssSize, KPageTableBase.PageSize);
 
             process.CpuMemory.Write(textStart, relocatableObject.Text);
             process.CpuMemory.Write(roStart,   relocatableObject.Ro);

Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs

@@ -530,7 +530,14 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
 
                     receiveRegion.Dispose();
 
-                    context.Memory.Write(sockAddrOutPosition, BsdSockAddr.FromIPEndPoint(endPoint));
+                    if (sockAddrOutSize != 0 && sockAddrOutSize >= (ulong) Unsafe.SizeOf<BsdSockAddr>())
+                    {
+                        context.Memory.Write(sockAddrOutPosition, BsdSockAddr.FromIPEndPoint(endPoint));
+                    }
+                    else
+                    {
+                        errno = LinuxError.ENOMEM;
+                    }
                 }
             }
 

Ryujinx.HLE/HOS/Services/SurfaceFlinger/Parcel.cs

@@ -36,7 +36,7 @@ namespace Ryujinx.HLE.HOS.Services.SurfaceFlinger
         {
             uint headerSize = (uint)Unsafe.SizeOf<ParcelHeader>();
 
-            _rawData = new byte[BitUtils.AlignUp(headerSize + payloadSize + objectsSize, 4)];
+            _rawData = new byte[BitUtils.AlignUp<uint>(headerSize + payloadSize + objectsSize, 4)];
 
             Header.PayloadSize   = payloadSize;
             Header.ObjectsSize   = objectsSize;