Merge branch 'main' into bp/decodePxr24

Author: brianpopow

src/ImageSharp/Advanced/AdvancedImageExtensions.cs

@@ -76,6 +76,15 @@ public static void AcceptVisitor(this Image source, IImageVisitor visitor)
     public static Task AcceptVisitorAsync(this Image source, IImageVisitorAsync visitor, CancellationToken cancellationToken = default)
         => source.AcceptAsync(visitor, cancellationToken);
 
+    /// <summary>
+    /// Accepts a <see cref="IImageVisitor"/> to implement a double-dispatch pattern in order to
+    /// apply pixel-specific operations on non-generic <see cref="Image"/> instances
+    /// </summary>
+    /// <param name="source">The source image frame.</param>
+    /// <param name="visitor">The image visitor.</param>
+    public static void AcceptVisitor(this ImageFrame source, IImageFrameVisitor visitor)
+        => source.Accept(visitor);
+
     /// <summary>
     /// Gets the representation of the pixels as a <see cref="IMemoryGroup{T}"/> containing the backing pixel data of the image
     /// stored in row major order, as a list of contiguous <see cref="Memory{T}"/> blocks in the source image's pixel format.

src/ImageSharp/Advanced/IImageFrameVisitor.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Advanced;
+
+/// <summary>
+/// A visitor to implement a double-dispatch pattern in order to apply pixel-specific operations
+/// on non-generic <see cref="ImageFrame"/> instances.
+/// </summary>
+public interface IImageFrameVisitor
+{
+    /// <summary>
+    /// Provides a pixel-specific implementation for a given operation.
+    /// </summary>
+    /// <param name="frame">The image frame.</param>
+    /// <typeparam name="TPixel">The pixel type.</typeparam>
+    public void Visit<TPixel>(ImageFrame<TPixel> frame)
+        where TPixel : unmanaged, IPixel<TPixel>;
+}

src/ImageSharp/Advanced/IImageVisitor.cs

@@ -16,7 +16,7 @@ public interface IImageVisitor
     /// </summary>
     /// <param name="image">The image.</param>
     /// <typeparam name="TPixel">The pixel type.</typeparam>
-    void Visit<TPixel>(Image<TPixel> image)
+    public void Visit<TPixel>(Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>;
 }
 
@@ -33,6 +33,6 @@ public interface IImageVisitorAsync
     /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
     /// <typeparam name="TPixel">The pixel type.</typeparam>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-    Task VisitAsync<TPixel>(Image<TPixel> image, CancellationToken cancellationToken)
+    public Task VisitAsync<TPixel>(Image<TPixel> image, CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>;
 }

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -303,7 +303,7 @@ private void EncodeFirstFrame<TPixel>(
         this.WriteGraphicalControlExtension(metadata, stream);
 
         Buffer2D<byte> indices = ((IPixelSource)quantized).PixelBuffer;
-        Rectangle interest = indices.FullRectangle();
+        Rectangle interest = indices.Bounds;
         bool useLocal = this.colorTableMode == FrameColorTableMode.Local || (metadata.ColorTableMode == FrameColorTableMode.Local);
         int bitDepth = ColorNumerics.GetBitsNeededForColorDepth(quantized.Palette.Length);
 

src/ImageSharp/ImageFrame.cs

@@ -71,6 +71,19 @@ public void Dispose()
     /// <param name="disposing">Whether to dispose of managed and unmanaged objects.</param>
     protected abstract void Dispose(bool disposing);
 
+    /// <summary>
+    /// Accepts a <see cref="IImageFrameVisitor"/>.
+    /// Implemented by <see cref="ImageFrame{TPixel}"/> invoking <see cref="IImageFrameVisitor.Visit{TPixel}"/>
+    /// with the pixel type of the image.
+    /// </summary>
+    /// <param name="visitor">The visitor.</param>
+    internal abstract void Accept(IImageFrameVisitor visitor);
+
+    /// <summary>
+    /// Copies the pixel data of the image frame to a <see cref="Buffer2D{TDestinationPixel}"/> of a specific pixel type.
+    /// </summary>
+    /// <typeparam name="TDestinationPixel">The pixel type of the destination buffer.</typeparam>
+    /// <param name="destination">The buffer to copy the pixel data to.</param>
     internal abstract void CopyPixelsTo<TDestinationPixel>(Buffer2D<TDestinationPixel> destination)
         where TDestinationPixel : unmanaged, IPixel<TDestinationPixel>;
 

src/ImageSharp/ImageFrame{TPixel}.cs

@@ -339,14 +339,18 @@ public bool DangerousTryGetSinglePixelMemory(out Memory<TPixel> memory)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal ref TPixel GetPixelReference(int x, int y) => ref this.PixelBuffer[x, y];
 
+    /// <inheritdoc />
+    internal override void Accept(IImageFrameVisitor visitor)
+        => visitor.Visit(this);
+
     /// <summary>
     /// Copies the pixels to a <see cref="Buffer2D{TPixel}"/> of the same size.
     /// </summary>
     /// <param name="target">The target pixel buffer accessor.</param>
     /// <exception cref="ArgumentException">ImageFrame{TPixel}.CopyTo(): target must be of the same size!</exception>
     internal void CopyTo(Buffer2D<TPixel> target)
     {
-        if (this.Size != target.Size())
+        if (this.Size != target.Size)
         {
             throw new ArgumentException("ImageFrame<TPixel>.CopyTo(): target must be of the same size!", nameof(target));
         }
@@ -363,8 +367,8 @@ internal void SwapOrCopyPixelsBufferFrom(ImageFrame<TPixel> source)
     {
         Guard.NotNull(source, nameof(source));
 
-        Buffer2D<TPixel>.SwapOrCopyContent(this.PixelBuffer, source.PixelBuffer);
-        this.UpdateSize(this.PixelBuffer.Size());
+        _ = Buffer2D<TPixel>.SwapOrCopyContent(this.PixelBuffer, source.PixelBuffer);
+        this.UpdateSize(this.PixelBuffer.Size);
     }
 
     /// <summary>
@@ -475,10 +479,7 @@ internal ImageFrame<TPixel2> CloneAs<TPixel2>(Configuration configuration)
     /// Clears the bitmap.
     /// </summary>
     /// <param name="value">The value to initialize the bitmap with.</param>
-    internal void Clear(TPixel value)
-    {
-        this.PixelBuffer.Clear(value);
-    }
+    internal void Clear(TPixel value) => this.PixelBuffer.Clear(value);
 
     [MethodImpl(InliningOptions.ShortMethod)]
     private void VerifyCoords(int x, int y)

src/ImageSharp/Image{TPixel}.cs

@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;

src/ImageSharp/Memory/Buffer2DExtensions.cs

@@ -104,60 +104,40 @@ internal static unsafe void DangerousCopyColumns<T>(
     }
 
     /// <summary>
-    /// Returns a <see cref="Rectangle"/> representing the full area of the buffer.
-    /// </summary>
-    /// <typeparam name="T">The element type</typeparam>
-    /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
-    /// <returns>The <see cref="Rectangle"/></returns>
-    internal static Rectangle FullRectangle<T>(this Buffer2D<T> buffer)
-        where T : struct
-        => new(0, 0, buffer.Width, buffer.Height);
-
-    /// <summary>
-    /// Return a <see cref="Buffer2DRegion{T}"/> to the subregion represented by 'rectangle'
+    /// Return a <see cref="Buffer2DRegion{T}"/> to the subregion represented by <paramref name="rectangle"/>.
     /// </summary>
     /// <typeparam name="T">The element type</typeparam>
     /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
     /// <param name="rectangle">The rectangle subregion</param>
     /// <returns>The <see cref="Buffer2DRegion{T}"/></returns>
-    internal static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer, Rectangle rectangle)
+    public static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer, Rectangle rectangle)
         where T : unmanaged =>
         new(buffer, rectangle);
 
-    internal static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer, int x, int y, int width, int height)
+    /// <summary>
+    /// Return a <see cref="Buffer2DRegion{T}"/> to the specified area of <paramref name="buffer"/>.
+    /// </summary>
+    /// <typeparam name="T">The element type.</typeparam>
+    /// <param name="buffer">The <see cref="Buffer2D{T}"/>.</param>
+    /// <param name="x">The X coordinate of the region.</param>
+    /// <param name="y">The Y coordinate of the region.</param>
+    /// <param name="width">The region width.</param>
+    /// <param name="height">The region height.</param>
+    /// <returns>The <see cref="Buffer2DRegion{T}"/>.</returns>
+    public static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer, int x, int y, int width, int height)
         where T : unmanaged =>
         new(buffer, new Rectangle(x, y, width, height));
 
     /// <summary>
-    /// Return a <see cref="Buffer2DRegion{T}"/> to the whole area of 'buffer'
+    /// Return a <see cref="Buffer2DRegion{T}"/> to the whole area of <paramref name="buffer"/>.
     /// </summary>
     /// <typeparam name="T">The element type</typeparam>
     /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
     /// <returns>The <see cref="Buffer2DRegion{T}"/></returns>
-    internal static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer)
+    public static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer)
         where T : unmanaged =>
         new(buffer);
 
-    /// <summary>
-    /// Returns the size of the buffer.
-    /// </summary>
-    /// <typeparam name="T">The element type</typeparam>
-    /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
-    /// <returns>The <see cref="Size{T}"/> of the buffer</returns>
-    internal static Size Size<T>(this Buffer2D<T> buffer)
-        where T : struct =>
-        new(buffer.Width, buffer.Height);
-
-    /// <summary>
-    /// Gets the bounds of the buffer.
-    /// </summary>
-    /// <typeparam name="T">The element type</typeparam>
-    /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
-    /// <returns>The <see cref="Rectangle"/></returns>
-    internal static Rectangle Bounds<T>(this Buffer2D<T> buffer)
-        where T : struct =>
-        new(0, 0, buffer.Width, buffer.Height);
-
     [Conditional("DEBUG")]
     private static void CheckColumnRegionsDoNotOverlap<T>(
         Buffer2D<T> buffer,

src/ImageSharp/Memory/Buffer2DRegion{T}.cs

@@ -15,17 +15,17 @@ public readonly struct Buffer2DRegion<T>
     /// Initializes a new instance of the <see cref="Buffer2DRegion{T}"/> struct.
     /// </summary>
     /// <param name="buffer">The <see cref="Buffer2D{T}"/>.</param>
-    /// <param name="rectangle">The <see cref="Rectangle"/> defining a rectangular area within the buffer.</param>
+    /// <param name="bounds">The <see cref="Bounds"/> defining a rectangular area within the buffer.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Buffer2DRegion(Buffer2D<T> buffer, Rectangle rectangle)
+    public Buffer2DRegion(Buffer2D<T> buffer, Rectangle bounds)
     {
-        DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.X, 0, nameof(rectangle));
-        DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.Y, 0, nameof(rectangle));
-        DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, buffer.Width, nameof(rectangle));
-        DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, buffer.Height, nameof(rectangle));
+        DebugGuard.MustBeGreaterThanOrEqualTo(bounds.X, 0, nameof(bounds));
+        DebugGuard.MustBeGreaterThanOrEqualTo(bounds.Y, 0, nameof(bounds));
+        DebugGuard.MustBeLessThanOrEqualTo(bounds.Width, buffer.Width, nameof(bounds));
+        DebugGuard.MustBeLessThanOrEqualTo(bounds.Height, buffer.Height, nameof(bounds));
 
         this.Buffer = buffer;
-        this.Rectangle = rectangle;
+        this.Bounds = bounds;
     }
 
     /// <summary>
@@ -34,15 +34,10 @@ public Buffer2DRegion(Buffer2D<T> buffer, Rectangle rectangle)
     /// <param name="buffer">The <see cref="Buffer2D{T}"/>.</param>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Buffer2DRegion(Buffer2D<T> buffer)
-        : this(buffer, buffer.FullRectangle())
+        : this(buffer, buffer.Bounds)
     {
     }
 
-    /// <summary>
-    /// Gets the rectangle specifying the boundaries of the area in <see cref="Buffer"/>.
-    /// </summary>
-    public Rectangle Rectangle { get; }
-
     /// <summary>
     /// Gets the <see cref="Buffer2D{T}"/> being pointed by this instance.
     /// </summary>
@@ -51,12 +46,12 @@ public Buffer2DRegion(Buffer2D<T> buffer)
     /// <summary>
     /// Gets the width
     /// </summary>
-    public int Width => this.Rectangle.Width;
+    public int Width => this.Bounds.Width;
 
     /// <summary>
     /// Gets the height
     /// </summary>
-    public int Height => this.Rectangle.Height;
+    public int Height => this.Bounds.Height;
 
     /// <summary>
     /// Gets the number of elements between row starts in <see cref="Buffer"/>.
@@ -66,20 +61,25 @@ public Buffer2DRegion(Buffer2D<T> buffer)
     /// <summary>
     /// Gets the size of the area.
     /// </summary>
-    internal Size Size => this.Rectangle.Size;
+    public Size Size => this.Bounds.Size;
+
+    /// <summary>
+    /// Gets the rectangle specifying the boundaries of the area in <see cref="Buffer"/>.
+    /// </summary>
+    public Rectangle Bounds { get; }
 
     /// <summary>
     /// Gets a value indicating whether the area refers to the entire <see cref="Buffer"/>
     /// </summary>
-    internal bool IsFullBufferArea => this.Size == this.Buffer.Size();
+    internal bool IsFullBufferArea => this.Size == this.Buffer.Size;
 
     /// <summary>
     /// Gets or sets a value at the given index.
     /// </summary>
     /// <param name="x">The position inside a row</param>
     /// <param name="y">The row index</param>
     /// <returns>The reference to the value</returns>
-    internal ref T this[int x, int y] => ref this.Buffer[x + this.Rectangle.X, y + this.Rectangle.Y];
+    internal ref T this[int x, int y] => ref this.Buffer[x + this.Bounds.X, y + this.Bounds.Y];
 
     /// <summary>
     /// Gets a span to row 'y' inside this area.
@@ -89,9 +89,9 @@ public Buffer2DRegion(Buffer2D<T> buffer)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Span<T> DangerousGetRowSpan(int y)
     {
-        int yy = this.Rectangle.Y + y;
-        int xx = this.Rectangle.X;
-        int width = this.Rectangle.Width;
+        int yy = this.Bounds.Y + y;
+        int xx = this.Bounds.X;
+        int width = this.Bounds.Width;
 
         return this.Buffer.DangerousGetRowSpan(yy).Slice(xx, width);
     }
@@ -114,16 +114,16 @@ public Buffer2DRegion<T> GetSubRegion(int x, int y, int width, int height)
     /// <summary>
     /// Returns a subregion as <see cref="Buffer2DRegion{T}"/>. (Similar to <see cref="Span{T}.Slice(int, int)"/>.)
     /// </summary>
-    /// <param name="rectangle">The <see cref="Rectangle"/> specifying the boundaries of the subregion</param>
+    /// <param name="rectangle">The <see cref="Bounds"/> specifying the boundaries of the subregion</param>
     /// <returns>The subregion</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Buffer2DRegion<T> GetSubRegion(Rectangle rectangle)
     {
-        DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, this.Rectangle.Width, nameof(rectangle));
-        DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, this.Rectangle.Height, nameof(rectangle));
+        DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, this.Bounds.Width, nameof(rectangle));
+        DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, this.Bounds.Height, nameof(rectangle));
 
-        int x = this.Rectangle.X + rectangle.X;
-        int y = this.Rectangle.Y + rectangle.Y;
+        int x = this.Bounds.X + rectangle.X;
+        int y = this.Bounds.Y + rectangle.Y;
         rectangle = new Rectangle(x, y, rectangle.Width, rectangle.Height);
         return new Buffer2DRegion<T>(this.Buffer, rectangle);
     }
@@ -135,8 +135,8 @@ public Buffer2DRegion<T> GetSubRegion(Rectangle rectangle)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal ref T GetReferenceToOrigin()
     {
-        int y = this.Rectangle.Y;
-        int x = this.Rectangle.X;
+        int y = this.Bounds.Y;
+        int x = this.Bounds.X;
         return ref this.Buffer.DangerousGetRowSpan(y)[x];
     }
 
@@ -152,7 +152,7 @@ internal void Clear()
             return;
         }
 
-        for (int y = 0; y < this.Rectangle.Height; y++)
+        for (int y = 0; y < this.Bounds.Height; y++)
         {
             Span<T> row = this.DangerousGetRowSpan(y);
             row.Clear();
@@ -172,7 +172,7 @@ internal void Fill(T value)
             return;
         }
 
-        for (int y = 0; y < this.Rectangle.Height; y++)
+        for (int y = 0; y < this.Bounds.Height; y++)
         {
             Span<T> row = this.DangerousGetRowSpan(y);
             row.Fill(value);