Merge branch 'main' into dependabot/github_actions/actions/checkout-6

Author: JimBobSquarePants

src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.CalculationType.cs

@@ -5,14 +5,19 @@ namespace SixLabors.ImageSharp.ColorProfiles.Conversion.Icc;
 
 internal partial class LutABCalculator
 {
+    /// <summary>
+    /// Identifies the transform direction for the configured LUT calculator.
+    /// </summary>
     private enum CalculationType
     {
-        AtoB = 1 << 3,
-        BtoA = 1 << 4,
+        /// <summary>
+        /// Converts from device space to PCS using ICC <c>mAB</c> stage order.
+        /// </summary>
+        AtoB,
 
-        SingleCurve = 1,
-        CurveMatrix = 2,
-        CurveClut = 3,
-        Full = 4,
+        /// <summary>
+        /// Converts from PCS to device space using ICC <c>mBA</c> stage order.
+        /// </summary>
+        BtoA,
     }
 }

src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.cs

@@ -17,67 +17,106 @@ internal partial class LutABCalculator : IVector4Calculator
     private MatrixCalculator matrixCalculator;
     private ClutCalculator clutCalculator;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LutABCalculator"/> class for an ICC <c>mAB</c> transform.
+    /// </summary>
+    /// <param name="entry">The parsed A-to-B LUT entry.</param>
     public LutABCalculator(IccLutAToBTagDataEntry entry)
     {
         Guard.NotNull(entry, nameof(entry));
         this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
-        this.type |= CalculationType.AtoB;
+        this.type = CalculationType.AtoB;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LutABCalculator"/> class for an ICC <c>mBA</c> transform.
+    /// </summary>
+    /// <param name="entry">The parsed B-to-A LUT entry.</param>
     public LutABCalculator(IccLutBToATagDataEntry entry)
     {
         Guard.NotNull(entry, nameof(entry));
         this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
-        this.type |= CalculationType.BtoA;
+        this.type = CalculationType.BtoA;
     }
 
+    /// <summary>
+    /// Calculates the transformed value by applying the configured ICC LUT stages in specification order.
+    /// </summary>
+    /// <param name="value">The input value.</param>
+    /// <returns>The transformed value.</returns>
     public Vector4 Calculate(Vector4 value)
     {
         switch (this.type)
         {
-            case CalculationType.Full | CalculationType.AtoB:
-                value = this.curveACalculator.Calculate(value);
-                value = this.clutCalculator.Calculate(value);
-                value = this.curveMCalculator.Calculate(value);
-                value = this.matrixCalculator.Calculate(value);
-                return this.curveBCalculator.Calculate(value);
-
-            case CalculationType.Full | CalculationType.BtoA:
-                value = this.curveBCalculator.Calculate(value);
-                value = this.matrixCalculator.Calculate(value);
-                value = this.curveMCalculator.Calculate(value);
-                value = this.clutCalculator.Calculate(value);
-                return this.curveACalculator.Calculate(value);
-
-            case CalculationType.CurveClut | CalculationType.AtoB:
-                value = this.curveACalculator.Calculate(value);
-                value = this.clutCalculator.Calculate(value);
-                return this.curveBCalculator.Calculate(value);
-
-            case CalculationType.CurveClut | CalculationType.BtoA:
-                value = this.curveBCalculator.Calculate(value);
-                value = this.clutCalculator.Calculate(value);
-                return this.curveACalculator.Calculate(value);
-
-            case CalculationType.CurveMatrix | CalculationType.AtoB:
-                value = this.curveMCalculator.Calculate(value);
-                value = this.matrixCalculator.Calculate(value);
-                return this.curveBCalculator.Calculate(value);
-
-            case CalculationType.CurveMatrix | CalculationType.BtoA:
-                value = this.curveBCalculator.Calculate(value);
-                value = this.matrixCalculator.Calculate(value);
-                return this.curveMCalculator.Calculate(value);
-
-            case CalculationType.SingleCurve | CalculationType.AtoB:
-            case CalculationType.SingleCurve | CalculationType.BtoA:
-                return this.curveBCalculator.Calculate(value);
+            case CalculationType.AtoB:
+                // ICC mAB order: A, CLUT, M, Matrix, B.
+                if (this.curveACalculator != null)
+                {
+                    value = this.curveACalculator.Calculate(value);
+                }
+
+                if (this.clutCalculator != null)
+                {
+                    value = this.clutCalculator.Calculate(value);
+                }
+
+                if (this.curveMCalculator != null)
+                {
+                    value = this.curveMCalculator.Calculate(value);
+                }
+
+                if (this.matrixCalculator != null)
+                {
+                    value = this.matrixCalculator.Calculate(value);
+                }
+
+                if (this.curveBCalculator != null)
+                {
+                    value = this.curveBCalculator.Calculate(value);
+                }
+
+                return value;
+
+            case CalculationType.BtoA:
+                // ICC mBA order: B, Matrix, M, CLUT, A.
+                if (this.curveBCalculator != null)
+                {
+                    value = this.curveBCalculator.Calculate(value);
+                }
+
+                if (this.matrixCalculator != null)
+                {
+                    value = this.matrixCalculator.Calculate(value);
+                }
+
+                if (this.curveMCalculator != null)
+                {
+                    value = this.curveMCalculator.Calculate(value);
+                }
+
+                if (this.clutCalculator != null)
+                {
+                    value = this.clutCalculator.Calculate(value);
+                }
+
+                if (this.curveACalculator != null)
+                {
+                    value = this.curveACalculator.Calculate(value);
+                }
+
+                return value;
 
             default:
                 throw new InvalidOperationException("Invalid calculation type");
         }
     }
 
+    /// <summary>
+    /// Creates calculators for the processing stages present in the LUT entry.
+    /// </summary>
+    /// <remarks>
+    /// The tag entry classes already validate channel continuity, so this method only materializes the available stages.
+    /// </remarks>
     private void Init(IccTagDataEntry[] curveA, IccTagDataEntry[] curveB, IccTagDataEntry[] curveM, Vector3? matrix3x1, Matrix4x4? matrix3x3, IccClut clut)
     {
         bool hasACurve = curveA != null;
@@ -86,26 +125,10 @@ private void Init(IccTagDataEntry[] curveA, IccTagDataEntry[] curveB, IccTagData
         bool hasMatrix = matrix3x1 != null && matrix3x3 != null;
         bool hasClut = clut != null;
 
-        if (hasBCurve && hasMatrix && hasMCurve && hasClut && hasACurve)
-        {
-            this.type = CalculationType.Full;
-        }
-        else if (hasBCurve && hasClut && hasACurve)
-        {
-            this.type = CalculationType.CurveClut;
-        }
-        else if (hasBCurve && hasMatrix && hasMCurve)
-        {
-            this.type = CalculationType.CurveMatrix;
-        }
-        else if (hasBCurve)
-        {
-            this.type = CalculationType.SingleCurve;
-        }
-        else
-        {
-            throw new InvalidIccProfileException("AToB or BToA tag has an invalid configuration");
-        }
+        Guard.IsTrue(
+            hasACurve || hasBCurve || hasMCurve || hasMatrix || hasClut,
+            "entry",
+            "AToB or BToA tag must contain at least one processing element");
 
         if (hasACurve)
         {

src/ImageSharp/ColorProfiles/Icc/IccConverterbase.Conversions.cs

@@ -60,7 +60,7 @@ private static IVector4Calculator InitA(IccProfile profile, IccProfileTag tag)
             IccLut16TagDataEntry lut16 => new LutEntryCalculator(lut16),
             IccLutAToBTagDataEntry lutAtoB => new LutABCalculator(lutAtoB),
             IccLutBToATagDataEntry lutBtoA => new LutABCalculator(lutBtoA),
-            _ => throw new InvalidIccProfileException("Invalid entry."),
+            _ => throw new InvalidIccProfileException($"Invalid entry {tag}."),
         };
 
     private static IVector4Calculator InitD(IccProfile profile, IccProfileTag tag)

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -131,30 +131,35 @@ protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, Cance
         try
         {
             int bytesPerColorMapEntry = this.ReadImageHeaders(stream, out bool inverted, out byte[] palette);
+            ushort bitsPerPixel = this.infoHeader.BitsPerPixel;
 
             image = new Image<TPixel>(this.configuration, this.infoHeader.Width, this.infoHeader.Height, this.metadata);
 
             Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
 
             switch (this.infoHeader.Compression)
             {
-                case BmpCompression.RGB when this.infoHeader.BitsPerPixel is 32 && this.bmpMetadata.InfoHeaderType is BmpInfoHeaderType.WinVersion3:
+                case BmpCompression.RGB when bitsPerPixel is 32 && this.bmpMetadata.InfoHeaderType is BmpInfoHeaderType.WinVersion3:
                     this.ReadRgb32Slow(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
 
                     break;
-                case BmpCompression.RGB when this.infoHeader.BitsPerPixel is 32:
+
+                case BmpCompression.RGB when bitsPerPixel is 32:
                     this.ReadRgb32Fast(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
 
                     break;
-                case BmpCompression.RGB when this.infoHeader.BitsPerPixel is 24:
+
+                case BmpCompression.RGB when bitsPerPixel is 24:
                     this.ReadRgb24(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
 
                     break;
-                case BmpCompression.RGB when this.infoHeader.BitsPerPixel is 16:
+
+                case BmpCompression.RGB when bitsPerPixel is 16:
                     this.ReadRgb16(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
 
                     break;
-                case BmpCompression.RGB when this.infoHeader.BitsPerPixel is <= 8 && this.processedAlphaMask:
+
+                case BmpCompression.RGB when bitsPerPixel is > 0 and <= 8 && this.processedAlphaMask:
                     this.ReadRgbPaletteWithAlphaMask(
                         stream,
                         pixels,
@@ -166,7 +171,8 @@ protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, Cance
                         inverted);
 
                     break;
-                case BmpCompression.RGB when this.infoHeader.BitsPerPixel is <= 8:
+
+                case BmpCompression.RGB when bitsPerPixel is > 0 and <= 8:
                     this.ReadRgbPalette(
                         stream,
                         pixels,
@@ -179,6 +185,10 @@ protected override Image<TPixel> Decode<TPixel>(BufferedReadStream stream, Cance
 
                     break;
 
+                case BmpCompression.RGB when bitsPerPixel is <= 0 or > 32:
+                    BmpThrowHelper.ThrowInvalidImageContentException($"Invalid bits per pixel: {bitsPerPixel}");
+                    break;
+
                 case BmpCompression.RLE24:
                     this.ReadRle24(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
 

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -519,6 +519,11 @@ internal void ParseStream(BufferedReadStream stream, SpectralConverter spectralC
             fileMarker = FindNextFileMarker(stream);
         }
 
+        if (!metadataOnly && this.Frame is null)
+        {
+            JpegThrowHelper.ThrowInvalidImageContentException("No readable SOFn (Start Of Frame) marker found.");
+        }
+
         this.Metadata.GetJpegMetadata().Interleaved = this.Frame.Interleaved;
     }
 

src/ImageSharp/GraphicsOptions.cs

@@ -6,11 +6,12 @@
 namespace SixLabors.ImageSharp;
 
 /// <summary>
-/// Options for influencing the drawing functions.
+/// Provides configuration for controlling how graphics operations are rendered,
+/// including antialiasing, pixel blending, alpha composition, and coverage thresholding.
 /// </summary>
 public class GraphicsOptions : IDeepCloneable<GraphicsOptions>
 {
-    private int antialiasSubpixelDepth = 16;
+    private float antialiasThreshold = .5F;
     private float blendPercentage = 1F;
 
     /// <summary>
@@ -24,61 +25,62 @@ private GraphicsOptions(GraphicsOptions source)
     {
         this.AlphaCompositionMode = source.AlphaCompositionMode;
         this.Antialias = source.Antialias;
-        this.AntialiasSubpixelDepth = source.AntialiasSubpixelDepth;
+        this.AntialiasThreshold = source.AntialiasThreshold;
         this.BlendPercentage = source.BlendPercentage;
         this.ColorBlendingMode = source.ColorBlendingMode;
     }
 
     /// <summary>
     /// Gets or sets a value indicating whether antialiasing should be applied.
-    /// Defaults to true.
+    /// When <see langword="true"/>, edges are rendered with smooth sub-pixel coverage.
+    /// When <see langword="false"/>, coverage is snapped to binary (fully opaque or fully transparent)
+    /// using <see cref="AntialiasThreshold"/> as the cutoff.
+    /// Defaults to <see langword="true"/>.
     /// </summary>
     public bool Antialias { get; set; } = true;
 
     /// <summary>
-    /// Gets or sets a value indicating the number of subpixels to use while rendering with antialiasing enabled.
-    /// Defaults to 16.
+    /// Gets or sets the coverage threshold used when <see cref="Antialias"/> is <see langword="false"/>.
+    /// Pixels with antialiased coverage above this value are rendered as fully opaque;
+    /// pixels below are discarded. Valid range is 0 to 1. Lower values preserve more
+    /// thin features at small sizes. Defaults to <c>0.5F</c>.
     /// </summary>
-    public int AntialiasSubpixelDepth
+    public float AntialiasThreshold
     {
-        get
-        {
-            return this.antialiasSubpixelDepth;
-        }
+        get => this.antialiasThreshold;
 
         set
         {
-            Guard.MustBeGreaterThanOrEqualTo(value, 0, nameof(this.AntialiasSubpixelDepth));
-            this.antialiasSubpixelDepth = value;
+            Guard.MustBeBetweenOrEqualTo(value, 0F, 1F, nameof(this.AntialiasThreshold));
+            this.antialiasThreshold = value;
         }
     }
 
     /// <summary>
-    /// Gets or sets a value between indicating the blending percentage to apply to the drawing operation.
-    /// Range 0..1; Defaults to 1.
+    /// Gets or sets the blending percentage applied to the drawing operation.
+    /// A value of <c>1.0</c> applies the operation at full strength; <c>0.0</c> makes it invisible.
+    /// Valid range is 0 to 1. Defaults to <c>1.0F</c>.
     /// </summary>
     public float BlendPercentage
     {
-        get
-        {
-            return this.blendPercentage;
-        }
+        get => this.blendPercentage;
 
         set
         {
-            Guard.MustBeBetweenOrEqualTo(value, 0, 1F, nameof(this.BlendPercentage));
+            Guard.MustBeBetweenOrEqualTo(value, 0F, 1F, nameof(this.BlendPercentage));
             this.blendPercentage = value;
         }
     }
 
     /// <summary>
-    /// Gets or sets a value indicating the color blending mode to apply to the drawing operation.
+    /// Gets or sets the color blending mode used to combine source and destination pixel colors.
     /// Defaults to <see cref="PixelColorBlendingMode.Normal"/>.
     /// </summary>
     public PixelColorBlendingMode ColorBlendingMode { get; set; } = PixelColorBlendingMode.Normal;
 
     /// <summary>
-    /// Gets or sets a value indicating the alpha composition mode to apply to the drawing operation
+    /// Gets or sets the alpha composition mode that determines how source and destination alpha
+    /// channels are combined using Porter-Duff operators.
     /// Defaults to <see cref="PixelAlphaCompositionMode.SrcOver"/>.
     /// </summary>
     public PixelAlphaCompositionMode AlphaCompositionMode { get; set; } = PixelAlphaCompositionMode.SrcOver;