Merge branch 'js/gif-fixes' into js/png-pallete

Author: JimBobSquarePants

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

@@ -640,7 +640,7 @@ public static Vector256<float> MultiplyAddNegated(
         /// <param name="mask">The mask vector.</param>
         /// <returns>The <see cref="Vector256{T}"/>.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Vector128<byte> BlendVariable(in Vector128<byte> left, in Vector128<byte> right, in Vector128<byte> mask)
+        public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask)
         {
             if (Sse41.IsSupported)
             {

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -291,20 +291,20 @@ private void EncodeFrame<TPixel>(
 
         this.WriteGraphicalControlExtension(metadata, transparencyIndex, stream);
 
-        // TODO: Consider an optimization that trims down the buffer to the minimum size required.
-        // We would use a process similar to entropy crop where we trim the buffer from the edges
-        // until we hit a non-transparent pixel.
-        this.WriteImageDescriptor(frame, useLocal, stream);
+        // Assign the correct buffer to compress.
+        // If we are using a local palette or it's the first run then we want to use the quantized frame.
+        Buffer2D<byte> buffer = useLocal || frameIndex == 0 ? ((IPixelSource)quantized).PixelBuffer : indices;
+
+        // Trim down the buffer to the minimum size required.
+        Buffer2DRegion<byte> region = TrimTransparentPixels(buffer, transparencyIndex);
+        this.WriteImageDescriptor(region.Rectangle, useLocal, stream);
 
         if (useLocal)
         {
             this.WriteColorTable(quantized, stream);
         }
 
-        // Assign the correct buffer to compress.
-        // If we are using a local palette or it's the first run then we want to use the quantized frame.
-        Buffer2D<byte> buffer = useLocal || frameIndex == 0 ? ((IPixelSource)quantized).PixelBuffer : indices;
-        this.WriteImageData(buffer, stream);
+        this.WriteImageData(region, stream);
 
         // Swap the buffers.
         (quantized, previousQuantized) = (previousQuantized, quantized);
@@ -386,6 +386,44 @@ private static void DeDuplicatePixels<TPixel>(
         }
     }
 
+    private static Buffer2DRegion<byte> TrimTransparentPixels(Buffer2D<byte> buffer, int transparencyIndex)
+    {
+        if (transparencyIndex < 0)
+        {
+            return buffer.GetRegion();
+        }
+
+        byte trimmableIndex = unchecked((byte)transparencyIndex);
+
+        int top = int.MaxValue;
+        int bottom = int.MinValue;
+        int left = int.MaxValue;
+        int right = int.MinValue;
+
+        for (int y = 0; y < buffer.Height; y++)
+        {
+            Span<byte> rowSpan = buffer.DangerousGetRowSpan(y);
+            for (int x = 0; x < rowSpan.Length; x++)
+            {
+                if (rowSpan[x] != trimmableIndex)
+                {
+                    top = Math.Min(top, y);
+                    bottom = Math.Max(bottom, y);
+                    left = Math.Min(left, x);
+                    right = Math.Max(right, x);
+                }
+            }
+        }
+
+        if (top == int.MaxValue || bottom == int.MinValue)
+        {
+            // No valid rectangle found
+            return buffer.GetRegion();
+        }
+
+        return buffer.GetRegion(Rectangle.FromLTRB(left, top, right, bottom));
+    }
+
     /// <summary>
     /// Returns the index of the most transparent color in the palette.
     /// </summary>
@@ -583,7 +621,7 @@ private void WriteGraphicalControlExtension(GifFrameMetadata? metadata, int tran
         if (metadata is null)
         {
             metadata = new();
-            hasTransparency = transparencyIndex > -1;
+            hasTransparency = transparencyIndex >= 0;
         }
         else
         {
@@ -619,7 +657,7 @@ private void WriteExtension<TGifExtension>(TGifExtension extension, Stream strea
         }
 
         IMemoryOwner<byte>? owner = null;
-        Span<byte> extensionBuffer = stackalloc byte[0];    // workaround compiler limitation
+        Span<byte> extensionBuffer = stackalloc byte[0]; // workaround compiler limitation
         if (extensionSize > 128)
         {
             owner = this.memoryAllocator.Allocate<byte>(extensionSize + 3);
@@ -642,14 +680,12 @@ private void WriteExtension<TGifExtension>(TGifExtension extension, Stream strea
     }
 
     /// <summary>
-    /// Writes the image descriptor to the stream.
+    /// Writes the image frame descriptor to the stream.
     /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    /// <param name="image">The <see cref="ImageFrame{TPixel}"/> to be encoded.</param>
+    /// <param name="rectangle">The frame location and size.</param>
     /// <param name="hasColorTable">Whether to use the global color table.</param>
     /// <param name="stream">The stream to write to.</param>
-    private void WriteImageDescriptor<TPixel>(ImageFrame<TPixel> image, bool hasColorTable, Stream stream)
-        where TPixel : unmanaged, IPixel<TPixel>
+    private void WriteImageDescriptor(Rectangle rectangle, bool hasColorTable, Stream stream)
     {
         byte packedValue = GifImageDescriptor.GetPackedValue(
             localColorTableFlag: hasColorTable,
@@ -658,10 +694,10 @@ private void WriteImageDescriptor<TPixel>(ImageFrame<TPixel> image, bool hasColo
             localColorTableSize: this.bitDepth - 1);
 
         GifImageDescriptor descriptor = new(
-            left: 0,
-            top: 0,
-            width: (ushort)image.Width,
-            height: (ushort)image.Height,
+            left: (ushort)rectangle.X,
+            top: (ushort)rectangle.Y,
+            width: (ushort)rectangle.Width,
+            height: (ushort)rectangle.Height,
             packed: packedValue);
 
         Span<byte> buffer = stackalloc byte[20];
@@ -697,9 +733,9 @@ private void WriteColorTable<TPixel>(IndexedImageFrame<TPixel> image, Stream str
     /// <summary>
     /// Writes the image pixel data to the stream.
     /// </summary>
-    /// <param name="indices">The <see cref="Buffer2D{Byte}"/> containing indexed pixels.</param>
+    /// <param name="indices">The <see cref="Buffer2DRegion{Byte}"/> containing indexed pixels.</param>
     /// <param name="stream">The stream to write to.</param>
-    private void WriteImageData(Buffer2D<byte> indices, Stream stream)
+    private void WriteImageData(Buffer2DRegion<byte> indices, Stream stream)
     {
         using LzwEncoder encoder = new(this.memoryAllocator, (byte)this.bitDepth);
         encoder.Encode(indices, stream);

src/ImageSharp/Formats/Gif/LzwEncoder.cs

@@ -186,7 +186,7 @@ public LzwEncoder(MemoryAllocator memoryAllocator, int colorDepth)
     /// </summary>
     /// <param name="indexedPixels">The 2D buffer of indexed pixels.</param>
     /// <param name="stream">The stream to write to.</param>
-    public void Encode(Buffer2D<byte> indexedPixels, Stream stream)
+    public void Encode(Buffer2DRegion<byte> indexedPixels, Stream stream)
     {
         // Write "initial code size" byte
         stream.WriteByte((byte)this.initialCodeSize);
@@ -249,7 +249,7 @@ private void ClearBlock(Stream stream)
     /// <param name="indexedPixels">The 2D buffer of indexed pixels.</param>
     /// <param name="initialBits">The initial bits.</param>
     /// <param name="stream">The stream to write to.</param>
-    private void Compress(Buffer2D<byte> indexedPixels, int initialBits, Stream stream)
+    private void Compress(Buffer2DRegion<byte> indexedPixels, int initialBits, Stream stream)
     {
         // Set up the globals: globalInitialBits - initial number of bits
         this.globalInitialBits = initialBits;

src/ImageSharp/IO/IFileSystem.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.IO;
@@ -9,16 +9,32 @@ namespace SixLabors.ImageSharp.IO;
 internal interface IFileSystem
 {
     /// <summary>
-    /// Returns a readable stream as defined by the path.
+    /// Opens a file as defined by the path and returns it as a readable stream.
     /// </summary>
     /// <param name="path">Path to the file to open.</param>
-    /// <returns>A stream representing the file to open.</returns>
+    /// <returns>A stream representing the opened file.</returns>
     Stream OpenRead(string path);
 
     /// <summary>
-    /// Creates or opens a file and returns it as a writable stream as defined by the path.
+    /// Opens a file as defined by the path and returns it as a readable stream
+    /// that can be used for asynchronous reading.
     /// </summary>
     /// <param name="path">Path to the file to open.</param>
-    /// <returns>A stream representing the file to open.</returns>
+    /// <returns>A stream representing the opened file.</returns>
+    Stream OpenReadAsynchronous(string path);
+
+    /// <summary>
+    /// Creates or opens a file as defined by the path and returns it as a writable stream.
+    /// </summary>
+    /// <param name="path">Path to the file to open.</param>
+    /// <returns>A stream representing the opened file.</returns>
     Stream Create(string path);
+
+    /// <summary>
+    /// Creates or opens a file as defined by the path and returns it as a writable stream
+    /// that can be used for asynchronous reading and writing.
+    /// </summary>
+    /// <param name="path">Path to the file to open.</param>
+    /// <returns>A stream representing the opened file.</returns>
+    Stream CreateAsynchronous(string path);
 }

src/ImageSharp/IO/LocalFileSystem.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.IO;
@@ -11,6 +11,24 @@ internal sealed class LocalFileSystem : IFileSystem
     /// <inheritdoc/>
     public Stream OpenRead(string path) => File.OpenRead(path);
 
+    /// <inheritdoc/>
+    public Stream OpenReadAsynchronous(string path) => File.Open(path, new FileStreamOptions
+    {
+        Mode = FileMode.Open,
+        Access = FileAccess.Read,
+        Share = FileShare.Read,
+        Options = FileOptions.Asynchronous,
+    });
+
     /// <inheritdoc/>
     public Stream Create(string path) => File.Create(path);
+
+    /// <inheritdoc/>
+    public Stream CreateAsynchronous(string path) => File.Open(path, new FileStreamOptions
+    {
+        Mode = FileMode.Create,
+        Access = FileAccess.ReadWrite,
+        Share = FileShare.None,
+        Options = FileOptions.Asynchronous,
+    });
 }

src/ImageSharp/Image.FromFile.cs

@@ -72,7 +72,7 @@ public static async Task<IImageFormat> DetectFormatAsync(
     {
         Guard.NotNull(options, nameof(options));
 
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await DetectFormatAsync(options, stream, cancellationToken).ConfigureAwait(false);
     }
 
@@ -144,7 +144,7 @@ public static async Task<ImageInfo> IdentifyAsync(
         CancellationToken cancellationToken = default)
     {
         Guard.NotNull(options, nameof(options));
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await IdentifyAsync(options, stream, cancellationToken).ConfigureAwait(false);
     }
 
@@ -214,7 +214,7 @@ public static async Task<Image> LoadAsync(
         string path,
         CancellationToken cancellationToken = default)
     {
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await LoadAsync(options, stream, cancellationToken).ConfigureAwait(false);
     }
 
@@ -291,7 +291,7 @@ public static async Task<Image<TPixel>> LoadAsync<TPixel>(
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(path, nameof(path));
 
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await LoadAsync<TPixel>(options, stream, cancellationToken).ConfigureAwait(false);
     }
 }

src/ImageSharp/ImageExtensions.cs

@@ -70,7 +70,7 @@ public static async Task SaveAsync(
         Guard.NotNull(path, nameof(path));
         Guard.NotNull(encoder, nameof(encoder));
 
-        using Stream fs = source.GetConfiguration().FileSystem.Create(path);
+        await using Stream fs = source.GetConfiguration().FileSystem.CreateAsynchronous(path);
         await source.SaveAsync(fs, encoder, cancellationToken).ConfigureAwait(false);
     }