Merge branch 'main' into dependabot/github_actions/codecov/codecov-action-6

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/Advanced/IRowOperation{TBuffer}.cs

@@ -15,12 +15,12 @@ public interface IRowOperation<TBuffer>
     /// </summary>
     /// <param name="bounds">The bounds of the operation.</param>
     /// <returns>The required buffer length.</returns>
-    int GetRequiredBufferLength(Rectangle bounds);
+    public int GetRequiredBufferLength(Rectangle bounds);
 
     /// <summary>
     /// Invokes the method passing the row and a buffer.
     /// </summary>
     /// <param name="y">The row y coordinate.</param>
     /// <param name="span">The contiguous region of memory.</param>
-    void Invoke(int y, Span<TBuffer> span);
+    public void Invoke(int y, Span<TBuffer> span);
 }

src/ImageSharp/Advanced/ParallelRowIterator.cs

@@ -68,7 +68,7 @@ public static void IterateRows<T>(
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
         RowOperationWrapper<T> wrappingOperation = new(top, bottom, verticalStep, in operation);
 
-        Parallel.For(
+        _ = Parallel.For(
             0,
             numOfSteps,
             parallelOptions,
@@ -138,7 +138,7 @@ public static void IterateRows<T, TBuffer>(
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
         RowOperationWrapper<T, TBuffer> wrappingOperation = new(top, bottom, verticalStep, bufferLength, allocator, in operation);
 
-        Parallel.For(
+        _ = Parallel.For(
             0,
             numOfSteps,
             parallelOptions,
@@ -195,7 +195,7 @@ public static void IterateRowIntervals<T>(
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
         RowIntervalOperationWrapper<T> wrappingOperation = new(top, bottom, verticalStep, in operation);
 
-        Parallel.For(
+        _ = Parallel.For(
             0,
             numOfSteps,
             parallelOptions,
@@ -262,7 +262,7 @@ public static void IterateRowIntervals<T, TBuffer>(
         ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = numOfSteps };
         RowIntervalOperationWrapper<T, TBuffer> wrappingOperation = new(top, bottom, verticalStep, bufferLength, allocator, in operation);
 
-        Parallel.For(
+        _ = Parallel.For(
             0,
             numOfSteps,
             parallelOptions,

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/GifDecoderCore.cs

@@ -468,7 +468,7 @@ private bool ReadFrame<TPixel>(
             int length = this.currentLocalColorTableSize = this.imageDescriptor.LocalColorTableSize * 3;
             this.currentLocalColorTable ??= this.configuration.MemoryAllocator.Allocate<byte>(768, AllocationOptions.Clean);
             stream.Read(this.currentLocalColorTable.GetSpan()[..length]);
-            rawColorTable = this.currentLocalColorTable!.GetSpan()[..length];
+            rawColorTable = this.currentLocalColorTable.GetSpan()[..length];
         }
         else if (this.globalColorTable != null)
         {

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/Png/PngDecoderCore.cs

@@ -214,7 +214,7 @@ protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, Cance
                             break;
                         case PngChunkType.FrameData:
                         {
-                            if (frameCount >= this.maxFrames)
+                            if (frameCount > this.maxFrames)
                             {
                                 goto EOF;
                             }
@@ -275,7 +275,7 @@ protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, Cance
                                 previousFrameControl = currentFrameControl;
                             }
 
-                            if (frameCount >= this.maxFrames)
+                            if (frameCount > this.maxFrames)
                             {
                                 goto EOF;
                             }
@@ -402,7 +402,7 @@ protected override ImageInfo Identify(BufferedReadStream stream, CancellationTok
                             break;
                         case PngChunkType.FrameControl:
                             ++frameCount;
-                            if (frameCount >= this.maxFrames)
+                            if (frameCount > this.maxFrames)
                             {
                                 break;
                             }
@@ -411,8 +411,12 @@ protected override ImageInfo Identify(BufferedReadStream stream, CancellationTok
 
                             break;
                         case PngChunkType.FrameData:
-                            if (frameCount >= this.maxFrames)
+                            if (frameCount > this.maxFrames)
                             {
+                                // Must skip the chunk data even when we've hit maxFrames, because TryReadChunk
+                                // restores the stream position to the start of the fdAT data after CRC validation.
+                                this.SkipChunkDataAndCrc(chunk);
+                                this.SkipRemainingFrameDataChunks(buffer);
                                 break;
                             }
 
@@ -428,9 +432,10 @@ protected override ImageInfo Identify(BufferedReadStream stream, CancellationTok
 
                             InitializeFrameMetadata(framesMetadata, currentFrameControl.Value);
 
-                            // Skip sequence number
-                            this.currentStream.Skip(4);
+                            // Skip data for this and all remaining FrameData chunks belonging to the same frame
+                            // (comparable to how Decode consumes them via ReadScanlines + ReadNextFrameDataChunk).
                             this.SkipChunkDataAndCrc(chunk);
+                            this.SkipRemainingFrameDataChunks(buffer);
                             break;
                         case PngChunkType.Data:
 
@@ -2093,6 +2098,31 @@ private int ReadNextFrameDataChunk()
         return 0;
     }
 
+    /// <summary>
+    /// Skips any remaining <see cref="PngChunkType.FrameData"/> chunks belonging to the current frame.
+    /// This mirrors how <see cref="ReadNextFrameDataChunk"/> is used during decoding:
+    /// consecutive fdAT chunks are consumed until a non-fdAT chunk is encountered,
+    /// which is stored in <see cref="nextChunk"/> for the next iteration.
+    /// </summary>
+    /// <param name="buffer">Temporary buffer.</param>
+    private void SkipRemainingFrameDataChunks(Span<byte> buffer)
+    {
+        while (this.TryReadChunk(buffer, out PngChunk chunk))
+        {
+            if (chunk.Type is PngChunkType.FrameData)
+            {
+                chunk.Data?.Dispose();
+                this.SkipChunkDataAndCrc(chunk);
+            }
+            else
+            {
+                // Not a FrameData chunk; store it so the next TryReadChunk call returns it.
+                this.nextChunk = chunk;
+                return;
+            }
+        }
+    }
+
     /// <summary>
     /// Reads a chunk from the stream.
     /// </summary>