Merge branch 'main' into icc-color-conversion

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -10,10 +10,13 @@
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.Formats.Pbm;
 using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.Formats.Qoi;
 using SixLabors.ImageSharp.Formats.Tga;
 using SixLabors.ImageSharp.Formats.Tiff;
+using SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors;
 using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -129,6 +132,7 @@ private static void Seed<TPixel>()
         AotCompileImageDecoderInternals<TPixel>();
         AotCompileImageEncoders<TPixel>();
         AotCompileImageDecoders<TPixel>();
+        AotCompileSpectralConverter<TPixel>();
         AotCompileImageProcessors<TPixel>();
         AotCompileGenericImageProcessors<TPixel>();
         AotCompileResamplers<TPixel>();
@@ -195,39 +199,41 @@ private static void AotCompileImageProcessingContextFactory<TPixel>()
             => default(DefaultImageOperationsProviderFactory).CreateImageProcessingContext<TPixel>(default, default, default);
 
     /// <summary>
-    /// This method pre-seeds the all <see cref="IImageEncoderInternals"/> in the AoT compiler.
+    /// This method pre-seeds the all core encoders in the AoT compiler.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
     [Preserve]
     private static void AotCompileImageEncoderInternals<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        default(WebpEncoderCore).Encode<TPixel>(default, default, default);
         default(BmpEncoderCore).Encode<TPixel>(default, default, default);
         default(GifEncoderCore).Encode<TPixel>(default, default, default);
         default(JpegEncoderCore).Encode<TPixel>(default, default, default);
         default(PbmEncoderCore).Encode<TPixel>(default, default, default);
         default(PngEncoderCore).Encode<TPixel>(default, default, default);
+        default(QoiEncoderCore).Encode<TPixel>(default, default, default);
         default(TgaEncoderCore).Encode<TPixel>(default, default, default);
         default(TiffEncoderCore).Encode<TPixel>(default, default, default);
+        default(WebpEncoderCore).Encode<TPixel>(default, default, default);
     }
 
     /// <summary>
-    /// This method pre-seeds the all <see cref="IImageDecoderInternals"/> in the AoT compiler.
+    /// This method pre-seeds the all <see cref="ImageDecoderCore"/> in the AoT compiler.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
     [Preserve]
     private static void AotCompileImageDecoderInternals<TPixel>()
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        default(WebpDecoderCore).Decode<TPixel>(default, default);
-        default(BmpDecoderCore).Decode<TPixel>(default, default);
-        default(GifDecoderCore).Decode<TPixel>(default, default);
-        default(JpegDecoderCore).Decode<TPixel>(default, default);
-        default(PbmDecoderCore).Decode<TPixel>(default, default);
-        default(PngDecoderCore).Decode<TPixel>(default, default);
-        default(TgaDecoderCore).Decode<TPixel>(default, default);
-        default(TiffDecoderCore).Decode<TPixel>(default, default);
+        default(BmpDecoderCore).Decode<TPixel>(default, default, default);
+        default(GifDecoderCore).Decode<TPixel>(default, default, default);
+        default(JpegDecoderCore).Decode<TPixel>(default, default, default);
+        default(PbmDecoderCore).Decode<TPixel>(default, default, default);
+        default(PngDecoderCore).Decode<TPixel>(default, default, default);
+        default(QoiDecoderCore).Decode<TPixel>(default, default, default);
+        default(TgaDecoderCore).Decode<TPixel>(default, default, default);
+        default(TiffDecoderCore).Decode<TPixel>(default, default, default);
+        default(WebpDecoderCore).Decode<TPixel>(default, default, default);
     }
 
     /// <summary>
@@ -266,6 +272,17 @@ private static void AotCompileImageDecoders<TPixel>()
         AotCompileImageDecoder<TPixel, TiffDecoder>();
     }
 
+    [Preserve]
+    private static void AotCompileSpectralConverter<TPixel>()
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        default(SpectralConverter<TPixel>).GetPixelBuffer(default);
+        default(GrayJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
+        default(RgbJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
+        default(TiffJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
+        default(TiffOldJpegSpectralConverter<TPixel>).GetPixelBuffer(default);
+    }
+
     /// <summary>
     /// This method pre-seeds the <see cref="IImageEncoder"/> in the AoT compiler.
     /// </summary>

src/ImageSharp/Formats/AnimatedImageFrameMetadata.cs

@@ -30,65 +30,3 @@ internal class AnimatedImageFrameMetadata
     /// </summary>
     public FrameDisposalMode DisposalMode { get; set; }
 }
-
-#pragma warning disable SA1201 // Elements should appear in the correct order
-internal enum FrameBlendMode
-#pragma warning restore SA1201 // Elements should appear in the correct order
-{
-    /// <summary>
-    /// Do not blend. Render the current frame on the canvas by overwriting the rectangle covered by the current frame.
-    /// </summary>
-    Source = 0,
-
-    /// <summary>
-    /// Blend the current frame with the previous frame in the animation sequence within the rectangle covered
-    /// by the current frame.
-    /// If the current has any transparent areas, the corresponding areas of the previous frame will be visible
-    /// through these transparent regions.
-    /// </summary>
-    Over = 1
-}
-
-internal enum FrameDisposalMode
-{
-    /// <summary>
-    /// No disposal specified.
-    /// The decoder is not required to take any action.
-    /// </summary>
-    Unspecified = 0,
-
-    /// <summary>
-    /// Do not dispose. The current frame is not disposed of, or in other words, not cleared or altered when moving to
-    /// the next frame. This means that the next frame is drawn over the current frame, and if the next frame contains
-    /// transparency, the previous frame will be visible through these transparent areas.
-    /// </summary>
-    DoNotDispose = 1,
-
-    /// <summary>
-    /// Restore to background color. When transitioning to the next frame, the area occupied by the current frame is
-    /// filled with the background color specified in the image metadata.
-    /// This effectively erases the current frame by replacing it with the background color before the next frame is displayed.
-    /// </summary>
-    RestoreToBackground = 2,
-
-    /// <summary>
-    /// Restore to previous. This method restores the area affected by the current frame to what it was before the
-    /// current frame was displayed. It essentially "undoes" the current frame, reverting to the state of the image
-    /// before the frame was displayed, then the next frame is drawn. This is useful for animations where only a small
-    /// part of the image changes from frame to frame.
-    /// </summary>
-    RestoreToPrevious = 3
-}
-
-internal enum FrameColorTableMode
-{
-    /// <summary>
-    /// The frame uses the shared color table specified by the image metadata.
-    /// </summary>
-    Global,
-
-    /// <summary>
-    /// The frame uses a color table specified by the frame metadata.
-    /// </summary>
-    Local
-}

src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs

@@ -11,35 +11,35 @@ public enum BmpBitsPerPixel : short
     /// <summary>
     /// 1 bit per pixel.
     /// </summary>
-    Pixel1 = 1,
+    Bit1 = 1,
 
     /// <summary>
     /// 2 bits per pixel.
     /// </summary>
-    Pixel2 = 2,
+    Bit2 = 2,
 
     /// <summary>
     /// 4 bits per pixel.
     /// </summary>
-    Pixel4 = 4,
+    Bit4 = 4,
 
     /// <summary>
     /// 8 bits per pixel. Each pixel consists of 1 byte.
     /// </summary>
-    Pixel8 = 8,
+    Bit8 = 8,
 
     /// <summary>
     /// 16 bits per pixel. Each pixel consists of 2 bytes.
     /// </summary>
-    Pixel16 = 16,
+    Bit16 = 16,
 
     /// <summary>
     /// 24 bits per pixel. Each pixel consists of 3 bytes.
     /// </summary>
-    Pixel24 = 24,
+    Bit24 = 24,
 
     /// <summary>
     /// 32 bits per pixel. Each pixel consists of 4 bytes.
     /// </summary>
-    Pixel32 = 32
+    Bit32 = 32
 }

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp;
 /// <remarks>
 /// A useful decoding source example can be found at <see href="https://dxr.mozilla.org/mozilla-central/source/image/decoders/nsBMPDecoder.cpp"/>
 /// </remarks>
-internal sealed class BmpDecoderCore : IImageDecoderInternals
+internal sealed class BmpDecoderCore : ImageDecoderCore
 {
     /// <summary>
     /// The default mask for the red part of the color for 16 bit rgb bitmaps.
@@ -114,8 +114,8 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// </summary>
     /// <param name="options">The options.</param>
     public BmpDecoderCore(BmpDecoderOptions options)
+        : base(options.GeneralOptions)
     {
-        this.Options = options.GeneralOptions;
         this.rleSkippedPixelHandling = options.RleSkippedPixelHandling;
         this.configuration = options.GeneralOptions.Configuration;
         this.memoryAllocator = this.configuration.MemoryAllocator;
@@ -125,14 +125,7 @@ public BmpDecoderCore(BmpDecoderOptions options)
     }
 
     /// <inheritdoc />
-    public DecoderOptions Options { get; }
-
-    /// <inheritdoc />
-    public Size Dimensions => new(this.infoHeader.Width, this.infoHeader.Height);
-
-    /// <inheritdoc />
-    public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
-        where TPixel : unmanaged, IPixel<TPixel>
+    protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
     {
         Image<TPixel>? image = null;
         try
@@ -224,10 +217,10 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
     }
 
     /// <inheritdoc />
-    public ImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
+    protected override ImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
     {
         this.ReadImageHeaders(stream, out _, out _);
-        return new ImageInfo(new PixelTypeInfo(this.infoHeader.BitsPerPixel), new(this.infoHeader.Width, this.infoHeader.Height), this.metadata);
+        return new ImageInfo(new(this.infoHeader.Width, this.infoHeader.Height), this.metadata);
     }
 
     /// <summary>
@@ -1463,6 +1456,8 @@ private void ReadInfoHeader(BufferedReadStream stream)
         this.bmpMetadata = this.metadata.GetBmpMetadata();
         this.bmpMetadata.InfoHeaderType = infoHeaderType;
         this.bmpMetadata.BitsPerPixel = (BmpBitsPerPixel)bitsPerPixel;
+
+        this.Dimensions = new(this.infoHeader.Width, this.infoHeader.Height);
     }
 
     /// <summary>

src/ImageSharp/Formats/Bmp/BmpEncoder.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Processing;
 
 namespace SixLabors.ImageSharp.Formats.Bmp;

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp;
 /// <summary>
 /// Image encoder for writing an image to a stream as a Windows bitmap.
 /// </summary>
-internal sealed class BmpEncoderCore : IImageEncoderInternals
+internal sealed class BmpEncoderCore
 {
     /// <summary>
     /// The amount to pad each row by.
@@ -146,10 +146,10 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
 
         int colorPaletteSize = this.bitsPerPixel switch
         {
-            BmpBitsPerPixel.Pixel8 => ColorPaletteSize8Bit,
-            BmpBitsPerPixel.Pixel4 => ColorPaletteSize4Bit,
-            BmpBitsPerPixel.Pixel2 => ColorPaletteSize2Bit,
-            BmpBitsPerPixel.Pixel1 => ColorPaletteSize1Bit,
+            BmpBitsPerPixel.Bit8 => ColorPaletteSize8Bit,
+            BmpBitsPerPixel.Bit4 => ColorPaletteSize4Bit,
+            BmpBitsPerPixel.Bit2 => ColorPaletteSize2Bit,
+            BmpBitsPerPixel.Bit1 => ColorPaletteSize1Bit,
             _ => 0
         };
 
@@ -248,7 +248,7 @@ private BmpInfoHeader CreateBmpInfoHeader(int width, int height, int infoHeaderS
             clrUsed: 0,
             clrImportant: 0);
 
-        if ((this.infoHeaderType is BmpInfoHeaderType.WinVersion4 or BmpInfoHeaderType.WinVersion5) && this.bitsPerPixel == BmpBitsPerPixel.Pixel32)
+        if ((this.infoHeaderType is BmpInfoHeaderType.WinVersion4 or BmpInfoHeaderType.WinVersion5) && this.bitsPerPixel == BmpBitsPerPixel.Bit32)
         {
             infoHeader.AlphaMask = Rgba32AlphaMask;
             infoHeader.RedMask = Rgba32RedMask;
@@ -351,31 +351,31 @@ private void WriteImage<TPixel>(Configuration configuration, Stream stream, Imag
         Buffer2D<TPixel> pixels = image.Frames.RootFrame.PixelBuffer;
         switch (this.bitsPerPixel)
         {
-            case BmpBitsPerPixel.Pixel32:
+            case BmpBitsPerPixel.Bit32:
                 this.Write32BitPixelData(configuration, stream, pixels);
                 break;
 
-            case BmpBitsPerPixel.Pixel24:
+            case BmpBitsPerPixel.Bit24:
                 this.Write24BitPixelData(configuration, stream, pixels);
                 break;
 
-            case BmpBitsPerPixel.Pixel16:
+            case BmpBitsPerPixel.Bit16:
                 this.Write16BitPixelData(configuration, stream, pixels);
                 break;
 
-            case BmpBitsPerPixel.Pixel8:
+            case BmpBitsPerPixel.Bit8:
                 this.Write8BitPixelData(configuration, stream, image);
                 break;
 
-            case BmpBitsPerPixel.Pixel4:
+            case BmpBitsPerPixel.Bit4:
                 this.Write4BitPixelData(configuration, stream, image);
                 break;
 
-            case BmpBitsPerPixel.Pixel2:
+            case BmpBitsPerPixel.Bit2:
                 this.Write2BitPixelData(configuration, stream, image);
                 break;
 
-            case BmpBitsPerPixel.Pixel1:
+            case BmpBitsPerPixel.Bit1:
                 this.Write1BitPixelData(configuration, stream, image);
                 break;
         }