Implement ASTC decoding for KTX1

Author: Erik-White

src/ImageSharp.Textures/Common/Helpers/FloatHelper.cs

@@ -3,70 +3,85 @@
 
 using System.Runtime.CompilerServices;
 
-namespace SixLabors.ImageSharp.Textures.Common.Helpers
+namespace SixLabors.ImageSharp.Textures.Common.Helpers;
+
+internal static class FloatHelper
 {
-    internal static class FloatHelper
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float UnpackFloat32ToFloat(uint value) => Unsafe.As<uint, float>(ref value);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float UnpackFloat32ToFloat(uint value) => Unsafe.As<uint, float>(ref value);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint PackFloatToFloat32(float value) => Unsafe.As<float, uint>(ref value);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint PackFloatToFloat32(float value) => Unsafe.As<float, uint>(ref value);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float UnpackFloat16ToFloat(uint value)
-        {
-            uint result =
-                ((value >> 15) << 31) |
-                ((((value >> 10) & 0x1f) - 15 + 127) << 23) |
-                ((value & 0x3ff) << 13);
-            return Unsafe.As<uint, float>(ref result);
-        }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float UnpackFloat16ToFloat(uint value) => (float)BitConverter.UInt16BitsToHalf((ushort)value);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint PackFloatToFloat16(float value)
-        {
-            uint temp = Unsafe.As<float, uint>(ref value);
-            return
-                ((temp >> 31) << 15) |
-                ((((temp >> 23) & 0xff) - 127 + 15) << 10) |
-                ((temp & 0x7fffff) >> 13);
-        }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint PackFloatToFloat16(float value) => BitConverter.HalfToUInt16Bits((Half)value);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float UnpackFloat10ToFloat(uint value)
-        {
-            uint result =
-                ((((value >> 5) & 0x1f) - 10 + 127) << 23) |
-                ((value & 0x1f) << 18);
-            return Unsafe.As<uint, float>(ref result);
-        }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float UnpackFloat10ToFloat(uint value, uint bias = 10)
+    {
+        uint e = (value >> 5) & 0x1Fu;
+        uint m = value & 0x1Fu;
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint PackFloatToFloat10(float value)
+        return e switch
         {
-            uint temp = Unsafe.As<float, uint>(ref value);
-            return
-                ((((temp >> 23) & 0xff) - 127 + 10) << 5) |
-                ((temp & 0x7fffff) >> 18);
-        }
+            // Zero
+            0 when m == 0 => 0f,
+
+            // Denormalized
+            0 => m * BitConverter.UInt32BitsToSingle((128u - bias - 5u) << 23),
+
+            // Inf/NaN
+            31 => BitConverter.UInt32BitsToSingle((0xFFu << 23) | (m << 18)),
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float UnpackFloat11ToFloat(uint value)
+            // Normalized
+            _ => BitConverter.UInt32BitsToSingle(((e + 127u - bias) << 23) | (m << 18)),
+        };
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint PackFloatToFloat10(float value)
+    {
+        uint temp = Unsafe.As<float, uint>(ref value);
+        return
+            ((((temp >> 23) & 0xff) - 127 + 10) << 5) |
+            ((temp & 0x7fffff) >> 18);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static float UnpackFloat11ToFloat(uint value, uint bias = 11)
+    {
+        uint e = (value >> 6) & 0x1Fu;
+        uint m = value & 0x3Fu;
+
+        if (e == 0)
         {
-            uint result =
-                ((((value >> 6) & 0x1f) - 11 + 127) << 23) |
-                ((value & 0x3f) << 17);
-            return Unsafe.As<uint, float>(ref result);
+            if (m == 0)
+            {
+                return 0f;
+            }
+
+            // Denormalized: m * 2^(1 - bias - 6)
+            return m * BitConverter.UInt32BitsToSingle((128u - bias - 6u) << 23);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint PackFloatToFloat11(float value)
+        if (e == 31)
         {
-            uint temp = Unsafe.As<float, uint>(ref value);
-            return
-                ((((temp >> 23) & 0xff) - 127 + 11) << 6) |
-                ((temp & 0x7fffff) >> 17);
+            uint ieee = (0xFFu << 23) | (m << 17);
+            return BitConverter.UInt32BitsToSingle(ieee);
         }
+
+        return BitConverter.UInt32BitsToSingle(((e + 127u - bias) << 23) | (m << 17));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static uint PackFloatToFloat11(float value)
+    {
+        uint temp = Unsafe.As<float, uint>(ref value);
+        return
+            ((((temp >> 23) & 0xff) - 127 + 11) << 6) |
+            ((temp & 0x7fffff) >> 17);
     }
 }

src/ImageSharp.Textures/Formats/Ktx/EndianHandler.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers.Binary;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Textures.Common.Exceptions;
+
+namespace SixLabors.ImageSharp.Textures.Formats.Ktx;
+
+/// <summary>
+/// Handles endianness conversions for KTX texture data. Reads header fields using the file's
+/// declared endianness and optionally swaps pixel bytes when the file and host disagree.
+/// </summary>
+internal sealed class EndianHandler
+{
+    private readonly bool isFileLittleEndian;
+    private readonly bool swapPixelData;
+
+    public EndianHandler(bool isFileLittleEndian)
+    {
+        this.isFileLittleEndian = isFileLittleEndian;
+        this.swapPixelData = isFileLittleEndian != BitConverter.IsLittleEndian;
+    }
+
+    public uint ReadUInt32(ReadOnlySpan<byte> buffer)
+        => this.isFileLittleEndian
+            ? BinaryPrimitives.ReadUInt32LittleEndian(buffer)
+            : BinaryPrimitives.ReadUInt32BigEndian(buffer);
+
+    public void ConvertPixelData(Span<byte> data, uint typeSize)
+    {
+        if (!this.swapPixelData)
+        {
+            return;
+        }
+
+        if (typeSize == 2)
+        {
+            if (data.Length % 2 != 0)
+            {
+                throw new TextureFormatException("Pixel data length is not a multiple of 2 for a 16-bit typed format");
+            }
+
+            BinaryPrimitives.ReverseEndianness(MemoryMarshal.Cast<byte, ushort>(data), MemoryMarshal.Cast<byte, ushort>(data));
+        }
+        else if (typeSize == 4)
+        {
+            if (data.Length % 4 != 0)
+            {
+                throw new TextureFormatException("Pixel data length is not a multiple of 4 for a 32-bit typed format");
+            }
+
+            BinaryPrimitives.ReverseEndianness(MemoryMarshal.Cast<byte, uint>(data), MemoryMarshal.Cast<byte, uint>(data));
+        }
+    }
+}