Add HDR support

Author: Erik-White

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

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System;
 using System.Runtime.CompilerServices;
 
 namespace SixLabors.ImageSharp.Textures.Common.Helpers
@@ -14,32 +15,31 @@ internal static class FloatHelper
         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);
-        }
+        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);
-        }
+        public static uint PackFloatToFloat16(float value) => BitConverter.HalfToUInt16Bits((Half)value);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float UnpackFloat10ToFloat(uint value)
+        public static float UnpackFloat10ToFloat(uint value, uint bias = 10)
         {
-            uint result =
-                ((((value >> 5) & 0x1f) - 10 + 127) << 23) |
-                ((value & 0x1f) << 18);
-            return Unsafe.As<uint, float>(ref result);
+            uint e = (value >> 5) & 0x1Fu;
+            uint m = value & 0x1Fu;
+
+            return e switch
+            {
+                // Zero
+                0 when m == 0 => 0f,
+
+                // Denormalized
+                0 => m * BitConverter.UInt32BitsToSingle((128u - bias - 5u) << 23),
+
+                // Inf/NaN
+                31 => BitConverter.UInt32BitsToSingle((0xFFu << 23) | (m << 18)),
+
+                // Normalized
+                _ => BitConverter.UInt32BitsToSingle(((e + 127u - bias) << 23) | (m << 18)),
+            };
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -52,12 +52,29 @@ public static uint PackFloatToFloat10(float value)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float UnpackFloat11ToFloat(uint value)
+        public static float UnpackFloat11ToFloat(uint value, uint bias = 11)
         {
-            uint result =
-                ((((value >> 6) & 0x1f) - 11 + 127) << 23) |
-                ((value & 0x3f) << 17);
-            return Unsafe.As<uint, float>(ref result);
+            uint e = (value >> 6) & 0x1Fu;
+            uint m = value & 0x3Fu;
+
+            if (e == 0)
+            {
+                if (m == 0)
+                {
+                    return 0f;
+                }
+
+                // Denormalized: m * 2^(1 - bias - 6)
+                return m * BitConverter.UInt32BitsToSingle((128u - bias - 6u) << 23);
+            }
+
+            if (e == 31)
+            {
+                uint ieee = (0xFFu << 23) | (m << 17);
+                return BitConverter.UInt32BitsToSingle(ieee);
+            }
+
+            return BitConverter.UInt32BitsToSingle(((e + 127u - bias) << 23) | (m << 17));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/ImageSharp.Textures/Formats/Ktx/Enums/GlInternalPixelFormat.cs

@@ -45,6 +45,22 @@ internal enum GlInternalPixelFormat : uint
 
         Rgba16 = 0x805B,
 
+        R16F = 0x822D,
+
+        Rg16F = 0x822F,
+
+        R32F = 0x822E,
+
+        Rg32F = 0x8230,
+
+        Rgb16F = 0x881B,
+
+        Rgba16F = 0x881A,
+
+        Rgb32F = 0x8815,
+
+        Rgba32F = 0x8814,
+
         R8 = 0x8229,
 
         R8UnsignedInt = 0x8232,
@@ -131,6 +147,11 @@ internal enum GlInternalPixelFormat : uint
 
         CompressedSrgb8Alpha8Etc2Eac = 0x9279,
 
+        /// <summary>
+        /// ASTC 4x4 block compression. Supports both LDR and HDR content.
+        /// HDR is determined by block encoding, not a separate format constant.
+        /// Note: Current decoder may not fully support HDR endpoint modes (2, 3, 7, 11, 14, 15).
+        /// </summary>
         CompressedRgbaAstc4x4Khr = 0x93B0,
 
         CompressedRgbaAstc5x4Khr = 0x93B1,
@@ -158,5 +179,37 @@ internal enum GlInternalPixelFormat : uint
         CompressedRgbaAstc12x10Khr = 0x93BC,
 
         CompressedRgbaAstc12x12Khr = 0x93BD,
+
+        /// <summary>
+        /// ASTC 4x4 block compression with sRGB color space.
+        /// HDR blocks in sRGB formats will decode incorrectly.
+        /// </summary>
+        CompressedSrgb8Alpha8Astc4x4Khr = 0x93D0,
+
+        CompressedSrgb8Alpha8Astc5x4Khr = 0x93D1,
+
+        CompressedSrgb8Alpha8Astc5x5Khr = 0x93D2,
+
+        CompressedSrgb8Alpha8Astc6x5Khr = 0x93D3,
+
+        CompressedSrgb8Alpha8Astc6x6Khr = 0x93D4,
+
+        CompressedSrgb8Alpha8Astc8x5Khr = 0x93D5,
+
+        CompressedSrgb8Alpha8Astc8x6Khr = 0x93D6,
+
+        CompressedSrgb8Alpha8Astc8x8Khr = 0x93D7,
+
+        CompressedSrgb8Alpha8Astc10x5Khr = 0x93D8,
+
+        CompressedSrgb8Alpha8Astc10x6Khr = 0x93D9,
+
+        CompressedSrgb8Alpha8Astc10x8Khr = 0x93DA,
+
+        CompressedSrgb8Alpha8Astc10x10Khr = 0x93DB,
+
+        CompressedSrgb8Alpha8Astc12x10Khr = 0x93DC,
+
+        CompressedSrgb8Alpha8Astc12x12Khr = 0x93DD,
     }
 }

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

@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System;
+
+namespace SixLabors.ImageSharp.Textures.Formats.Ktx
+{
+    /// <summary>
+    /// Handles endianness conversions for KTX texture data.
+    /// </summary>
+    internal interface IEndianHandler
+    {
+        /// <summary>
+        /// Reads a UInt32 value from a buffer with appropriate endianness.
+        /// </summary>
+        /// <param name="buffer">The buffer containing the UInt32 data.</param>
+        /// <returns>The UInt32 value.</returns>
+        uint ReadUInt32(ReadOnlySpan<byte> buffer);
+
+        /// <summary>
+        /// Converts pixel data endianness if needed based on the type size.
+        /// </summary>
+        /// <param name="data">The pixel data to convert.</param>
+        /// <param name="typeSize">The size of each data element (2 for half-float, 4 for float).</param>
+        void ConvertPixelData(Span<byte> data, uint typeSize);
+    }
+}