Add support for HEIF based images

.gitattributes

@@ -138,6 +138,12 @@
 *.heic              filter=lfs diff=lfs merge=lfs -text
 *.hif               filter=lfs diff=lfs merge=lfs -text
 *.avif              filter=lfs diff=lfs merge=lfs -text
+*.hvc1              filter=lfs diff=lfs merge=lfs -text
+*.hvcc              filter=lfs diff=lfs merge=lfs -text
+*.ivf               filter=lfs diff=lfs merge=lfs -text
+*.y4m               filter=lfs diff=lfs merge=lfs -text
+*.yuv               filter=lfs diff=lfs merge=lfs -text
+*.bit               filter=lfs diff=lfs merge=lfs -text
 ###############################################################################
 # Handle ICC files by git lfs
 ###############################################################################

.github/workflows/build-and-test.yml

@@ -213,8 +213,13 @@ jobs:
         uses: actions/upload-artifact@v7
         if: failure()
         with:
-          name: actual_output_${{ runner.os }}_${{ matrix.options.framework }}${{ matrix.options.runtime }}.zip
-          path: tests/Images/ActualOutput/
+          name: actual_output_${{ runner.os }}_${{ runner.arch }}_${{ matrix.options.framework }}${{ matrix.options.runtime }}.zip
+          # ActualOutput holds the images that the tests write and the test runner log from ci-test.ps1.
+          # TestResults is the default results folder of dotnet test. When the test process crashes, --blame
+          # writes a sequence file there that lists the tests that ran before the crash.
+          path: |
+            tests/Images/ActualOutput/
+            tests/ImageSharp.Tests/TestResults/
 
   Publish:
     needs: [Build]

ImageSharp.slnx

@@ -114,6 +114,11 @@
         <File Path="tests/Images/Input/Gif/issues/issue405_badappextlength252-2.gif" />
         <File Path="tests/Images/Input/Gif/issues/issue405_badappextlength252.gif" />
     </Folder>
+    <Folder Name="/tests/Images/Input/Heif/">
+        <File Path="tests/Images/Input/Heif/Irvine_CA.avif" />
+        <File Path="tests/Images/Input/Heif/jpeg444_xnconvert.avif" />
+        <File Path="tests/Images/Input/Heif/Orange4x4.avif" />
+    </Folder>
     <Folder Name="/tests/Images/Input/Icon/">
         <File Path="tests/Images/Input/Icon/aero_arrow.cur" />
         <File Path="tests/Images/Input/Icon/flutter.ico" />

THIRD-PARTY-NOTICES.TXT

@@ -30,3 +30,145 @@ See the LICENSE file in the CoreFX project root for more information.
 https://github.com/dotnet/corefx/blob/17300169760c61a90cab8d913636c1058a30a8c1/LICENSE.TXT
 https://github.com/dotnet/corefx/blob/17300169760c61a90cab8d913636c1058a30a8c1/src/Common/src/CoreLib/System/IO/Stream.cs#L742
 https://github.com/dotnet/corefx/blob/17300169760c61a90cab8d913636c1058a30a8c1/src/Common/src/CoreLib/System/IO/Stream.cs#L775
+
+
+License notice for the AOM AV1 Codec Library
+-----
+
+Parts of the AV1 implementation are adapted from the AOM AV1 Codec Library.
+https://aomedia.googlesource.com/aom/
+
+Copyright (c) 2016, Alliance for Open Media. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+Alliance for Open Media Patent License 1.0
+
+1. License Terms.
+
+1.1. Patent License. Subject to the terms and conditions of this License, each
+     Licensor, on behalf of itself and successors in interest and assigns,
+     grants Licensee a non-sublicensable, perpetual, worldwide, non-exclusive,
+     no-charge, royalty-free, irrevocable (except as expressly stated in this
+     License) patent license to its Necessary Claims to make, use, sell, offer
+     for sale, import or distribute any Implementation.
+
+1.2. Conditions.
+
+1.2.1. Availability. As a condition to the grant of rights to Licensee to make,
+       sell, offer for sale, import or distribute an Implementation under
+       Section 1.1, Licensee must make its Necessary Claims available under
+       this License, and must reproduce this License with any Implementation
+       as follows:
+
+       a. For distribution in source code, by including this License in the
+          root directory of the source code with its Implementation.
+
+       b. For distribution in any other form (including binary, object form,
+          and/or hardware description code (e.g., HDL, RTL, Gate Level Netlist,
+          GDSII, etc.)), by including this License in the documentation, legal
+          notices, and/or other written materials provided with the
+          Implementation.
+
+1.2.2. Additional Conditions. This license is directly from Licensor to
+       Licensee.  Licensee acknowledges as a condition of benefiting from it
+       that no rights from Licensor are received from suppliers, distributors,
+       or otherwise in connection with this License.
+
+1.3. Defensive Termination. If any Licensee, its Affiliates, or its agents
+     initiates patent litigation or files, maintains, or voluntarily
+     participates in a lawsuit against another entity or any person asserting
+     that any Implementation infringes Necessary Claims, any patent licenses
+     granted under this License directly to the Licensee are immediately
+     terminated as of the date of the initiation of action unless 1) that suit
+     was in response to a corresponding suit regarding an Implementation first
+     brought against an initiating entity, or 2) that suit was brought to
+     enforce the terms of this License (including intervention in a third-party
+     action by a Licensee).
+
+1.4. Disclaimers. The Reference Implementation and Specification are provided
+     "AS IS" and without warranty. The entire risk as to implementing or
+     otherwise using the Reference Implementation or Specification is assumed
+     by the implementer and user. Licensor expressly disclaims any warranties
+     (express, implied, or otherwise), including implied warranties of
+     merchantability, non-infringement, fitness for a particular purpose, or
+     title, related to the material. IN NO EVENT WILL LICENSOR BE LIABLE TO
+     ANY OTHER PARTY FOR LOST PROFITS OR ANY FORM OF INDIRECT, SPECIAL,
+     INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER FROM ANY CAUSES OF
+     ACTION OF ANY KIND WITH RESPECT TO THIS LICENSE, WHETHER BASED ON BREACH
+     OF CONTRACT, TORT (INCLUDING NEGLIGENCE), OR OTHERWISE, AND WHETHER OR
+     NOT THE OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+2. Definitions.
+
+2.1. Affiliate.  "Affiliate" means an entity that directly or indirectly
+     Controls, is Controlled by, or is under common Control of that party.
+
+2.2. Control. "Control" means direct or indirect control of more than 50% of
+     the voting power to elect directors of that corporation, or for any other
+     entity, the power to direct management of such entity.
+
+2.3. Decoder.  "Decoder" means any decoder that conforms fully with all
+     non-optional portions of the Specification.
+
+2.4. Encoder.  "Encoder" means any encoder that produces a bitstream that can
+     be decoded by a Decoder only to the extent it produces such a bitstream.
+
+2.5. Final Deliverable.  "Final Deliverable" means the final version of a
+     deliverable approved by the Alliance for Open Media as a Final
+     Deliverable.
+
+2.6. Implementation.  "Implementation" means any implementation, including the
+     Reference Implementation, that is an Encoder and/or a Decoder. An
+     Implementation also includes components of an Implementation only to the
+     extent they are used as part of an Implementation.
+
+2.7. License. "License" means this license.
+
+2.8. Licensee. "Licensee" means any person or entity who exercises patent
+     rights granted under this License.
+
+2.9. Licensor.  "Licensor" means (i) any Licensee that makes, sells, offers
+     for sale, imports or distributes any Implementation, or (ii) a person
+     or entity that has a licensing obligation to the Implementation as a
+     result of its membership and/or participation in the Alliance for Open
+     Media working group that developed the Specification.
+
+2.10. Necessary Claims.  "Necessary Claims" means all claims of patents or
+      patent applications, (a) that currently or at any time in the future,
+      are owned or controlled by the Licensor, and (b) (i) would be an
+      Essential Claim as defined by the W3C Policy as of February 5, 2004
+      (https://www.w3.org/Consortium/Patent-Policy-20040205/#def-essential)
+      as if the Specification was a W3C Recommendation; or (ii) are infringed
+      by the Reference Implementation.
+
+2.11. Reference Implementation. "Reference Implementation" means an Encoder
+      and/or Decoder released by the Alliance for Open Media as a Final
+      Deliverable.
+
+2.12. Specification. "Specification" means the specification designated by
+      the Alliance for Open Media as a Final Deliverable for which this
+      License was issued.

ci-test.ps1

@@ -17,7 +17,7 @@ if ($codecov -eq 'true') {
 
   # Allow toggling of profile to workaround any potential JIT errors caused by code injection.
   dotnet clean -c $codecovProfile
-  dotnet test --collect "XPlat Code Coverage" --settings .\tests\coverlet.runsettings -c $codecovProfile -f $targetFramework /p:CodeCov=true
+  dotnet test --collect "XPlat Code Coverage" --settings (Join-Path $PSScriptRoot 'tests' 'coverlet.runsettings') -c $codecovProfile -f $targetFramework /p:CodeCov=true
 }
 elseif ($platform -eq '-x86' -and $targetFramework -match $netFxRegex) {
 
@@ -33,5 +33,8 @@ elseif ($platform -eq '-x86' -and $targetFramework -match $netFxRegex) {
 }
 else {
 
-  dotnet test --no-build -c Release -f $targetFramework --blame --diag .tests\Images\ActualOutput\diaglog.txt
+  # The workflow uploads tests/Images/ActualOutput when a job fails, so the diagnostic log must be written there.
+  # Join-Path keeps the path valid on Linux and macOS, where a backslash is part of the file name.
+  $diagLog = Join-Path $PSScriptRoot 'tests' 'Images' 'ActualOutput' 'diaglog.txt'
+  dotnet test --no-build -c Release -f $targetFramework --blame --diag $diagLog
 }

src/ImageSharp/ColorProfiles/ColorConversionOptions.cs

@@ -73,6 +73,11 @@ public YCbCrTransform YCbCrTransform
     /// </summary>
     public IccProfile? TargetIccProfile { get; init; }
 
+    /// <summary>
+    /// Gets the interpolation method used for ICC color lookup tables. Defaults to <see cref="IccInterpolationMethod.Auto"/>.
+    /// </summary>
+    public IccInterpolationMethod IccInterpolationMethod { get; init; }
+
     /// <summary>
     /// Gets the transformation matrix used in conversion to perform chromatic adaptation.
     /// <see cref="KnownChromaticAdaptationMatrices"/> for further information. Default is Bradford.

src/ImageSharp/ColorProfiles/ColorProfileConverter.cs

@@ -8,6 +8,12 @@ namespace SixLabors.ImageSharp.ColorProfiles;
 /// </summary>
 public class ColorProfileConverter
 {
+    /// <summary>
+    /// The ICC transforms, built on first use. They depend only on the immutable options and hold no mutable state,
+    /// so every conversion and every thread shares them.
+    /// </summary>
+    private ColorProfileConverterExtensionsIcc.IccTransform? iccTransform;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ColorProfileConverter"/> class.
     /// </summary>
@@ -28,6 +34,13 @@ public ColorProfileConverter(ColorConversionOptions options)
     /// </summary>
     public ColorConversionOptions Options { get; }
 
+    /// <summary>
+    /// Gets the ICC transforms of this converter, building them on first use.
+    /// </summary>
+    /// <returns>The <see cref="ColorProfileConverterExtensionsIcc.IccTransform"/>.</returns>
+    internal ColorProfileConverterExtensionsIcc.IccTransform GetIccTransform()
+        => LazyInitializer.EnsureInitialized(ref this.iccTransform, () => new ColorProfileConverterExtensionsIcc.IccTransform(this.Options));
+
     internal (CieXyz From, CieXyz To) GetChromaticAdaptionWhitePoints<TFrom, TTo>()
                where TFrom : struct, IColorProfile
                where TTo : struct, IColorProfile

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsIcc.cs

@@ -75,18 +75,11 @@ internal static TTo ConvertUsingIccProfile<TFrom, TTo>(this ColorProfileConverte
             throw new InvalidOperationException("Target ICC profile is missing.");
         }
 
-        // The embedded source profile supplies the connection's intent. Use it for both transform
-        // selection and PCS adjustment; the destination header may recommend a different intent.
-        IccRenderingIntent renderingIntent = converter.Options.SourceIccProfile.Header.RenderingIntent;
-        ConversionParams sourceParams = new(converter.Options.SourceIccProfile, toPcs: true, renderingIntent);
-        ConversionParams targetParams = new(converter.Options.TargetIccProfile, toPcs: false, renderingIntent);
-
-        ColorProfileConverter pcsConverter = new(new ColorConversionOptions
-        {
-            MemoryAllocator = converter.Options.MemoryAllocator,
-            SourceWhitePoint = KnownIlluminants.D50Icc,
-            TargetWhitePoint = KnownIlluminants.D50Icc
-        });
+        // The transforms depend only on the converter's options, so they are built once per converter.
+        IccTransform transform = converter.GetIccTransform();
+        ConversionParams sourceParams = transform.Source;
+        ConversionParams targetParams = transform.Target;
+        ColorProfileConverter pcsConverter = transform.PcsConverter;
 
         // Normalize the source, then convert to the PCS space.
         Vector4 sourcePcs = sourceParams.Converter.Calculate(source.ToScaledVector4());
@@ -145,18 +138,11 @@ internal static void ConvertUsingIccProfile<TFrom, TTo>(this ColorProfileConvert
 
         Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(destination));
 
-        // Resolve the connection's intent once for the entire span, before selecting either transform
-        // or deciding whether perceptual PCS adjustment is needed.
-        IccRenderingIntent renderingIntent = converter.Options.SourceIccProfile.Header.RenderingIntent;
-        ConversionParams sourceParams = new(converter.Options.SourceIccProfile, toPcs: true, renderingIntent);
-        ConversionParams targetParams = new(converter.Options.TargetIccProfile, toPcs: false, renderingIntent);
-
-        ColorProfileConverter pcsConverter = new(new ColorConversionOptions
-        {
-            MemoryAllocator = converter.Options.MemoryAllocator,
-            SourceWhitePoint = KnownIlluminants.D50Icc,
-            TargetWhitePoint = KnownIlluminants.D50Icc
-        });
+        // The transforms depend only on the converter's options, so they are built once per converter.
+        IccTransform transform = converter.GetIccTransform();
+        ConversionParams sourceParams = transform.Source;
+        ConversionParams targetParams = transform.Target;
+        ColorProfileConverter pcsConverter = transform.PcsConverter;
 
         using IMemoryOwner<Vector4> pcsBuffer = converter.Options.MemoryAllocator.Allocate<Vector4>(source.Length);
         Span<Vector4> pcs = pcsBuffer.GetSpan();
@@ -694,7 +680,47 @@ private static void LabToLab(Span<Vector4> source, Span<Vector4> destination, [C
         TensorPrimitives.Multiply(MemoryMarshal.Cast<Vector4, float>(source), scale, MemoryMarshal.Cast<Vector4, float>(destination));
     }
 
-    private class ConversionParams
+    /// <summary>
+    /// The immutable ICC connection of a converter: both profile transforms and the PCS converter.
+    /// </summary>
+    internal sealed class IccTransform
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IccTransform"/> class.
+        /// </summary>
+        /// <param name="options">The conversion options carrying both ICC profiles.</param>
+        public IccTransform(ColorConversionOptions options)
+        {
+            // The embedded source profile supplies the connection's intent. Use it for both transform
+            // selection and PCS adjustment; the destination header may recommend a different intent.
+            IccRenderingIntent renderingIntent = options.SourceIccProfile!.Header.RenderingIntent;
+            this.Source = new ConversionParams(options.SourceIccProfile, toPcs: true, renderingIntent, options.IccInterpolationMethod);
+            this.Target = new ConversionParams(options.TargetIccProfile!, toPcs: false, renderingIntent, options.IccInterpolationMethod);
+            this.PcsConverter = new ColorProfileConverter(new ColorConversionOptions
+            {
+                MemoryAllocator = options.MemoryAllocator,
+                SourceWhitePoint = KnownIlluminants.D50Icc,
+                TargetWhitePoint = KnownIlluminants.D50Icc
+            });
+        }
+
+        /// <summary>
+        /// Gets the transform from the source profile's device values to its PCS.
+        /// </summary>
+        public ConversionParams Source { get; }
+
+        /// <summary>
+        /// Gets the transform from the PCS to the target profile's device values.
+        /// </summary>
+        public ConversionParams Target { get; }
+
+        /// <summary>
+        /// Gets the converter between the two profile connection spaces.
+        /// </summary>
+        public ColorProfileConverter PcsConverter { get; }
+    }
+
+    internal sealed class ConversionParams
     {
         private readonly IccProfile profile;
 
@@ -704,11 +730,14 @@ private class ConversionParams
         /// <param name="profile">The profile used by this transform.</param>
         /// <param name="toPcs">Whether this transform converts device values to the PCS.</param>
         /// <param name="renderingIntent">The rendering intent shared by both profiles.</param>
-        internal ConversionParams(IccProfile profile, bool toPcs, IccRenderingIntent renderingIntent)
+        /// <param name="interpolationMethod">The interpolation method used for color lookup tables.</param>
+        internal ConversionParams(IccProfile profile, bool toPcs, IccRenderingIntent renderingIntent, IccInterpolationMethod interpolationMethod)
         {
             this.profile = profile;
             this.Intent = renderingIntent;
-            this.Converter = toPcs ? new IccDataToPcsConverter(profile, renderingIntent) : new IccPcsToDataConverter(profile, renderingIntent);
+            this.Converter = toPcs
+                ? new IccDataToPcsConverter(profile, renderingIntent, interpolationMethod)
+                : new IccPcsToDataConverter(profile, renderingIntent, interpolationMethod);
         }
 
         internal IccConverterBase Converter { get; }