Add support for HEIF based images

.gitattributes

@@ -136,3 +136,6 @@
 *.ico               filter=lfs diff=lfs merge=lfs -text
 *.cur               filter=lfs diff=lfs merge=lfs -text
 *.ani               filter=lfs diff=lfs merge=lfs -text
+*.heic              filter=lfs diff=lfs merge=lfs -text
+*.hif               filter=lfs diff=lfs merge=lfs -text
+*.avif              filter=lfs diff=lfs merge=lfs -text

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}"
@@ -661,6 +661,18 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Qoi", "Qoi", "{E801B508-493
 		tests\Images\Input\Qoi\wikipedia_008.qoi = tests\Images\Input\Qoi\wikipedia_008.qoi
 	EndProjectSection
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Heif", "Heif", "{BA5D603A-C84C-43E5-B300-8BB886B02936}"
+	ProjectSection(SolutionItems) = preProject
+		tests\Images\Input\Heif\dwsample-heic-640.heic = tests\Images\Input\Heif\dwsample-heic-640.heic
+		tests\Images\Input\Heif\image1.heic = tests\Images\Input\Heif\image1.heic
+		tests\Images\Input\Heif\image2.heic = tests\Images\Input\Heif\image2.heic
+		tests\Images\Input\Heif\image3.heic = tests\Images\Input\Heif\image3.heic
+		tests\Images\Input\Heif\image4.heic = tests\Images\Input\Heif\image4.heic
+		tests\Images\Input\Heif\IMG-20230508-0053.hif = tests\Images\Input\Heif\IMG-20230508-0053.hif
+		tests\Images\Input\Heif\Irvine_CA.avif = tests\Images\Input\Heif\Irvine_CA.avif
+		tests\Images\Input\Heif\jpeg444_xnconvert.avif = tests\Images\Input\Heif\jpeg444_xnconvert.avif
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -714,6 +726,7 @@ Global
 		{670DD46C-82E9-499A-B2D2-00A802ED0141} = {E1C42A6F-913B-4A7B-B1A8-2BB62843B254}
 		{5DFC394F-136F-4B76-9BCA-3BA786515EFC} = {9DA226A1-8656-49A8-A58A-A8B5C081AD66}
 		{E801B508-4935-41CD-BA85-CF11BFF55A45} = {9DA226A1-8656-49A8-A58A-A8B5C081AD66}
+		{BA5D603A-C84C-43E5-B300-8BB886B02936} = {9DA226A1-8656-49A8-A58A-A8B5C081AD66}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {5F8B9D1F-CD8B-4CC5-8216-D531E25BD795}

src/ImageSharp/Configuration.cs

@@ -5,6 +5,7 @@
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Gif;
+using SixLabors.ImageSharp.Formats.Heif;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Pbm;
 using SixLabors.ImageSharp.Formats.Png;
@@ -211,6 +212,7 @@ public void Configure(IImageFormatConfigurationModule configuration)
     /// <see cref="TiffConfigurationModule"/>.
     /// <see cref="WebpConfigurationModule"/>.
     /// <see cref="QoiConfigurationModule"/>.
+    /// <see cref="HeifConfigurationModule"/>.
     /// </summary>
     /// <returns>The default configuration of <see cref="Configuration"/>.</returns>
     internal static Configuration CreateDefaultInstance() => new(
@@ -222,5 +224,6 @@ public void Configure(IImageFormatConfigurationModule configuration)
             new TgaConfigurationModule(),
             new TiffConfigurationModule(),
             new WebpConfigurationModule(),
-            new QoiConfigurationModule());
+            new QoiConfigurationModule(),
+            new HeifConfigurationModule());
 }

src/ImageSharp/Formats/Heif/Av1/Av1BitDepth.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1;
+
+internal enum Av1BitDepth : int
+{
+    EightBit = 0,
+    TenBit = 1,
+    TwelveBit = 2,
+}

src/ImageSharp/Formats/Heif/Av1/Av1BitStreamReader.cs

@@ -0,0 +1,185 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1;
+
+internal ref struct Av1BitStreamReader
+{
+    private const int WordSize = 32;
+
+    private readonly Span<uint> data;
+    private uint currentWord;
+    private uint nextWord;
+    private int wordPosition = 0;
+    private int bitOffset = 0;
+
+    public Av1BitStreamReader(Span<byte> data)
+    {
+        this.data = MemoryMarshal.Cast<byte, uint>(data);
+        this.wordPosition = -1;
+        this.AdvanceToNextWord();
+        this.AdvanceToNextWord();
+    }
+
+    public readonly int BitPosition => ((this.wordPosition - 1) * WordSize) + this.bitOffset;
+
+    /// <summary>
+    /// Gets the number of bytes in the readers buffer.
+    /// </summary>
+    public readonly int Length => this.data.Length;
+
+    public void Reset()
+    {
+        this.wordPosition = 0;
+        this.bitOffset = 0;
+    }
+
+    public void Skip(int bitCount)
+    {
+        this.bitOffset += bitCount;
+        while (this.bitOffset >= WordSize)
+        {
+            this.bitOffset -= WordSize;
+            this.wordPosition++;
+        }
+    }
+
+    public uint ReadLiteral(int bitCount)
+    {
+        DebugGuard.MustBeBetweenOrEqualTo(bitCount, 0, 32, nameof(bitCount));
+
+        uint bits = (this.currentWord << this.bitOffset) >> (WordSize - bitCount);
+        this.bitOffset += bitCount;
+        if (this.bitOffset > WordSize)
+        {
+            int overshoot = WordSize + WordSize - this.bitOffset;
+            if (overshoot < 32)
+            {
+                bits |= this.nextWord >> overshoot;
+            }
+        }
+
+        if (this.bitOffset >= WordSize)
+        {
+            this.AdvanceToNextWord();
+            this.bitOffset -= WordSize;
+        }
+
+        return bits;
+    }
+
+    internal bool ReadBoolean() => this.ReadLiteral(1) > 0;
+
+    public ulong ReadLittleEndianBytes128(out int length)
+    {
+        // See section 4.10.5 of the AV1-Specification
+        DebugGuard.IsTrue((this.bitOffset & 0x07) == 0, $"Reading of Little Endian 128 value only allowed on byte alignment (offset {this.BitPosition}).");
+
+        ulong value = 0;
+        length = 0;
+        for (int i = 0; i < 56; i += 7)
+        {
+            uint leb128Byte = this.ReadLiteral(8);
+            value |= (leb128Byte & 0x7FUL) << i;
+            length++;
+            if ((leb128Byte & 0x80U) == 0)
+            {
+                break;
+            }
+        }
+
+        return value;
+    }
+
+    public uint ReadUnsignedVariableLength()
+    {
+        // See section 4.10.3 of the AV1-Specification
+        int leadingZerosCount = 0;
+        while (leadingZerosCount < 32 && this.ReadLiteral(1) == 0U)
+        {
+            leadingZerosCount++;
+        }
+
+        if (leadingZerosCount == 32)
+        {
+            return uint.MaxValue;
+        }
+
+        uint basis = (1U << leadingZerosCount) - 1U;
+        uint value = this.ReadLiteral(leadingZerosCount);
+        return basis + value;
+    }
+
+    public uint ReadNonSymmetric(uint n)
+    {
+        // See section 4.10.7 of the AV1-Specification
+        if (n <= 1)
+        {
+            return 0;
+        }
+
+        int w = (int)(Av1Math.FloorLog2(n) + 1);
+        uint m = (uint)((1 << w) - n);
+        uint v = this.ReadLiteral(w - 1);
+        if (v < m)
+        {
+            return v;
+        }
+
+        return (v << 1) - m + this.ReadLiteral(1);
+    }
+
+    public int ReadSignedFromUnsigned(int n)
+    {
+        // See section 4.10.6 of the AV1-Specification
+        int signedValue;
+        uint value = this.ReadLiteral(n);
+        uint signMask = 1U << (n - 1);
+        if ((value & signMask) == signMask)
+        {
+            // Prevent overflow by casting to long;
+            signedValue = (int)((long)value - (signMask << 1));
+        }
+        else
+        {
+            signedValue = (int)value;
+        }
+
+        return signedValue;
+    }
+
+    public uint ReadLittleEndian(int n)
+    {
+        // See section 4.10.4 of the AV1-Specification
+        DebugGuard.IsTrue((this.bitOffset & (WordSize - 1)) == 0, "Reading of Little Endian value only allowed on byte alignment");
+
+        uint t = 0;
+        for (int i = 0; i < 8 * n; i += 8)
+        {
+            t += this.ReadLiteral(8) << i;
+        }
+
+        return t;
+    }
+
+    public void AdvanceToNextWord()
+    {
+        this.currentWord = this.nextWord;
+        this.wordPosition++;
+        uint temp = this.data[this.wordPosition];
+        this.nextWord = (temp << 24) | ((temp & 0x0000ff00U) << 8) | ((temp & 0x00ff0000U) >> 8) | (temp >> 24);
+    }
+
+    public Span<byte> GetSymbolReader(int tileDataSize)
+    {
+        DebugGuard.IsTrue((this.bitOffset & (WordSize - 1)) == 0, "Symbol reading needs to start on byte boundary.");
+
+        // TODO: Pass exact byte iso Word start.
+        Span<uint> span = this.data.Slice(this.bitOffset >> WordSize, tileDataSize);
+        this.bitOffset += tileDataSize << 8;
+        return MemoryMarshal.Cast<uint, byte>(span);
+    }
+}

src/ImageSharp/Formats/Heif/Av1/Av1BitStreamWriter.cs

@@ -0,0 +1,111 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1;
+
+internal ref struct Av1BitStreamWriter(Stream stream)
+{
+    private const int WordSize = 8;
+    private readonly Stream stream = stream;
+    private byte buffer = 0;
+    private int bitOffset = 0;
+
+    public readonly int BitPosition => (int)(this.stream.Position * WordSize) + this.bitOffset;
+
+    public readonly int Length => (int)this.stream.Length;
+
+    public void Skip(int bitCount)
+    {
+        this.bitOffset += bitCount;
+        while (this.bitOffset >= WordSize)
+        {
+            this.bitOffset -= WordSize;
+            this.stream.WriteByte(this.buffer);
+            this.buffer = 0;
+        }
+    }
+
+    public void Flush()
+    {
+        this.stream.WriteByte(this.buffer);
+        this.bitOffset = 0;
+    }
+
+    public void WriteLiteral(uint value, int bitCount)
+    {
+        for (int bit = bitCount - 1; bit >= 0; bit--)
+        {
+            this.WriteBit((byte)((value >> bit) & 0x1));
+        }
+    }
+
+    internal void WriteBoolean(bool value)
+    {
+        byte boolByte = value ? (byte)1 : (byte)0;
+        this.WriteBit(boolByte);
+    }
+
+    public void WriteSignedFromUnsigned(int signedValue, int n)
+    {
+        // See section 4.10.6 of the AV1-Specification
+        ulong value = (ulong)signedValue;
+        if (signedValue < 0)
+        {
+            value += 1UL << n;
+        }
+
+        this.WriteLiteral((uint)value, n);
+    }
+
+    public void WriteLittleEndianBytes128(uint value)
+    {
+        if (value < 128)
+        {
+            this.WriteLiteral(value, 8);
+        }
+        else if (value < 0x8000U)
+        {
+            this.WriteLiteral((value & 0x7FU) | 0x80U, 8);
+            this.WriteLiteral(value >> 7, 8);
+        }
+        else
+        {
+            throw new NotImplementedException("No such large values yet.");
+        }
+    }
+
+    internal void WriteNonSymmetric(uint value, uint numberOfSymbols)
+    {
+        // See section 4.10.7 of the AV1-Specification
+        if (numberOfSymbols <= 1)
+        {
+            return;
+        }
+
+        int w = (int)(Av1Math.FloorLog2(numberOfSymbols) + 1);
+        uint m = (uint)((1 << w) - numberOfSymbols);
+        if (value < m)
+        {
+            this.WriteLiteral(value, w - 1);
+        }
+        else
+        {
+            uint extraBit = ((value + m) >> 1) - value;
+            uint k = (value + m - extraBit) >> 1;
+            this.WriteLiteral(k, w - 1);
+            this.WriteLiteral(extraBit, 1);
+        }
+    }
+
+    private void WriteBit(byte value)
+    {
+        this.buffer = (byte)(((value << (7 - this.bitOffset)) & 0xff) | this.buffer);
+        this.bitOffset++;
+        if (this.bitOffset == WordSize)
+        {
+            this.stream.WriteByte(this.buffer);
+            this.buffer = 0;
+            this.bitOffset = 0;
+        }
+    }
+}