Merge branch 'main' into ImageInfo.FrameMetadataCollection-not-populated-correctly-for-animated-png-images

Author: JimBobSquarePants

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -54,7 +54,7 @@ internal static class AotCompilerTools
     /// <remarks>
     /// This method doesn't actually do anything but serves an important purpose...
     /// If you are running ImageSharp on iOS and try to call SaveAsGif, it will throw an exception:
-    /// "Attempting to JIT compile method... OctreeFrameQuantizer.ConstructPalette... while running in aot-only mode."
+    /// "Attempting to JIT compile method... HexadecatreeQuantizer.ConstructPalette... while running in aot-only mode."
     /// The reason this happens is the SaveAsGif method makes heavy use of generics, which are too confusing for the AoT
     /// compiler used on Xamarin.iOS. It spins up the JIT compiler to try and figure it out, but that is an illegal op on
     /// iOS so it bombs out.
@@ -479,7 +479,7 @@ private static void AotCompileResampler<TPixel, TResampler>()
     private static void AotCompileQuantizers<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        AotCompileQuantizer<TPixel, OctreeQuantizer>();
+        AotCompileQuantizer<TPixel, HexadecatreeQuantizer>();
         AotCompileQuantizer<TPixel, PaletteQuantizer>();
         AotCompileQuantizer<TPixel, WebSafePaletteQuantizer>();
         AotCompileQuantizer<TPixel, WernerPaletteQuantizer>();
@@ -523,10 +523,8 @@ private static void AotCompilePixelSamplingStrategys<TPixel>()
     private static void AotCompilePixelMaps<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        default(EuclideanPixelMap<TPixel, HybridCache>).GetClosestColor(default, out _);
         default(EuclideanPixelMap<TPixel, AccurateCache>).GetClosestColor(default, out _);
         default(EuclideanPixelMap<TPixel, CoarseCache>).GetClosestColor(default, out _);
-        default(EuclideanPixelMap<TPixel, NullCache>).GetClosestColor(default, out _);
     }
 
     /// <summary>
@@ -551,8 +549,8 @@ private static void AotCompileDither<TPixel, TDither>()
         where TPixel : unmanaged, IPixel<TPixel>
         where TDither : struct, IDither
     {
-        OctreeQuantizer<TPixel> octree = default;
-        default(TDither).ApplyQuantizationDither<OctreeQuantizer<TPixel>, TPixel>(ref octree, default, default, default);
+        HexadecatreeQuantizer<TPixel> hexadecatree = default;
+        default(TDither).ApplyQuantizationDither<HexadecatreeQuantizer<TPixel>, TPixel>(ref hexadecatree, default, default, default);
 
         PaletteQuantizer<TPixel> palette = default;
         default(TDither).ApplyQuantizationDither<PaletteQuantizer<TPixel>, TPixel>(ref palette, default, default, default);

src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs

@@ -752,7 +752,7 @@ internal static void ByteToNormalizedFloatReduce(
         /// Implementation is based on MagicScaler code:
         /// https://github.com/saucecontrol/PhotoSauce/blob/b5811908041200488aa18fdfd17df5fc457415dc/src/MagicScaler/Magic/Processors/ConvertersFloat.cs#L80-L182
         /// </remarks>
-        internal static unsafe void ByteToNormalizedFloat(
+        internal static void ByteToNormalizedFloat(
             ReadOnlySpan<byte> source,
             Span<float> destination)
         {
@@ -1172,8 +1172,10 @@ internal static void UnpackToRgbPlanesAvx2Reduce(
             Vector256<byte> rgb, rg, bx;
             Vector256<float> r, g, b;
 
+            // Each iteration consumes 8 Rgb24 pixels (24 bytes) but starts with a 32-byte load,
+            // so we need 3 extra pixels of addressable slack beyond the vectorized chunk.
             const int bytesPerRgbStride = 24;
-            nuint count = (uint)source.Length / 8;
+            nuint count = source.Length > 3 ? (uint)(source.Length - 3) / 8 : 0;
             for (nuint i = 0; i < count; i++)
             {
                 rgb = Avx2.PermuteVar8x32(Unsafe.AddByteOffset(ref rgbByteSpan, (uint)(bytesPerRgbStride * i)).AsUInt32(), extractToLanesMask).AsByte();
@@ -1193,10 +1195,10 @@ internal static void UnpackToRgbPlanesAvx2Reduce(
             }
 
             int sliceCount = (int)(count * 8);
-            redChannel = redChannel.Slice(sliceCount);
-            greenChannel = greenChannel.Slice(sliceCount);
-            blueChannel = blueChannel.Slice(sliceCount);
-            source = source.Slice(sliceCount);
+            redChannel = redChannel[sliceCount..];
+            greenChannel = greenChannel[sliceCount..];
+            blueChannel = blueChannel[sliceCount..];
+            source = source[sliceCount..];
         }
     }
 }

src/ImageSharp/Formats/Bmp/BmpEncoder.cs

@@ -13,7 +13,7 @@ public sealed class BmpEncoder : QuantizingImageEncoder
     /// <summary>
     /// Initializes a new instance of the <see cref="BmpEncoder"/> class.
     /// </summary>
-    public BmpEncoder() => this.Quantizer = KnownQuantizers.Octree;
+    public BmpEncoder() => this.Quantizer = KnownQuantizers.Hexadecatree;
 
     /// <summary>
     /// Gets the number of bits per pixel.

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -116,7 +116,7 @@ public BmpEncoderCore(BmpEncoder encoder, MemoryAllocator memoryAllocator)
         this.bitsPerPixel = encoder.BitsPerPixel;
 
         // TODO: Use a palette quantizer if supplied.
-        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Octree;
+        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Hexadecatree;
         this.pixelSamplingStrategy = encoder.PixelSamplingStrategy;
         this.transparentColorMode = encoder.TransparentColorMode;
         this.infoHeaderType = encoder.SupportTransparency ? BmpInfoHeaderType.WinVersion4 : BmpInfoHeaderType.WinVersion3;

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -117,7 +117,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
 
         if (globalQuantizer is null)
         {
-            // Is this a gif with color information. If so use that, otherwise use octree.
+            // Is this a gif with color information. If so use that, otherwise use the adaptive hexadecatree quantizer.
             if (gifMetadata.ColorTableMode == FrameColorTableMode.Global && gifMetadata.GlobalColorTable?.Length > 0)
             {
                 int ti = GetTransparentIndex(quantized, frameMetadata);
@@ -132,12 +132,12 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
                 }
                 else
                 {
-                    globalQuantizer = new OctreeQuantizer(options);
+                    globalQuantizer = new HexadecatreeQuantizer(options);
                 }
             }
             else
             {
-                globalQuantizer = new OctreeQuantizer(options);
+                globalQuantizer = new HexadecatreeQuantizer(options);
             }
         }
 

src/ImageSharp/Formats/Jpeg/Components/Encoder/SpectralConverter{TPixel}.cs

@@ -114,9 +114,9 @@ private void ConvertStride(int spectralStep)
             Span<TPixel> sourceRow = this.pixelBuffer.DangerousGetRowSpan(srcIndex);
             PixelOperations<TPixel>.Instance.UnpackIntoRgbPlanes(rLane, gLane, bLane, sourceRow);
 
-            rLane.Slice(paddingStartIndex).Fill(rLane[paddingStartIndex - 1]);
-            gLane.Slice(paddingStartIndex).Fill(gLane[paddingStartIndex - 1]);
-            bLane.Slice(paddingStartIndex).Fill(bLane[paddingStartIndex - 1]);
+            rLane.Slice(paddingStartIndex, paddedPixelsCount).Fill(rLane[paddingStartIndex - 1]);
+            gLane.Slice(paddingStartIndex, paddedPixelsCount).Fill(gLane[paddingStartIndex - 1]);
+            bLane.Slice(paddingStartIndex, paddedPixelsCount).Fill(bLane[paddingStartIndex - 1]);
 
             // Convert from rgb24 to target pixel type
             JpegColorConverterBase.ComponentValues values = new(this.componentProcessors, y);

src/ImageSharp/Formats/Tiff/TiffEncoder.cs

@@ -15,7 +15,7 @@ public class TiffEncoder : QuantizingImageEncoder
     /// <summary>
     /// Initializes a new instance of the <see cref="TiffEncoder"/> class.
     /// </summary>
-    public TiffEncoder() => this.Quantizer = KnownQuantizers.Octree;
+    public TiffEncoder() => this.Quantizer = KnownQuantizers.Hexadecatree;
 
     /// <summary>
     /// Gets the number of bits per pixel.

src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs

@@ -71,7 +71,7 @@ public TiffEncoderCore(TiffEncoder encoder, Configuration configuration)
         this.configuration = configuration;
         this.memoryAllocator = configuration.MemoryAllocator;
         this.PhotometricInterpretation = encoder.PhotometricInterpretation;
-        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Octree;
+        this.quantizer = encoder.Quantizer ?? KnownQuantizers.Hexadecatree;
         this.pixelSamplingStrategy = encoder.PixelSamplingStrategy;
         this.BitsPerPixel = encoder.BitsPerPixel;
         this.HorizontalPredictor = encoder.HorizontalPredictor;

src/ImageSharp/Processing/Extensions/Quantization/QuantizeExtensions.cs

@@ -12,12 +12,12 @@ namespace SixLabors.ImageSharp.Processing;
 public static class QuantizeExtensions
 {
     /// <summary>
-    /// Applies quantization to the image using the <see cref="OctreeQuantizer"/>.
+    /// Applies quantization to the image using the <see cref="HexadecatreeQuantizer"/>.
     /// </summary>
     /// <param name="source">The current image processing context.</param>
     /// <returns>The <see cref="IImageProcessingContext"/>.</returns>
     public static IImageProcessingContext Quantize(this IImageProcessingContext source) =>
-        Quantize(source, KnownQuantizers.Octree);
+        Quantize(source, KnownQuantizers.Hexadecatree);
 
     /// <summary>
     /// Applies quantization to the image.
@@ -29,15 +29,15 @@ public static IImageProcessingContext Quantize(this IImageProcessingContext sour
         source.ApplyProcessor(new QuantizeProcessor(quantizer));
 
     /// <summary>
-    /// Applies quantization to the image using the <see cref="OctreeQuantizer"/>.
+    /// Applies quantization to the image using the <see cref="HexadecatreeQuantizer"/>.
     /// </summary>
     /// <param name="source">The current image processing context.</param>
     /// <param name="rectangle">
     /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
     /// </param>
     /// <returns>The <see cref="IImageProcessingContext"/>.</returns>
     public static IImageProcessingContext Quantize(this IImageProcessingContext source, Rectangle rectangle) =>
-        Quantize(source, KnownQuantizers.Octree, rectangle);
+        Quantize(source, KnownQuantizers.Hexadecatree, rectangle);
 
     /// <summary>
     /// Applies quantization to the image.

src/ImageSharp/Processing/KnownQuantizers.cs

@@ -1,19 +1,19 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 
 namespace SixLabors.ImageSharp.Processing;
 
 /// <summary>
-/// Contains reusable static instances of known quantizing algorithms
+/// Contains reusable static instances of known quantizing algorithms.
 /// </summary>
 public static class KnownQuantizers
 {
     /// <summary>
-    /// Gets the adaptive Octree quantizer. Fast with good quality.
+    /// Gets the adaptive hexadecatree quantizer. Fast with good quality.
     /// </summary>
-    public static IQuantizer Octree { get; } = new OctreeQuantizer();
+    public static IQuantizer Hexadecatree { get; } = new HexadecatreeQuantizer();
 
     /// <summary>
     /// Gets the Xiaolin Wu's Color Quantizer which generates high quality output.