Add support for OpenEXR image format

ImageSharp.sln

@@ -37,8 +37,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{815C0625-CD3
 	ProjectSection(SolutionItems) = preProject
 		src\Directory.Build.props = src\Directory.Build.props
 		src\Directory.Build.targets = src\Directory.Build.targets
-		src\README.md = src\README.md
 		src\ImageSharp.ruleset = src\ImageSharp.ruleset
+		src\README.md = src\README.md
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ImageSharp", "src\ImageSharp\ImageSharp.csproj", "{2AA31A1F-142C-43F4-8687-09ABCA4B3A26}"
@@ -215,6 +215,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "issues", "issues", "{5C9B68
 	ProjectSection(SolutionItems) = preProject
 		tests\Images\Input\Jpg\issues\issue-1076-invalid-subsampling.jpg = tests\Images\Input\Jpg\issues\issue-1076-invalid-subsampling.jpg
 		tests\Images\Input\Jpg\issues\issue-1221-identify-multi-frame.jpg = tests\Images\Input\Jpg\issues\issue-1221-identify-multi-frame.jpg
+		tests\Images\Input\Jpg\issues\issue-2067-comment.jpg = tests\Images\Input\Jpg\issues\issue-2067-comment.jpg
 		tests\Images\Input\Jpg\issues\issue1006-incorrect-resize.jpg = tests\Images\Input\Jpg\issues\issue1006-incorrect-resize.jpg
 		tests\Images\Input\Jpg\issues\issue1049-exif-resize.jpg = tests\Images\Input\Jpg\issues\issue1049-exif-resize.jpg
 		tests\Images\Input\Jpg\issues\Issue159-MissingFF00-Progressive-Bedroom.jpg = tests\Images\Input\Jpg\issues\Issue159-MissingFF00-Progressive-Bedroom.jpg
@@ -238,7 +239,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "issues", "issues", "{5C9B68
 		tests\Images\Input\Jpg\issues\issue750-exif-tranform.jpg = tests\Images\Input\Jpg\issues\issue750-exif-tranform.jpg
 		tests\Images\Input\Jpg\issues\Issue845-Incorrect-Quality99.jpg = tests\Images\Input\Jpg\issues\Issue845-Incorrect-Quality99.jpg
 		tests\Images\Input\Jpg\issues\issue855-incorrect-colorspace.jpg = tests\Images\Input\Jpg\issues\issue855-incorrect-colorspace.jpg
-		tests\Images\Input\Jpg\issues\issue-2067-comment.jpg = tests\Images\Input\Jpg\issues\issue-2067-comment.jpg
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "fuzz", "fuzz", "{516A3532-6AC2-417B-AD79-9BD5D0D378A0}"

src/ImageSharp/Common/Helpers/ColorNumerics.cs

@@ -12,6 +12,8 @@ namespace SixLabors.ImageSharp;
 /// </summary>
 internal static class ColorNumerics
 {
+    private const float Scale32Bit = 1f / 0xFFFFFFFF;
+
     /// <summary>
     /// Vector for converting pixel to gray value as specified by
     /// ITU-R Recommendation BT.709.
@@ -132,6 +134,15 @@ public static byte From16BitTo8Bit(ushort component) =>
         //    (V * 255 + 32895) >> 16
         (byte)(((component * 255) + 32895) >> 16);
 
+    /// <summary>
+    /// Scales a value from an 32 bit <see cref="uint"/> to
+    /// an 8 bit <see cref="byte"/> equivalent.
+    /// </summary>
+    /// <param name="component">The 32 bit component value.</param>
+    /// <returns>The <see cref="byte"/> value.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static byte From32BitTo8Bit(uint component) => (byte)(component * Scale32Bit);
+
     /// <summary>
     /// Scales a value from an 8 bit <see cref="byte"/> to
     /// an 16 bit <see cref="ushort"/> equivalent.

src/ImageSharp/Configuration.cs

@@ -5,6 +5,7 @@
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Cur;
+using SixLabors.ImageSharp.Formats.Exr;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Ico;
 using SixLabors.ImageSharp.Formats.Jpeg;
@@ -212,6 +213,7 @@ public void Configure(IImageFormatConfigurationModule configuration)
     /// <see cref="TgaConfigurationModule"/>.
     /// <see cref="TiffConfigurationModule"/>.
     /// <see cref="WebpConfigurationModule"/>.
+    /// <see cref="ExrConfigurationModule"/>.
     /// <see cref="QoiConfigurationModule"/>.
     /// </summary>
     /// <returns>The default configuration of <see cref="Configuration"/>.</returns>
@@ -224,6 +226,7 @@ public void Configure(IImageFormatConfigurationModule configuration)
             new TgaConfigurationModule(),
             new TiffConfigurationModule(),
             new WebpConfigurationModule(),
+            new ExrConfigurationModule(),
             new QoiConfigurationModule(),
             new IcoConfigurationModule(),
             new CurConfigurationModule());

src/ImageSharp/Formats/Bmp/BmpConstants.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.Formats.Bmp;

src/ImageSharp/Formats/Bmp/BmpFormat.cs

@@ -30,5 +30,5 @@ private BmpFormat()
     public IEnumerable<string> FileExtensions => BmpConstants.FileExtensions;
 
     /// <inheritdoc/>
-    public BmpMetadata CreateDefaultFormatMetadata() => new();
+    public BmpMetadata CreateDefaultFormatMetadata() => new BmpMetadata();
 }

src/ImageSharp/Formats/Exr/Compression/Compressors/NoneExrCompressor.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Formats.Exr.Constants;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Exr.Compression.Compressors;
+
+internal class NoneExrCompressor : ExrBaseCompressor
+{
+    public NoneExrCompressor(Stream output, MemoryAllocator allocator, uint bytesPerBlock, uint bytesPerRow)
+        : base(output, allocator, bytesPerBlock, bytesPerRow)
+    {
+    }
+
+    /// <inheritdoc/>
+    public override ExrCompression Method => ExrCompression.Zip;
+
+    /// <inheritdoc/>
+    public override uint CompressRowBlock(Span<byte> rows, int rowCount)
+    {
+        this.Output.Write(rows);
+        return (uint)rows.Length;
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+    }
+}

src/ImageSharp/Formats/Exr/Compression/Compressors/ZipExrCompressor.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Compression.Zlib;
+using SixLabors.ImageSharp.Formats.Exr.Constants;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Exr.Compression.Compressors;
+
+internal class ZipExrCompressor : ExrBaseCompressor
+{
+    private readonly DeflateCompressionLevel compressionLevel;
+
+    private readonly MemoryStream memoryStream;
+
+    private readonly System.Buffers.IMemoryOwner<byte> buffer;
+
+    public ZipExrCompressor(Stream output, MemoryAllocator allocator, uint bytesPerBlock, uint bytesPerRow, DeflateCompressionLevel compressionLevel)
+        : base(output, allocator, bytesPerBlock, bytesPerRow)
+    {
+        this.compressionLevel = compressionLevel;
+        this.buffer = allocator.Allocate<byte>((int)bytesPerBlock);
+        this.memoryStream = new();
+    }
+
+    /// <inheritdoc/>
+    public override ExrCompression Method => ExrCompression.Zip;
+
+    /// <inheritdoc/>
+    public override uint CompressRowBlock(Span<byte> rows, int rowCount)
+    {
+        // Re-oder pixel values.
+        Span<byte> reordered = this.buffer.GetSpan()[..(int)(rowCount * this.BytesPerRow)];
+        int n = reordered.Length;
+        int t1 = 0;
+        int t2 = (n + 1) >> 1;
+        for (int i = 0; i < n; i++)
+        {
+            bool isOdd = (i & 1) == 1;
+            reordered[isOdd ? t2++ : t1++] = rows[i];
+        }
+
+        // Predictor.
+        Span<byte> predicted = reordered;
+        byte p = predicted[0];
+        for (int i = 1; i < predicted.Length; i++)
+        {
+            int d = (predicted[i] - p + 128 + 256) & 255;
+            p = predicted[i];
+            predicted[i] = (byte)d;
+        }
+
+        this.memoryStream.Seek(0, SeekOrigin.Begin);
+        using (ZlibDeflateStream stream = new(this.Allocator, this.memoryStream, this.compressionLevel))
+        {
+            stream.Write(predicted);
+            stream.Flush();
+        }
+
+        int size = (int)this.memoryStream.Position;
+        byte[] buffer = this.memoryStream.GetBuffer();
+        this.Output.Write(buffer, 0, size);
+
+        // Reset memory stream for next pixel row.
+        this.memoryStream.Seek(0, SeekOrigin.Begin);
+        this.memoryStream.SetLength(0);
+
+        return (uint)size;
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        this.buffer.Dispose();
+        this.memoryStream?.Dispose();
+    }
+}

src/ImageSharp/Formats/Exr/Compression/Decompressors/B44ExrCompression.cs

@@ -0,0 +1,190 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Exr.Compression.Decompressors;
+
+internal class B44ExrCompression : ExrBaseDecompressor
+{
+    private readonly int width;
+
+    private readonly uint rowsPerBlock;
+
+    private readonly int channelCount;
+
+    private readonly byte[] scratch = new byte[14];
+
+    private readonly ushort[] s = new ushort[16];
+
+    private readonly IMemoryOwner<ushort> tmpBuffer;
+
+    public B44ExrCompression(MemoryAllocator allocator, uint bytesPerBlock, uint bytesPerRow, uint rowsPerBlock, int width, int channelCount)
+        : base(allocator, bytesPerBlock, bytesPerRow)
+    {
+        this.width = width;
+        this.rowsPerBlock = rowsPerBlock;
+        this.channelCount = channelCount;
+        this.tmpBuffer = allocator.Allocate<ushort>((int)(width * rowsPerBlock * channelCount));
+    }
+
+    /// <inheritdoc/>
+    public override void Decompress(BufferedReadStream stream, uint compressedBytes, Span<byte> buffer)
+    {
+        Span<ushort> outputBuffer = MemoryMarshal.Cast<byte, ushort>(buffer);
+        Span<ushort> decompressed = this.tmpBuffer.GetSpan();
+        int outputOffset = 0;
+        int bytesLeft = (int)compressedBytes;
+        for (int i = 0; i < this.channelCount && bytesLeft > 0; i++)
+        {
+            for (int y = 0; y < this.rowsPerBlock; y += 4)
+            {
+                Span<ushort> row0 = decompressed.Slice(outputOffset, this.width);
+                outputOffset += this.width;
+                Span<ushort> row1 = decompressed.Slice(outputOffset, this.width);
+                outputOffset += this.width;
+                Span<ushort> row2 = decompressed.Slice(outputOffset, this.width);
+                outputOffset += this.width;
+                Span<ushort> row3 = decompressed.Slice(outputOffset, this.width);
+                outputOffset += this.width;
+
+                int rowOffset = 0;
+                for (int x = 0; x < this.width && bytesLeft > 0; x += 4)
+                {
+                    int bytesRead = stream.Read(this.scratch, 0, 3);
+                    if (bytesRead == 0)
+                    {
+                        ExrThrowHelper.ThrowInvalidImageContentException("Could not read enough data from the stream");
+                    }
+
+                    if (this.scratch[2] >= 13 << 2)
+                    {
+                        Unpack3(this.scratch, this.s);
+                        bytesLeft -= 3;
+                    }
+                    else
+                    {
+                        bytesRead = stream.Read(this.scratch, 3, 11);
+                        if (bytesRead == 0)
+                        {
+                            ExrThrowHelper.ThrowInvalidImageContentException("Could not read enough data from the stream");
+                        }
+
+                        Unpack14(this.scratch, this.s);
+                        bytesLeft -= 14;
+                    }
+
+                    int n = x + 3 < this.width ? 4 : this.width - x;
+                    if (y + 3 < this.rowsPerBlock)
+                    {
+                        this.s.AsSpan(0, n).CopyTo(row0.Slice(rowOffset));
+                        this.s.AsSpan(4, n).CopyTo(row1.Slice(rowOffset));
+                        this.s.AsSpan(8, n).CopyTo(row2.Slice(rowOffset));
+                        this.s.AsSpan(12, n).CopyTo(row3.Slice(rowOffset));
+                    }
+                    else
+                    {
+                        this.s.AsSpan(0, n).CopyTo(row0.Slice(rowOffset));
+                        if (y + 1 < this.rowsPerBlock)
+                        {
+                            this.s.AsSpan(4, n).CopyTo(row1.Slice(rowOffset));
+                        }
+
+                        if (y + 2 < this.rowsPerBlock)
+                        {
+                            this.s.AsSpan(8, n).CopyTo(row2.Slice(rowOffset));
+                        }
+                    }
+
+                    rowOffset += 4;
+                }
+
+                if (bytesLeft <= 0)
+                {
+                    break;
+                }
+            }
+        }
+
+        // Rearrange the decompressed data such that the data for each scan line form a contiguous block.
+        int offsetDecompressed = 0;
+        int offsetOutput = 0;
+        int blockSize = (int)(this.width * this.rowsPerBlock);
+        for (int y = 0; y < this.rowsPerBlock; y++)
+        {
+            for (int i = 0; i < this.channelCount; i++)
+            {
+                decompressed.Slice(offsetDecompressed + (i * blockSize), this.width).CopyTo(outputBuffer.Slice(offsetOutput));
+                offsetOutput += this.width;
+            }
+
+            offsetDecompressed += this.width;
+        }
+    }
+
+    // Unpack a 14-byte block into 4 by 4 16-bit pixels.
+    private static void Unpack14(Span<byte> b, Span<ushort> s)
+    {
+        s[0] = (ushort)((b[0] << 8) | b[1]);
+
+        ushort shift = (ushort)(b[2] >> 2);
+        ushort bias = (ushort)(0x20u << shift);
+
+        s[4] = (ushort)(s[0] + ((((b[2] << 4) | (b[3] >> 4)) & 0x3fu) << shift) - bias);
+        s[8] = (ushort)(s[4] + ((((b[3] << 2) | (b[4] >> 6)) & 0x3fu) << shift) - bias);
+        s[12] = (ushort)(s[8] + ((b[4] & 0x3fu) << shift) - bias);
+
+        s[1] = (ushort)(s[0] + ((uint)(b[5] >> 2) << shift) - bias);
+        s[5] = (ushort)(s[4] + ((((b[5] << 4) | (b[6] >> 4)) & 0x3fu) << shift) - bias);
+        s[9] = (ushort)(s[8] + ((((b[6] << 2) | (b[7] >> 6)) & 0x3fu) << shift) - bias);
+        s[13] = (ushort)(s[12] + ((b[7] & 0x3fu) << shift) - bias);
+
+        s[2] = (ushort)(s[1] + ((uint)(b[8] >> 2) << shift) - bias);
+        s[6] = (ushort)(s[5] + ((((b[8] << 4) | (b[9] >> 4)) & 0x3fu) << shift) - bias);
+        s[10] = (ushort)(s[9] + ((((b[9] << 2) | (b[10] >> 6)) & 0x3fu) << shift) - bias);
+        s[14] = (ushort)(s[13] + ((b[10] & 0x3fu) << shift) - bias);
+
+        s[3] = (ushort)(s[2] + ((uint)(b[11] >> 2) << shift) - bias);
+        s[7] = (ushort)(s[6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3fu) << shift) - bias);
+        s[11] = (ushort)(s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3fu) << shift) - bias);
+        s[15] = (ushort)(s[14] + ((b[13] & 0x3fu) << shift) - bias);
+
+        for (int i = 0; i < 16; ++i)
+        {
+            if ((s[i] & 0x8000) != 0)
+            {
+                s[i] &= 0x7fff;
+            }
+            else
+            {
+                s[i] = (ushort)~s[i];
+            }
+        }
+    }
+
+    // Unpack a 3-byte block into 4 by 4 identical 16-bit pixels.
+    private static void Unpack3(Span<byte> b, Span<ushort> s)
+    {
+        s[0] = (ushort)((b[0] << 8) | b[1]);
+
+        if ((s[0] & 0x8000) != 0)
+        {
+            s[0] &= 0x7fff;
+        }
+        else
+        {
+            s[0] = (ushort)~s[0];
+        }
+
+        for (int i = 1; i < 16; ++i)
+        {
+            s[i] = s[0];
+        }
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing) => this.tmpBuffer.Dispose();
+}