Merge branch 'main' into sn/net8

Author: stefannikolei

src/ImageSharp/Formats/AnimationUtilities.cs

@@ -6,6 +6,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -175,7 +176,52 @@ public static (bool Difference, Rectangle Bounds) DeDuplicatePixels<TPixel>(
                 }
             }
 
-            // TODO: v4 AdvSimd when we can use .NET 8
+            if (AdvSimd.IsSupported && remaining >= 4)
+            {
+                // Update offset since we may be operating on the remainder previously incremented by pixel steps of 8.
+                x *= 2;
+                Vector128<uint> r128 = previousFrame != null ? Vector128.Create(bg.PackedValue) : Vector128<uint>.Zero;
+                Vector128<uint> vmb128 = Vector128<uint>.Zero;
+                if (blend)
+                {
+                    vmb128 = AdvSimd.CompareEqual(vmb128, vmb128);
+                }
+
+                while (remaining >= 4)
+                {
+                    Vector128<uint> p = Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref previousBase256), x);
+                    Vector128<uint> c = Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref currentBase256), x);
+
+                    Vector128<uint> eq = AdvSimd.CompareEqual(p, c);
+                    Vector128<uint> r = SimdUtils.HwIntrinsics.BlendVariable(c, r128, AdvSimd.And(eq, vmb128));
+
+                    if (nextFrame != null)
+                    {
+                        Vector128<int> n = AdvSimd.ShiftRightLogical(Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref nextBase256), x), 24).AsInt32();
+                        eq = AdvSimd.BitwiseClear(eq, AdvSimd.CompareGreaterThan(AdvSimd.ShiftRightLogical(c, 24).AsInt32(), n).AsUInt32());
+                    }
+
+                    Unsafe.Add(ref Unsafe.As<Vector256<byte>, Vector128<uint>>(ref resultBase256), x) = r;
+
+                    ulong msk = ~AdvSimd.ExtractNarrowingLower(eq).AsUInt64().ToScalar();
+                    if (msk != 0)
+                    {
+                        // If is diff is found, the left side is marked by the min of previously found left side and the start position.
+                        // The right is the max of the previously found right side and the end position.
+                        int start = i + (BitOperations.TrailingZeroCount(msk) / 16);
+                        int end = i + (4 - (BitOperations.LeadingZeroCount(msk) / 16));
+                        left = Math.Min(left, start);
+                        right = Math.Max(right, end);
+                        hasRowDiff = true;
+                        hasDiff = true;
+                    }
+
+                    x++;
+                    i += 4;
+                    remaining -= 4;
+                }
+            }
+
             for (i = remaining; i > 0; i--)
             {
                 x = (uint)(length - i);

src/ImageSharp/Formats/Png/PngChunkType.cs

@@ -140,6 +140,12 @@ internal enum PngChunkType : uint
     /// <remarks>cHRM (Single)</remarks>
     Chroma = 0x6348524d,
 
+    /// <summary>
+    /// If this chunk is present, it specifies the color space, transfer function, matrix coefficients of the image
+    /// using the code points specified in [ITU-T-H.273]
+    /// </summary>
+    Cicp = 0x63494350,
+
     /// <summary>
     /// This chunk is an ancillary chunk as defined in the PNG Specification.
     /// It must appear before the first IDAT chunk within a valid PNG stream.

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -17,6 +17,7 @@
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Memory.Internals;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
@@ -191,6 +192,9 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
                         case PngChunkType.Gamma:
                             ReadGammaChunk(pngMetadata, chunk.Data.GetSpan());
                             break;
+                        case PngChunkType.Cicp:
+                            ReadCicpChunk(metadata, chunk.Data.GetSpan());
+                            break;
                         case PngChunkType.FrameControl:
                             frameCount++;
                             if (frameCount == this.maxFrames)
@@ -360,6 +364,15 @@ public ImageInfo Identify(BufferedReadStream stream, CancellationToken cancellat
 
                             ReadGammaChunk(pngMetadata, chunk.Data.GetSpan());
                             break;
+                        case PngChunkType.Cicp:
+                            if (this.colorMetadataOnly)
+                            {
+                                this.SkipChunkDataAndCrc(chunk);
+                                break;
+                            }
+
+                            ReadCicpChunk(metadata, chunk.Data.GetSpan());
+                            break;
                         case PngChunkType.FrameControl:
                             ++frameCount;
                             if (frameCount == this.maxFrames)
@@ -1426,6 +1439,26 @@ private static bool TryReadTextChunkMetadata(ImageMetadata baseMetadata, string
         return false;
     }
 
+    /// <summary>
+    /// Reads the CICP color profile chunk.
+    /// </summary>
+    /// <param name="metadata">The metadata.</param>
+    /// <param name="data">The bytes containing the profile.</param>
+    private static void ReadCicpChunk(ImageMetadata metadata, ReadOnlySpan<byte> data)
+    {
+        if (data.Length < 4)
+        {
+            // Ignore invalid cICP chunks.
+            return;
+        }
+
+        byte colorPrimaries = data[0];
+        byte transferFunction = data[1];
+        byte matrixCoefficients = data[2];
+        bool? fullRange = data[3] == 1 ? true : data[3] == 0 ? false : null;
+        metadata.CicpProfile = new CicpProfile(colorPrimaries, transferFunction, matrixCoefficients, fullRange);
+    }
+
     /// <summary>
     /// Reads exif data encoded into a text chunk with the name "raw profile type exif".
     /// This method was used by ImageMagick, exiftool, exiv2, digiKam, etc, before the

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -177,6 +177,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
 
         this.WriteHeaderChunk(stream);
         this.WriteGammaChunk(stream);
+        this.WriteCicpChunk(stream, metadata);
         this.WriteColorProfileChunk(stream, metadata);
         this.WritePaletteChunk(stream, quantized);
         this.WriteTransparencyChunk(stream, pngMetadata);
@@ -852,6 +853,32 @@ private void WriteXmpChunk(Stream stream, ImageMetadata meta)
         this.WriteChunk(stream, PngChunkType.InternationalText, payload);
     }
 
+    /// <summary>
+    /// Writes the CICP profile chunk
+    /// </summary>
+    /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
+    /// <param name="metaData">The image meta data.</param>
+    private void WriteCicpChunk(Stream stream, ImageMetadata metaData)
+    {
+        if (metaData.CicpProfile is null)
+        {
+            return;
+        }
+
+        // by spec, the matrix coefficients must be set to Identity
+        if (metaData.CicpProfile.MatrixCoefficients != Metadata.Profiles.Cicp.CicpMatrixCoefficients.Identity)
+        {
+            throw new NotSupportedException("CICP matrix coefficients other than Identity are not supported in PNG");
+        }
+
+        Span<byte> outputBytes = this.chunkDataBuffer.Span[..4];
+        outputBytes[0] = (byte)metaData.CicpProfile.ColorPrimaries;
+        outputBytes[1] = (byte)metaData.CicpProfile.TransferCharacteristics;
+        outputBytes[2] = (byte)metaData.CicpProfile.MatrixCoefficients;
+        outputBytes[3] = (byte)(metaData.CicpProfile.FullRange ? 1 : 0);
+        this.WriteChunk(stream, PngChunkType.Cicp, outputBytes);
+    }
+
     /// <summary>
     /// Writes the color profile chunk.
     /// </summary>

src/ImageSharp/Formats/Webp/WebpDecoderCore.cs

@@ -3,6 +3,7 @@
 
 using System.Buffers;
 using System.Buffers.Binary;
+using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Webp.Lossless;
 using SixLabors.ImageSharp.Formats.Webp.Lossy;
 using SixLabors.ImageSharp.IO;
@@ -339,10 +340,33 @@ private void ReadExifProfile(BufferedReadStream stream, ImageMetadata metadata,
                 return;
             }
 
-            metadata.ExifProfile = new ExifProfile(exifData);
+            ExifProfile exifProfile = new(exifData);
+
+            // Set the resolution from the metadata.
+            double horizontalValue = GetExifResolutionValue(exifProfile, ExifTag.XResolution);
+            double verticalValue = GetExifResolutionValue(exifProfile, ExifTag.YResolution);
+
+            if (horizontalValue > 0 && verticalValue > 0)
+            {
+                metadata.HorizontalResolution = horizontalValue;
+                metadata.VerticalResolution = verticalValue;
+                metadata.ResolutionUnits = UnitConverter.ExifProfileToResolutionUnit(exifProfile);
+            }
+
+            metadata.ExifProfile = exifProfile;
         }
     }
 
+    private static double GetExifResolutionValue(ExifProfile exifProfile, ExifTag<Rational> tag)
+    {
+        if (exifProfile.TryGetValue(tag, out IExifValue<Rational>? resolution))
+        {
+            return resolution.Value.ToDouble();
+        }
+
+        return 0;
+    }
+
     /// <summary>
     /// Reads the XMP profile the stream.
     /// </summary>

src/ImageSharp/Metadata/ImageFrameMetadata.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
@@ -43,6 +44,7 @@ internal ImageFrameMetadata(ImageFrameMetadata other)
         this.IccProfile = other.IccProfile?.DeepClone();
         this.IptcProfile = other.IptcProfile?.DeepClone();
         this.XmpProfile = other.XmpProfile?.DeepClone();
+        this.CicpProfile = other.CicpProfile?.DeepClone();
     }
 
     /// <summary>
@@ -65,6 +67,11 @@ internal ImageFrameMetadata(ImageFrameMetadata other)
     /// </summary>
     public IptcProfile? IptcProfile { get; set; }
 
+    /// <summary>
+    /// Gets or sets the CICP profile
+    /// </summary>
+    public CicpProfile? CicpProfile { get; set; }
+
     /// <inheritdoc/>
     public ImageFrameMetadata DeepClone() => new(this);
 

src/ImageSharp/Metadata/ImageMetadata.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Formats;
+using SixLabors.ImageSharp.Metadata.Profiles.Cicp;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Iptc;
@@ -68,6 +69,7 @@ private ImageMetadata(ImageMetadata other)
         this.IccProfile = other.IccProfile?.DeepClone();
         this.IptcProfile = other.IptcProfile?.DeepClone();
         this.XmpProfile = other.XmpProfile?.DeepClone();
+        this.CicpProfile = other.CicpProfile?.DeepClone();
 
         // NOTE: This clone is actually shallow but we share the same format
         // instances for all images in the configuration.
@@ -157,6 +159,11 @@ public double VerticalResolution
     /// </summary>
     public IptcProfile? IptcProfile { get; set; }
 
+    /// <summary>
+    /// Gets or sets the CICP profile.
+    /// </summary>
+    public CicpProfile? CicpProfile { get; set; }
+
     /// <summary>
     /// Gets the original format, if any, the image was decode from.
     /// </summary>

src/ImageSharp/Metadata/Profiles/CICP/CicpProfile.cs

@@ -0,0 +1,72 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Cicp;
+
+/// <summary>
+/// Represents a Cicp profile as per ITU-T H.273 / ISO/IEC 23091-2_2019 providing access to color space information
+/// </summary>
+public sealed class CicpProfile : IDeepCloneable<CicpProfile>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CicpProfile"/> class.
+    /// </summary>
+    public CicpProfile()
+        : this(2, 2, 2, null)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CicpProfile"/> class.
+    /// </summary>
+    /// <param name="colorPrimaries">The color primaries as number according to ITU-T H.273 / ISO/IEC 23091-2_2019.</param>
+    /// <param name="transferCharacteristics">The transfer characteristics as number according to ITU-T H.273 / ISO/IEC 23091-2_2019.</param>
+    /// <param name="matrixCoefficients">The matrix coefficients as number according to ITU-T H.273 / ISO/IEC 23091-2_2019.</param>
+    /// <param name="fullRange">The full range flag, or null if unknown.</param>
+    public CicpProfile(byte colorPrimaries, byte transferCharacteristics, byte matrixCoefficients, bool? fullRange)
+    {
+        this.ColorPrimaries = Enum.IsDefined(typeof(CicpColorPrimaries), colorPrimaries) ? (CicpColorPrimaries)colorPrimaries : CicpColorPrimaries.Unspecified;
+        this.TransferCharacteristics = Enum.IsDefined(typeof(CicpTransferCharacteristics), transferCharacteristics) ? (CicpTransferCharacteristics)transferCharacteristics : CicpTransferCharacteristics.Unspecified;
+        this.MatrixCoefficients = Enum.IsDefined(typeof(CicpMatrixCoefficients), matrixCoefficients) ? (CicpMatrixCoefficients)matrixCoefficients : CicpMatrixCoefficients.Unspecified;
+        this.FullRange = fullRange ?? (this.MatrixCoefficients == CicpMatrixCoefficients.Identity);
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CicpProfile"/> class
+    /// by making a copy from another CICP profile.
+    /// </summary>
+    /// <param name="other">The other CICP profile, where the clone should be made from.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="other"/> is null.</exception>>
+    private CicpProfile(CicpProfile other)
+    {
+        Guard.NotNull(other, nameof(other));
+
+        this.ColorPrimaries = other.ColorPrimaries;
+        this.TransferCharacteristics = other.TransferCharacteristics;
+        this.MatrixCoefficients = other.MatrixCoefficients;
+        this.FullRange = other.FullRange;
+    }
+
+    /// <summary>
+    /// Gets or sets the color primaries
+    /// </summary>
+    public CicpColorPrimaries ColorPrimaries { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transfer characteristics
+    /// </summary>
+    public CicpTransferCharacteristics TransferCharacteristics { get; set; }
+
+    /// <summary>
+    /// Gets or sets the matrix coefficients
+    /// </summary>
+    public CicpMatrixCoefficients MatrixCoefficients { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the colors use the full numeric range
+    /// </summary>
+    public bool FullRange { get; set; }
+
+    /// <inheritdoc/>
+    public CicpProfile DeepClone() => new(this);
+}