From b52ef56181615d91df24977f66fd48fa2d6ca048 Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Sun, 3 Dec 2023 21:44:53 +0100
Subject: [PATCH 01/14] Promote PixelTypeInfo to TPixel

Fixes #2534
---
 src/ImageSharp/Formats/PixelTypeInfo.cs       |  32 +--
 src/ImageSharp/Image{TPixel}.cs               |   8 +-
 src/ImageSharp/PixelFormats/IPixel.cs         |   3 +
 .../PixelFormats/PixelImplementations/A8.cs   |   3 +
 .../PixelImplementations/Abgr32.cs            |   3 +
 .../PixelImplementations/Argb32.cs            |   3 +
 .../PixelImplementations/Bgr24.cs             |   3 +
 .../PixelImplementations/Bgr565.cs            |   3 +
 .../PixelImplementations/Bgra32.cs            |   3 +
 .../PixelImplementations/Bgra4444.cs          |   3 +
 .../PixelImplementations/Bgra5551.cs          |   3 +
 .../PixelImplementations/Byte4.cs             |   3 +
 .../PixelImplementations/HalfSingle.cs        |   3 +
 .../PixelImplementations/HalfVector2.cs       |   3 +
 .../PixelImplementations/HalfVector4.cs       |   3 +
 .../PixelFormats/PixelImplementations/L16.cs  |   3 +
 .../PixelFormats/PixelImplementations/L8.cs   |   3 +
 .../PixelFormats/PixelImplementations/La16.cs |   3 +
 .../PixelFormats/PixelImplementations/La32.cs |   3 +
 .../PixelImplementations/NormalizedByte2.cs   |   3 +
 .../PixelImplementations/NormalizedByte4.cs   |   3 +
 .../PixelImplementations/NormalizedShort2.cs  |   3 +
 .../PixelImplementations/NormalizedShort4.cs  |   3 +
 .../PixelOperations/A8.PixelOperations.cs     |   9 +-
 .../PixelOperations/Abgr32.PixelOperations.cs |   9 +-
 .../PixelOperations/Argb32.PixelOperations.cs |   9 +-
 .../PixelOperations/Bgr24.PixelOperations.cs  |   9 +-
 .../PixelOperations/Bgr565.PixelOperations.cs |   9 +-
 .../PixelOperations/Bgra32.PixelOperations.cs |   9 +-
 .../Bgra4444.PixelOperations.cs               |   9 +-
 .../Bgra5551.PixelOperations.cs               |   9 +-
 .../PixelOperations/Byte4.PixelOperations.cs  |   9 +-
 .../HalfSingle.PixelOperations.cs             |   9 +-
 .../HalfVector2.PixelOperations.cs            |   9 +-
 .../HalfVector4.PixelOperations.cs            |   9 +-
 .../PixelOperations/L16.PixelOperations.cs    |   9 +-
 .../PixelOperations/L8.PixelOperations.cs     |   9 +-
 .../PixelOperations/La16.PixelOperations.cs   |   9 +-
 .../PixelOperations/La32.PixelOperations.cs   |   9 +-
 .../NormalizedByte2.PixelOperations.cs        |   9 +-
 .../NormalizedByte4.PixelOperations.cs        |   9 +-
 .../NormalizedShort2.PixelOperations.cs       |   9 +-
 .../NormalizedShort4.PixelOperations.cs       |   9 +-
 .../PixelOperations/Rg32.PixelOperations.cs   |   9 +-
 .../PixelOperations/Rgb24.PixelOperations.cs  |   5 -
 .../PixelOperations/Rgb48.PixelOperations.cs  |   9 +-
 .../Rgba1010102.PixelOperations.cs            |   9 +-
 .../PixelOperations/Rgba32.PixelOperations.cs |   6 -
 .../PixelOperations/Rgba64.PixelOperations.cs |   9 +-
 .../RgbaVector.PixelOperations.cs             |   6 -
 .../PixelOperations/Short2.PixelOperations.cs |   9 +-
 .../PixelOperations/Short4.PixelOperations.cs |   9 +-
 .../PixelFormats/PixelImplementations/Rg32.cs |   3 +
 .../PixelImplementations/Rgb24.cs             |   3 +
 .../PixelImplementations/Rgb48.cs             |   3 +
 .../PixelImplementations/Rgba1010102.cs       |   3 +
 .../PixelImplementations/Rgba32.cs            |   3 +
 .../PixelImplementations/Rgba64.cs            |   3 +
 .../PixelImplementations/RgbaVector.cs        |   3 +
 .../PixelImplementations/Short2.cs            |   3 +
 .../PixelImplementations/Short4.cs            |   3 +
 .../PixelFormats/PixelOperations{TPixel}.cs   |   3 +-
 .../Resize/ResizeProcessor{TPixel}.cs         |   2 +-
 .../Formats/Bmp/BmpDecoderTests.cs            |   2 +-
 .../Formats/Tiff/BigTiffDecoderTests.cs       |   2 +-
 ...elOperationsTests.Specialized.Generated.cs | 263 ++++--------------
 .../Generated/_Common.ttinclude               |   9 +-
 .../PixelOperations/PixelOperationsTests.cs   |   6 +-
 tests/ImageSharp.Tests/TestFormat.cs          |   2 +
 .../BasicTestPatternProvider.cs               |   5 +
 70 files changed, 207 insertions(+), 468 deletions(-)

diff --git a/src/ImageSharp/Formats/PixelTypeInfo.cs b/src/ImageSharp/Formats/PixelTypeInfo.cs
index 1328c6528..15fd0dc2a 100644
--- a/src/ImageSharp/Formats/PixelTypeInfo.cs
+++ b/src/ImageSharp/Formats/PixelTypeInfo.cs
@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Formats;
 /// <summary>
 /// Contains information about the pixels that make up an images visual data.
 /// </summary>
-public class PixelTypeInfo
+public readonly struct PixelTypeInfo
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="PixelTypeInfo"/> class.
@@ -21,33 +21,25 @@ public class PixelTypeInfo
     public PixelTypeInfo(int bitsPerPixel)
         => this.BitsPerPixel = bitsPerPixel;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PixelTypeInfo"/> class.
-    /// </summary>
-    /// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
-    /// <param name="alpha">The pixel alpha transparency behavior.</param>
-    public PixelTypeInfo(int bitsPerPixel, PixelAlphaRepresentation alpha)
-    {
-        this.BitsPerPixel = bitsPerPixel;
-        this.AlphaRepresentation = alpha;
-    }
-
     /// <summary>
     /// Gets color depth, in number of bits per pixel.
     /// </summary>
-    public int BitsPerPixel { get; }
+    public int BitsPerPixel { get; init; }
+
+    public byte ComponentCount { get; init; }
 
     /// <summary>
     /// Gets the pixel alpha transparency behavior.
     /// <see langword="null"/> means unknown, unspecified.
     /// </summary>
-    public PixelAlphaRepresentation? AlphaRepresentation { get; }
-
-    internal static PixelTypeInfo Create<TPixel>()
-        where TPixel : unmanaged, IPixel<TPixel>
-        => new(Unsafe.SizeOf<TPixel>() * 8);
+    public PixelAlphaRepresentation? AlphaRepresentation { get; init; }
 
-    internal static PixelTypeInfo Create<TPixel>(PixelAlphaRepresentation alpha)
+    internal static PixelTypeInfo Create<TPixel>(byte componentCount, PixelAlphaRepresentation pixelAlphaRepresentation)
         where TPixel : unmanaged, IPixel<TPixel>
-        => new(Unsafe.SizeOf<TPixel>() * 8, alpha);
+        => new()
+        {
+            BitsPerPixel = Unsafe.SizeOf<TPixel>() * 8,
+            ComponentCount = componentCount,
+            AlphaRepresentation = pixelAlphaRepresentation
+        };
 }
diff --git a/src/ImageSharp/Image{TPixel}.cs b/src/ImageSharp/Image{TPixel}.cs
index c24014e69..38f0b94d6 100644
--- a/src/ImageSharp/Image{TPixel}.cs
+++ b/src/ImageSharp/Image{TPixel}.cs
@@ -78,7 +78,7 @@ public sealed class Image<TPixel> : Image
     /// <param name="height">The height of the image in pixels.</param>
     /// <param name="metadata">The images metadata.</param>
     internal Image(Configuration configuration, int width, int height, ImageMetadata? metadata)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata ?? new(), width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new(), width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, default(TPixel));
 
     /// <summary>
@@ -111,7 +111,7 @@ public sealed class Image<TPixel> : Image
         int width,
         int height,
         ImageMetadata metadata)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata, width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, memoryGroup);
 
     /// <summary>
@@ -129,7 +129,7 @@ public sealed class Image<TPixel> : Image
         int height,
         TPixel backgroundColor,
         ImageMetadata? metadata)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata ?? new(), width, height)
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata ?? new(), width, height)
         => this.frames = new ImageFrameCollection<TPixel>(this, width, height, backgroundColor);
 
     /// <summary>
@@ -140,7 +140,7 @@ public sealed class Image<TPixel> : Image
     /// <param name="metadata">The images metadata.</param>
     /// <param name="frames">The frames that will be owned by this image instance.</param>
     internal Image(Configuration configuration, ImageMetadata metadata, IEnumerable<ImageFrame<TPixel>> frames)
-        : base(configuration, PixelTypeInfo.Create<TPixel>(), metadata, ValidateFramesAndGetSize(frames))
+        : base(configuration, TPixel.GetPixelTypeInfo(), metadata, ValidateFramesAndGetSize(frames))
         => this.frames = new ImageFrameCollection<TPixel>(this, frames);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/IPixel.cs b/src/ImageSharp/PixelFormats/IPixel.cs
index 099444466..cddf6453d 100644
--- a/src/ImageSharp/PixelFormats/IPixel.cs
+++ b/src/ImageSharp/PixelFormats/IPixel.cs
@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -14,6 +15,8 @@ namespace SixLabors.ImageSharp.PixelFormats;
 public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
     where TSelf : unmanaged, IPixel<TSelf>
 {
+    static abstract PixelTypeInfo GetPixelTypeInfo();
+
     /// <summary>
     /// Creates a <see cref="PixelOperations{TPixel}"/> instance for this pixel type.
     /// This method is not intended to be consumed directly. Use <see cref="PixelOperations{TPixel}.Instance"/> instead.
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index 025690712..b2d99ac4b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -55,6 +56,8 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<A8> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 8bd24c7a0..7c0dba552 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -183,6 +184,8 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Abgr32> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index fa8af98a0..f09f25ab0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -183,6 +184,8 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Argb32> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index aedf4ad19..499c72b8d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -87,6 +88,8 @@ public partial struct Bgr24 : IPixel<Bgr24>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelAlphaRepresentation.None);
+
     /// <inheritdoc/>
     public readonly PixelOperations<Bgr24> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index ac3b6f829..1ac9fbddb 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -59,6 +60,8 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<Bgr565> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index d7222f2ef..a689067e5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -136,6 +137,8 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc/>
     public readonly PixelOperations<Bgra32> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index 8ba32c8ac..de94817d4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -57,6 +58,8 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Bgra4444> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index c282f03d8..2bfbde7c6 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -60,6 +61,8 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index e699e5fe5..e1d6bdd52 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -60,6 +61,8 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Byte4> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index db1e02adc..b37b7260c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -45,6 +46,8 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public PixelOperations<HalfSingle> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 9caae58c9..02c3433fd 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -52,6 +53,8 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector2> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index 609fec3bd..ee8be97c1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -57,6 +58,8 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector4> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index c6ee8744d..2b70c1563 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -47,6 +48,8 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<L16> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index 383e09b27..df6189706 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -48,6 +49,8 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<L8> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 58aeb6189..97e5db9f0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -71,6 +72,8 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc/>
     public readonly PixelOperations<La16> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index db7f43329..090824a83 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -73,6 +74,8 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc/>
     public readonly PixelOperations<La32> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index 92b9e6148..ba56e9ecd 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -60,6 +61,8 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte2> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index f87bb5a60..27fed194f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -62,6 +63,8 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte4> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index f77dd69b7..55ab0888b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -61,6 +62,8 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort2> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index 989edbd2b..0306a6329 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -63,6 +64,8 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort4> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs
index a7b4b5df0..131191ee2 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/A8.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct A8
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<A8>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<A8>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<A8>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs
index 66f3ecb24..17ca5edd8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Abgr32.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Abgr32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Abgr32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Abgr32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Abgr32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs
index 894e92963..f2a5eb28b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Argb32.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Argb32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Argb32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Argb32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Argb32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs
index a8f6ab155..05b198636 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr24.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Bgr24
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Bgr24>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgr24>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Bgr24>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs
index de9690325..7217b7c0b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgr565.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Bgr565
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Bgr565>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgr565>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Bgr565>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs
index 1a62b0809..0d77f8566 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra32.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Bgra32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Bgra32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgra32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Bgra32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs
index 8ffdaf6cb..5f516f094 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra4444.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Bgra4444
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Bgra4444>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgra4444>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Bgra4444>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs
index 97f5d805e..ea11e5309 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Bgra5551.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Bgra5551
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Bgra5551>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Bgra5551>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Bgra5551>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs
index f6e0b833c..0946dd4c7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Byte4.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Byte4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Byte4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Byte4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Byte4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs
index c8c4110c7..8343b4b3c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfSingle.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct HalfSingle
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<HalfSingle>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<HalfSingle>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<HalfSingle>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs
index bdf58145f..9a2bdd260 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector2.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct HalfVector2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<HalfVector2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<HalfVector2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<HalfVector2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs
index c3fe59804..0590b43c8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/HalfVector4.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct HalfVector4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<HalfVector4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<HalfVector4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<HalfVector4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs
index 7495cee53..fc7a81ae2 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L16.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct L16
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<L16>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<L16>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<L16>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs
index 5dd98c3a6..c97af4e34 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/L8.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct L8
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<L8>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<L8>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<L8>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs
index d9bda3e0f..9be38ac4e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La16.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct La16
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<La16>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<La16>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<La16>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs
index 1fb5adfc8..824618c65 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/La32.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct La32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<La32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<La32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<La32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs
index 717629586..848d0d6f3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte2.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct NormalizedByte2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedByte2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedByte2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedByte2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs
index 9bb48f592..79319070d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedByte4.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct NormalizedByte4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedByte4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedByte4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedByte4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs
index 3913f64bb..0b5f23bc5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort2.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct NormalizedShort2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedShort2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedShort2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedShort2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs
index 6334f4e7e..21634a2b3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/NormalizedShort4.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct NormalizedShort4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<NormalizedShort4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<NormalizedShort4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<NormalizedShort4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs
index a5b803f76..e0e117727 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rg32.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Rg32
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Rg32>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rg32>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Rg32>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
index 5473a602f..f88640d9e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
@@ -15,11 +15,6 @@ public partial struct Rgb24
     /// </summary>
     internal partial class PixelOperations : PixelOperations<Rgb24>
     {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new(() => PixelTypeInfo.Create<Rgb24>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
 
         /// <inheritdoc />
         internal override void PackFromRgbPlanes(
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs
index 56a052a7d..26f216ae2 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb48.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Rgb48
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Rgb48>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rgb48>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Rgb48>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
index f55039627..80c54ac2b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Rgba1010102
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Rgba1010102>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rgba1010102>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Rgba1010102>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs
index a4887b393..36b9f85f7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba32.PixelOperations.cs
@@ -18,12 +18,6 @@ public partial struct Rgba32
     /// </summary>
     internal partial class PixelOperations : PixelOperations<Rgba32>
     {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new(() => PixelTypeInfo.Create<Rgba32>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-
         /// <inheritdoc />
         public override void ToVector4(
             Configuration configuration,
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs
index 56bbc6b25..f796098c6 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba64.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Rgba64
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal partial class PixelOperations : PixelOperations<Rgba64>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Rgba64>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal partial class PixelOperations : PixelOperations<Rgba64>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs
index a3833583f..c18c3d868 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/RgbaVector.PixelOperations.cs
@@ -19,12 +19,6 @@ public partial struct RgbaVector
     /// </summary>
     internal class PixelOperations : PixelOperations<RgbaVector>
     {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new(() => PixelTypeInfo.Create<RgbaVector>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-
         /// <inheritdoc />
         public override void From<TSourcePixel>(
             Configuration configuration,
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs
index 435a521ba..737cd5299 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short2.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Short2
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Short2>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Short2>(PixelAlphaRepresentation.None), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Short2>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs
index 546da9c57..ab069c0ab 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Short4.PixelOperations.cs
@@ -13,12 +13,5 @@ public partial struct Short4
     /// <summary>
     /// Provides optimized overrides for bulk operations.
     /// </summary>
-    internal class PixelOperations : PixelOperations<Short4>
-    {
-        private static readonly Lazy<PixelTypeInfo> LazyInfo =
-            new Lazy<PixelTypeInfo>(() => PixelTypeInfo.Create<Short4>(PixelAlphaRepresentation.Unassociated), true);
-
-        /// <inheritdoc />
-        public override PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
-    }
+    internal class PixelOperations : PixelOperations<Short4>;
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 0a13a15ed..b824acad4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -57,6 +58,8 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<Rg32> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index 105618cd9..609ad21b7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -106,6 +107,8 @@ public partial struct Rgb24 : IPixel<Rgb24>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelAlphaRepresentation.None);
+
     /// <inheritdoc/>
     public readonly PixelOperations<Rgb24> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index 6bf25717c..e89393c52 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -69,6 +70,8 @@ public partial struct Rgb48 : IPixel<Rgb48>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<Rgb48> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 7bac1d920..734b1e229 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -60,6 +61,8 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Rgba1010102> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index 75fe8f3f4..e1be7d0ec 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -6,6 +6,7 @@ using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -286,6 +287,8 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
         return true;
     }
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Rgba32> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index 75235c900..95b1f242f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -4,6 +4,7 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -206,6 +207,8 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Rgba64> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index 899987b71..c914ca9e3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -5,6 +5,7 @@ using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -96,6 +97,8 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     /// </returns>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<RgbaVector> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 832e8c770..b5155c1fa 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -64,6 +65,8 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelAlphaRepresentation.None);
+
     /// <inheritdoc />
     public readonly PixelOperations<Short2> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index c4dc324a1..331888999 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -66,6 +67,8 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelAlphaRepresentation.Unassociated);
+
     /// <inheritdoc />
     public readonly PixelOperations<Short4> CreatePixelOperations() => new PixelOperations();
 
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
index beebec828..ee675e2e2 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
@@ -18,7 +18,6 @@ namespace SixLabors.ImageSharp.PixelFormats;
 public partial class PixelOperations<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private static readonly Lazy<PixelTypeInfo> LazyInfo = new(() => PixelTypeInfo.Create<TPixel>(), true);
     private static readonly Lazy<PixelOperations<TPixel>> LazyInstance = new(() => default(TPixel).CreatePixelOperations(), true);
 
     /// <summary>
@@ -32,7 +31,7 @@ public partial class PixelOperations<TPixel>
     /// Gets the pixel type info for the given <typeparamref name="TPixel"/>.
     /// </summary>
     /// <returns>The <see cref="PixelTypeInfo"/>.</returns>
-    public virtual PixelTypeInfo GetPixelTypeInfo() => LazyInfo.Value;
+    public static PixelTypeInfo GetPixelTypeInfo() => TPixel.GetPixelTypeInfo();
 
     /// <summary>
     /// Bulk version of <see cref="IPixel.FromVector4"/> converting 'sourceVectors.Length' pixels into 'destinationColors'.
diff --git a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
index 98c2523fa..38aab0283 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
@@ -197,7 +197,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         bool compand,
         bool premultiplyAlpha)
     {
-        PixelAlphaRepresentation? alphaRepresentation = PixelOperations<TPixel>.Instance.GetPixelTypeInfo()?.AlphaRepresentation;
+        PixelAlphaRepresentation? alphaRepresentation = PixelOperations<TPixel>.GetPixelTypeInfo().AlphaRepresentation;
 
         // Premultiply only if alpha representation is unknown or Unassociated:
         bool needsPremultiplication = alphaRepresentation == null || alphaRepresentation.Value == PixelAlphaRepresentation.Unassociated;
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs
index e76f21d0e..78a7b2c11 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpDecoderTests.cs
@@ -477,7 +477,7 @@ public class BmpDecoderTests
         using MemoryStream stream = new(testFile.Bytes, false);
         ImageInfo imageInfo = Image.Identify(stream);
         Assert.NotNull(imageInfo);
-        Assert.Equal(expectedPixelSize, imageInfo.PixelType?.BitsPerPixel);
+        Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
     }
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs
index 8e90b1dd5..72f53cab7 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/BigTiffDecoderTests.cs
@@ -65,7 +65,7 @@ public class BigTiffDecoderTests : TiffDecoderBaseTester
         using MemoryStream stream = new(testFile.Bytes, false);
         ImageInfo info = Image.Identify(stream);
 
-        Assert.Equal(expectedPixelSize, info.PixelType?.BitsPerPixel);
+        Assert.Equal(expectedPixelSize, info.PixelType.BitsPerPixel);
         Assert.Equal(expectedWidth, info.Width);
         Assert.Equal(expectedHeight, info.Height);
         Assert.NotNull(info.Metadata);
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs
index 5ba5c1bed..b37282927 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/PixelOperationsTests.Specialized.Generated.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations;
 
 public partial class PixelOperationsTests
 {
-        
+    
     public partial class A8_OperationsTests : PixelOperationsTests<A8>
     {
         public A8_OperationsTests(ITestOutputHelper output)
@@ -20,19 +20,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<A8> Operations => A8.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<A8.PixelOperations>(PixelOperations<A8>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = A8.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Argb32_OperationsTests : PixelOperationsTests<Argb32>
     {
         public Argb32_OperationsTests(ITestOutputHelper output)
@@ -40,19 +35,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Argb32> Operations => Argb32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Argb32.PixelOperations>(PixelOperations<Argb32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Argb32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Abgr32_OperationsTests : PixelOperationsTests<Abgr32>
     {
         public Abgr32_OperationsTests(ITestOutputHelper output)
@@ -60,19 +50,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Abgr32> Operations => Abgr32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Abgr32.PixelOperations>(PixelOperations<Abgr32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Abgr32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgr24_OperationsTests : PixelOperationsTests<Bgr24>
     {
         public Bgr24_OperationsTests(ITestOutputHelper output)
@@ -80,19 +65,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgr24> Operations => Bgr24.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgr24.PixelOperations>(PixelOperations<Bgr24>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgr24.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgr565_OperationsTests : PixelOperationsTests<Bgr565>
     {
         public Bgr565_OperationsTests(ITestOutputHelper output)
@@ -100,19 +80,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgr565> Operations => Bgr565.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgr565.PixelOperations>(PixelOperations<Bgr565>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgr565.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgra32_OperationsTests : PixelOperationsTests<Bgra32>
     {
         public Bgra32_OperationsTests(ITestOutputHelper output)
@@ -120,19 +95,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgra32> Operations => Bgra32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgra32.PixelOperations>(PixelOperations<Bgra32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgra32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgra4444_OperationsTests : PixelOperationsTests<Bgra4444>
     {
         public Bgra4444_OperationsTests(ITestOutputHelper output)
@@ -140,19 +110,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgra4444> Operations => Bgra4444.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgra4444.PixelOperations>(PixelOperations<Bgra4444>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgra4444.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Bgra5551_OperationsTests : PixelOperationsTests<Bgra5551>
     {
         public Bgra5551_OperationsTests(ITestOutputHelper output)
@@ -160,19 +125,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Bgra5551> Operations => Bgra5551.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Bgra5551.PixelOperations>(PixelOperations<Bgra5551>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Bgra5551.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Byte4_OperationsTests : PixelOperationsTests<Byte4>
     {
         public Byte4_OperationsTests(ITestOutputHelper output)
@@ -180,19 +140,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Byte4> Operations => Byte4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Byte4.PixelOperations>(PixelOperations<Byte4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Byte4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class HalfSingle_OperationsTests : PixelOperationsTests<HalfSingle>
     {
         public HalfSingle_OperationsTests(ITestOutputHelper output)
@@ -200,19 +155,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<HalfSingle> Operations => HalfSingle.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<HalfSingle.PixelOperations>(PixelOperations<HalfSingle>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = HalfSingle.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class HalfVector2_OperationsTests : PixelOperationsTests<HalfVector2>
     {
         public HalfVector2_OperationsTests(ITestOutputHelper output)
@@ -220,19 +170,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<HalfVector2> Operations => HalfVector2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<HalfVector2.PixelOperations>(PixelOperations<HalfVector2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = HalfVector2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class HalfVector4_OperationsTests : PixelOperationsTests<HalfVector4>
     {
         public HalfVector4_OperationsTests(ITestOutputHelper output)
@@ -240,19 +185,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<HalfVector4> Operations => HalfVector4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<HalfVector4.PixelOperations>(PixelOperations<HalfVector4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = HalfVector4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class L16_OperationsTests : PixelOperationsTests<L16>
     {
         public L16_OperationsTests(ITestOutputHelper output)
@@ -260,19 +200,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<L16> Operations => L16.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<L16.PixelOperations>(PixelOperations<L16>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = L16.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class L8_OperationsTests : PixelOperationsTests<L8>
     {
         public L8_OperationsTests(ITestOutputHelper output)
@@ -280,19 +215,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<L8> Operations => L8.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<L8.PixelOperations>(PixelOperations<L8>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = L8.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class La16_OperationsTests : PixelOperationsTests<La16>
     {
         public La16_OperationsTests(ITestOutputHelper output)
@@ -300,19 +230,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<La16> Operations => La16.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<La16.PixelOperations>(PixelOperations<La16>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = La16.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class La32_OperationsTests : PixelOperationsTests<La32>
     {
         public La32_OperationsTests(ITestOutputHelper output)
@@ -320,19 +245,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<La32> Operations => La32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<La32.PixelOperations>(PixelOperations<La32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = La32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedByte2_OperationsTests : PixelOperationsTests<NormalizedByte2>
     {
         public NormalizedByte2_OperationsTests(ITestOutputHelper output)
@@ -340,19 +260,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedByte2> Operations => NormalizedByte2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedByte2.PixelOperations>(PixelOperations<NormalizedByte2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedByte2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedByte4_OperationsTests : PixelOperationsTests<NormalizedByte4>
     {
         public NormalizedByte4_OperationsTests(ITestOutputHelper output)
@@ -360,19 +275,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedByte4> Operations => NormalizedByte4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedByte4.PixelOperations>(PixelOperations<NormalizedByte4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedByte4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedShort2_OperationsTests : PixelOperationsTests<NormalizedShort2>
     {
         public NormalizedShort2_OperationsTests(ITestOutputHelper output)
@@ -380,19 +290,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedShort2> Operations => NormalizedShort2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedShort2.PixelOperations>(PixelOperations<NormalizedShort2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedShort2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class NormalizedShort4_OperationsTests : PixelOperationsTests<NormalizedShort4>
     {
         public NormalizedShort4_OperationsTests(ITestOutputHelper output)
@@ -400,19 +305,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<NormalizedShort4> Operations => NormalizedShort4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<NormalizedShort4.PixelOperations>(PixelOperations<NormalizedShort4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = NormalizedShort4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Rg32_OperationsTests : PixelOperationsTests<Rg32>
     {
         public Rg32_OperationsTests(ITestOutputHelper output)
@@ -420,19 +320,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rg32> Operations => Rg32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rg32.PixelOperations>(PixelOperations<Rg32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rg32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgb24_OperationsTests : PixelOperationsTests<Rgb24>
     {
         public Rgb24_OperationsTests(ITestOutputHelper output)
@@ -440,19 +335,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgb24> Operations => Rgb24.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgb24.PixelOperations>(PixelOperations<Rgb24>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgb24.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgb48_OperationsTests : PixelOperationsTests<Rgb48>
     {
         public Rgb48_OperationsTests(ITestOutputHelper output)
@@ -460,19 +350,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgb48> Operations => Rgb48.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgb48.PixelOperations>(PixelOperations<Rgb48>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgb48.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgba1010102_OperationsTests : PixelOperationsTests<Rgba1010102>
     {
         public Rgba1010102_OperationsTests(ITestOutputHelper output)
@@ -480,19 +365,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgba1010102> Operations => Rgba1010102.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgba1010102.PixelOperations>(PixelOperations<Rgba1010102>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgba1010102.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgba32_OperationsTests : PixelOperationsTests<Rgba32>
     {
         public Rgba32_OperationsTests(ITestOutputHelper output)
@@ -500,19 +380,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgba32> Operations => Rgba32.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgba32.PixelOperations>(PixelOperations<Rgba32>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgba32.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Rgba64_OperationsTests : PixelOperationsTests<Rgba64>
     {
         public Rgba64_OperationsTests(ITestOutputHelper output)
@@ -520,19 +395,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Rgba64> Operations => Rgba64.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Rgba64.PixelOperations>(PixelOperations<Rgba64>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Rgba64.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class RgbaVector_OperationsTests : PixelOperationsTests<RgbaVector>
     {
         public RgbaVector_OperationsTests(ITestOutputHelper output)
@@ -540,19 +410,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<RgbaVector> Operations => RgbaVector.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<RgbaVector.PixelOperations>(PixelOperations<RgbaVector>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = RgbaVector.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
-    
+
     public partial class Short2_OperationsTests : PixelOperationsTests<Short2>
     {
         public Short2_OperationsTests(ITestOutputHelper output)
@@ -560,19 +425,14 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Short2> Operations => Short2.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Short2.PixelOperations>(PixelOperations<Short2>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Short2.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.None, alphaRepresentation);
         }
     }
-    
+
     public partial class Short4_OperationsTests : PixelOperationsTests<Short4>
     {
         public Short4_OperationsTests(ITestOutputHelper output)
@@ -580,15 +440,10 @@ public partial class PixelOperationsTests
         {
         }
 
-        protected override PixelOperations<Short4> Operations => Short4.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<Short4.PixelOperations>(PixelOperations<Short4>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = Short4.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(PixelAlphaRepresentation.Unassociated, alphaRepresentation);
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
index 0e7b1f335..90cb3a866 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/Generated/_Common.ttinclude
@@ -70,7 +70,7 @@ using Xunit.Abstractions;
 
     void GenerateSpecializedClass(string pixelType, string alpha)
     {#>
-    
+
     public partial class <#=pixelType#>_OperationsTests : PixelOperationsTests<<#=pixelType#>>
     {
         public <#=pixelType#>_OperationsTests(ITestOutputHelper output)
@@ -78,15 +78,10 @@ using Xunit.Abstractions;
         {
         }
 
-        protected override PixelOperations<<#=pixelType#>> Operations => <#=pixelType#>.PixelOperations.Instance;
-
-        [Fact]
-        public void IsSpecialImplementation() => Assert.IsType<<#=pixelType#>.PixelOperations>(PixelOperations<<#=pixelType#>>.Instance);
-
         [Fact]
         public void PixelTypeInfoHasCorrectAlphaRepresentation()
         {
-            var alphaRepresentation = this.Operations.GetPixelTypeInfo().AlphaRepresentation;
+            var alphaRepresentation = <#=pixelType#>.GetPixelTypeInfo().AlphaRepresentation;
             Assert.Equal(<#=alpha#>, alphaRepresentation);
         }
     }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs
index a9b3ee9a4..8c16a72df 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperations/PixelOperationsTests.cs
@@ -70,7 +70,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
 
     protected virtual PixelOperations<TPixel> Operations { get; } = PixelOperations<TPixel>.Instance;
 
-    protected bool HasUnassociatedAlpha => this.Operations.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
+    protected bool HasUnassociatedAlpha => TPixel.GetPixelTypeInfo().AlphaRepresentation == PixelAlphaRepresentation.Unassociated;
 
     internal static TPixel[] CreateExpectedPixelData(Vector4[] source, RefAction<Vector4> vectorModifier = null)
     {
@@ -105,7 +105,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
     [Fact]
     public void PixelTypeInfoHasCorrectBitsPerPixel()
     {
-        int bits = this.Operations.GetPixelTypeInfo().BitsPerPixel;
+        int bits = TPixel.GetPixelTypeInfo().BitsPerPixel;
         Assert.Equal(Unsafe.SizeOf<TPixel>() * 8, bits);
     }
 
@@ -123,7 +123,7 @@ public abstract class PixelOperationsTests<TPixel> : MeasureFixture
         Rgba32 dest = default;
         pixel.ToRgba32(ref dest);
 
-        bool hasAlpha = this.Operations.GetPixelTypeInfo().AlphaRepresentation != PixelAlphaRepresentation.None;
+        bool hasAlpha = TPixel.GetPixelTypeInfo().AlphaRepresentation != PixelAlphaRepresentation.None;
 
         byte expectedAlpha = hasAlpha ? Alpha : NoAlpha;
         Assert.Equal(expectedAlpha, dest.A);
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs
index f597b708d..465a21970 100644
--- a/tests/ImageSharp.Tests/TestFormat.cs
+++ b/tests/ImageSharp.Tests/TestFormat.cs
@@ -263,6 +263,8 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public struct TestPixelForAgnosticDecode : IPixel<TestPixelForAgnosticDecode>
     {
+        public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(2, PixelAlphaRepresentation.None);
+
         public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
 
         public void FromScaledVector4(Vector4 vector)
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
index 1e3ad3a5d..5fb3501e3 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
@@ -8,6 +8,11 @@ namespace SixLabors.ImageSharp.Tests;
 
 public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
 {
+    [Obsolete("Called by the de-serializer; should only be called by deriving classes for de-serialization purposes")]
+    public TestImageProvider()
+    {
+    }
+
     public virtual TPixel GetExpectedBasicTestPatternPixelAt(int x, int y)
     {
         throw new NotSupportedException("GetExpectedBasicTestPatternPixelAt(x,y) only works with BasicTestPattern");

From 2bf8d78f0fd7fd38f95f5cf99b2e0c9e01554b98 Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Mon, 4 Dec 2023 10:52:24 +0100
Subject: [PATCH 02/14] Fix Analyzer errors

---
 src/ImageSharp.ruleset                                       | 3 +++
 src/ImageSharp/Formats/PixelTypeInfo.cs                      | 5 ++++-
 src/ImageSharp/PixelFormats/IPixel.cs                        | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/A8.cs       | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs   | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs   | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs    | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs   | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs   | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs    | 4 ++++
 .../PixelFormats/PixelImplementations/HalfSingle.cs          | 4 ++++
 .../PixelFormats/PixelImplementations/HalfVector2.cs         | 4 ++++
 .../PixelFormats/PixelImplementations/HalfVector4.cs         | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/L16.cs      | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/L8.cs       | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/La16.cs     | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/La32.cs     | 4 ++++
 .../PixelFormats/PixelImplementations/NormalizedByte2.cs     | 4 ++++
 .../PixelFormats/PixelImplementations/NormalizedByte4.cs     | 4 ++++
 .../PixelFormats/PixelImplementations/NormalizedShort2.cs    | 4 ++++
 .../PixelFormats/PixelImplementations/NormalizedShort4.cs    | 4 ++++
 .../PixelOperations/Rgb24.PixelOperations.cs                 | 1 -
 src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs     | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs    | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs    | 4 ++++
 .../PixelFormats/PixelImplementations/Rgba1010102.cs         | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs   | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs   | 4 ++++
 .../PixelFormats/PixelImplementations/RgbaVector.cs          | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs   | 4 ++++
 src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs   | 4 ++++
 33 files changed, 127 insertions(+), 2 deletions(-)

diff --git a/src/ImageSharp.ruleset b/src/ImageSharp.ruleset
index d7a147df0..856838ade 100644
--- a/src/ImageSharp.ruleset
+++ b/src/ImageSharp.ruleset
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <RuleSet Name="ImageSharp" ToolsVersion="17.0">
   <Include Path="..\shared-infrastructure\sixlabors.ruleset" Action="Default" />
+  <Rules AnalyzerId="Microsoft.CodeAnalysis.CSharp.NetAnalyzers" RuleNamespace="Microsoft.CodeAnalysis.CSharp.NetAnalyzers">
+    <Rule Id="CA1000" Action="None"/>
+  </Rules>
   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
     <Rule Id="SA1011" Action="None" />
   </Rules>
diff --git a/src/ImageSharp/Formats/PixelTypeInfo.cs b/src/ImageSharp/Formats/PixelTypeInfo.cs
index 15fd0dc2a..ba26e48ee 100644
--- a/src/ImageSharp/Formats/PixelTypeInfo.cs
+++ b/src/ImageSharp/Formats/PixelTypeInfo.cs
@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats;
 public readonly struct PixelTypeInfo
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="PixelTypeInfo"/> class.
+    /// Initializes a new instance of the <see cref="PixelTypeInfo"/> struct.
     /// </summary>
     /// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
     public PixelTypeInfo(int bitsPerPixel)
@@ -26,6 +26,9 @@ public readonly struct PixelTypeInfo
     /// </summary>
     public int BitsPerPixel { get; init; }
 
+    /// <summary>
+    /// Gets the count of the color components
+    /// </summary>
     public byte ComponentCount { get; init; }
 
     /// <summary>
diff --git a/src/ImageSharp/PixelFormats/IPixel.cs b/src/ImageSharp/PixelFormats/IPixel.cs
index cddf6453d..ed02bc917 100644
--- a/src/ImageSharp/PixelFormats/IPixel.cs
+++ b/src/ImageSharp/PixelFormats/IPixel.cs
@@ -15,6 +15,10 @@ namespace SixLabors.ImageSharp.PixelFormats;
 public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
     where TSelf : unmanaged, IPixel<TSelf>
 {
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     static abstract PixelTypeInfo GetPixelTypeInfo();
 
     /// <summary>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index b2d99ac4b..8a641da4b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -56,6 +56,10 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 7c0dba552..692258add 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -184,6 +184,10 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index f09f25ab0..1ed505ce0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -184,6 +184,10 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index 499c72b8d..16f3a3aa3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -88,6 +88,10 @@ public partial struct Bgr24 : IPixel<Bgr24>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index 1ac9fbddb..76ba91d26 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -60,6 +60,10 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index a689067e5..33b5cbdf8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -137,6 +137,10 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index de94817d4..551f9ae8b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -58,6 +58,10 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index 2bfbde7c6..2477fd017 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -61,6 +61,10 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index e1d6bdd52..de35a345e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -61,6 +61,10 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index b37b7260c..f1a8c175c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -46,6 +46,10 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 02c3433fd..5a0bdb437 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -53,6 +53,10 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index ee8be97c1..0f4059461 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -58,6 +58,10 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index 2b70c1563..f9ec88f8e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -48,6 +48,10 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index df6189706..5b3b8934b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -49,6 +49,10 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 97e5db9f0..5d72818ac 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -72,6 +72,10 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index 090824a83..1cf04d157 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -74,6 +74,10 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index ba56e9ecd..f843d2781 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -61,6 +61,10 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index 27fed194f..a3266437d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -63,6 +63,10 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index 55ab0888b..2049acf3f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -62,6 +62,10 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index 0306a6329..b80ad0a74 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -64,6 +64,10 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
index f88640d9e..b4dd4fcc3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgb24.PixelOperations.cs
@@ -15,7 +15,6 @@ public partial struct Rgb24
     /// </summary>
     internal partial class PixelOperations : PixelOperations<Rgb24>
     {
-
         /// <inheritdoc />
         internal override void PackFromRgbPlanes(
             ReadOnlySpan<byte> redChannel,
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index b824acad4..074acf911 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -58,6 +58,10 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index 609ad21b7..f4350c786 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -107,6 +107,10 @@ public partial struct Rgb24 : IPixel<Rgb24>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index e89393c52..64cbfc046 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -70,6 +70,10 @@ public partial struct Rgb48 : IPixel<Rgb48>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 734b1e229..305144863 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -61,6 +61,10 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index e1be7d0ec..a6267d771 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -287,6 +287,10 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
         return true;
     }
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index 95b1f242f..e564b26f7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -207,6 +207,10 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index c914ca9e3..41f564861 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -97,6 +97,10 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     /// </returns>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index b5155c1fa..015d334bd 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -65,6 +65,10 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index 331888999..2c85a8d77 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -67,6 +67,10 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
+    /// <summary>
+    /// Gets the The pixel type information.
+    /// </summary>
+    /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />

From 4b69d06a4b02a3cdc04304438a901de3a8adf83d Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Tue, 5 Dec 2023 06:56:35 +0100
Subject: [PATCH 03/14] Made GetPixelTypeInfo non static

---
 src/ImageSharp.ruleset                                 | 3 ---
 src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs | 2 +-
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/ImageSharp.ruleset b/src/ImageSharp.ruleset
index 856838ade..d7a147df0 100644
--- a/src/ImageSharp.ruleset
+++ b/src/ImageSharp.ruleset
@@ -1,9 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <RuleSet Name="ImageSharp" ToolsVersion="17.0">
   <Include Path="..\shared-infrastructure\sixlabors.ruleset" Action="Default" />
-  <Rules AnalyzerId="Microsoft.CodeAnalysis.CSharp.NetAnalyzers" RuleNamespace="Microsoft.CodeAnalysis.CSharp.NetAnalyzers">
-    <Rule Id="CA1000" Action="None"/>
-  </Rules>
   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
     <Rule Id="SA1011" Action="None" />
   </Rules>
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
index ee675e2e2..cf3707f9e 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
@@ -31,7 +31,7 @@ public partial class PixelOperations<TPixel>
     /// Gets the pixel type info for the given <typeparamref name="TPixel"/>.
     /// </summary>
     /// <returns>The <see cref="PixelTypeInfo"/>.</returns>
-    public static PixelTypeInfo GetPixelTypeInfo() => TPixel.GetPixelTypeInfo();
+    public PixelTypeInfo GetPixelTypeInfo() => TPixel.GetPixelTypeInfo();
 
     /// <summary>
     /// Bulk version of <see cref="IPixel.FromVector4"/> converting 'sourceVectors.Length' pixels into 'destinationColors'.

From 2949655d92a8b18f16a7192ad2b5c715297b9386 Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Tue, 5 Dec 2023 07:02:53 +0100
Subject: [PATCH 04/14] Fix typos

---
 src/ImageSharp/PixelFormats/IPixel.cs                       | 6 ++++--
 src/ImageSharp/PixelFormats/PixelImplementations/A8.cs      | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs  | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs  | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs   | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs  | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs  | 2 +-
 .../PixelFormats/PixelImplementations/Bgra4444.cs           | 2 +-
 .../PixelFormats/PixelImplementations/Bgra5551.cs           | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs   | 2 +-
 .../PixelFormats/PixelImplementations/HalfSingle.cs         | 2 +-
 .../PixelFormats/PixelImplementations/HalfVector2.cs        | 2 +-
 .../PixelFormats/PixelImplementations/HalfVector4.cs        | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/L16.cs     | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/L8.cs      | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/La16.cs    | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/La32.cs    | 2 +-
 .../PixelFormats/PixelImplementations/NormalizedByte2.cs    | 2 +-
 .../PixelFormats/PixelImplementations/NormalizedByte4.cs    | 2 +-
 .../PixelFormats/PixelImplementations/NormalizedShort2.cs   | 2 +-
 .../PixelFormats/PixelImplementations/NormalizedShort4.cs   | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs    | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs   | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs   | 2 +-
 .../PixelFormats/PixelImplementations/Rgba1010102.cs        | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs  | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs  | 2 +-
 .../PixelFormats/PixelImplementations/RgbaVector.cs         | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs  | 2 +-
 src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs  | 2 +-
 30 files changed, 33 insertions(+), 31 deletions(-)

diff --git a/src/ImageSharp/PixelFormats/IPixel.cs b/src/ImageSharp/PixelFormats/IPixel.cs
index ed02bc917..adbf68861 100644
--- a/src/ImageSharp/PixelFormats/IPixel.cs
+++ b/src/ImageSharp/PixelFormats/IPixel.cs
@@ -16,10 +16,12 @@ public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
     where TSelf : unmanaged, IPixel<TSelf>
 {
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <returns>The <see cref="PixelTypeInfo"/>.</returns>
+#pragma warning disable CA1000
     static abstract PixelTypeInfo GetPixelTypeInfo();
+#pragma warning restore CA1000
 
     /// <summary>
     /// Creates a <see cref="PixelOperations{TPixel}"/> instance for this pixel type.
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index 8a641da4b..0dc88ac90 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -57,7 +57,7 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 692258add..1abf3e79f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -185,7 +185,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index 1ed505ce0..b5717c052 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -185,7 +185,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index 16f3a3aa3..05d995a4e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -89,7 +89,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index 76ba91d26..14a690a0c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -61,7 +61,7 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index 33b5cbdf8..d97f4025a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -138,7 +138,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index 551f9ae8b..15f84a604 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -59,7 +59,7 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index 2477fd017..109e52d4c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -62,7 +62,7 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index de35a345e..f900b49d7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -62,7 +62,7 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index f1a8c175c..42ba1a309 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -47,7 +47,7 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 5a0bdb437..b9feee519 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -54,7 +54,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index 0f4059461..597fa6c46 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -59,7 +59,7 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index f9ec88f8e..807ff0f0c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -49,7 +49,7 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index 5b3b8934b..999a6f2d1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -50,7 +50,7 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 5d72818ac..70d1e37d7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -73,7 +73,7 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index 1cf04d157..2d303525d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -75,7 +75,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index f843d2781..e81db6c1a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -62,7 +62,7 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index a3266437d..79f6f15f5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -64,7 +64,7 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index 2049acf3f..0e4746ca6 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -63,7 +63,7 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index b80ad0a74..a7d470eff 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -65,7 +65,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 074acf911..2a52bd33e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -59,7 +59,7 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index f4350c786..4f7cc0d10 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -108,7 +108,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index 64cbfc046..20463ca2f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -71,7 +71,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 305144863..740f44c85 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -62,7 +62,7 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index a6267d771..39054e06d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -288,7 +288,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     }
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index e564b26f7..d013e3fd5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -208,7 +208,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index 41f564861..fd30103c9 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -98,7 +98,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelAlphaRepresentation.Unassociated);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 015d334bd..697cc78a2 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -66,7 +66,7 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelAlphaRepresentation.None);
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index 2c85a8d77..9c205eeef 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -68,7 +68,7 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
     /// <summary>
-    /// Gets the The pixel type information.
+    /// Gets the pixel type information.
     /// </summary>
     /// <returns>PixelTypeInfo</returns>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelAlphaRepresentation.Unassociated);

From 6cbbb19a86a816f11b32e9a7f54cb7a457a72ebf Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Tue, 5 Dec 2023 07:08:23 +0100
Subject: [PATCH 05/14] Fix usage of static method in ResizeProcessor

---
 .../Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
index 38aab0283..cfc30edc0 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs
@@ -197,7 +197,7 @@ internal class ResizeProcessor<TPixel> : TransformProcessor<TPixel>, IResampling
         bool compand,
         bool premultiplyAlpha)
     {
-        PixelAlphaRepresentation? alphaRepresentation = PixelOperations<TPixel>.GetPixelTypeInfo().AlphaRepresentation;
+        PixelAlphaRepresentation? alphaRepresentation = PixelOperations<TPixel>.Instance.GetPixelTypeInfo().AlphaRepresentation;
 
         // Premultiply only if alpha representation is unknown or Unassociated:
         bool needsPremultiplication = alphaRepresentation == null || alphaRepresentation.Value == PixelAlphaRepresentation.Unassociated;

From 0b2cf3200d0ecd60484345a32ad345b32a893b58 Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Tue, 5 Dec 2023 07:08:38 +0100
Subject: [PATCH 06/14] Replaced comment with /// <inheritdoc />

---
 src/ImageSharp/PixelFormats/PixelImplementations/A8.cs       | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs   | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs   | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs    | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs   | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs   | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs    | 5 +----
 .../PixelFormats/PixelImplementations/HalfSingle.cs          | 5 +----
 .../PixelFormats/PixelImplementations/HalfVector2.cs         | 5 +----
 .../PixelFormats/PixelImplementations/HalfVector4.cs         | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/L16.cs      | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/L8.cs       | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/La16.cs     | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/La32.cs     | 5 +----
 .../PixelFormats/PixelImplementations/NormalizedByte2.cs     | 5 +----
 .../PixelFormats/PixelImplementations/NormalizedByte4.cs     | 5 +----
 .../PixelFormats/PixelImplementations/NormalizedShort2.cs    | 5 +----
 .../PixelFormats/PixelImplementations/NormalizedShort4.cs    | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs     | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs    | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs    | 5 +----
 .../PixelFormats/PixelImplementations/Rgba1010102.cs         | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs   | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs   | 5 +----
 .../PixelFormats/PixelImplementations/RgbaVector.cs          | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs   | 5 +----
 src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs   | 5 +----
 29 files changed, 29 insertions(+), 116 deletions(-)

diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index 0dc88ac90..7662495ff 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -56,10 +56,7 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc/>
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 1abf3e79f..8fae07aa1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -184,10 +184,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index b5717c052..9f36e31b8 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -184,10 +184,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index 05d995a4e..4a6caa4ce 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -88,10 +88,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index 14a690a0c..564a0c53f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -60,10 +60,7 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index d97f4025a..afd6c395e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -137,10 +137,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index 15f84a604..81f37c554 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -58,10 +58,7 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index 109e52d4c..c80af59b3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -61,10 +61,7 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index f900b49d7..6efbc9623 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -61,10 +61,7 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index 42ba1a309..8d658b240 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -46,10 +46,7 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index b9feee519..faec2b069 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -53,10 +53,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index 597fa6c46..e9a364ed1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -58,10 +58,7 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index 807ff0f0c..63c1c63c5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -48,10 +48,7 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index 999a6f2d1..cc834fefe 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -49,10 +49,7 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 70d1e37d7..53f14d16b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -72,10 +72,7 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index 2d303525d..ab542c4dc 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -74,10 +74,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index e81db6c1a..bb5238985 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -61,10 +61,7 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index 79f6f15f5..3bc796795 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -63,10 +63,7 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index 0e4746ca6..17aecfbce 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -62,10 +62,7 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index a7d470eff..6bd7c140b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -64,10 +64,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 2a52bd33e..3f624df4a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -58,10 +58,7 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index 4f7cc0d10..ebb0e4eac 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -107,10 +107,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index 20463ca2f..89f6e32db 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -70,10 +70,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 740f44c85..9ed14aaad 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -61,10 +61,7 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index 39054e06d..af149e392 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -287,10 +287,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
         return true;
     }
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index d013e3fd5..a21407174 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -207,10 +207,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index fd30103c9..12f7ff267 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -97,10 +97,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     /// </returns>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 697cc78a2..e5bbeb37f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -65,10 +65,7 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index 9c205eeef..c01c4394c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -67,10 +67,7 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
-    /// <summary>
-    /// Gets the pixel type information.
-    /// </summary>
-    /// <returns>PixelTypeInfo</returns>
+    /// <inheritdoc />
     public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />

From 153ccc312eb1f0b8cc8645a84d3aa06081bd1bd2 Mon Sep 17 00:00:00 2001
From: Stefan Nikolei <stefan@nikolei.eu>
Date: Wed, 6 Dec 2023 08:42:00 +0100
Subject: [PATCH 07/14] Disable SA1648 and add Ruleset to solution

---
 ImageSharp.sln         | 1 +
 src/ImageSharp.ruleset | 1 +
 2 files changed, 2 insertions(+)

diff --git a/ImageSharp.sln b/ImageSharp.sln
index 2967acb8f..b8204c47d 100644
--- a/ImageSharp.sln
+++ b/ImageSharp.sln
@@ -38,6 +38,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{815C0625-CD3
 		src\Directory.Build.props = src\Directory.Build.props
 		src\Directory.Build.targets = src\Directory.Build.targets
 		src\README.md = src\README.md
+		src\ImageSharp.ruleset = src\ImageSharp.ruleset
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ImageSharp", "src\ImageSharp\ImageSharp.csproj", "{2AA31A1F-142C-43F4-8687-09ABCA4B3A26}"
diff --git a/src/ImageSharp.ruleset b/src/ImageSharp.ruleset
index d7a147df0..6c291bfb1 100644
--- a/src/ImageSharp.ruleset
+++ b/src/ImageSharp.ruleset
@@ -3,5 +3,6 @@
   <Include Path="..\shared-infrastructure\sixlabors.ruleset" Action="Default" />
   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
     <Rule Id="SA1011" Action="None" />
+    <Rule Id="SA1648" Action="None" /> <!--https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3595-->
   </Rules>
 </RuleSet>

From db705814df9786ed45982c38bb0f665c873afc75 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Mon, 11 Dec 2023 16:06:03 +1000
Subject: [PATCH 08/14] Add PixelComponentPrecision

---
 src/ImageSharp/Color/Color.cs                 |   2 +-
 src/ImageSharp/Formats/PixelTypeInfo.cs       |  28 +++--
 .../CieLabPlanarTiffColor{TPixel}.cs          |   8 +-
 .../CieLabTiffColor{TPixel}.cs                |   2 +-
 .../CmykTiffColor{TPixel}.cs                  |   2 +-
 .../PixelFormats/PixelComponentPrecision.cs   |  50 ++++++++
 .../PixelFormats/PixelImplementations/A8.cs   |   2 +-
 .../PixelImplementations/Abgr32.cs            |   2 +-
 .../PixelImplementations/Argb32.cs            |   2 +-
 .../PixelImplementations/Bgr24.cs             |   2 +-
 .../PixelImplementations/Bgr565.cs            |   2 +-
 .../PixelImplementations/Bgra32.cs            |   2 +-
 .../PixelImplementations/Bgra4444.cs          |   2 +-
 .../PixelImplementations/Bgra5551.cs          |   2 +-
 .../PixelImplementations/Byte4.cs             |   2 +-
 .../PixelImplementations/HalfSingle.cs        |   2 +-
 .../PixelImplementations/HalfVector2.cs       |   2 +-
 .../PixelImplementations/HalfVector4.cs       |   2 +-
 .../PixelFormats/PixelImplementations/L16.cs  |   2 +-
 .../PixelFormats/PixelImplementations/L8.cs   |   2 +-
 .../PixelFormats/PixelImplementations/La16.cs |   2 +-
 .../PixelFormats/PixelImplementations/La32.cs |   2 +-
 .../PixelImplementations/NormalizedByte2.cs   |   2 +-
 .../PixelImplementations/NormalizedByte4.cs   |   2 +-
 .../PixelImplementations/NormalizedShort2.cs  |   2 +-
 .../PixelImplementations/NormalizedShort4.cs  |   2 +-
 .../Rgba1010102.PixelOperations.cs            |   2 -
 .../PixelFormats/PixelImplementations/Rg32.cs |   2 +-
 .../PixelImplementations/Rgb24.cs             |   2 +-
 .../PixelImplementations/Rgb48.cs             |   2 +-
 .../PixelImplementations/Rgba1010102.cs       |   4 +-
 .../PixelImplementations/Rgba32.cs            |   2 +-
 .../PixelImplementations/Rgba64.cs            |   2 +-
 .../PixelImplementations/RgbaVector.cs        |   2 +-
 .../PixelImplementations/Short2.cs            |   2 +-
 .../PixelImplementations/Short4.cs            |   2 +-
 .../ImageSharp.Tests/PixelFormats/A8Tests.cs  |  28 +++--
 .../PixelFormats/Abgr32Tests.cs               |  42 ++++---
 .../PixelFormats/Argb32Tests.cs               |  42 ++++---
 .../PixelFormats/Bgr24Tests.cs                |  42 ++++---
 .../PixelFormats/Bgr565Tests.cs               |  60 +++++----
 .../PixelFormats/Bgra32Tests.cs               |  42 ++++---
 .../PixelFormats/Bgra4444Tests.cs             |  58 +++++----
 .../PixelFormats/Bgra5551Tests.cs             |  67 ++++++----
 .../PixelFormats/Byte4Tests.cs                |  56 +++++----
 .../PixelFormats/HalfSingleTests.cs           |  22 +++-
 .../PixelFormats/HalfVector2Tests.cs          |  24 +++-
 .../PixelFormats/HalfVector4Tests.cs          |  18 ++-
 .../ImageSharp.Tests/PixelFormats/L16Tests.cs |  32 +++--
 .../ImageSharp.Tests/PixelFormats/L8Tests.cs  |  50 +++++---
 .../PixelFormats/La16Tests.cs                 |  50 +++++---
 .../PixelFormats/La32Tests.cs                 |  32 +++--
 .../PixelFormats/NormalizedByte2Tests.cs      |  20 ++-
 .../PixelFormats/NormalizedByte4Tests.cs      |  56 +++++----
 .../PixelFormats/NormalizedShort2Tests.cs     |  20 ++-
 .../PixelFormats/NormalizedShort4Tests.cs     |  56 +++++----
 .../PixelFormats/Rg32Tests.cs                 |  20 ++-
 .../PixelFormats/Rgb24Tests.cs                |  36 ++++--
 .../PixelFormats/Rgb48Tests.cs                |  26 ++--
 .../PixelFormats/Rgba1010102Tests.cs          |  58 +++++----
 .../PixelFormats/Rgba32Tests.cs               |  96 +++++++-------
 .../PixelFormats/Rgba64Tests.cs               | 118 ++++++++++--------
 .../PixelFormats/RgbaVectorTests.cs           |  59 +++++----
 .../PixelFormats/Short2Tests.cs               |  44 ++++---
 .../PixelFormats/Short4Tests.cs               |  74 ++++++-----
 .../PixelFormats/UnPackedPixelTests.cs        |  32 ++---
 tests/ImageSharp.Tests/TestFormat.cs          |   2 +-
 .../BasicTestPatternProvider.cs               |   4 +-
 68 files changed, 971 insertions(+), 569 deletions(-)
 create mode 100644 src/ImageSharp/PixelFormats/PixelComponentPrecision.cs

diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index cebceabe0..99458d58a 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -107,7 +107,7 @@ public readonly partial struct Color : IEquatable<Color>
     public static Color FromPixel<TPixel>(TPixel pixel)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        // Avoid boxing in case we can convert to Rgba64 safely and efficently
+        // Avoid boxing in case we can convert to Rgba64 safely and efficiently
         if (typeof(TPixel) == typeof(Rgba64))
         {
             return new((Rgba64)(object)pixel);
diff --git a/src/ImageSharp/Formats/PixelTypeInfo.cs b/src/ImageSharp/Formats/PixelTypeInfo.cs
index ba26e48ee..0c2a4f4c8 100644
--- a/src/ImageSharp/Formats/PixelTypeInfo.cs
+++ b/src/ImageSharp/Formats/PixelTypeInfo.cs
@@ -4,7 +4,7 @@
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
-// TODO: Review this class as it's used to represent 2 different things.
+// TODO: Review this type as it's used to represent 2 different things.
 // 1.The encoded image pixel format.
 // 2. The pixel format of the decoded image.
 namespace SixLabors.ImageSharp.Formats;
@@ -12,37 +12,43 @@ namespace SixLabors.ImageSharp.Formats;
 /// <summary>
 /// Contains information about the pixels that make up an images visual data.
 /// </summary>
-public readonly struct PixelTypeInfo
+/// <remarks>
+/// Initializes a new instance of the <see cref="PixelTypeInfo"/> struct.
+/// </remarks>
+/// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
+public readonly struct PixelTypeInfo(int bitsPerPixel)
 {
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PixelTypeInfo"/> struct.
-    /// </summary>
-    /// <param name="bitsPerPixel">Color depth, in number of bits per pixel.</param>
-    public PixelTypeInfo(int bitsPerPixel)
-        => this.BitsPerPixel = bitsPerPixel;
-
     /// <summary>
     /// Gets color depth, in number of bits per pixel.
     /// </summary>
-    public int BitsPerPixel { get; init; }
+    public int BitsPerPixel { get; init; } = bitsPerPixel;
 
     /// <summary>
     /// Gets the count of the color components
     /// </summary>
     public byte ComponentCount { get; init; }
 
+    /// <summary>
+    /// Gets the pixel component precision.
+    /// </summary>
+    public PixelComponentPrecision? ComponentPrecision { get; init; }
+
     /// <summary>
     /// Gets the pixel alpha transparency behavior.
     /// <see langword="null"/> means unknown, unspecified.
     /// </summary>
     public PixelAlphaRepresentation? AlphaRepresentation { get; init; }
 
-    internal static PixelTypeInfo Create<TPixel>(byte componentCount, PixelAlphaRepresentation pixelAlphaRepresentation)
+    internal static PixelTypeInfo Create<TPixel>(
+        byte componentCount,
+        PixelComponentPrecision componentPrecision,
+        PixelAlphaRepresentation pixelAlphaRepresentation)
         where TPixel : unmanaged, IPixel<TPixel>
         => new()
         {
             BitsPerPixel = Unsafe.SizeOf<TPixel>() * 8,
             ComponentCount = componentCount,
+            ComponentPrecision = componentPrecision,
             AlphaRepresentation = pixelAlphaRepresentation
         };
 }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
index 216d17330..eb2fe353e 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabPlanarTiffColor{TPixel}.cs
@@ -27,17 +27,17 @@ internal class CieLabPlanarTiffColor<TPixel> : TiffBasePlanarColorDecoder<TPixel
         Span<byte> a = data[1].GetSpan();
         Span<byte> b = data[2].GetSpan();
 
-        var color = default(TPixel);
+        TPixel color = default;
         int offset = 0;
         for (int y = top; y < top + height; y++)
         {
             Span<TPixel> pixelRow = pixels.DangerousGetRowSpan(y).Slice(left, width);
             for (int x = 0; x < pixelRow.Length; x++)
             {
-                var lab = new CieLab((l[offset] & 0xFF) * 100f * Inv255, (sbyte)a[offset], (sbyte)b[offset]);
-                var rgb = ColorSpaceConverter.ToRgb(lab);
+                CieLab lab = new((l[offset] & 0xFF) * 100f * Inv255, (sbyte)a[offset], (sbyte)b[offset]);
+                Rgb rgb = ColorSpaceConverter.ToRgb(lab);
 
-                color.FromVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
+                color.FromScaledVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
                 pixelRow[x] = color;
 
                 offset++;
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
index b39a64644..f5418774b 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CieLabTiffColor{TPixel}.cs
@@ -34,7 +34,7 @@ internal class CieLabTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 CieLab lab = new(l, (sbyte)data[offset + 1], (sbyte)data[offset + 2]);
                 Rgb rgb = ColorSpaceConverter.ToRgb(lab);
 
-                color.FromVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
+                color.FromScaledVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
                 pixelRow[x] = color;
 
                 offset += 3;
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
index c87051d52..2074fb254 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/CmykTiffColor{TPixel}.cs
@@ -27,7 +27,7 @@ internal class CmykTiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
                 Cmyk cmyk = new(data[offset] * Inv255, data[offset + 1] * Inv255, data[offset + 2] * Inv255, data[offset + 3] * Inv255);
                 Rgb rgb = ColorSpaceConverter.ToRgb(in cmyk);
 
-                color.FromVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
+                color.FromScaledVector4(new Vector4(rgb.R, rgb.G, rgb.B, 1.0f));
                 pixelRow[x] = color;
 
                 offset += 4;
diff --git a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
new file mode 100644
index 000000000..8b1298657
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Provides enumeration of the maximum precision of individual components within a pixel format.
+/// </summary>
+public enum PixelComponentPrecision
+{
+    /// <summary>
+    /// 8-bit signed integer.
+    /// </summary>
+    SByte,
+
+    /// <summary>
+    /// 8-bit unsigned integer.
+    /// </summary>
+    Byte,
+
+    /// <summary>
+    /// 16-bit signed integer.
+    /// </summary>
+    Short,
+
+    /// <summary>
+    /// 16-bit unsigned integer.
+    /// </summary>
+    UShort,
+
+    /// <summary>
+    /// 32-bit signed integer.
+    /// </summary>
+    Int,
+
+    /// <summary>
+    /// 32-bit unsigned integer.
+    /// </summary>
+    UInt,
+
+    /// <summary>
+    /// 16-bit floating point.
+    /// </summary>
+    Half,
+
+    /// <summary>
+    /// 32-bit floating point.
+    /// </summary>
+    Float
+}
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index 7662495ff..33fa62d1a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -57,7 +57,7 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<A8> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 8fae07aa1..66523f040 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -185,7 +185,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Abgr32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index 9f36e31b8..d3375f65f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -185,7 +185,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Argb32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index 4a6caa4ce..9d0186c83 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -89,7 +89,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Bgr24> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index 564a0c53f..6135ab3e7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -61,7 +61,7 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgr565> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index afd6c395e..7da4fad4f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -138,7 +138,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Bgra32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index 81f37c554..effc0d6e5 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -59,7 +59,7 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgra4444> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index c80af59b3..14110b1d1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -62,7 +62,7 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index 6efbc9623..f9a36305d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -62,7 +62,7 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Byte4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index 8d658b240..7e1997251 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -47,7 +47,7 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelComponentPrecision.Half, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public PixelOperations<HalfSingle> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index faec2b069..1e3854feb 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -54,7 +54,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelComponentPrecision.Half, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index e9a364ed1..233160579 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -59,7 +59,7 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelComponentPrecision.Half, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index 63c1c63c5..fa07d650b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -49,7 +49,7 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelComponentPrecision.UShort, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<L16> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index cc834fefe..28fb7ec72 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -50,7 +50,7 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<L8> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 53f14d16b..99203518a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -73,7 +73,7 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<La16> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index ab542c4dc..a8c0dcd94 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -75,7 +75,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelComponentPrecision.UShort, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<La32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index bb5238985..5db53e853 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -62,7 +62,7 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelComponentPrecision.SByte, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index 3bc796795..4c850e426 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -64,7 +64,7 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelComponentPrecision.SByte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index 17aecfbce..7fd299d6d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -63,7 +63,7 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelComponentPrecision.Short, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index 6bd7c140b..ff5cd6a98 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -65,7 +65,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelComponentPrecision.Short, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
index 80c54ac2b..8dcbb319f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/PixelOperations/Rgba1010102.PixelOperations.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
-
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <content>
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 3f624df4a..9a2753341 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -59,7 +59,7 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelComponentPrecision.UShort, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rg32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index ebb0e4eac..f4c907abf 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -108,7 +108,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Rgb24> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index 89f6e32db..642883ff0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -71,7 +71,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelComponentPrecision.UShort, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgb48> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 9ed14aaad..5f289577f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -8,7 +8,7 @@ using SixLabors.ImageSharp.Formats;
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
-/// Packed vector type containing unsigned normalized values ranging from 0 to 1.
+/// Packed vector type containing 4 unsigned normalized values ranging from 0 to 1.
 /// The x, y and z components use 10 bits, and the w component uses 2 bits.
 /// <para>
 /// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
@@ -62,7 +62,7 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelComponentPrecision.UShort, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba1010102> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index af149e392..f775e8ae1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -288,7 +288,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     }
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index a21407174..84860d66d 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -208,7 +208,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelComponentPrecision.UShort, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba64> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index 12f7ff267..064064f73 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -98,7 +98,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelComponentPrecision.Float, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<RgbaVector> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index e5bbeb37f..8af952b18 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -66,7 +66,7 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelComponentPrecision.Short, PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Short2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index c01c4394c..4c60887df 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -68,7 +68,7 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelComponentPrecision.Short, PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Short4> CreatePixelOperations() => new PixelOperations();
diff --git a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
index 95574a4d6..008bc652c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -28,8 +30,8 @@ public class A8Tests
     [Fact]
     public void A8_Equality()
     {
-        var left = new A8(16);
-        var right = new A8(32);
+        A8 left = new(16);
+        A8 right = new(32);
 
         Assert.True(left == new A8(16));
         Assert.True(left != right);
@@ -56,7 +58,7 @@ public class A8Tests
     public void A8_ToScaledVector4()
     {
         // Arrange
-        var alpha = new A8(.5F);
+        A8 alpha = new(.5F);
 
         // Act
         Vector4 actual = alpha.ToScaledVector4();
@@ -72,10 +74,10 @@ public class A8Tests
     public void A8_ToVector4()
     {
         // Arrange
-        var alpha = new A8(.5F);
+        A8 alpha = new(.5F);
 
         // Act
-        var actual = alpha.ToVector4();
+        Vector4 actual = alpha.ToVector4();
 
         // Assert
         Assert.Equal(0, actual.X);
@@ -87,8 +89,8 @@ public class A8Tests
     [Fact]
     public void A8_ToRgba32()
     {
-        var input = new A8(128);
-        var expected = new Rgba32(0, 0, 0, 128);
+        A8 input = new(128);
+        Rgba32 expected = new(0, 0, 0, 128);
 
         Rgba32 actual = default;
         input.ToRgba32(ref actual);
@@ -99,7 +101,7 @@ public class A8Tests
     public void A8_FromBgra5551()
     {
         // arrange
-        var alpha = default(A8);
+        A8 alpha = default;
         byte expected = byte.MaxValue;
 
         // act
@@ -108,4 +110,14 @@ public class A8Tests
         // assert
         Assert.Equal(expected, alpha.PackedValue);
     }
+
+    [Fact]
+    public void A8_PixelInformation()
+    {
+        PixelTypeInfo info = A8.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<A8>() * 8, info.BitsPerPixel);
+        Assert.Equal(1, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
index 13c84784c..3c185383c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,8 +17,8 @@ public class Abgr32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Abgr32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var color2 = new Abgr32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Abgr32 color1 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Abgr32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.Equal(color1, color2);
     }
@@ -27,8 +29,8 @@ public class Abgr32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Abgr32(0, 0, byte.MaxValue, byte.MaxValue);
-        var color2 = new Abgr32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Abgr32 color1 = new(0, 0, byte.MaxValue, byte.MaxValue);
+        Abgr32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.NotEqual(color1, color2);
     }
@@ -46,7 +48,7 @@ public class Abgr32Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte b, byte g, byte r, byte a)
     {
-        var p = new Abgr32(r, g, b, a);
+        Abgr32 p = new(r, g, b, a);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -57,7 +59,7 @@ public class Abgr32Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialBgra()
     {
-        var color = new Abgr32(1, 2, 3, 4);
+        Abgr32 color = new(1, 2, 3, 4);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(4, ptr[0]);
@@ -70,8 +72,8 @@ public class Abgr32Tests
     [MemberData(nameof(ColorData))]
     public void Equality_WhenTrue(byte r, byte g, byte b, byte a)
     {
-        var x = new Abgr32(r, g, b, a);
-        var y = new Abgr32(r, g, b, a);
+        Abgr32 x = new(r, g, b, a);
+        Abgr32 y = new(r, g, b, a);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -85,8 +87,8 @@ public class Abgr32Tests
     [InlineData(1, 255, 0, 0, 0, 255, 0, 0)]
     public void Equality_WhenFalse(byte b1, byte g1, byte r1, byte a1, byte b2, byte g2, byte r2, byte a2)
     {
-        var x = new Abgr32(r1, g1, b1, a1);
-        var y = new Abgr32(r2, g2, b2, a2);
+        Abgr32 x = new(r1, g1, b1, a1);
+        Abgr32 y = new(r2, g2, b2, a2);
 
         Assert.False(x.Equals(y));
         Assert.False(x.Equals((object)y));
@@ -95,7 +97,7 @@ public class Abgr32Tests
     [Fact]
     public void FromRgba32()
     {
-        var abgr = default(Abgr32);
+        Abgr32 abgr = default;
         abgr.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, abgr.R);
@@ -104,7 +106,7 @@ public class Abgr32Tests
         Assert.Equal(4, abgr.A);
     }
 
-    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new(
         r / 255f,
         g / 255f,
         b / 255f,
@@ -113,7 +115,7 @@ public class Abgr32Tests
     [Fact]
     public void FromVector4()
     {
-        var c = default(Abgr32);
+        Abgr32 c = default;
         c.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, c.R);
@@ -125,7 +127,7 @@ public class Abgr32Tests
     [Fact]
     public void ToVector4()
     {
-        var abgr = new Abgr32(1, 2, 3, 4);
+        Abgr32 abgr = new(1, 2, 3, 4);
 
         Assert.Equal(Vec(1, 2, 3, 4), abgr.ToVector4());
     }
@@ -134,7 +136,7 @@ public class Abgr32Tests
     public void Abgr32_FromBgra5551()
     {
         // arrange
-        var abgr = default(Abgr32);
+        Abgr32 abgr = default;
         uint expected = uint.MaxValue;
 
         // act
@@ -143,4 +145,14 @@ public class Abgr32Tests
         // assert
         Assert.Equal(expected, abgr.PackedValue);
     }
+
+    [Fact]
+    public void Abgr32_PixelInformation()
+    {
+        PixelTypeInfo info = Abgr32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Abgr32>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
index 70012afb0..f6b818fb5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class Argb32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Argb32(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Argb32(new Vector4(0.0f));
-        var color3 = new Argb32(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Argb32(1.0f, 0.0f, 1.0f, 1.0f);
+        Argb32 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Argb32 color2 = new(new Vector4(0.0f));
+        Argb32 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        Argb32 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class Argb32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Argb32(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Argb32(new Vector4(1.0f));
-        var color3 = new Argb32(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Argb32(1.0f, 1.0f, 0.0f, 1.0f);
+        Argb32 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Argb32 color2 = new(new Vector4(1.0f));
+        Argb32 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Argb32 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -45,25 +47,25 @@ public class Argb32Tests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var color1 = new Argb32(1, .1f, .133f, .864f);
+        Argb32 color1 = new(1, .1f, .133f, .864f);
         Assert.Equal(255, color1.R);
         Assert.Equal((byte)Math.Round(.1f * 255), color1.G);
         Assert.Equal((byte)Math.Round(.133f * 255), color1.B);
         Assert.Equal((byte)Math.Round(.864f * 255), color1.A);
 
-        var color2 = new Argb32(1, .1f, .133f);
+        Argb32 color2 = new(1, .1f, .133f);
         Assert.Equal(255, color2.R);
         Assert.Equal(Math.Round(.1f * 255), color2.G);
         Assert.Equal(Math.Round(.133f * 255), color2.B);
         Assert.Equal(255, color2.A);
 
-        var color4 = new Argb32(new Vector3(1, .1f, .133f));
+        Argb32 color4 = new(new Vector3(1, .1f, .133f));
         Assert.Equal(255, color4.R);
         Assert.Equal(Math.Round(.1f * 255), color4.G);
         Assert.Equal(Math.Round(.133f * 255), color4.B);
         Assert.Equal(255, color4.A);
 
-        var color5 = new Argb32(new Vector4(1, .1f, .133f, .5f));
+        Argb32 color5 = new(new Vector4(1, .1f, .133f, .5f));
         Assert.Equal(255, color5.R);
         Assert.Equal(Math.Round(.1f * 255), color5.G);
         Assert.Equal(Math.Round(.133f * 255), color5.B);
@@ -93,7 +95,7 @@ public class Argb32Tests
     public void Argb32_ToScaledVector4()
     {
         // arrange
-        var argb = new Argb32(Vector4.One);
+        Argb32 argb = new(Vector4.One);
 
         // act
         Vector4 actual = argb.ToScaledVector4();
@@ -110,7 +112,7 @@ public class Argb32Tests
     {
         // arrange
         Vector4 scaled = new Argb32(Vector4.One).ToScaledVector4();
-        var pixel = default(Argb32);
+        Argb32 pixel = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -125,7 +127,7 @@ public class Argb32Tests
     public void Argb32_FromBgra5551()
     {
         // arrange
-        var argb = default(Argb32);
+        Argb32 argb = default;
         uint expected = uint.MaxValue;
 
         // act
@@ -141,4 +143,14 @@ public class Argb32Tests
         Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Argb32_PixelInformation()
+    {
+        PixelTypeInfo info = Argb32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Argb32>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
index 730e3996d..6861dab41 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +14,8 @@ public class Bgr24Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
-        var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+        Bgr24 color1 = new(byte.MaxValue, 0, byte.MaxValue);
+        Bgr24 color2 = new(byte.MaxValue, 0, byte.MaxValue);
 
         Assert.Equal(color1, color2);
     }
@@ -21,8 +23,8 @@ public class Bgr24Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgr24(byte.MaxValue, 0, 0);
-        var color2 = new Bgr24(byte.MaxValue, 0, byte.MaxValue);
+        Bgr24 color1 = new(byte.MaxValue, 0, 0);
+        Bgr24 color2 = new(byte.MaxValue, 0, byte.MaxValue);
 
         Assert.NotEqual(color1, color2);
     }
@@ -33,7 +35,7 @@ public class Bgr24Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte r, byte g, byte b)
     {
-        var p = new Rgb24(r, g, b);
+        Rgb24 p = new(r, g, b);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -43,7 +45,7 @@ public class Bgr24Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialBgr()
     {
-        var color = new Bgr24(1, 2, 3);
+        Bgr24 color = new(1, 2, 3);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(3, ptr[0]);
@@ -55,8 +57,8 @@ public class Bgr24Tests
     [MemberData(nameof(ColorData))]
     public void Equals_WhenTrue(byte r, byte g, byte b)
     {
-        var x = new Bgr24(r, g, b);
-        var y = new Bgr24(r, g, b);
+        Bgr24 x = new(r, g, b);
+        Bgr24 y = new(r, g, b);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -69,8 +71,8 @@ public class Bgr24Tests
     [InlineData(1, 255, 0, 0, 255, 0)]
     public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
     {
-        var a = new Bgr24(r1, g1, b1);
-        var b = new Bgr24(r2, g2, b2);
+        Bgr24 a = new(r1, g1, b1);
+        Bgr24 b = new(r2, g2, b2);
 
         Assert.False(a.Equals(b));
         Assert.False(a.Equals((object)b));
@@ -79,7 +81,7 @@ public class Bgr24Tests
     [Fact]
     public void FromRgba32()
     {
-        var rgb = default(Bgr24);
+        Bgr24 rgb = default;
         rgb.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
@@ -87,7 +89,7 @@ public class Bgr24Tests
         Assert.Equal(3, rgb.B);
     }
 
-    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new(
         r / 255f,
         g / 255f,
         b / 255f,
@@ -96,7 +98,7 @@ public class Bgr24Tests
     [Fact]
     public void FromVector4()
     {
-        var rgb = default(Bgr24);
+        Bgr24 rgb = default;
         rgb.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
@@ -107,7 +109,7 @@ public class Bgr24Tests
     [Fact]
     public void ToVector4()
     {
-        var rgb = new Bgr24(1, 2, 3);
+        Bgr24 rgb = new(1, 2, 3);
 
         Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
     }
@@ -116,7 +118,7 @@ public class Bgr24Tests
     public void Bgr24_FromBgra5551()
     {
         // arrange
-        var bgr = default(Bgr24);
+        Bgr24 bgr = default;
 
         // act
         bgr.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
@@ -126,4 +128,14 @@ public class Bgr24Tests
         Assert.Equal(255, bgr.G);
         Assert.Equal(255, bgr.B);
     }
+
+    [Fact]
+    public void Bgr24_PixelInformation()
+    {
+        PixelTypeInfo info = Bgr24.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgr24>() * 8, info.BitsPerPixel);
+        Assert.Equal(3, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
index 8245a578f..b68b94325 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class Bgr565Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgr565(0.0f, 0.0f, 0.0f);
-        var color2 = new Bgr565(new Vector3(0.0f));
-        var color3 = new Bgr565(new Vector3(1.0f, 0.0f, 1.0f));
-        var color4 = new Bgr565(1.0f, 0.0f, 1.0f);
+        Bgr565 color1 = new(0.0f, 0.0f, 0.0f);
+        Bgr565 color2 = new(new Vector3(0.0f));
+        Bgr565 color3 = new(new Vector3(1.0f, 0.0f, 1.0f));
+        Bgr565 color4 = new(1.0f, 0.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class Bgr565Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgr565(0.0f, 0.0f, 0.0f);
-        var color2 = new Bgr565(new Vector3(1.0f));
-        var color3 = new Bgr565(new Vector3(1.0f, 0.0f, 0.0f));
-        var color4 = new Bgr565(1.0f, 1.0f, 0.0f);
+        Bgr565 color1 = new(0.0f, 0.0f, 0.0f);
+        Bgr565 color2 = new(new Vector3(1.0f));
+        Bgr565 color3 = new(new Vector3(1.0f, 0.0f, 0.0f));
+        Bgr565 color4 = new(1.0f, 1.0f, 0.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -66,7 +68,7 @@ public class Bgr565Tests
     public void Bgr565_ToScaledVector4()
     {
         // arrange
-        var bgr = new Bgr565(Vector3.One);
+        Bgr565 bgr = new(Vector3.One);
 
         // act
         Vector4 actual = bgr.ToScaledVector4();
@@ -84,7 +86,7 @@ public class Bgr565Tests
         // arrange
         Vector4 scaled = new Bgr565(Vector3.One).ToScaledVector4();
         int expected = 0xFFFF;
-        var pixel = default(Bgr565);
+        Bgr565 pixel = default;
 
         // act
         pixel.FromScaledVector4(scaled);
@@ -98,7 +100,7 @@ public class Bgr565Tests
     public void Bgr565_FromBgra5551()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -112,8 +114,8 @@ public class Bgr565Tests
     public void Bgr565_FromArgb32()
     {
         // arrange
-        var bgr1 = default(Bgr565);
-        var bgr2 = default(Bgr565);
+        Bgr565 bgr1 = default;
+        Bgr565 bgr2 = default;
         ushort expected1 = ushort.MaxValue;
         ushort expected2 = ushort.MaxValue;
 
@@ -130,8 +132,8 @@ public class Bgr565Tests
     public void Bgr565_FromRgba32()
     {
         // arrange
-        var bgr1 = default(Bgr565);
-        var bgr2 = default(Bgr565);
+        Bgr565 bgr1 = default;
+        Bgr565 bgr2 = default;
         ushort expected1 = ushort.MaxValue;
         ushort expected2 = ushort.MaxValue;
 
@@ -148,9 +150,9 @@ public class Bgr565Tests
     public void Bgr565_ToRgba32()
     {
         // arrange
-        var bgra = new Bgr565(Vector3.One);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Bgr565 bgra = new(Vector3.One);
+        Rgba32 expected = new(Vector4.One);
+        Rgba32 actual = default;
 
         // act
         bgra.ToRgba32(ref actual);
@@ -162,7 +164,7 @@ public class Bgr565Tests
     public void Bgra565_FromRgb48()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -176,7 +178,7 @@ public class Bgr565Tests
     public void Bgra565_FromRgba64()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -190,7 +192,7 @@ public class Bgr565Tests
     public void Bgr565_FromBgr24()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -204,7 +206,7 @@ public class Bgr565Tests
     public void Bgr565_FromRgb24()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -218,7 +220,7 @@ public class Bgr565Tests
     public void Bgr565_FromGrey8()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -232,7 +234,7 @@ public class Bgr565Tests
     public void Bgr565_FromGrey16()
     {
         // arrange
-        var bgr = default(Bgr565);
+        Bgr565 bgr = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -248,4 +250,14 @@ public class Bgr565Tests
         Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3());
         Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3());
     }
+
+    [Fact]
+    public void Bgr565_PixelInformation()
+    {
+        PixelTypeInfo info = Bgr565.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgr565>() * 8, info.BitsPerPixel);
+        Assert.Equal(3, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
index 04c8813d5..17d184d1a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,8 +17,8 @@ public class Bgra32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var color2 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Bgra32 color1 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Bgra32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.Equal(color1, color2);
     }
@@ -27,8 +29,8 @@ public class Bgra32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgra32(0, 0, byte.MaxValue, byte.MaxValue);
-        var color2 = new Bgra32(byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Bgra32 color1 = new(0, 0, byte.MaxValue, byte.MaxValue);
+        Bgra32 color2 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue);
 
         Assert.NotEqual(color1, color2);
     }
@@ -46,7 +48,7 @@ public class Bgra32Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte b, byte g, byte r, byte a)
     {
-        var p = new Bgra32(r, g, b, a);
+        Bgra32 p = new(r, g, b, a);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -57,7 +59,7 @@ public class Bgra32Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialBgra()
     {
-        var color = new Bgra32(1, 2, 3, 4);
+        Bgra32 color = new(1, 2, 3, 4);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(3, ptr[0]);
@@ -70,8 +72,8 @@ public class Bgra32Tests
     [MemberData(nameof(ColorData))]
     public void Equality_WhenTrue(byte b, byte g, byte r, byte a)
     {
-        var x = new Bgra32(r, g, b, a);
-        var y = new Bgra32(r, g, b, a);
+        Bgra32 x = new(r, g, b, a);
+        Bgra32 y = new(r, g, b, a);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -85,8 +87,8 @@ public class Bgra32Tests
     [InlineData(1, 255, 0, 0, 0, 255, 0, 0)]
     public void Equality_WhenFalse(byte b1, byte g1, byte r1, byte a1, byte b2, byte g2, byte r2, byte a2)
     {
-        var x = new Bgra32(r1, g1, b1, a1);
-        var y = new Bgra32(r2, g2, b2, a2);
+        Bgra32 x = new(r1, g1, b1, a1);
+        Bgra32 y = new(r2, g2, b2, a2);
 
         Assert.False(x.Equals(y));
         Assert.False(x.Equals((object)y));
@@ -95,7 +97,7 @@ public class Bgra32Tests
     [Fact]
     public void FromRgba32()
     {
-        var bgra = default(Bgra32);
+        Bgra32 bgra = default;
         bgra.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, bgra.R);
@@ -104,7 +106,7 @@ public class Bgra32Tests
         Assert.Equal(4, bgra.A);
     }
 
-    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+    private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new(
         r / 255f,
         g / 255f,
         b / 255f,
@@ -113,7 +115,7 @@ public class Bgra32Tests
     [Fact]
     public void FromVector4()
     {
-        var c = default(Bgra32);
+        Bgra32 c = default;
         c.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, c.R);
@@ -125,7 +127,7 @@ public class Bgra32Tests
     [Fact]
     public void ToVector4()
     {
-        var rgb = new Bgra32(1, 2, 3, 4);
+        Bgra32 rgb = new(1, 2, 3, 4);
 
         Assert.Equal(Vec(1, 2, 3, 4), rgb.ToVector4());
     }
@@ -134,7 +136,7 @@ public class Bgra32Tests
     public void Bgra32_FromBgra5551()
     {
         // arrange
-        var bgra = default(Bgra32);
+        Bgra32 bgra = default;
         uint expected = uint.MaxValue;
 
         // act
@@ -143,4 +145,14 @@ public class Bgra32Tests
         // assert
         Assert.Equal(expected, bgra.PackedValue);
     }
+
+    [Fact]
+    public void Bgra32_PixelInformation()
+    {
+        PixelTypeInfo info = Bgra32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgra32>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
index 543b5814f..648ef79d5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class Bgra4444Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgra4444(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra4444(new Vector4(0.0f));
-        var color3 = new Bgra4444(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Bgra4444(1.0f, 0.0f, 1.0f, 1.0f);
+        Bgra4444 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra4444 color2 = new(new Vector4(0.0f));
+        Bgra4444 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        Bgra4444 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class Bgra4444Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgra4444(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra4444(new Vector4(1.0f));
-        var color3 = new Bgra4444(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Bgra4444(1.0f, 1.0f, 0.0f, 1.0f);
+        Bgra4444 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra4444 color2 = new(new Vector4(1.0f));
+        Bgra4444 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Bgra4444 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -66,7 +68,7 @@ public class Bgra4444Tests
     public void Bgra4444_ToScaledVector4()
     {
         // arrange
-        var bgra = new Bgra4444(Vector4.One);
+        Bgra4444 bgra = new(Vector4.One);
 
         // act
         Vector4 actual = bgra.ToScaledVector4();
@@ -82,9 +84,9 @@ public class Bgra4444Tests
     public void Bgra4444_ToRgba32()
     {
         // arrange
-        var bgra = new Bgra4444(Vector4.One);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Bgra4444 bgra = new(Vector4.One);
+        Rgba32 expected = new(Vector4.One);
+        Rgba32 actual = default;
 
         // act
         bgra.ToRgba32(ref actual);
@@ -98,7 +100,7 @@ public class Bgra4444Tests
         // arrange
         Vector4 scaled = new Bgra4444(Vector4.One).ToScaledVector4();
         int expected = 0xFFFF;
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
 
         // act
         bgra.FromScaledVector4(scaled);
@@ -112,7 +114,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromBgra5551()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -126,7 +128,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromArgb32()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -140,8 +142,8 @@ public class Bgra4444Tests
     public void Bgra4444_FromRgba32()
     {
         // arrange
-        var bgra1 = default(Bgra4444);
-        var bgra2 = default(Bgra4444);
+        Bgra4444 bgra1 = default;
+        Bgra4444 bgra2 = default;
         ushort expectedPackedValue1 = ushort.MaxValue;
         ushort expectedPackedValue2 = 0xFF0F;
 
@@ -158,7 +160,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromRgb48()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -172,7 +174,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromRgba64()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -186,7 +188,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromGrey16()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -200,7 +202,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromGrey8()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -214,7 +216,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromBgr24()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -228,7 +230,7 @@ public class Bgra4444Tests
     public void Bgra4444_FromRgb24()
     {
         // arrange
-        var bgra = default(Bgra4444);
+        Bgra4444 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -244,4 +246,14 @@ public class Bgra4444Tests
         Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Bgra4444_PixelInformation()
+    {
+        PixelTypeInfo info = Bgra4444.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgra4444>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
index ec5417310..e32ec665e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class Bgra5551Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Bgra5551(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra5551(new Vector4(0.0f));
-        var color3 = new Bgra5551(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Bgra5551(1.0f, 0.0f, 0.0f, 1.0f);
+        Bgra5551 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra5551 color2 = new(new Vector4(0.0f));
+        Bgra5551 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Bgra5551 color4 = new(1.0f, 0.0f, 0.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class Bgra5551Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Bgra5551(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Bgra5551(new Vector4(1.0f));
-        var color3 = new Bgra5551(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Bgra5551(1.0f, 1.0f, 0.0f, 1.0f);
+        Bgra5551 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Bgra5551 color2 = new(new Vector4(1.0f));
+        Bgra5551 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Bgra5551 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -71,7 +73,7 @@ public class Bgra5551Tests
     public void Bgra5551_ToScaledVector4()
     {
         // arrange
-        var bgra = new Bgra5551(Vector4.One);
+        Bgra5551 bgra = new(Vector4.One);
 
         // act
         Vector4 actual = bgra.ToScaledVector4();
@@ -87,9 +89,9 @@ public class Bgra5551Tests
     public void Bgra5551_ToRgba32()
     {
         // arrange
-        var bgra = new Bgra5551(Vector4.One);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Bgra5551 bgra = new(Vector4.One);
+        Rgba32 expected = new(Vector4.One);
+        Rgba32 actual = default;
 
         // act
         bgra.ToRgba32(ref actual);
@@ -103,7 +105,7 @@ public class Bgra5551Tests
         // arrange
         Vector4 scaled = new Bgra5551(Vector4.One).ToScaledVector4();
         int expected = 0xFFFF;
-        var pixel = default(Bgra5551);
+        Bgra5551 pixel = default;
 
         // act
         pixel.FromScaledVector4(scaled);
@@ -117,9 +119,9 @@ public class Bgra5551Tests
     public void Bgra5551_FromBgra5551()
     {
         // arrange
-        var bgra = default(Bgra5551);
-        var actual = default(Bgra5551);
-        var expected = new Bgra5551(1.0f, 0.0f, 1.0f, 1.0f);
+        Bgra5551 bgra = default;
+        Bgra5551 actual = default;
+        Bgra5551 expected = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         // act
         bgra.FromBgra5551(expected);
@@ -133,8 +135,8 @@ public class Bgra5551Tests
     public void Bgra5551_FromRgba32()
     {
         // arrange
-        var bgra1 = default(Bgra5551);
-        var bgra2 = default(Bgra5551);
+        Bgra5551 bgra1 = default;
+        Bgra5551 bgra2 = default;
         ushort expectedPackedValue1 = ushort.MaxValue;
         ushort expectedPackedValue2 = 0xFC1F;
 
@@ -151,8 +153,8 @@ public class Bgra5551Tests
     public void Bgra5551_FromBgra32()
     {
         // arrange
-        var bgra1 = default(Bgra5551);
-        var bgra2 = default(Bgra5551);
+        Bgra5551 bgra1 = default;
+        Bgra5551 bgra2 = default;
         ushort expectedPackedValue1 = ushort.MaxValue;
         ushort expectedPackedValue2 = 0xFC1F;
 
@@ -169,7 +171,7 @@ public class Bgra5551Tests
     public void Bgra5551_FromArgb32()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -183,7 +185,7 @@ public class Bgra5551Tests
     public void Bgra5551_FromRgb48()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -197,7 +199,7 @@ public class Bgra5551Tests
     public void Bgra5551_FromRgba64()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -211,7 +213,7 @@ public class Bgra5551Tests
     public void Bgra5551_FromGrey16()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -225,7 +227,7 @@ public class Bgra5551Tests
     public void Bgra5551_FromGrey8()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -239,7 +241,7 @@ public class Bgra5551Tests
     public void Bgra5551_FromBgr24()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551 bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -253,7 +255,8 @@ public class Bgra5551Tests
     public void Bgra5551_FromRgb24()
     {
         // arrange
-        var bgra = default(Bgra5551);
+        Bgra5551
+            bgra = default;
         ushort expectedPackedValue = ushort.MaxValue;
 
         // act
@@ -269,4 +272,14 @@ public class Bgra5551Tests
         Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Bgra5551_PixelInformation()
+    {
+        PixelTypeInfo info = Bgra5551.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Bgra5551>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
index 435f07391..ce5752fba 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ImageSharp.Formats;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class Byte4Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Byte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Byte4(new Vector4(0.0f));
-        var color3 = new Byte4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Byte4(1.0f, 0.0f, 1.0f, 1.0f);
+        Byte4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Byte4 color2 = new(new Vector4(0.0f));
+        Byte4 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        Byte4 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class Byte4Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Byte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Byte4(new Vector4(1.0f));
-        var color3 = new Byte4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Byte4(1.0f, 1.0f, 0.0f, 1.0f);
+        Byte4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Byte4 color2 = new(new Vector4(1.0f));
+        Byte4 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Byte4 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -63,7 +65,7 @@ public class Byte4Tests
     public void Byte4_ToScaledVector4()
     {
         // arrange
-        var byte4 = new Byte4(Vector4.One * 255);
+        Byte4 byte4 = new(Vector4.One * 255);
 
         // act
         Vector4 actual = byte4.ToScaledVector4();
@@ -79,9 +81,9 @@ public class Byte4Tests
     public void Byte4_ToRgba32()
     {
         // arrange
-        var byte4 = new Byte4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Byte4 byte4 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Rgba32 expected = new(Vector4.One);
+        Rgba32 actual = default;
 
         // act
         byte4.ToRgba32(ref actual);
@@ -94,7 +96,7 @@ public class Byte4Tests
     {
         // arrange
         Vector4 scaled = new Byte4(Vector4.One * 255).ToScaledVector4();
-        var pixel = default(Byte4);
+        Byte4 pixel = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -109,7 +111,7 @@ public class Byte4Tests
     public void Byte4_FromArgb32()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -123,7 +125,7 @@ public class Byte4Tests
     public void Byte4_FromBgr24()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -137,7 +139,7 @@ public class Byte4Tests
     public void Byte4_FromGrey8()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -151,7 +153,7 @@ public class Byte4Tests
     public void Byte4_FromGrey16()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -165,7 +167,7 @@ public class Byte4Tests
     public void Byte4_FromRgb24()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -179,7 +181,7 @@ public class Byte4Tests
     public void Byte4_FromBgra5551()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -193,7 +195,7 @@ public class Byte4Tests
     public void Byte4_FromRgba32()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue1 = uint.MaxValue;
 
         // act
@@ -207,7 +209,7 @@ public class Byte4Tests
     public void Byte4_FromRgb48()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -221,7 +223,7 @@ public class Byte4Tests
     public void Byte4_FromRgba64()
     {
         // arrange
-        var byte4 = default(Byte4);
+        Byte4 byte4 = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -237,4 +239,14 @@ public class Byte4Tests
         Assert.Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4());
         Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4());
     }
+
+    [Fact]
+    public void Byte4_PixelInformation()
+    {
+        PixelTypeInfo info = Byte4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Byte4>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
index 9ffaf3e21..cbff2b85e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -25,11 +27,11 @@ public class HalfSingleTests
     public void HalfSingle_ToVector4()
     {
         // arrange
-        var halfSingle = new HalfSingle(0.5f);
-        var expected = new Vector4(0.5f, 0, 0, 1);
+        HalfSingle halfSingle = new(0.5f);
+        Vector4 expected = new(0.5f, 0, 0, 1);
 
         // act
-        var actual = halfSingle.ToVector4();
+        Vector4 actual = halfSingle.ToVector4();
 
         // assert
         Assert.Equal(expected, actual);
@@ -39,7 +41,7 @@ public class HalfSingleTests
     public void HalfSingle_ToScaledVector4()
     {
         // arrange
-        var halfSingle = new HalfSingle(-1F);
+        HalfSingle halfSingle = new(-1F);
 
         // act
         Vector4 actual = halfSingle.ToScaledVector4();
@@ -57,7 +59,7 @@ public class HalfSingleTests
         // arrange
         Vector4 scaled = new HalfSingle(-1F).ToScaledVector4();
         int expected = 48128;
-        var halfSingle = default(HalfSingle);
+        HalfSingle halfSingle = default;
 
         // act
         halfSingle.FromScaledVector4(scaled);
@@ -66,4 +68,14 @@ public class HalfSingleTests
         // assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void HalfSingle_PixelInformation()
+    {
+        PixelTypeInfo info = HalfSingle.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<HalfSingle>() * 8, info.BitsPerPixel);
+        Assert.Equal(1, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Half, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
index eda931536..98a5cb0bf 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ImageSharp.Formats;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -30,7 +32,7 @@ public class HalfVector2Tests
     public void HalfVector2_ToScaledVector4()
     {
         // arrange
-        var halfVector = new HalfVector2(Vector2.One);
+        HalfVector2 halfVector = new(Vector2.One);
 
         // act
         Vector4 actual = halfVector.ToScaledVector4();
@@ -48,7 +50,7 @@ public class HalfVector2Tests
         // arrange
         Vector4 scaled = new HalfVector2(Vector2.One).ToScaledVector4();
         uint expected = 1006648320u;
-        var halfVector = default(HalfVector2);
+        HalfVector2 halfVector = default;
 
         // act
         halfVector.FromScaledVector4(scaled);
@@ -62,11 +64,11 @@ public class HalfVector2Tests
     public void HalfVector2_ToVector4()
     {
         // arrange
-        var halfVector = new HalfVector2(.5F, .25F);
-        var expected = new Vector4(0.5f, .25F, 0, 1);
+        HalfVector2 halfVector = new(.5F, .25F);
+        Vector4 expected = new(0.5f, .25F, 0, 1);
 
         // act
-        var actual = halfVector.ToVector4();
+        Vector4 actual = halfVector.ToVector4();
 
         // assert
         Assert.Equal(expected, actual);
@@ -76,7 +78,7 @@ public class HalfVector2Tests
     public void HalfVector2_FromBgra5551()
     {
         // arrange
-        var halfVector2 = default(HalfVector2);
+        HalfVector2 halfVector2 = default;
 
         // act
         halfVector2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
@@ -88,4 +90,14 @@ public class HalfVector2Tests
         Assert.Equal(0, actual.Z);
         Assert.Equal(1, actual.W);
     }
+
+    [Fact]
+    public void HalfVector2_PixelInformation()
+    {
+        PixelTypeInfo info = HalfVector2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<HalfVector2>() * 8, info.BitsPerPixel);
+        Assert.Equal(2, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Half, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
index 77120192b..48d10f1c1 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -38,7 +40,7 @@ public class HalfVector4Tests
     public void HalfVector4_ToScaledVector4()
     {
         // arrange
-        var halfVector4 = new HalfVector4(-Vector4.One);
+        HalfVector4 halfVector4 = new(-Vector4.One);
 
         // act
         Vector4 actual = halfVector4.ToScaledVector4();
@@ -54,7 +56,7 @@ public class HalfVector4Tests
     public void HalfVector4_FromScaledVector4()
     {
         // arrange
-        var halfVector4 = default(HalfVector4);
+        HalfVector4 halfVector4 = default;
         Vector4 scaled = new HalfVector4(-Vector4.One).ToScaledVector4();
         ulong expected = 13547034390470638592uL;
 
@@ -70,7 +72,7 @@ public class HalfVector4Tests
     public void HalfVector4_FromBgra5551()
     {
         // arrange
-        var halfVector4 = default(HalfVector4);
+        HalfVector4 halfVector4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -79,4 +81,14 @@ public class HalfVector4Tests
         // assert
         Assert.Equal(expected, halfVector4.ToScaledVector4());
     }
+
+    [Fact]
+    public void HalfVector4_PixelInformation()
+    {
+        PixelTypeInfo info = HalfVector4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<HalfVector4>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Half, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
index 685da2ddf..18481712a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +14,8 @@ public class L16Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new L16(3000);
-        var color2 = new L16(3000);
+        L16 color1 = new(3000);
+        L16 color2 = new(3000);
 
         Assert.Equal(color1, color2);
     }
@@ -21,8 +23,8 @@ public class L16Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new L16(12345);
-        var color2 = new L16(54321);
+        L16 color1 = new(12345);
+        L16 color2 = new(54321);
 
         Assert.NotEqual(color1, color2);
     }
@@ -58,7 +60,7 @@ public class L16Tests
     public void L16_ToScaledVector4(ushort input)
     {
         // Arrange
-        var gray = new L16(input);
+        L16 gray = new(input);
 
         // Act
         Vector4 actual = gray.ToScaledVector4();
@@ -77,7 +79,7 @@ public class L16Tests
         // Arrange
         L16 gray = default;
         const ushort expected = 32767;
-        var vector = new L16(expected).ToVector4();
+        Vector4 vector = new L16(expected).ToVector4();
 
         // Act
         gray.FromVector4(vector);
@@ -94,10 +96,10 @@ public class L16Tests
     public void L16_ToVector4(ushort input)
     {
         // Arrange
-        var gray = new L16(input);
+        L16 gray = new(input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = gray.ToVector4();
 
         // Assert
         float vectorInput = input / 65535F;
@@ -132,7 +134,7 @@ public class L16Tests
     {
         // Arrange
         ushort expected = ColorNumerics.DownScaleFrom16BitTo8Bit(input);
-        var gray = new L16(input);
+        L16 gray = new(input);
 
         // Act
         Rgba32 actual = default;
@@ -149,7 +151,7 @@ public class L16Tests
     public void L16_FromBgra5551()
     {
         // arrange
-        var gray = default(L16);
+        L16 gray = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -158,4 +160,14 @@ public class L16Tests
         // assert
         Assert.Equal(expected, gray.PackedValue);
     }
+
+    [Fact]
+    public void L16_PixelInformation()
+    {
+        PixelTypeInfo info = L16.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<L16>() * 8, info.BitsPerPixel);
+        Assert.Equal(1, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
index afdc039a2..80dc36fa3 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
@@ -24,8 +26,8 @@ public class L8Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new L8(100);
-        var color2 = new L8(100);
+        L8 color1 = new(100);
+        L8 color2 = new(100);
 
         Assert.Equal(color1, color2);
     }
@@ -33,8 +35,8 @@ public class L8Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new L8(100);
-        var color2 = new L8(200);
+        L8 color1 = new(100);
+        L8 color2 = new(200);
 
         Assert.NotEqual(color1, color2);
     }
@@ -60,7 +62,7 @@ public class L8Tests
     public void L8_ToScaledVector4(byte input)
     {
         // Arrange
-        var gray = new L8(input);
+        L8 gray = new(input);
 
         // Act
         Vector4 actual = gray.ToScaledVector4();
@@ -79,7 +81,7 @@ public class L8Tests
     {
         // Arrange
         L8 gray = default;
-        var vector = new L8(luminance).ToVector4();
+        Vector4 vector = new L8(luminance).ToVector4();
 
         // Act
         gray.FromVector4(vector);
@@ -94,10 +96,10 @@ public class L8Tests
     public void L8_ToVector4(byte input)
     {
         // Arrange
-        var gray = new L8(input);
+        L8 gray = new(input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = gray.ToVector4();
 
         // Assert
         float scaledInput = input / 255F;
@@ -128,7 +130,7 @@ public class L8Tests
     public void L8_ToRgba32(byte luminance)
     {
         // Arrange
-        var gray = new L8(luminance);
+        L8 gray = new(luminance);
 
         // Act
         Rgba32 actual = default;
@@ -145,7 +147,7 @@ public class L8Tests
     public void L8_FromBgra5551()
     {
         // arrange
-        var grey = default(L8);
+        L8 grey = default;
         byte expected = byte.MaxValue;
 
         // act
@@ -164,7 +166,7 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void L8_FromRgba32_IsInverseOf_ToRgba32(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -179,7 +181,7 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void Rgba32_ToL8_IsInverseOf_L8_ToRgba32(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -194,13 +196,13 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void ToVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
 
-            var l8Vector = original.ToVector4();
-            var rgbaVector = original.ToVector4();
+            Vector4 l8Vector = original.ToVector4();
+            Vector4 rgbaVector = original.ToVector4();
 
             Assert.Equal(l8Vector, rgbaVector, new ApproximateFloatComparer(1e-5f));
         }
@@ -209,12 +211,12 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void FromVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
 
-            var rgbaVector = original.ToVector4();
+            Vector4 rgbaVector = original.ToVector4();
 
             L8 mirror = default;
             mirror.FromVector4(rgbaVector);
@@ -226,7 +228,7 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void ToScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -241,7 +243,7 @@ public class L8Tests
         [MemberData(nameof(LuminanceData))]
         public void FromScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new L8(luminance);
+            L8 original = new(luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -253,5 +255,15 @@ public class L8Tests
 
             Assert.Equal(original, mirror);
         }
+
+        [Fact]
+        public void L8_PixelInformation()
+        {
+            PixelTypeInfo info = L8.GetPixelTypeInfo();
+            Assert.Equal(Unsafe.SizeOf<L8>() * 8, info.BitsPerPixel);
+            Assert.Equal(1, info.ComponentCount);
+            Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+            Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
index 92b4a4e1a..c3d8a873a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
@@ -24,8 +26,8 @@ public class La16Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new La16(100, 50);
-        var color2 = new La16(100, 50);
+        La16 color1 = new(100, 50);
+        La16 color2 = new(100, 50);
 
         Assert.Equal(color1, color2);
     }
@@ -33,8 +35,8 @@ public class La16Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new La16(100, 50);
-        var color2 = new La16(200, 50);
+        La16 color1 = new(100, 50);
+        La16 color2 = new(200, 50);
 
         Assert.NotEqual(color1, color2);
     }
@@ -60,7 +62,7 @@ public class La16Tests
     public void La16_ToScaledVector4(byte input)
     {
         // Arrange
-        var gray = new La16(input, input);
+        La16 gray = new(input, input);
 
         // Act
         Vector4 actual = gray.ToScaledVector4();
@@ -79,7 +81,7 @@ public class La16Tests
     {
         // Arrange
         La16 gray = default;
-        var vector = new La16(luminance, luminance).ToVector4();
+        Vector4 vector = new La16(luminance, luminance).ToVector4();
 
         // Act
         gray.FromVector4(vector);
@@ -96,10 +98,10 @@ public class La16Tests
     public void La16_ToVector4(byte input)
     {
         // Arrange
-        var gray = new La16(input, input);
+        La16 gray = new(input, input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = gray.ToVector4();
 
         // Assert
         float scaledInput = input / 255F;
@@ -131,7 +133,7 @@ public class La16Tests
     public void La16_ToRgba32(byte luminance)
     {
         // Arrange
-        var gray = new La16(luminance, luminance);
+        La16 gray = new(luminance, luminance);
 
         // Act
         Rgba32 actual = default;
@@ -148,7 +150,7 @@ public class La16Tests
     public void La16_FromBgra5551()
     {
         // arrange
-        var grey = default(La16);
+        La16 grey = default;
         byte expected = byte.MaxValue;
 
         // act
@@ -168,7 +170,7 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void La16_FromRgba32_IsInverseOf_ToRgba32(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -183,7 +185,7 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void Rgba32_ToLa16_IsInverseOf_La16_ToRgba32(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -198,13 +200,13 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void ToVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
 
-            var la16Vector = original.ToVector4();
-            var rgbaVector = original.ToVector4();
+            Vector4 la16Vector = original.ToVector4();
+            Vector4 rgbaVector = original.ToVector4();
 
             Assert.Equal(la16Vector, rgbaVector, new ApproximateFloatComparer(1e-5f));
         }
@@ -213,12 +215,12 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void FromVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
 
-            var rgbaVector = original.ToVector4();
+            Vector4 rgbaVector = original.ToVector4();
 
             La16 mirror = default;
             mirror.FromVector4(rgbaVector);
@@ -230,7 +232,7 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void ToScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -245,7 +247,7 @@ public class La16Tests
         [MemberData(nameof(LuminanceData))]
         public void FromScaledVector4_IsRgba32Compatible(byte luminance)
         {
-            var original = new La16(luminance, luminance);
+            La16 original = new(luminance, luminance);
 
             Rgba32 rgba = default;
             original.ToRgba32(ref rgba);
@@ -257,5 +259,15 @@ public class La16Tests
 
             Assert.Equal(original, mirror);
         }
+
+        [Fact]
+        public void La16_PixelInformation()
+        {
+            PixelTypeInfo info = La16.GetPixelTypeInfo();
+            Assert.Equal(Unsafe.SizeOf<La16>() * 8, info.BitsPerPixel);
+            Assert.Equal(2, info.ComponentCount);
+            Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+            Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
index d333818c7..17e10e15d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +14,8 @@ public class La32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new La32(3000, 100);
-        var color2 = new La32(3000, 100);
+        La32 color1 = new(3000, 100);
+        La32 color2 = new(3000, 100);
 
         Assert.Equal(color1, color2);
     }
@@ -21,8 +23,8 @@ public class La32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new La32(12345, 100);
-        var color2 = new La32(54321, 100);
+        La32 color1 = new(12345, 100);
+        La32 color2 = new(54321, 100);
 
         Assert.NotEqual(color1, color2);
     }
@@ -60,7 +62,7 @@ public class La32Tests
     public void La32_ToScaledVector4(ushort input)
     {
         // Arrange
-        var gray = new La32(input, input);
+        La32 gray = new(input, input);
 
         // Act
         Vector4 actual = gray.ToScaledVector4();
@@ -79,7 +81,7 @@ public class La32Tests
         // Arrange
         La32 gray = default;
         const ushort expected = 32767;
-        var vector = new La32(expected, expected).ToVector4();
+        Vector4 vector = new La32(expected, expected).ToVector4();
 
         // Act
         gray.FromVector4(vector);
@@ -98,10 +100,10 @@ public class La32Tests
     public void La32_ToVector4(ushort input)
     {
         // Arrange
-        var gray = new La32(input, input);
+        La32 gray = new(input, input);
 
         // Act
-        var actual = gray.ToVector4();
+        Vector4 actual = gray.ToVector4();
 
         // Assert
         float vectorInput = input / 65535F;
@@ -137,7 +139,7 @@ public class La32Tests
     {
         // Arrange
         ushort expected = ColorNumerics.DownScaleFrom16BitTo8Bit(input);
-        var gray = new La32(input, ushort.MaxValue);
+        La32 gray = new(input, ushort.MaxValue);
 
         // Act
         Rgba32 actual = default;
@@ -154,7 +156,7 @@ public class La32Tests
     public void La32_FromBgra5551()
     {
         // arrange
-        var gray = default(La32);
+        La32 gray = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -164,4 +166,14 @@ public class La32Tests
         Assert.Equal(expected, gray.L);
         Assert.Equal(expected, gray.A);
     }
+
+    [Fact]
+    public void La32_PixelInformation()
+    {
+        PixelTypeInfo info = La32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<La32>() * 8, info.BitsPerPixel);
+        Assert.Equal(2, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
index 14c590d0b..a09454f5b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ImageSharp.Formats;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -39,7 +41,7 @@ public class NormalizedByte2Tests
     public void NormalizedByte2_ToScaledVector4()
     {
         // arrange
-        var byte2 = new NormalizedByte2(-Vector2.One);
+        NormalizedByte2 byte2 = new(-Vector2.One);
 
         // act
         Vector4 actual = byte2.ToScaledVector4();
@@ -56,7 +58,7 @@ public class NormalizedByte2Tests
     {
         // arrange
         Vector4 scaled = new NormalizedByte2(-Vector2.One).ToScaledVector4();
-        var byte2 = default(NormalizedByte2);
+        NormalizedByte2 byte2 = default;
         uint expected = 0x8181;
 
         // act
@@ -71,8 +73,8 @@ public class NormalizedByte2Tests
     public void NormalizedByte2_FromBgra5551()
     {
         // arrange
-        var normalizedByte2 = default(NormalizedByte2);
-        var expected = new Vector4(1, 1, 0, 1);
+        NormalizedByte2 normalizedByte2 = default;
+        Vector4 expected = new(1, 1, 0, 1);
 
         // act
         normalizedByte2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
@@ -80,4 +82,14 @@ public class NormalizedByte2Tests
         // assert
         Assert.Equal(expected, normalizedByte2.ToVector4());
     }
+
+    [Fact]
+    public void NormalizedByte2_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedByte2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedByte2>() * 8, info.BitsPerPixel);
+        Assert.Equal(2, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.SByte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
index ca73a6c1f..aa0136b37 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class NormalizedByte4Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new NormalizedByte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedByte4(new Vector4(0.0f));
-        var color3 = new NormalizedByte4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new NormalizedByte4(1.0f, 0.0f, 1.0f, 1.0f);
+        NormalizedByte4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedByte4 color2 = new(new Vector4(0.0f));
+        NormalizedByte4 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        NormalizedByte4 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class NormalizedByte4Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new NormalizedByte4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedByte4(new Vector4(1.0f));
-        var color3 = new NormalizedByte4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new NormalizedByte4(1.0f, 1.0f, 0.0f, 1.0f);
+        NormalizedByte4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedByte4 color2 = new(new Vector4(1.0f));
+        NormalizedByte4 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        NormalizedByte4 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -63,7 +65,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_ToScaledVector4()
     {
         // arrange
-        var short4 = new NormalizedByte4(-Vector4.One);
+        NormalizedByte4 short4 = new(-Vector4.One);
 
         // act
         Vector4 actual = short4.ToScaledVector4();
@@ -79,7 +81,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromScaledVector4()
     {
         // arrange
-        var pixel = default(NormalizedByte4);
+        NormalizedByte4 pixel = default;
         Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4();
         uint expected = 0x81818181;
 
@@ -95,7 +97,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromArgb32()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -109,7 +111,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromBgr24()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -123,7 +125,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromGrey8()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -137,7 +139,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromGrey16()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -151,7 +153,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromRgb24()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -165,7 +167,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromRgba32()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -179,7 +181,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromBgra5551()
     {
         // arrange
-        var normalizedByte4 = default(NormalizedByte4);
+        NormalizedByte4 normalizedByte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -193,7 +195,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromRgb48()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -207,7 +209,7 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_FromRgba64()
     {
         // arrange
-        var byte4 = default(NormalizedByte4);
+        NormalizedByte4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -221,13 +223,23 @@ public class NormalizedByte4Tests
     public void NormalizedByte4_ToRgba32()
     {
         // arrange
-        var byte4 = new NormalizedByte4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        NormalizedByte4 byte4 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Rgba32 expected = new(Vector4.One);
+        Rgba32 actual = default;
 
         // act
         byte4.ToRgba32(ref actual);
 
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void NormalizedByte4_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedByte4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedByte4>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.SByte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
index 70bfa1be7..6ac18fa08 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -43,7 +45,7 @@ public class NormalizedShort2Tests
     public void NormalizedShort2_ToScaledVector4()
     {
         // arrange
-        var short2 = new NormalizedShort2(-Vector2.One);
+        NormalizedShort2 short2 = new(-Vector2.One);
 
         // act
         Vector4 actual = short2.ToScaledVector4();
@@ -60,7 +62,7 @@ public class NormalizedShort2Tests
     {
         // arrange
         Vector4 scaled = new NormalizedShort2(-Vector2.One).ToScaledVector4();
-        var short2 = default(NormalizedShort2);
+        NormalizedShort2 short2 = default;
         uint expected = 0x80018001;
 
         // act
@@ -75,8 +77,8 @@ public class NormalizedShort2Tests
     public void NormalizedShort2_FromBgra5551()
     {
         // arrange
-        var normalizedShort2 = default(NormalizedShort2);
-        var expected = new Vector4(1, 1, 0, 1);
+        NormalizedShort2 normalizedShort2 = default;
+        Vector4 expected = new(1, 1, 0, 1);
 
         // act
         normalizedShort2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
@@ -84,4 +86,14 @@ public class NormalizedShort2Tests
         // assert
         Assert.Equal(expected, normalizedShort2.ToVector4());
     }
+
+    [Fact]
+    public void NormalizedShort2_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedShort2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedShort2>() * 8, info.BitsPerPixel);
+        Assert.Equal(2, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
index 997c6df82..fcab7318b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ImageSharp.Formats;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class NormalizedShort4Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new NormalizedShort4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedShort4(new Vector4(0.0f));
-        var color3 = new NormalizedShort4(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new NormalizedShort4(1.0f, 0.0f, 1.0f, 1.0f);
+        NormalizedShort4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedShort4 color2 = new(new Vector4(0.0f));
+        NormalizedShort4 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        NormalizedShort4 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class NormalizedShort4Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new NormalizedShort4(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new NormalizedShort4(new Vector4(1.0f));
-        var color3 = new NormalizedShort4(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new NormalizedShort4(1.0f, 1.0f, 0.0f, 1.0f);
+        NormalizedShort4 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        NormalizedShort4 color2 = new(new Vector4(1.0f));
+        NormalizedShort4 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        NormalizedShort4 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -64,7 +66,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_ToScaledVector4()
     {
         // arrange
-        var short4 = new NormalizedShort4(Vector4.One);
+        NormalizedShort4 short4 = new(Vector4.One);
 
         // act
         Vector4 actual = short4.ToScaledVector4();
@@ -80,7 +82,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromScaledVector4()
     {
         // arrange
-        var pixel = default(NormalizedShort4);
+        NormalizedShort4 pixel = default;
         Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4();
         ulong expected = 0x7FFF7FFF7FFF7FFF;
 
@@ -96,7 +98,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromArgb32()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -110,7 +112,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromBgr24()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -124,7 +126,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromGrey8()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -138,7 +140,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromGrey16()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -152,7 +154,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromRgb24()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -166,7 +168,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromRgba32()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -180,7 +182,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromRgb48()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -194,7 +196,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromRgba64()
     {
         // arrange
-        var byte4 = default(NormalizedShort4);
+        NormalizedShort4 byte4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -208,9 +210,9 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_ToRgba32()
     {
         // arrange
-        var byte4 = new NormalizedShort4(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
-        var expected = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        NormalizedShort4 byte4 = new(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
+        Rgba32 expected = new(Vector4.One);
+        Rgba32 actual = default;
 
         // act
         byte4.ToRgba32(ref actual);
@@ -222,7 +224,7 @@ public class NormalizedShort4Tests
     public void NormalizedShort4_FromBgra5551()
     {
         // arrange
-        var normalizedShort4 = default(NormalizedShort4);
+        NormalizedShort4 normalizedShort4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -231,4 +233,14 @@ public class NormalizedShort4Tests
         // assert
         Assert.Equal(expected, normalizedShort4.ToVector4());
     }
+
+    [Fact]
+    public void NormalizedShort4_PixelInformation()
+    {
+        PixelTypeInfo info = NormalizedShort4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<NormalizedShort4>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
index 2900b0d29..c5c534655 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ImageSharp.Formats;
+using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -33,7 +35,7 @@ public class Rg32Tests
     public void Rg32_ToScaledVector4()
     {
         // arrange
-        var rg32 = new Rg32(Vector2.One);
+        Rg32 rg32 = new(Vector2.One);
 
         // act
         Vector4 actual = rg32.ToScaledVector4();
@@ -49,8 +51,8 @@ public class Rg32Tests
     public void Rg32_FromScaledVector4()
     {
         // arrange
-        var rg32 = new Rg32(Vector2.One);
-        var pixel = default(Rg32);
+        Rg32 rg32 = new(Vector2.One);
+        Rg32 pixel = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -66,7 +68,7 @@ public class Rg32Tests
     public void Rg32_FromBgra5551()
     {
         // arrange
-        var rg32 = new Rg32(Vector2.One);
+        Rg32 rg32 = new(Vector2.One);
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -82,4 +84,14 @@ public class Rg32Tests
         Assert.Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2());
         Assert.Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2());
     }
+
+    [Fact]
+    public void Rg32_PixelInformation()
+    {
+        PixelTypeInfo info = Rg32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rg32>() * 8, info.BitsPerPixel);
+        Assert.Equal(2, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
index 2d1be8ab4..dbb2e8f03 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -21,7 +23,7 @@ public class Rgb24Tests
     [MemberData(nameof(ColorData))]
     public void Constructor(byte r, byte g, byte b)
     {
-        var p = new Rgb24(r, g, b);
+        Rgb24 p = new(r, g, b);
 
         Assert.Equal(r, p.R);
         Assert.Equal(g, p.G);
@@ -31,7 +33,7 @@ public class Rgb24Tests
     [Fact]
     public unsafe void ByteLayoutIsSequentialRgb()
     {
-        var color = new Rgb24(1, 2, 3);
+        Rgb24 color = new(1, 2, 3);
         byte* ptr = (byte*)&color;
 
         Assert.Equal(1, ptr[0]);
@@ -43,8 +45,8 @@ public class Rgb24Tests
     [MemberData(nameof(ColorData))]
     public void Equals_WhenTrue(byte r, byte g, byte b)
     {
-        var x = new Rgb24(r, g, b);
-        var y = new Rgb24(r, g, b);
+        Rgb24 x = new(r, g, b);
+        Rgb24 y = new(r, g, b);
 
         Assert.True(x.Equals(y));
         Assert.True(x.Equals((object)y));
@@ -57,8 +59,8 @@ public class Rgb24Tests
     [InlineData(1, 255, 0, 0, 255, 0)]
     public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
     {
-        var a = new Rgb24(r1, g1, b1);
-        var b = new Rgb24(r2, g2, b2);
+        Rgb24 a = new(r1, g1, b1);
+        Rgb24 b = new(r2, g2, b2);
 
         Assert.False(a.Equals(b));
         Assert.False(a.Equals((object)b));
@@ -67,7 +69,7 @@ public class Rgb24Tests
     [Fact]
     public void FromRgba32()
     {
-        var rgb = default(Rgb24);
+        Rgb24 rgb = default;
         rgb.FromRgba32(new Rgba32(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
@@ -84,7 +86,7 @@ public class Rgb24Tests
     [Fact]
     public void FromVector4()
     {
-        var rgb = default(Rgb24);
+        Rgb24 rgb = default;
         rgb.FromVector4(Vec(1, 2, 3, 4));
 
         Assert.Equal(1, rgb.R);
@@ -95,7 +97,7 @@ public class Rgb24Tests
     [Fact]
     public void ToVector4()
     {
-        var rgb = new Rgb24(1, 2, 3);
+        Rgb24 rgb = new(1, 2, 3);
 
         Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
     }
@@ -104,9 +106,9 @@ public class Rgb24Tests
     public void ToRgba32()
     {
         // arrange
-        var rgb = new Rgb24(1, 2, 3);
+        Rgb24 rgb = new(1, 2, 3);
         Rgba32 rgba = default;
-        var expected = new Rgba32(1, 2, 3, 255);
+        Rgba32 expected = new(1, 2, 3, 255);
 
         // act
         rgb.ToRgba32(ref rgba);
@@ -119,7 +121,7 @@ public class Rgb24Tests
     public void Rgb24_FromBgra5551()
     {
         // arrange
-        var rgb = new Rgb24(255, 255, 255);
+        Rgb24 rgb = new(255, 255, 255);
 
         // act
         rgb.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
@@ -129,4 +131,14 @@ public class Rgb24Tests
         Assert.Equal(255, rgb.G);
         Assert.Equal(255, rgb.B);
     }
+
+    [Fact]
+    public void Rgb24_PixelInformation()
+    {
+        PixelTypeInfo info = Rgb24.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgb24>() * 8, info.BitsPerPixel);
+        Assert.Equal(3, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
index d8a61940b..04bbaf7f7 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,7 +14,7 @@ public class Rgb48Tests
     [Fact]
     public void Rgb48_Values()
     {
-        var rgb = new Rgba64(5243, 9830, 19660, 29491);
+        Rgba64 rgb = new(5243, 9830, 19660, 29491);
 
         Assert.Equal(5243, rgb.R);
         Assert.Equal(9830, rgb.G);
@@ -32,9 +34,9 @@ public class Rgb48Tests
     public void Rgb48_FromScaledVector4()
     {
         // arrange
-        var pixel = default(Rgb48);
-        var short3 = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
-        var expected = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
+        Rgb48 pixel = default;
+        Rgb48 short3 = new(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
+        Rgb48 expected = new(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
 
         // act
         Vector4 scaled = short3.ToScaledVector4();
@@ -48,8 +50,8 @@ public class Rgb48Tests
     public void Rgb48_ToRgba32()
     {
         // arrange
-        var rgba48 = new Rgb48(5140, 9766, 19532);
-        var expected = new Rgba32(20, 38, 76, 255);
+        Rgb48 rgba48 = new(5140, 9766, 19532);
+        Rgba32 expected = new(20, 38, 76, 255);
 
         // act
         Rgba32 actual = default;
@@ -63,7 +65,7 @@ public class Rgb48Tests
     public void Rgb48_FromBgra5551()
     {
         // arrange
-        var rgb = default(Rgb48);
+        Rgb48 rgb = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -74,4 +76,14 @@ public class Rgb48Tests
         Assert.Equal(expected, rgb.G);
         Assert.Equal(expected, rgb.B);
     }
+
+    [Fact]
+    public void Rgb48_PixelInformation()
+    {
+        PixelTypeInfo info = Rgb48.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgb48>() * 8, info.BitsPerPixel);
+        Assert.Equal(3, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
index 0c28b35c6..678ac2274 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -15,10 +17,10 @@ public class Rgba1010102Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Rgba1010102(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Rgba1010102(new Vector4(0.0f));
-        var color3 = new Rgba1010102(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
-        var color4 = new Rgba1010102(1.0f, 0.0f, 1.0f, 1.0f);
+        Rgba1010102 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Rgba1010102 color2 = new(new Vector4(0.0f));
+        Rgba1010102 color3 = new(new Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+        Rgba1010102 color4 = new(1.0f, 0.0f, 1.0f, 1.0f);
 
         Assert.Equal(color1, color2);
         Assert.Equal(color3, color4);
@@ -30,10 +32,10 @@ public class Rgba1010102Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Rgba1010102(0.0f, 0.0f, 0.0f, 0.0f);
-        var color2 = new Rgba1010102(new Vector4(1.0f));
-        var color3 = new Rgba1010102(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-        var color4 = new Rgba1010102(1.0f, 1.0f, 0.0f, 1.0f);
+        Rgba1010102 color1 = new(0.0f, 0.0f, 0.0f, 0.0f);
+        Rgba1010102 color2 = new(new Vector4(1.0f));
+        Rgba1010102 color3 = new(new Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+        Rgba1010102 color4 = new(1.0f, 1.0f, 0.0f, 1.0f);
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color3, color4);
@@ -66,7 +68,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_ToScaledVector4()
     {
         // arrange
-        var rgba = new Rgba1010102(Vector4.One);
+        Rgba1010102 rgba = new(Vector4.One);
 
         // act
         Vector4 actual = rgba.ToScaledVector4();
@@ -82,8 +84,8 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromScaledVector4()
     {
         // arrange
-        var rgba = new Rgba1010102(Vector4.One);
-        var actual = default(Rgba1010102);
+        Rgba1010102 rgba = new(Vector4.One);
+        Rgba1010102 actual = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -98,7 +100,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromBgra5551()
     {
         // arrange
-        var rgba = new Rgba1010102(Vector4.One);
+        Rgba1010102 rgba = new(Vector4.One);
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -112,7 +114,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromArgb32()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -126,8 +128,8 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgba32()
     {
         // arrange
-        var rgba1 = default(Rgba1010102);
-        var rgba2 = default(Rgba1010102);
+        Rgba1010102 rgba1 = default;
+        Rgba1010102 rgba2 = default;
         uint expectedPackedValue1 = uint.MaxValue;
         uint expectedPackedValue2 = 0xFFF003FF;
 
@@ -144,7 +146,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromBgr24()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -158,7 +160,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromGrey8()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -172,7 +174,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromGrey16()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -186,7 +188,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgb24()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -200,7 +202,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgb48()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -214,7 +216,7 @@ public class Rgba1010102Tests
     public void Rgba1010102_FromRgba64()
     {
         // arrange
-        var rgba = default(Rgba1010102);
+        Rgba1010102 rgba = default;
         uint expectedPackedValue = uint.MaxValue;
 
         // act
@@ -235,8 +237,8 @@ public class Rgba1010102Tests
     public void Rgba1010102_ToRgba32()
     {
         // arrange
-        var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
-        var expected = new Rgba32(25, 0, 128, 0);
+        Rgba1010102 rgba = new(0.1f, -0.3f, 0.5f, -0.7f);
+        Rgba32 expected = new(25, 0, 128, 0);
 
         // act
         Rgba32 actual = default;
@@ -245,4 +247,14 @@ public class Rgba1010102Tests
         // assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void Rgba1010102_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba1010102.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba1010102>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
index 64903f65b..6154773e8 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -18,12 +20,12 @@ public class Rgba32Tests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new Rgba32(0, 0, 0);
-        var color2 = new Rgba32(0, 0, 0, 1F);
-        var color3 = Rgba32.ParseHex("#000");
-        var color4 = Rgba32.ParseHex("#000F");
-        var color5 = Rgba32.ParseHex("#000000");
-        var color6 = Rgba32.ParseHex("#000000FF");
+        Rgba32 color1 = new(0, 0, 0);
+        Rgba32 color2 = new(0, 0, 0, 1F);
+        Rgba32 color3 = Rgba32.ParseHex("#000");
+        Rgba32 color4 = Rgba32.ParseHex("#000F");
+        Rgba32 color5 = Rgba32.ParseHex("#000000");
+        Rgba32 color6 = Rgba32.ParseHex("#000000FF");
 
         Assert.Equal(color1, color2);
         Assert.Equal(color1, color3);
@@ -38,11 +40,11 @@ public class Rgba32Tests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new Rgba32(255, 0, 0, 255);
-        var color2 = new Rgba32(0, 0, 0, 255);
-        var color3 = Rgba32.ParseHex("#000");
-        var color4 = Rgba32.ParseHex("#000000");
-        var color5 = Rgba32.ParseHex("#FF000000");
+        Rgba32 color1 = new(255, 0, 0, 255);
+        Rgba32 color2 = new(0, 0, 0, 255);
+        Rgba32 color3 = Rgba32.ParseHex("#000");
+        Rgba32 color4 = Rgba32.ParseHex("#000000");
+        Rgba32 color5 = Rgba32.ParseHex("#FF000000");
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color1, color3);
@@ -56,25 +58,25 @@ public class Rgba32Tests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var color1 = new Rgba32(1, .1f, .133f, .864f);
+        Rgba32 color1 = new(1, .1f, .133f, .864f);
         Assert.Equal(255, color1.R);
         Assert.Equal((byte)Math.Round(.1f * 255), color1.G);
         Assert.Equal((byte)Math.Round(.133f * 255), color1.B);
         Assert.Equal((byte)Math.Round(.864f * 255), color1.A);
 
-        var color2 = new Rgba32(1, .1f, .133f);
+        Rgba32 color2 = new(1, .1f, .133f);
         Assert.Equal(255, color2.R);
         Assert.Equal(Math.Round(.1f * 255), color2.G);
         Assert.Equal(Math.Round(.133f * 255), color2.B);
         Assert.Equal(255, color2.A);
 
-        var color4 = new Rgba32(new Vector3(1, .1f, .133f));
+        Rgba32 color4 = new(new Vector3(1, .1f, .133f));
         Assert.Equal(255, color4.R);
         Assert.Equal(Math.Round(.1f * 255), color4.G);
         Assert.Equal(Math.Round(.133f * 255), color4.B);
         Assert.Equal(255, color4.A);
 
-        var color5 = new Rgba32(new Vector4(1, .1f, .133f, .5f));
+        Rgba32 color5 = new(new Vector4(1, .1f, .133f, .5f));
         Assert.Equal(255, color5.R);
         Assert.Equal(Math.Round(.1f * 255), color5.G);
         Assert.Equal(Math.Round(.133f * 255), color5.B);
@@ -88,7 +90,7 @@ public class Rgba32Tests
     public void FromAndToHex()
     {
         // 8 digit hex matches css4 spec. RRGGBBAA
-        var color = Rgba32.ParseHex("#AABBCCDD"); // 170, 187, 204, 221
+        Rgba32 color = Rgba32.ParseHex("#AABBCCDD"); // 170, 187, 204, 221
         Assert.Equal(170, color.R);
         Assert.Equal(187, color.G);
         Assert.Equal(204, color.B);
@@ -111,7 +113,7 @@ public class Rgba32Tests
     [Fact]
     public unsafe void ByteLayout()
     {
-        var color = new Rgba32(1, 2, 3, 4);
+        Rgba32 color = new(1, 2, 3, 4);
         byte* colorBase = (byte*)&color;
         Assert.Equal(1, colorBase[0]);
         Assert.Equal(2, colorBase[1]);
@@ -146,7 +148,7 @@ public class Rgba32Tests
     public void Rgba32_ToScaledVector4()
     {
         // arrange
-        var rgba = new Rgba32(Vector4.One);
+        Rgba32 rgba = new(Vector4.One);
 
         // act
         Vector4 actual = rgba.ToScaledVector4();
@@ -162,8 +164,8 @@ public class Rgba32Tests
     public void Rgba32_FromScaledVector4()
     {
         // arrange
-        var rgba = new Rgba32(Vector4.One);
-        var actual = default(Rgba32);
+        Rgba32 rgba = new(Vector4.One);
+        Rgba32 actual = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -185,9 +187,9 @@ public class Rgba32Tests
     public void Rgba32_ToRgba32()
     {
         // arrange
-        var rgba = new Rgba32(+0.1f, -0.3f, +0.5f, -0.7f);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(0x1a, 0, 0x80, 0);
+        Rgba32 rgba = new(+0.1f, -0.3f, +0.5f, -0.7f);
+        Rgba32 actual = default;
+        Rgba32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
         actual.FromRgba32(rgba);
@@ -200,9 +202,9 @@ public class Rgba32Tests
     public void Rgba32_FromRgba32_ToRgba32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(0x1a, 0, 0x80, 0);
+        Rgba32 rgba = default;
+        Rgba32 actual = default;
+        Rgba32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
         rgba.FromRgba32(expected);
@@ -216,9 +218,9 @@ public class Rgba32Tests
     public void Rgba32_FromBgra32_ToRgba32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Bgra32);
-        var expected = new Bgra32(0x1a, 0, 0x80, 0);
+        Rgba32 rgba = default;
+        Bgra32 actual = default;
+        Bgra32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
         rgba.FromBgra32(expected);
@@ -232,9 +234,9 @@ public class Rgba32Tests
     public void Rgba32_FromAbgr32_ToRgba32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Abgr32);
-        var expected = new Abgr32(0x1a, 0, 0x80, 0);
+        Rgba32 rgba = default;
+        Abgr32 actual = default;
+        Abgr32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
         rgba.FromAbgr32(expected);
@@ -248,9 +250,9 @@ public class Rgba32Tests
     public void Rgba32_FromArgb32_ToArgb32()
     {
         // arrange
-        var rgba = default(Rgba32);
-        var actual = default(Argb32);
-        var expected = new Argb32(0x1a, 0, 0x80, 0);
+        Rgba32 rgba = default;
+        Argb32 actual = default;
+        Argb32 expected = new(0x1a, 0, 0x80, 0);
 
         // act
         rgba.FromArgb32(expected);
@@ -264,9 +266,9 @@ public class Rgba32Tests
     public void Rgba32_FromRgb48()
     {
         // arrange
-        var input = default(Rgba32);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 0, 65535);
+        Rgba32 input = default;
+        Rgb48 actual = default;
+        Rgb48 expected = new(65535, 0, 65535);
 
         // act
         input.FromRgb48(expected);
@@ -280,9 +282,9 @@ public class Rgba32Tests
     public void Rgba32_FromRgba64()
     {
         // arrange
-        var input = default(Rgba32);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 0, 65535, 0);
+        Rgba32 input = default;
+        Rgba64 actual = default;
+        Rgba64 expected = new(65535, 0, 65535, 0);
 
         // act
         input.FromRgba64(expected);
@@ -296,7 +298,7 @@ public class Rgba32Tests
     public void Rgba32_FromBgra5551()
     {
         // arrange
-        var rgb = default(Rgba32);
+        Rgba32 rgb = default;
         uint expected = 0xFFFFFFFF;
 
         // act
@@ -305,4 +307,14 @@ public class Rgba32Tests
         // assert
         Assert.Equal(expected, rgb.PackedValue);
     }
+
+    [Fact]
+    public void Rgba32_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba32.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba32>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
index f60ed8a52..e9b61c1e3 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -38,7 +40,7 @@ public class Rgba64Tests
     public void Rgba64_ToScaledVector4(ushort r, ushort g, ushort b, ushort a)
     {
         // arrange
-        var short2 = new Rgba64(r, g, b, a);
+        Rgba64 short2 = new(r, g, b, a);
 
         float max = ushort.MaxValue;
         float rr = r / max;
@@ -63,7 +65,7 @@ public class Rgba64Tests
     public void Rgba64_FromScaledVector4(ushort r, ushort g, ushort b, ushort a)
     {
         // arrange
-        var source = new Rgba64(r, g, b, a);
+        Rgba64 source = new(r, g, b, a);
 
         // act
         Vector4 scaled = source.ToScaledVector4();
@@ -78,8 +80,8 @@ public class Rgba64Tests
     [Fact]
     public void Rgba64_Clamping()
     {
-        var zero = default(Rgba64);
-        var one = default(Rgba64);
+        Rgba64 zero = default;
+        Rgba64 one = default;
         zero.FromVector4(Vector4.One * -1234.0f);
         one.FromVector4(Vector4.One * 1234.0f);
         Assert.Equal(Vector4.Zero, zero.ToVector4());
@@ -90,9 +92,9 @@ public class Rgba64Tests
     public void Rgba64_ToRgba32()
     {
         // arrange
-        var rgba64 = new Rgba64(5140, 9766, 19532, 29555);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(20, 38, 76, 115);
+        Rgba64 rgba64 = new(5140, 9766, 19532, 29555);
+        Rgba32 actual = default;
+        Rgba32 expected = new(20, 38, 76, 115);
 
         // act
         rgba64.ToRgba32(ref actual);
@@ -105,7 +107,7 @@ public class Rgba64Tests
     public void Rgba64_FromBgra5551()
     {
         // arrange
-        var rgba = default(Rgba64);
+        Rgba64 rgba = default;
         ushort expected = ushort.MaxValue;
 
         // act
@@ -121,8 +123,8 @@ public class Rgba64Tests
     [Fact]
     public void Equality_WhenTrue()
     {
-        var c1 = new Rgba64(100, 2000, 3000, 40000);
-        var c2 = new Rgba64(100, 2000, 3000, 40000);
+        Rgba64 c1 = new(100, 2000, 3000, 40000);
+        Rgba64 c2 = new(100, 2000, 3000, 40000);
 
         Assert.True(c1.Equals(c2));
         Assert.True(c1.GetHashCode() == c2.GetHashCode());
@@ -131,9 +133,9 @@ public class Rgba64Tests
     [Fact]
     public void Equality_WhenFalse()
     {
-        var c1 = new Rgba64(100, 2000, 3000, 40000);
-        var c2 = new Rgba64(101, 2000, 3000, 40000);
-        var c3 = new Rgba64(100, 2000, 3000, 40001);
+        Rgba64 c1 = new(100, 2000, 3000, 40000);
+        Rgba64 c2 = new(101, 2000, 3000, 40000);
+        Rgba64 c3 = new(100, 2000, 3000, 40001);
 
         Assert.False(c1.Equals(c2));
         Assert.False(c2.Equals(c3));
@@ -143,8 +145,8 @@ public class Rgba64Tests
     [Fact]
     public void Rgba64_FromRgba32()
     {
-        var source = new Rgba32(20, 38, 76, 115);
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
+        Rgba32 source = new(20, 38, 76, 115);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
 
         Rgba64 actual = default;
         actual.FromRgba32(source);
@@ -155,9 +157,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Rgba32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Rgba32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Rgba32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -165,9 +167,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Bgra32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Bgra32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Bgra32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -175,9 +177,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Argb32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Argb32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Argb32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -185,9 +187,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Abgr32()
     {
-        var expected = new Rgba64(5140, 9766, 19532, 29555);
-        var source = new Abgr32(20, 38, 76, 115);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, 29555);
+        Abgr32 source = new(20, 38, 76, 115);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -195,9 +197,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Rgb24()
     {
-        var expected = new Rgba64(5140, 9766, 19532, ushort.MaxValue);
-        var source = new Rgb24(20, 38, 76);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, ushort.MaxValue);
+        Rgb24 source = new(20, 38, 76);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -205,9 +207,9 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Bgr24()
     {
-        var expected = new Rgba64(5140, 9766, 19532, ushort.MaxValue);
-        var source = new Bgr24(20, 38, 76);
-        var actual = new Rgba64(source);
+        Rgba64 expected = new(5140, 9766, 19532, ushort.MaxValue);
+        Bgr24 source = new(20, 38, 76);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -215,11 +217,11 @@ public class Rgba64Tests
     [Fact]
     public void ConstructFrom_Vector4()
     {
-        var source = new Vector4(0f, 0.2f, 0.5f, 1f);
+        Vector4 source = new(0f, 0.2f, 0.5f, 1f);
         Rgba64 expected = default;
         expected.FromScaledVector4(source);
 
-        var actual = new Rgba64(source);
+        Rgba64 actual = new(source);
 
         Assert.Equal(expected, actual);
     }
@@ -228,11 +230,11 @@ public class Rgba64Tests
     public void ToRgba32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Rgba32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Rgba32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToRgba32();
+        Rgba32 actual = source.ToRgba32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -242,11 +244,11 @@ public class Rgba64Tests
     public void ToBgra32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Bgra32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Bgra32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToBgra32();
+        Bgra32 actual = source.ToBgra32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -256,11 +258,11 @@ public class Rgba64Tests
     public void ToArgb32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Argb32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Argb32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToArgb32();
+        Argb32 actual = source.ToArgb32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -270,11 +272,11 @@ public class Rgba64Tests
     public void ToAbgr32_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Abgr32(20, 38, 76, 115);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Abgr32 expected = new(20, 38, 76, 115);
 
         // act
-        var actual = source.ToAbgr32();
+        Abgr32 actual = source.ToAbgr32();
 
         // assert
         Assert.Equal(expected, actual);
@@ -284,11 +286,11 @@ public class Rgba64Tests
     public void ToRgb24_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Rgb24(20, 38, 76);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Rgb24 expected = new(20, 38, 76);
 
         // act
-        var actual = source.ToRgb24();
+        Rgb24 actual = source.ToRgb24();
 
         // assert
         Assert.Equal(expected, actual);
@@ -298,13 +300,23 @@ public class Rgba64Tests
     public void ToBgr24_Retval()
     {
         // arrange
-        var source = new Rgba64(5140, 9766, 19532, 29555);
-        var expected = new Bgr24(20, 38, 76);
+        Rgba64 source = new(5140, 9766, 19532, 29555);
+        Bgr24 expected = new(20, 38, 76);
 
         // act
-        var actual = source.ToBgr24();
+        Bgr24 actual = source.ToBgr24();
 
         // assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void Rgba64_PixelInformation()
+    {
+        PixelTypeInfo info = Rgba64.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Rgba64>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
index ac6d2e3ca..ba30b0bfe 100644
--- a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -19,12 +20,12 @@ public class RgbaVectorTests
     [Fact]
     public void AreEqual()
     {
-        var color1 = new RgbaVector(0, 0, 0F);
-        var color2 = new RgbaVector(0, 0, 0, 1F);
-        var color3 = RgbaVector.FromHex("#000");
-        var color4 = RgbaVector.FromHex("#000F");
-        var color5 = RgbaVector.FromHex("#000000");
-        var color6 = RgbaVector.FromHex("#000000FF");
+        RgbaVector color1 = new(0, 0, 0F);
+        RgbaVector color2 = new(0, 0, 0, 1F);
+        RgbaVector color3 = RgbaVector.FromHex("#000");
+        RgbaVector color4 = RgbaVector.FromHex("#000F");
+        RgbaVector color5 = RgbaVector.FromHex("#000000");
+        RgbaVector color6 = RgbaVector.FromHex("#000000FF");
 
         Assert.Equal(color1, color2);
         Assert.Equal(color1, color3);
@@ -39,11 +40,11 @@ public class RgbaVectorTests
     [Fact]
     public void AreNotEqual()
     {
-        var color1 = new RgbaVector(1, 0, 0, 1);
-        var color2 = new RgbaVector(0, 0, 0, 1);
-        var color3 = RgbaVector.FromHex("#000");
-        var color4 = RgbaVector.FromHex("#000000");
-        var color5 = RgbaVector.FromHex("#FF000000");
+        RgbaVector color1 = new(1, 0, 0, 1);
+        RgbaVector color2 = new(0, 0, 0, 1);
+        RgbaVector color3 = RgbaVector.FromHex("#000");
+        RgbaVector color4 = RgbaVector.FromHex("#000000");
+        RgbaVector color5 = RgbaVector.FromHex("#FF000000");
 
         Assert.NotEqual(color1, color2);
         Assert.NotEqual(color1, color3);
@@ -57,13 +58,13 @@ public class RgbaVectorTests
     [Fact]
     public void ConstructorAssignsProperties()
     {
-        var color1 = new RgbaVector(1, .1F, .133F, .864F);
+        RgbaVector color1 = new(1, .1F, .133F, .864F);
         Assert.Equal(1F, color1.R);
         Assert.Equal(.1F, color1.G);
         Assert.Equal(.133F, color1.B);
         Assert.Equal(.864F, color1.A);
 
-        var color2 = new RgbaVector(1, .1f, .133f);
+        RgbaVector color2 = new(1, .1f, .133f);
         Assert.Equal(1F, color2.R);
         Assert.Equal(.1F, color2.G);
         Assert.Equal(.133F, color2.B);
@@ -76,7 +77,7 @@ public class RgbaVectorTests
     [Fact]
     public void FromAndToHex()
     {
-        var color = RgbaVector.FromHex("#AABBCCDD");
+        RgbaVector color = RgbaVector.FromHex("#AABBCCDD");
         Assert.Equal(170 / 255F, color.R);
         Assert.Equal(187 / 255F, color.G);
         Assert.Equal(204 / 255F, color.B);
@@ -104,7 +105,7 @@ public class RgbaVectorTests
     [Fact]
     public void FloatLayout()
     {
-        var color = new RgbaVector(1F, 2, 3, 4);
+        RgbaVector color = new(1F, 2, 3, 4);
         Vector4 colorBase = Unsafe.As<RgbaVector, Vector4>(ref Unsafe.Add(ref color, 0));
         float[] ordered = new float[4];
         colorBase.CopyTo(ordered);
@@ -119,9 +120,9 @@ public class RgbaVectorTests
     public void RgbaVector_FromRgb48()
     {
         // arrange
-        var input = default(RgbaVector);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 0, 65535);
+        RgbaVector input = default;
+        Rgb48 actual = default;
+        Rgb48 expected = new(65535, 0, 65535);
 
         // act
         input.FromRgb48(expected);
@@ -135,9 +136,9 @@ public class RgbaVectorTests
     public void RgbaVector_FromRgba64()
     {
         // arrange
-        var input = default(RgbaVector);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 0, 65535, 0);
+        RgbaVector input = default;
+        Rgba64 actual = default;
+        Rgba64 expected = new(65535, 0, 65535, 0);
 
         // act
         input.FromRgba64(expected);
@@ -151,7 +152,7 @@ public class RgbaVectorTests
     public void RgbaVector_FromBgra5551()
     {
         // arrange
-        var rgb = default(RgbaVector);
+        RgbaVector rgb = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -165,7 +166,7 @@ public class RgbaVectorTests
     public void RgbaVector_FromGrey16()
     {
         // arrange
-        var rgba = default(RgbaVector);
+        RgbaVector rgba = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -179,7 +180,7 @@ public class RgbaVectorTests
     public void RgbaVector_FromGrey8()
     {
         // arrange
-        var rgba = default(RgbaVector);
+        RgbaVector rgba = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -204,4 +205,14 @@ public class RgbaVectorTests
 
         Assert.Equal(srcColor, cloneColor);
     }
+
+    [Fact]
+    public void RgbaVector_PixelInformation()
+    {
+        PixelTypeInfo info = RgbaVector.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<RgbaVector>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Float, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
index 8fc080d81..27631cbc7 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -51,7 +53,7 @@ public class Short2Tests
     public void Short2_ToScaledVector4()
     {
         // arrange
-        var short2 = new Short2(Vector2.One * 0x7FFF);
+        Short2 short2 = new(Vector2.One * 0x7FFF);
 
         // act
         Vector4 actual = short2.ToScaledVector4();
@@ -67,8 +69,8 @@ public class Short2Tests
     public void Short2_FromScaledVector4()
     {
         // arrange
-        var pixel = default(Short2);
-        var short2 = new Short2(Vector2.One * 0x7FFF);
+        Short2 pixel = default;
+        Short2 short2 = new(Vector2.One * 0x7FFF);
         const ulong expected = 0x7FFF7FFF;
 
         // act
@@ -84,9 +86,9 @@ public class Short2Tests
     public void Short2_ToRgba32()
     {
         // arrange
-        var short2 = new Short2(127.5f, -5.3f);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(128, 127, 0, 255);
+        Short2 short2 = new(127.5f, -5.3f);
+        Rgba32 actual = default;
+        Rgba32 expected = new(128, 127, 0, 255);
 
         // act
         short2.ToRgba32(ref actual);
@@ -99,9 +101,9 @@ public class Short2Tests
     public void Short2_FromRgba32_ToRgba32()
     {
         // arrange
-        var short2 = default(Short2);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(20, 38, 0, 255);
+        Short2 short2 = default;
+        Rgba32 actual = default;
+        Rgba32 expected = new(20, 38, 0, 255);
 
         // act
         short2.FromRgba32(expected);
@@ -115,9 +117,9 @@ public class Short2Tests
     public void Short2_FromRgb48()
     {
         // arrange
-        var input = default(Short2);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 65535, 0);
+        Short2 input = default;
+        Rgb48 actual = default;
+        Rgb48 expected = new(65535, 65535, 0);
 
         // act
         input.FromRgb48(expected);
@@ -131,9 +133,9 @@ public class Short2Tests
     public void Short2_FromRgba64()
     {
         // arrange
-        var input = default(Short2);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 65535, 0, 65535);
+        Short2 input = default;
+        Rgba64 actual = default;
+        Rgba64 expected = new(65535, 65535, 0, 65535);
 
         // act
         input.FromRgba64(expected);
@@ -147,7 +149,7 @@ public class Short2Tests
     public void Short2_FromBgra5551()
     {
         // arrange
-        var short2 = default(Short2);
+        Short2 short2 = default;
 
         // act
         short2.FromBgra5551(new Bgra5551(1.0f, 1.0f, 1.0f, 1.0f));
@@ -159,4 +161,14 @@ public class Short2Tests
         Assert.Equal(0, actual.Z);
         Assert.Equal(1, actual.W);
     }
+
+    [Fact]
+    public void Short2_PixelInformation()
+    {
+        PixelTypeInfo info = Short2.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Short2>() * 8, info.BitsPerPixel);
+        Assert.Equal(2, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
index c42062703..8d853f059 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -12,8 +14,8 @@ public class Short4Tests
     [Fact]
     public void Short4_PackedValues()
     {
-        var shortValue1 = new Short4(11547, 12653, 29623, 193);
-        var shortValue2 = new Short4(0.1f, -0.3f, 0.5f, -0.7f);
+        Short4 shortValue1 = new(11547, 12653, 29623, 193);
+        Short4 shortValue2 = new(0.1f, -0.3f, 0.5f, -0.7f);
 
         Assert.Equal(0x00c173b7316d2d1bUL, shortValue1.PackedValue);
         Assert.Equal(18446462598732840960, shortValue2.PackedValue);
@@ -38,7 +40,7 @@ public class Short4Tests
     public void Short4_ToScaledVector4()
     {
         // arrange
-        var short4 = new Short4(Vector4.One * 0x7FFF);
+        Short4 short4 = new(Vector4.One * 0x7FFF);
 
         // act
         Vector4 actual = short4.ToScaledVector4();
@@ -54,12 +56,12 @@ public class Short4Tests
     public void Short4_FromScaledVector4()
     {
         // arrange
-        var short4 = new Short4(Vector4.One * 0x7FFF);
+        Short4 short4 = new(Vector4.One * 0x7FFF);
         Vector4 scaled = short4.ToScaledVector4();
         const long expected = 0x7FFF7FFF7FFF7FFF;
 
         // act
-        var pixel = default(Short4);
+        Short4 pixel = default;
         pixel.FromScaledVector4(scaled);
 
         // assert
@@ -70,12 +72,12 @@ public class Short4Tests
     public void Short4_Clamping()
     {
         // arrange
-        var short1 = new Short4(Vector4.One * 1234567.0f);
-        var short2 = new Short4(Vector4.One * -1234567.0f);
+        Short4 short1 = new(Vector4.One * 1234567.0f);
+        Short4 short2 = new(Vector4.One * -1234567.0f);
 
         // act
-        var vector1 = short1.ToVector4();
-        var vector2 = short2.ToVector4();
+        Vector4 vector1 = short1.ToVector4();
+        Vector4 vector2 = short2.ToVector4();
 
         // assert
         Assert.Equal(Vector4.One * 0x7FFF, vector1);
@@ -86,9 +88,9 @@ public class Short4Tests
     public void Short4_ToRgba32()
     {
         // arrange
-        var shortValue = new Short4(11547, 12653, 29623, 193);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(172, 177, 243, 128);
+        Short4 shortValue = new(11547, 12653, 29623, 193);
+        Rgba32 actual = default;
+        Rgba32 expected = new(172, 177, 243, 128);
 
         // act
         shortValue.ToRgba32(ref actual);
@@ -101,9 +103,9 @@ public class Short4Tests
     public void Short4_FromRgba32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Rgba32);
-        var expected = new Rgba32(20, 38, 0, 255);
+        Short4 short4 = default;
+        Rgba32 actual = default;
+        Rgba32 expected = new(20, 38, 0, 255);
 
         // act
         short4.FromRgba32(expected);
@@ -117,9 +119,9 @@ public class Short4Tests
     public void Short4_FromBgra32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Bgra32);
-        var expected = new Bgra32(20, 38, 0, 255);
+        Short4 short4 = default;
+        Bgra32 actual = default;
+        Bgra32 expected = new(20, 38, 0, 255);
 
         // act
         short4.FromBgra32(expected);
@@ -135,9 +137,9 @@ public class Short4Tests
     public void Short4_FromArgb32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Argb32);
-        var expected = new Argb32(20, 38, 0, 255);
+        Short4 short4 = default;
+        Argb32 actual = default;
+        Argb32 expected = new(20, 38, 0, 255);
 
         // act
         short4.FromArgb32(expected);
@@ -153,9 +155,9 @@ public class Short4Tests
     public void Short4_FromAbgrb32_ToRgba32()
     {
         // arrange
-        var short4 = default(Short4);
-        var actual = default(Abgr32);
-        var expected = new Abgr32(20, 38, 0, 255);
+        Short4 short4 = default;
+        Abgr32 actual = default;
+        Abgr32 expected = new(20, 38, 0, 255);
 
         // act
         short4.FromAbgr32(expected);
@@ -171,9 +173,9 @@ public class Short4Tests
     public void Short4_FromRgb48_ToRgb48()
     {
         // arrange
-        var input = default(Short4);
-        var actual = default(Rgb48);
-        var expected = new Rgb48(65535, 0, 65535);
+        Short4 input = default;
+        Rgb48 actual = default;
+        Rgb48 expected = new(65535, 0, 65535);
 
         // act
         input.FromRgb48(expected);
@@ -187,9 +189,9 @@ public class Short4Tests
     public void Short4_FromRgba64_ToRgba64()
     {
         // arrange
-        var input = default(Short4);
-        var actual = default(Rgba64);
-        var expected = new Rgba64(65535, 0, 65535, 0);
+        Short4 input = default;
+        Rgba64 actual = default;
+        Rgba64 expected = new(65535, 0, 65535, 0);
 
         // act
         input.FromRgba64(expected);
@@ -203,7 +205,7 @@ public class Short4Tests
     public void Short4_FromBgra5551()
     {
         // arrange
-        var short4 = default(Short4);
+        Short4 short4 = default;
         Vector4 expected = Vector4.One;
 
         // act
@@ -212,4 +214,14 @@ public class Short4Tests
         // assert
         Assert.Equal(expected, short4.ToScaledVector4());
     }
+
+    [Fact]
+    public void Short4_PixelInformation()
+    {
+        PixelTypeInfo info = Short4.GetPixelTypeInfo();
+        Assert.Equal(Unsafe.SizeOf<Short4>() * 8, info.BitsPerPixel);
+        Assert.Equal(4, info.ComponentCount);
+        Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+    }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
index 5cc35b43e..75e3b693c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
@@ -12,8 +12,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Bytes_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -24,8 +24,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Floats_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -36,8 +36,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Vector4_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -48,8 +48,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Vector3_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F);
+        Rgba32 color = new(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F);
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -60,8 +60,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_From_Hex_Produce_Equal_Scaled_Component_OutPut()
     {
-        var color = Rgba32.ParseHex("183060C0");
-        var colorVector = RgbaVector.FromHex("183060C0");
+        Rgba32 color = Rgba32.ParseHex("183060C0");
+        RgbaVector colorVector = RgbaVector.FromHex("183060C0");
 
         Assert.Equal(color.R, (byte)(colorVector.R * 255));
         Assert.Equal(color.G, (byte)(colorVector.G * 255));
@@ -72,8 +72,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_To_Vector4_Produce_Equal_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Assert.Equal(color.ToVector4(), colorVector.ToVector4());
     }
@@ -81,8 +81,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_To_RgbaBytes_Produce_Equal_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         Rgba32 rgba = default;
         Rgba32 rgbaVector = default;
@@ -95,8 +95,8 @@ public class UnPackedPixelTests
     [Fact]
     public void Color_Types_To_Hex_Produce_Equal_OutPut()
     {
-        var color = new Rgba32(24, 48, 96, 192);
-        var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
+        Rgba32 color = new(24, 48, 96, 192);
+        RgbaVector colorVector = new(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
 
         // 183060C0
         Assert.Equal(color.ToHex(), colorVector.ToHex());
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs
index 465a21970..a4232a968 100644
--- a/tests/ImageSharp.Tests/TestFormat.cs
+++ b/tests/ImageSharp.Tests/TestFormat.cs
@@ -263,7 +263,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public struct TestPixelForAgnosticDecode : IPixel<TestPixelForAgnosticDecode>
     {
-        public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(2, PixelAlphaRepresentation.None);
+        public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(2, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
 
         public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
index 5fb3501e3..ccb149ca3 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/BasicTestPatternProvider.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
@@ -85,7 +85,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         private static TPixel GetBottomRightColor()
         {
             TPixel bottomRightColor = default;
-            bottomRightColor.FromVector4(new Vector4(1f, 0f, 1f, 0.5f));
+            bottomRightColor.FromScaledVector4(new Vector4(1f, 0f, 1f, 0.5f));
             return bottomRightColor;
         }
     }

From c7f18c8a6f18051ab3cb1b9fed90442a5530e062 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Mon, 11 Dec 2023 19:28:34 +1000
Subject: [PATCH 09/14] Use info for color conversion

---
 src/ImageSharp/Color/Color.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index 99458d58a..3af3e04f0 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp;
@@ -124,7 +125,9 @@ public readonly partial struct Color : IEquatable<Color>
         {
             return new((L16)(object)pixel);
         }
-        else if (Unsafe.SizeOf<TPixel>() <= Unsafe.SizeOf<Rgba32>())
+
+        PixelTypeInfo info = TPixel.GetPixelTypeInfo();
+        if (info.ComponentPrecision <= PixelComponentPrecision.Byte)
         {
             Rgba32 p = default;
             pixel.ToRgba32(ref p);

From d1c231bb85876ed40d569a5f29497fb5e68c5cda Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Tue, 12 Dec 2023 08:08:51 +1000
Subject: [PATCH 10/14] Rename property, use int.

---
 src/ImageSharp/Color/Color.cs                             | 2 +-
 src/ImageSharp/Formats/PixelTypeInfo.cs                   | 8 ++++----
 src/ImageSharp/PixelFormats/PixelComponentPrecision.cs    | 2 +-
 tests/ImageSharp.Tests/PixelFormats/A8Tests.cs            | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs         | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs      | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs      | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs         | 2 +-
 tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs    | 2 +-
 tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs   | 2 +-
 tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs   | 2 +-
 tests/ImageSharp.Tests/PixelFormats/L16Tests.cs           | 2 +-
 tests/ImageSharp.Tests/PixelFormats/L8Tests.cs            | 2 +-
 tests/ImageSharp.Tests/PixelFormats/La16Tests.cs          | 2 +-
 tests/ImageSharp.Tests/PixelFormats/La32Tests.cs          | 2 +-
 .../ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs | 2 +-
 .../ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs | 2 +-
 .../PixelFormats/NormalizedShort2Tests.cs                 | 2 +-
 .../PixelFormats/NormalizedShort4Tests.cs                 | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs          | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs         | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs         | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs   | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs    | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs        | 2 +-
 tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs        | 2 +-
 32 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index 3af3e04f0..711009050 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -127,7 +127,7 @@ public readonly partial struct Color : IEquatable<Color>
         }
 
         PixelTypeInfo info = TPixel.GetPixelTypeInfo();
-        if (info.ComponentPrecision <= PixelComponentPrecision.Byte)
+        if (info.MaxComponentPrecision <= PixelComponentPrecision.Byte)
         {
             Rgba32 p = default;
             pixel.ToRgba32(ref p);
diff --git a/src/ImageSharp/Formats/PixelTypeInfo.cs b/src/ImageSharp/Formats/PixelTypeInfo.cs
index 0c2a4f4c8..170ffcfae 100644
--- a/src/ImageSharp/Formats/PixelTypeInfo.cs
+++ b/src/ImageSharp/Formats/PixelTypeInfo.cs
@@ -26,12 +26,12 @@ public readonly struct PixelTypeInfo(int bitsPerPixel)
     /// <summary>
     /// Gets the count of the color components
     /// </summary>
-    public byte ComponentCount { get; init; }
+    public int ComponentCount { get; init; }
 
     /// <summary>
-    /// Gets the pixel component precision.
+    /// Gets the maximum precision of components within the pixel.
     /// </summary>
-    public PixelComponentPrecision? ComponentPrecision { get; init; }
+    public PixelComponentPrecision? MaxComponentPrecision { get; init; }
 
     /// <summary>
     /// Gets the pixel alpha transparency behavior.
@@ -48,7 +48,7 @@ public readonly struct PixelTypeInfo(int bitsPerPixel)
         {
             BitsPerPixel = Unsafe.SizeOf<TPixel>() * 8,
             ComponentCount = componentCount,
-            ComponentPrecision = componentPrecision,
+            MaxComponentPrecision = componentPrecision,
             AlphaRepresentation = pixelAlphaRepresentation
         };
 }
diff --git a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
index 8b1298657..3480ac76e 100644
--- a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
+++ b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
-/// Provides enumeration of the maximum precision of individual components within a pixel format.
+/// Provides enumeration of the precision of individual components within a pixel format.
 /// </summary>
 public enum PixelComponentPrecision
 {
diff --git a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
index 008bc652c..518aa203d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
@@ -118,6 +118,6 @@ public class A8Tests
         Assert.Equal(Unsafe.SizeOf<A8>() * 8, info.BitsPerPixel);
         Assert.Equal(1, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
index 3c185383c..dbe02e986 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
@@ -153,6 +153,6 @@ public class Abgr32Tests
         Assert.Equal(Unsafe.SizeOf<Abgr32>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
index f6b818fb5..fd8ee144b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
@@ -151,6 +151,6 @@ public class Argb32Tests
         Assert.Equal(Unsafe.SizeOf<Argb32>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
index 6861dab41..78c58e5c2 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
@@ -136,6 +136,6 @@ public class Bgr24Tests
         Assert.Equal(Unsafe.SizeOf<Bgr24>() * 8, info.BitsPerPixel);
         Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
index b68b94325..68f953225 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
@@ -258,6 +258,6 @@ public class Bgr565Tests
         Assert.Equal(Unsafe.SizeOf<Bgr565>() * 8, info.BitsPerPixel);
         Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
index 17d184d1a..e92fcf1d3 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
@@ -153,6 +153,6 @@ public class Bgra32Tests
         Assert.Equal(Unsafe.SizeOf<Bgra32>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
index 648ef79d5..1af84c0c8 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
@@ -254,6 +254,6 @@ public class Bgra4444Tests
         Assert.Equal(Unsafe.SizeOf<Bgra4444>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
index e32ec665e..a0926d4dd 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
@@ -280,6 +280,6 @@ public class Bgra5551Tests
         Assert.Equal(Unsafe.SizeOf<Bgra5551>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
index ce5752fba..5b456459e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
@@ -247,6 +247,6 @@ public class Byte4Tests
         Assert.Equal(Unsafe.SizeOf<Byte4>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
index cbff2b85e..9c546e2f0 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
@@ -76,6 +76,6 @@ public class HalfSingleTests
         Assert.Equal(Unsafe.SizeOf<HalfSingle>() * 8, info.BitsPerPixel);
         Assert.Equal(1, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Half, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Half, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
index 98a5cb0bf..4f84d6087 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
@@ -98,6 +98,6 @@ public class HalfVector2Tests
         Assert.Equal(Unsafe.SizeOf<HalfVector2>() * 8, info.BitsPerPixel);
         Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Half, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Half, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
index 48d10f1c1..33f0173d2 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
@@ -89,6 +89,6 @@ public class HalfVector4Tests
         Assert.Equal(Unsafe.SizeOf<HalfVector4>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Half, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Half, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
index 18481712a..0c0cdbe3b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
@@ -168,6 +168,6 @@ public class L16Tests
         Assert.Equal(Unsafe.SizeOf<L16>() * 8, info.BitsPerPixel);
         Assert.Equal(1, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
index 80dc36fa3..d8bce0640 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
@@ -263,7 +263,7 @@ public class L8Tests
             Assert.Equal(Unsafe.SizeOf<L8>() * 8, info.BitsPerPixel);
             Assert.Equal(1, info.ComponentCount);
             Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-            Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+            Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
index c3d8a873a..46e7457a5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
@@ -267,7 +267,7 @@ public class La16Tests
             Assert.Equal(Unsafe.SizeOf<La16>() * 8, info.BitsPerPixel);
             Assert.Equal(2, info.ComponentCount);
             Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-            Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+            Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
index 17e10e15d..65aa8b1c9 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
@@ -174,6 +174,6 @@ public class La32Tests
         Assert.Equal(Unsafe.SizeOf<La32>() * 8, info.BitsPerPixel);
         Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
index a09454f5b..999ddb934 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
@@ -90,6 +90,6 @@ public class NormalizedByte2Tests
         Assert.Equal(Unsafe.SizeOf<NormalizedByte2>() * 8, info.BitsPerPixel);
         Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.SByte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.SByte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
index aa0136b37..64a996453 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
@@ -240,6 +240,6 @@ public class NormalizedByte4Tests
         Assert.Equal(Unsafe.SizeOf<NormalizedByte4>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.SByte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.SByte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
index 6ac18fa08..e6d4ae98d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
@@ -94,6 +94,6 @@ public class NormalizedShort2Tests
         Assert.Equal(Unsafe.SizeOf<NormalizedShort2>() * 8, info.BitsPerPixel);
         Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
index fcab7318b..cd684311a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
@@ -241,6 +241,6 @@ public class NormalizedShort4Tests
         Assert.Equal(Unsafe.SizeOf<NormalizedShort4>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
index c5c534655..bf3ff6416 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
@@ -92,6 +92,6 @@ public class Rg32Tests
         Assert.Equal(Unsafe.SizeOf<Rg32>() * 8, info.BitsPerPixel);
         Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
index dbb2e8f03..c69c757b5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
@@ -139,6 +139,6 @@ public class Rgb24Tests
         Assert.Equal(Unsafe.SizeOf<Rgb24>() * 8, info.BitsPerPixel);
         Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
index 04bbaf7f7..dda5af9fb 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
@@ -84,6 +84,6 @@ public class Rgb48Tests
         Assert.Equal(Unsafe.SizeOf<Rgb48>() * 8, info.BitsPerPixel);
         Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
index 678ac2274..5b0e4c287 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
@@ -255,6 +255,6 @@ public class Rgba1010102Tests
         Assert.Equal(Unsafe.SizeOf<Rgba1010102>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
index 6154773e8..d1ad4c304 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
@@ -315,6 +315,6 @@ public class Rgba32Tests
         Assert.Equal(Unsafe.SizeOf<Rgba32>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
index e9b61c1e3..3dc580460 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
@@ -317,6 +317,6 @@ public class Rgba64Tests
         Assert.Equal(Unsafe.SizeOf<Rgba64>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
index ba30b0bfe..968e274e2 100644
--- a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
@@ -213,6 +213,6 @@ public class RgbaVectorTests
         Assert.Equal(Unsafe.SizeOf<RgbaVector>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Float, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Float, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
index 27631cbc7..7afe61b02 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
@@ -169,6 +169,6 @@ public class Short2Tests
         Assert.Equal(Unsafe.SizeOf<Short2>() * 8, info.BitsPerPixel);
         Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
index 8d853f059..bdde5cd8f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
@@ -222,6 +222,6 @@ public class Short4Tests
         Assert.Equal(Unsafe.SizeOf<Short4>() * 8, info.BitsPerPixel);
         Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.ComponentPrecision);
+        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
     }
 }

From 6b6b474892d1a4ecfc450c3b61323d11a68145ab Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Tue, 2 Jan 2024 22:05:58 +1000
Subject: [PATCH 11/14] Introduce PixelComponentInfo + simplify Color

---
 src/ImageSharp/Color/Color.Conversions.cs     | 240 ---------------
 src/ImageSharp/Color/Color.NamedColors.cs     | 288 +++++++++---------
 src/ImageSharp/Color/Color.cs                 | 145 ++++-----
 src/ImageSharp/Formats/AnimationUtilities.cs  |   4 +-
 src/ImageSharp/Formats/Gif/GifDecoderCore.cs  |  10 +-
 src/ImageSharp/Formats/Png/PngDecoderCore.cs  |   9 +-
 src/ImageSharp/Formats/Png/PngEncoderCore.cs  |   4 +-
 .../Formats/Png/PngScanlineProcessor.cs       |   2 +-
 .../BlackIsZero1TiffColor{TPixel}.cs          |   4 +-
 .../WhiteIsZero1TiffColor{TPixel}.cs          |   4 +-
 .../Formats/Webp/BitWriter/BitWriterBase.cs   |   3 +-
 .../Formats/Webp/WebpAnimationDecoder.cs      |   2 +-
 .../Formats/Webp/WebpDecoderCore.cs           |   2 +-
 src/ImageSharp/ImageInfo.cs                   |   2 +-
 src/ImageSharp/Image{TPixel}.cs               |   1 -
 src/ImageSharp/PixelFormats/IPixel.cs         |   1 -
 .../PixelFormats/PixelComponentInfo.cs        | 111 +++++++
 .../PixelFormats/PixelComponentPrecision.cs   |  38 ++-
 .../PixelFormats/PixelImplementations/A8.cs   |   3 +-
 .../PixelImplementations/Abgr32.cs            |  19 +-
 .../PixelImplementations/Argb32.cs            |  19 +-
 .../PixelImplementations/Bgr24.cs             |  19 +-
 .../PixelImplementations/Bgr565.cs            |   3 +-
 .../PixelImplementations/Bgra32.cs            |  19 +-
 .../PixelImplementations/Bgra4444.cs          |   3 +-
 .../PixelImplementations/Bgra5551.cs          |   3 +-
 .../PixelImplementations/Byte4.cs             |   3 +-
 .../PixelImplementations/HalfSingle.cs        |   3 +-
 .../PixelImplementations/HalfVector2.cs       |   3 +-
 .../PixelImplementations/HalfVector4.cs       |   3 +-
 .../PixelFormats/PixelImplementations/L16.cs  |   3 +-
 .../PixelFormats/PixelImplementations/L8.cs   |   3 +-
 .../PixelFormats/PixelImplementations/La16.cs |   3 +-
 .../PixelFormats/PixelImplementations/La32.cs |   3 +-
 .../PixelImplementations/NormalizedByte2.cs   |   3 +-
 .../PixelImplementations/NormalizedByte4.cs   |   3 +-
 .../PixelImplementations/NormalizedShort2.cs  |   3 +-
 .../PixelImplementations/NormalizedShort4.cs  |   3 +-
 .../PixelFormats/PixelImplementations/Rg32.cs |   3 +-
 .../PixelImplementations/Rgb24.cs             |  19 +-
 .../PixelImplementations/Rgb48.cs             |   3 +-
 .../PixelImplementations/Rgba1010102.cs       |   3 +-
 .../PixelImplementations/Rgba32.cs            |  19 +-
 .../PixelImplementations/Rgba64.cs            |  19 +-
 .../PixelImplementations/RgbaVector.cs        |   3 +-
 .../PixelImplementations/Short2.cs            |   3 +-
 .../PixelImplementations/Short4.cs            |   3 +-
 .../PixelFormats/PixelOperations{TPixel}.cs   |   1 -
 .../PixelTypeInfo.cs                          |  29 +-
 .../Filters/LomographProcessor{TPixel}.cs     |   2 +-
 .../Filters/PolaroidProcessor{TPixel}.cs      |   4 +-
 .../General/GetSetPixel.cs                    |   2 +-
 .../Processing/BokehBlur.cs                   |   2 +-
 .../Processing/Diffuse.cs                     |   4 +-
 .../Processing/GaussianBlur.cs                |   2 +-
 .../Processing/Rotate.cs                      |   2 +-
 .../ImageSharp.Benchmarks/Processing/Skew.cs  |   2 +-
 .../Color/ColorTests.CastFrom.cs              |  28 +-
 .../Color/ColorTests.CastTo.cs                |  32 +-
 .../Color/ColorTests.ConstructFrom.cs         |  28 +-
 tests/ImageSharp.Tests/Color/ColorTests.cs    | 128 +++-----
 tests/ImageSharp.Tests/Color/RgbaDouble.cs    | 180 +++++++++++
 .../Drawing/DrawImageTests.cs                 |   4 +-
 .../Formats/Png/PngDecoderTests.cs            |   4 +-
 .../Formats/Png/PngEncoderTests.cs            |   7 +-
 .../PhotometricInterpretationTestBase.cs      |   2 +-
 .../Tiff/TiffEncoderMultiframeTests.cs        |  20 +-
 .../ImageFrameCollectionTests.Generic.cs      |   2 +-
 .../ImageFrameCollectionTests.NonGeneric.cs   |  13 +-
 .../ImageSharp.Tests/Image/ImageFrameTests.cs |   4 +-
 .../Image/ImageTests.LoadPixelData.cs         |  49 ++-
 .../Image/ImageTests.WrapMemory.cs            |  16 +-
 tests/ImageSharp.Tests/Image/ImageTests.cs    |   6 +-
 tests/ImageSharp.Tests/ImageInfoTests.cs      |   2 +-
 .../ImageSharp.Tests/PixelFormats/A8Tests.cs  |   9 +-
 .../PixelFormats/Abgr32Tests.cs               |  12 +-
 .../PixelFormats/Argb32Tests.cs               |  12 +-
 .../PixelFormats/Bgr24Tests.cs                |  11 +-
 .../PixelFormats/Bgr565Tests.cs               |  11 +-
 .../PixelFormats/Bgra32Tests.cs               |  12 +-
 .../PixelFormats/Bgra4444Tests.cs             |  12 +-
 .../PixelFormats/Bgra5551Tests.cs             |  12 +-
 .../PixelFormats/Byte4Tests.cs                |  12 +-
 .../PixelFormats/HalfSingleTests.cs           |   9 +-
 .../PixelFormats/HalfVector2Tests.cs          |  10 +-
 .../PixelFormats/HalfVector4Tests.cs          |  12 +-
 .../ImageSharp.Tests/PixelFormats/L16Tests.cs |   9 +-
 .../ImageSharp.Tests/PixelFormats/L8Tests.cs  |   9 +-
 .../PixelFormats/La16Tests.cs                 |  10 +-
 .../PixelFormats/La32Tests.cs                 |  10 +-
 .../PixelFormats/NormalizedByte2Tests.cs      |  10 +-
 .../PixelFormats/NormalizedByte4Tests.cs      |  12 +-
 .../PixelFormats/NormalizedShort2Tests.cs     |  10 +-
 .../PixelFormats/NormalizedShort4Tests.cs     |  12 +-
 .../PixelFormats/PixelBlenderTests.cs         |  42 +--
 .../PixelFormats/Rg32Tests.cs                 |  10 +-
 .../PixelFormats/Rgb24Tests.cs                |  11 +-
 .../PixelFormats/Rgb48Tests.cs                |  11 +-
 .../PixelFormats/Rgba1010102Tests.cs          |  12 +-
 .../PixelFormats/Rgba32Tests.cs               |  12 +-
 .../PixelFormats/Rgba64Tests.cs               |  12 +-
 .../PixelFormats/RgbaVectorTests.cs           |  12 +-
 .../PixelFormats/Short2Tests.cs               |  10 +-
 .../PixelFormats/Short4Tests.cs               |  12 +-
 .../Quantization/WuQuantizerTests.cs          |   4 +-
 tests/ImageSharp.Tests/TestFormat.cs          |   2 +-
 .../ImageProviders/SolidProvider.cs           |   2 +-
 107 files changed, 1021 insertions(+), 991 deletions(-)
 delete mode 100644 src/ImageSharp/Color/Color.Conversions.cs
 create mode 100644 src/ImageSharp/PixelFormats/PixelComponentInfo.cs
 rename src/ImageSharp/{Formats => PixelFormats}/PixelTypeInfo.cs (65%)
 create mode 100644 tests/ImageSharp.Tests/Color/RgbaDouble.cs

diff --git a/src/ImageSharp/Color/Color.Conversions.cs b/src/ImageSharp/Color/Color.Conversions.cs
deleted file mode 100644
index 309ab83ec..000000000
--- a/src/ImageSharp/Color/Color.Conversions.cs
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp;
-
-/// <content>
-/// Contains constructors and implicit conversion methods.
-/// </content>
-public readonly partial struct Color
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgba64"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgba64 pixel)
-    {
-        this.data = pixel;
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgb48"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgb48 pixel)
-    {
-        this.data = new Rgba64(pixel.R, pixel.G, pixel.B, ushort.MaxValue);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="La32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(La32 pixel)
-    {
-        this.data = new Rgba64(pixel.L, pixel.L, pixel.L, pixel.A);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="L16"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(L16 pixel)
-    {
-        this.data = new Rgba64(pixel.PackedValue, pixel.PackedValue, pixel.PackedValue, ushort.MaxValue);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgba32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgba32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Argb32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Argb32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Bgra32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Bgra32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Abgr32"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Abgr32 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Rgb24"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Rgb24 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="pixel">The <see cref="Bgr24"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Bgr24 pixel)
-    {
-        this.data = new Rgba64(pixel);
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Color"/> struct.
-    /// </summary>
-    /// <param name="vector">The <see cref="Vector4"/> containing the color information.</param>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public Color(Vector4 vector)
-    {
-        vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
-        this.boxedHighPrecisionPixel = new RgbaVector(vector.X, vector.Y, vector.Z, vector.W);
-        this.data = default;
-    }
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Vector4"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Vector4"/>.</returns>
-    public static explicit operator Vector4(Color color) => color.ToScaledVector4();
-
-    /// <summary>
-    /// Converts an <see cref="Vector4"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Vector4"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static explicit operator Color(Vector4 source) => new(source);
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Rgba32 ToRgba32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToRgba32();
-        }
-
-        Rgba32 value = default;
-        this.boxedHighPrecisionPixel.ToRgba32(ref value);
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Bgra32 ToBgra32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToBgra32();
-        }
-
-        Bgra32 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Argb32 ToArgb32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToArgb32();
-        }
-
-        Argb32 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Abgr32 ToAbgr32()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToAbgr32();
-        }
-
-        Abgr32 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Rgb24 ToRgb24()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToRgb24();
-        }
-
-        Rgb24 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Bgr24 ToBgr24()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToBgr24();
-        }
-
-        Bgr24 value = default;
-        value.FromScaledVector4(this.boxedHighPrecisionPixel.ToScaledVector4());
-        return value;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    internal Vector4 ToScaledVector4()
-    {
-        if (this.boxedHighPrecisionPixel is null)
-        {
-            return this.data.ToScaledVector4();
-        }
-
-        return this.boxedHighPrecisionPixel.ToScaledVector4();
-    }
-}
diff --git a/src/ImageSharp/Color/Color.NamedColors.cs b/src/ImageSharp/Color/Color.NamedColors.cs
index f8b4c90fd..00130dd90 100644
--- a/src/ImageSharp/Color/Color.NamedColors.cs
+++ b/src/ImageSharp/Color/Color.NamedColors.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.ImageSharp.PixelFormats;
+
 namespace SixLabors.ImageSharp;
 
 /// <content>
@@ -9,107 +11,107 @@ namespace SixLabors.ImageSharp;
 /// </content>
 public readonly partial struct Color
 {
-    private static readonly Lazy<Dictionary<string, Color>> NamedColorsLookupLazy = new Lazy<Dictionary<string, Color>>(CreateNamedColorsLookup, true);
+    private static readonly Lazy<Dictionary<string, Color>> NamedColorsLookupLazy = new(CreateNamedColorsLookup, true);
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0F8FF.
     /// </summary>
-    public static readonly Color AliceBlue = FromRgba(240, 248, 255, 255);
+    public static readonly Color AliceBlue = FromPixel(new Rgba32(240, 248, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FAEBD7.
     /// </summary>
-    public static readonly Color AntiqueWhite = FromRgba(250, 235, 215, 255);
+    public static readonly Color AntiqueWhite = FromPixel(new Rgba32(250, 235, 215, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FFFF.
     /// </summary>
-    public static readonly Color Aqua = FromRgba(0, 255, 255, 255);
+    public static readonly Color Aqua = FromPixel(new Rgba32(0, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7FFFD4.
     /// </summary>
-    public static readonly Color Aquamarine = FromRgba(127, 255, 212, 255);
+    public static readonly Color Aquamarine = FromPixel(new Rgba32(127, 255, 212, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0FFFF.
     /// </summary>
-    public static readonly Color Azure = FromRgba(240, 255, 255, 255);
+    public static readonly Color Azure = FromPixel(new Rgba32(240, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5F5DC.
     /// </summary>
-    public static readonly Color Beige = FromRgba(245, 245, 220, 255);
+    public static readonly Color Beige = FromPixel(new Rgba32(245, 245, 220, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFE4C4.
     /// </summary>
-    public static readonly Color Bisque = FromRgba(255, 228, 196, 255);
+    public static readonly Color Bisque = FromPixel(new Rgba32(255, 228, 196, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #000000.
     /// </summary>
-    public static readonly Color Black = FromRgba(0, 0, 0, 255);
+    public static readonly Color Black = FromPixel(new Rgba32(0, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFEBCD.
     /// </summary>
-    public static readonly Color BlanchedAlmond = FromRgba(255, 235, 205, 255);
+    public static readonly Color BlanchedAlmond = FromPixel(new Rgba32(255, 235, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #0000FF.
     /// </summary>
-    public static readonly Color Blue = FromRgba(0, 0, 255, 255);
+    public static readonly Color Blue = FromPixel(new Rgba32(0, 0, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8A2BE2.
     /// </summary>
-    public static readonly Color BlueViolet = FromRgba(138, 43, 226, 255);
+    public static readonly Color BlueViolet = FromPixel(new Rgba32(138, 43, 226, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A52A2A.
     /// </summary>
-    public static readonly Color Brown = FromRgba(165, 42, 42, 255);
+    public static readonly Color Brown = FromPixel(new Rgba32(165, 42, 42, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DEB887.
     /// </summary>
-    public static readonly Color BurlyWood = FromRgba(222, 184, 135, 255);
+    public static readonly Color BurlyWood = FromPixel(new Rgba32(222, 184, 135, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #5F9EA0.
     /// </summary>
-    public static readonly Color CadetBlue = FromRgba(95, 158, 160, 255);
+    public static readonly Color CadetBlue = FromPixel(new Rgba32(95, 158, 160, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7FFF00.
     /// </summary>
-    public static readonly Color Chartreuse = FromRgba(127, 255, 0, 255);
+    public static readonly Color Chartreuse = FromPixel(new Rgba32(127, 255, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D2691E.
     /// </summary>
-    public static readonly Color Chocolate = FromRgba(210, 105, 30, 255);
+    public static readonly Color Chocolate = FromPixel(new Rgba32(210, 105, 30, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF7F50.
     /// </summary>
-    public static readonly Color Coral = FromRgba(255, 127, 80, 255);
+    public static readonly Color Coral = FromPixel(new Rgba32(255, 127, 80, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #6495ED.
     /// </summary>
-    public static readonly Color CornflowerBlue = FromRgba(100, 149, 237, 255);
+    public static readonly Color CornflowerBlue = FromPixel(new Rgba32(100, 149, 237, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFF8DC.
     /// </summary>
-    public static readonly Color Cornsilk = FromRgba(255, 248, 220, 255);
+    public static readonly Color Cornsilk = FromPixel(new Rgba32(255, 248, 220, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DC143C.
     /// </summary>
-    public static readonly Color Crimson = FromRgba(220, 20, 60, 255);
+    public static readonly Color Crimson = FromPixel(new Rgba32(220, 20, 60, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FFFF.
@@ -119,27 +121,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00008B.
     /// </summary>
-    public static readonly Color DarkBlue = FromRgba(0, 0, 139, 255);
+    public static readonly Color DarkBlue = FromPixel(new Rgba32(0, 0, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #008B8B.
     /// </summary>
-    public static readonly Color DarkCyan = FromRgba(0, 139, 139, 255);
+    public static readonly Color DarkCyan = FromPixel(new Rgba32(0, 139, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B8860B.
     /// </summary>
-    public static readonly Color DarkGoldenrod = FromRgba(184, 134, 11, 255);
+    public static readonly Color DarkGoldenrod = FromPixel(new Rgba32(184, 134, 11, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A9A9A9.
     /// </summary>
-    public static readonly Color DarkGray = FromRgba(169, 169, 169, 255);
+    public static readonly Color DarkGray = FromPixel(new Rgba32(169, 169, 169, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #006400.
     /// </summary>
-    public static readonly Color DarkGreen = FromRgba(0, 100, 0, 255);
+    public static readonly Color DarkGreen = FromPixel(new Rgba32(0, 100, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A9A9A9.
@@ -149,52 +151,52 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #BDB76B.
     /// </summary>
-    public static readonly Color DarkKhaki = FromRgba(189, 183, 107, 255);
+    public static readonly Color DarkKhaki = FromPixel(new Rgba32(189, 183, 107, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8B008B.
     /// </summary>
-    public static readonly Color DarkMagenta = FromRgba(139, 0, 139, 255);
+    public static readonly Color DarkMagenta = FromPixel(new Rgba32(139, 0, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #556B2F.
     /// </summary>
-    public static readonly Color DarkOliveGreen = FromRgba(85, 107, 47, 255);
+    public static readonly Color DarkOliveGreen = FromPixel(new Rgba32(85, 107, 47, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF8C00.
     /// </summary>
-    public static readonly Color DarkOrange = FromRgba(255, 140, 0, 255);
+    public static readonly Color DarkOrange = FromPixel(new Rgba32(255, 140, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9932CC.
     /// </summary>
-    public static readonly Color DarkOrchid = FromRgba(153, 50, 204, 255);
+    public static readonly Color DarkOrchid = FromPixel(new Rgba32(153, 50, 204, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8B0000.
     /// </summary>
-    public static readonly Color DarkRed = FromRgba(139, 0, 0, 255);
+    public static readonly Color DarkRed = FromPixel(new Rgba32(139, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #E9967A.
     /// </summary>
-    public static readonly Color DarkSalmon = FromRgba(233, 150, 122, 255);
+    public static readonly Color DarkSalmon = FromPixel(new Rgba32(233, 150, 122, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8FBC8F.
     /// </summary>
-    public static readonly Color DarkSeaGreen = FromRgba(143, 188, 143, 255);
+    public static readonly Color DarkSeaGreen = FromPixel(new Rgba32(143, 188, 143, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #483D8B.
     /// </summary>
-    public static readonly Color DarkSlateBlue = FromRgba(72, 61, 139, 255);
+    public static readonly Color DarkSlateBlue = FromPixel(new Rgba32(72, 61, 139, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #2F4F4F.
     /// </summary>
-    public static readonly Color DarkSlateGray = FromRgba(47, 79, 79, 255);
+    public static readonly Color DarkSlateGray = FromPixel(new Rgba32(47, 79, 79, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #2F4F4F.
@@ -204,27 +206,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00CED1.
     /// </summary>
-    public static readonly Color DarkTurquoise = FromRgba(0, 206, 209, 255);
+    public static readonly Color DarkTurquoise = FromPixel(new Rgba32(0, 206, 209, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9400D3.
     /// </summary>
-    public static readonly Color DarkViolet = FromRgba(148, 0, 211, 255);
+    public static readonly Color DarkViolet = FromPixel(new Rgba32(148, 0, 211, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF1493.
     /// </summary>
-    public static readonly Color DeepPink = FromRgba(255, 20, 147, 255);
+    public static readonly Color DeepPink = FromPixel(new Rgba32(255, 20, 147, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00BFFF.
     /// </summary>
-    public static readonly Color DeepSkyBlue = FromRgba(0, 191, 255, 255);
+    public static readonly Color DeepSkyBlue = FromPixel(new Rgba32(0, 191, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #696969.
     /// </summary>
-    public static readonly Color DimGray = FromRgba(105, 105, 105, 255);
+    public static readonly Color DimGray = FromPixel(new Rgba32(105, 105, 105, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #696969.
@@ -234,62 +236,62 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #1E90FF.
     /// </summary>
-    public static readonly Color DodgerBlue = FromRgba(30, 144, 255, 255);
+    public static readonly Color DodgerBlue = FromPixel(new Rgba32(30, 144, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B22222.
     /// </summary>
-    public static readonly Color Firebrick = FromRgba(178, 34, 34, 255);
+    public static readonly Color Firebrick = FromPixel(new Rgba32(178, 34, 34, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFAF0.
     /// </summary>
-    public static readonly Color FloralWhite = FromRgba(255, 250, 240, 255);
+    public static readonly Color FloralWhite = FromPixel(new Rgba32(255, 250, 240, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #228B22.
     /// </summary>
-    public static readonly Color ForestGreen = FromRgba(34, 139, 34, 255);
+    public static readonly Color ForestGreen = FromPixel(new Rgba32(34, 139, 34, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF00FF.
     /// </summary>
-    public static readonly Color Fuchsia = FromRgba(255, 0, 255, 255);
+    public static readonly Color Fuchsia = FromPixel(new Rgba32(255, 0, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DCDCDC.
     /// </summary>
-    public static readonly Color Gainsboro = FromRgba(220, 220, 220, 255);
+    public static readonly Color Gainsboro = FromPixel(new Rgba32(220, 220, 220, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F8F8FF.
     /// </summary>
-    public static readonly Color GhostWhite = FromRgba(248, 248, 255, 255);
+    public static readonly Color GhostWhite = FromPixel(new Rgba32(248, 248, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFD700.
     /// </summary>
-    public static readonly Color Gold = FromRgba(255, 215, 0, 255);
+    public static readonly Color Gold = FromPixel(new Rgba32(255, 215, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DAA520.
     /// </summary>
-    public static readonly Color Goldenrod = FromRgba(218, 165, 32, 255);
+    public static readonly Color Goldenrod = FromPixel(new Rgba32(218, 165, 32, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #808080.
     /// </summary>
-    public static readonly Color Gray = FromRgba(128, 128, 128, 255);
+    public static readonly Color Gray = FromPixel(new Rgba32(128, 128, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #008000.
     /// </summary>
-    public static readonly Color Green = FromRgba(0, 128, 0, 255);
+    public static readonly Color Green = FromPixel(new Rgba32(0, 128, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #ADFF2F.
     /// </summary>
-    public static readonly Color GreenYellow = FromRgba(173, 255, 47, 255);
+    public static readonly Color GreenYellow = FromPixel(new Rgba32(173, 255, 47, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #808080.
@@ -299,82 +301,82 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0FFF0.
     /// </summary>
-    public static readonly Color Honeydew = FromRgba(240, 255, 240, 255);
+    public static readonly Color Honeydew = FromPixel(new Rgba32(240, 255, 240, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF69B4.
     /// </summary>
-    public static readonly Color HotPink = FromRgba(255, 105, 180, 255);
+    public static readonly Color HotPink = FromPixel(new Rgba32(255, 105, 180, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #CD5C5C.
     /// </summary>
-    public static readonly Color IndianRed = FromRgba(205, 92, 92, 255);
+    public static readonly Color IndianRed = FromPixel(new Rgba32(205, 92, 92, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #4B0082.
     /// </summary>
-    public static readonly Color Indigo = FromRgba(75, 0, 130, 255);
+    public static readonly Color Indigo = FromPixel(new Rgba32(75, 0, 130, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFF0.
     /// </summary>
-    public static readonly Color Ivory = FromRgba(255, 255, 240, 255);
+    public static readonly Color Ivory = FromPixel(new Rgba32(255, 255, 240, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F0E68C.
     /// </summary>
-    public static readonly Color Khaki = FromRgba(240, 230, 140, 255);
+    public static readonly Color Khaki = FromPixel(new Rgba32(240, 230, 140, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #E6E6FA.
     /// </summary>
-    public static readonly Color Lavender = FromRgba(230, 230, 250, 255);
+    public static readonly Color Lavender = FromPixel(new Rgba32(230, 230, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFF0F5.
     /// </summary>
-    public static readonly Color LavenderBlush = FromRgba(255, 240, 245, 255);
+    public static readonly Color LavenderBlush = FromPixel(new Rgba32(255, 240, 245, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7CFC00.
     /// </summary>
-    public static readonly Color LawnGreen = FromRgba(124, 252, 0, 255);
+    public static readonly Color LawnGreen = FromPixel(new Rgba32(124, 252, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFACD.
     /// </summary>
-    public static readonly Color LemonChiffon = FromRgba(255, 250, 205, 255);
+    public static readonly Color LemonChiffon = FromPixel(new Rgba32(255, 250, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #ADD8E6.
     /// </summary>
-    public static readonly Color LightBlue = FromRgba(173, 216, 230, 255);
+    public static readonly Color LightBlue = FromPixel(new Rgba32(173, 216, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F08080.
     /// </summary>
-    public static readonly Color LightCoral = FromRgba(240, 128, 128, 255);
+    public static readonly Color LightCoral = FromPixel(new Rgba32(240, 128, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #E0FFFF.
     /// </summary>
-    public static readonly Color LightCyan = FromRgba(224, 255, 255, 255);
+    public static readonly Color LightCyan = FromPixel(new Rgba32(224, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FAFAD2.
     /// </summary>
-    public static readonly Color LightGoldenrodYellow = FromRgba(250, 250, 210, 255);
+    public static readonly Color LightGoldenrodYellow = FromPixel(new Rgba32(250, 250, 210, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D3D3D3.
     /// </summary>
-    public static readonly Color LightGray = FromRgba(211, 211, 211, 255);
+    public static readonly Color LightGray = FromPixel(new Rgba32(211, 211, 211, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #90EE90.
     /// </summary>
-    public static readonly Color LightGreen = FromRgba(144, 238, 144, 255);
+    public static readonly Color LightGreen = FromPixel(new Rgba32(144, 238, 144, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D3D3D3.
@@ -384,27 +386,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFB6C1.
     /// </summary>
-    public static readonly Color LightPink = FromRgba(255, 182, 193, 255);
+    public static readonly Color LightPink = FromPixel(new Rgba32(255, 182, 193, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFA07A.
     /// </summary>
-    public static readonly Color LightSalmon = FromRgba(255, 160, 122, 255);
+    public static readonly Color LightSalmon = FromPixel(new Rgba32(255, 160, 122, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #20B2AA.
     /// </summary>
-    public static readonly Color LightSeaGreen = FromRgba(32, 178, 170, 255);
+    public static readonly Color LightSeaGreen = FromPixel(new Rgba32(32, 178, 170, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #87CEFA.
     /// </summary>
-    public static readonly Color LightSkyBlue = FromRgba(135, 206, 250, 255);
+    public static readonly Color LightSkyBlue = FromPixel(new Rgba32(135, 206, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #778899.
     /// </summary>
-    public static readonly Color LightSlateGray = FromRgba(119, 136, 153, 255);
+    public static readonly Color LightSlateGray = FromPixel(new Rgba32(119, 136, 153, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #778899.
@@ -414,27 +416,27 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B0C4DE.
     /// </summary>
-    public static readonly Color LightSteelBlue = FromRgba(176, 196, 222, 255);
+    public static readonly Color LightSteelBlue = FromPixel(new Rgba32(176, 196, 222, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFE0.
     /// </summary>
-    public static readonly Color LightYellow = FromRgba(255, 255, 224, 255);
+    public static readonly Color LightYellow = FromPixel(new Rgba32(255, 255, 224, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FF00.
     /// </summary>
-    public static readonly Color Lime = FromRgba(0, 255, 0, 255);
+    public static readonly Color Lime = FromPixel(new Rgba32(0, 255, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #32CD32.
     /// </summary>
-    public static readonly Color LimeGreen = FromRgba(50, 205, 50, 255);
+    public static readonly Color LimeGreen = FromPixel(new Rgba32(50, 205, 50, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FAF0E6.
     /// </summary>
-    public static readonly Color Linen = FromRgba(250, 240, 230, 255);
+    public static readonly Color Linen = FromPixel(new Rgba32(250, 240, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF00FF.
@@ -444,237 +446,237 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #800000.
     /// </summary>
-    public static readonly Color Maroon = FromRgba(128, 0, 0, 255);
+    public static readonly Color Maroon = FromPixel(new Rgba32(128, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #66CDAA.
     /// </summary>
-    public static readonly Color MediumAquamarine = FromRgba(102, 205, 170, 255);
+    public static readonly Color MediumAquamarine = FromPixel(new Rgba32(102, 205, 170, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #0000CD.
     /// </summary>
-    public static readonly Color MediumBlue = FromRgba(0, 0, 205, 255);
+    public static readonly Color MediumBlue = FromPixel(new Rgba32(0, 0, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #BA55D3.
     /// </summary>
-    public static readonly Color MediumOrchid = FromRgba(186, 85, 211, 255);
+    public static readonly Color MediumOrchid = FromPixel(new Rgba32(186, 85, 211, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9370DB.
     /// </summary>
-    public static readonly Color MediumPurple = FromRgba(147, 112, 219, 255);
+    public static readonly Color MediumPurple = FromPixel(new Rgba32(147, 112, 219, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #3CB371.
     /// </summary>
-    public static readonly Color MediumSeaGreen = FromRgba(60, 179, 113, 255);
+    public static readonly Color MediumSeaGreen = FromPixel(new Rgba32(60, 179, 113, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #7B68EE.
     /// </summary>
-    public static readonly Color MediumSlateBlue = FromRgba(123, 104, 238, 255);
+    public static readonly Color MediumSlateBlue = FromPixel(new Rgba32(123, 104, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FA9A.
     /// </summary>
-    public static readonly Color MediumSpringGreen = FromRgba(0, 250, 154, 255);
+    public static readonly Color MediumSpringGreen = FromPixel(new Rgba32(0, 250, 154, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #48D1CC.
     /// </summary>
-    public static readonly Color MediumTurquoise = FromRgba(72, 209, 204, 255);
+    public static readonly Color MediumTurquoise = FromPixel(new Rgba32(72, 209, 204, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #C71585.
     /// </summary>
-    public static readonly Color MediumVioletRed = FromRgba(199, 21, 133, 255);
+    public static readonly Color MediumVioletRed = FromPixel(new Rgba32(199, 21, 133, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #191970.
     /// </summary>
-    public static readonly Color MidnightBlue = FromRgba(25, 25, 112, 255);
+    public static readonly Color MidnightBlue = FromPixel(new Rgba32(25, 25, 112, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5FFFA.
     /// </summary>
-    public static readonly Color MintCream = FromRgba(245, 255, 250, 255);
+    public static readonly Color MintCream = FromPixel(new Rgba32(245, 255, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFE4E1.
     /// </summary>
-    public static readonly Color MistyRose = FromRgba(255, 228, 225, 255);
+    public static readonly Color MistyRose = FromPixel(new Rgba32(255, 228, 225, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFE4B5.
     /// </summary>
-    public static readonly Color Moccasin = FromRgba(255, 228, 181, 255);
+    public static readonly Color Moccasin = FromPixel(new Rgba32(255, 228, 181, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFDEAD.
     /// </summary>
-    public static readonly Color NavajoWhite = FromRgba(255, 222, 173, 255);
+    public static readonly Color NavajoWhite = FromPixel(new Rgba32(255, 222, 173, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #000080.
     /// </summary>
-    public static readonly Color Navy = FromRgba(0, 0, 128, 255);
+    public static readonly Color Navy = FromPixel(new Rgba32(0, 0, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FDF5E6.
     /// </summary>
-    public static readonly Color OldLace = FromRgba(253, 245, 230, 255);
+    public static readonly Color OldLace = FromPixel(new Rgba32(253, 245, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #808000.
     /// </summary>
-    public static readonly Color Olive = FromRgba(128, 128, 0, 255);
+    public static readonly Color Olive = FromPixel(new Rgba32(128, 128, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #6B8E23.
     /// </summary>
-    public static readonly Color OliveDrab = FromRgba(107, 142, 35, 255);
+    public static readonly Color OliveDrab = FromPixel(new Rgba32(107, 142, 35, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFA500.
     /// </summary>
-    public static readonly Color Orange = FromRgba(255, 165, 0, 255);
+    public static readonly Color Orange = FromPixel(new Rgba32(255, 165, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF4500.
     /// </summary>
-    public static readonly Color OrangeRed = FromRgba(255, 69, 0, 255);
+    public static readonly Color OrangeRed = FromPixel(new Rgba32(255, 69, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DA70D6.
     /// </summary>
-    public static readonly Color Orchid = FromRgba(218, 112, 214, 255);
+    public static readonly Color Orchid = FromPixel(new Rgba32(218, 112, 214, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #EEE8AA.
     /// </summary>
-    public static readonly Color PaleGoldenrod = FromRgba(238, 232, 170, 255);
+    public static readonly Color PaleGoldenrod = FromPixel(new Rgba32(238, 232, 170, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #98FB98.
     /// </summary>
-    public static readonly Color PaleGreen = FromRgba(152, 251, 152, 255);
+    public static readonly Color PaleGreen = FromPixel(new Rgba32(152, 251, 152, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #AFEEEE.
     /// </summary>
-    public static readonly Color PaleTurquoise = FromRgba(175, 238, 238, 255);
+    public static readonly Color PaleTurquoise = FromPixel(new Rgba32(175, 238, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DB7093.
     /// </summary>
-    public static readonly Color PaleVioletRed = FromRgba(219, 112, 147, 255);
+    public static readonly Color PaleVioletRed = FromPixel(new Rgba32(219, 112, 147, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFEFD5.
     /// </summary>
-    public static readonly Color PapayaWhip = FromRgba(255, 239, 213, 255);
+    public static readonly Color PapayaWhip = FromPixel(new Rgba32(255, 239, 213, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFDAB9.
     /// </summary>
-    public static readonly Color PeachPuff = FromRgba(255, 218, 185, 255);
+    public static readonly Color PeachPuff = FromPixel(new Rgba32(255, 218, 185, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #CD853F.
     /// </summary>
-    public static readonly Color Peru = FromRgba(205, 133, 63, 255);
+    public static readonly Color Peru = FromPixel(new Rgba32(205, 133, 63, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFC0CB.
     /// </summary>
-    public static readonly Color Pink = FromRgba(255, 192, 203, 255);
+    public static readonly Color Pink = FromPixel(new Rgba32(255, 192, 203, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #DDA0DD.
     /// </summary>
-    public static readonly Color Plum = FromRgba(221, 160, 221, 255);
+    public static readonly Color Plum = FromPixel(new Rgba32(221, 160, 221, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #B0E0E6.
     /// </summary>
-    public static readonly Color PowderBlue = FromRgba(176, 224, 230, 255);
+    public static readonly Color PowderBlue = FromPixel(new Rgba32(176, 224, 230, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #800080.
     /// </summary>
-    public static readonly Color Purple = FromRgba(128, 0, 128, 255);
+    public static readonly Color Purple = FromPixel(new Rgba32(128, 0, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #663399.
     /// </summary>
-    public static readonly Color RebeccaPurple = FromRgba(102, 51, 153, 255);
+    public static readonly Color RebeccaPurple = FromPixel(new Rgba32(102, 51, 153, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF0000.
     /// </summary>
-    public static readonly Color Red = FromRgba(255, 0, 0, 255);
+    public static readonly Color Red = FromPixel(new Rgba32(255, 0, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #BC8F8F.
     /// </summary>
-    public static readonly Color RosyBrown = FromRgba(188, 143, 143, 255);
+    public static readonly Color RosyBrown = FromPixel(new Rgba32(188, 143, 143, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #4169E1.
     /// </summary>
-    public static readonly Color RoyalBlue = FromRgba(65, 105, 225, 255);
+    public static readonly Color RoyalBlue = FromPixel(new Rgba32(65, 105, 225, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #8B4513.
     /// </summary>
-    public static readonly Color SaddleBrown = FromRgba(139, 69, 19, 255);
+    public static readonly Color SaddleBrown = FromPixel(new Rgba32(139, 69, 19, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FA8072.
     /// </summary>
-    public static readonly Color Salmon = FromRgba(250, 128, 114, 255);
+    public static readonly Color Salmon = FromPixel(new Rgba32(250, 128, 114, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F4A460.
     /// </summary>
-    public static readonly Color SandyBrown = FromRgba(244, 164, 96, 255);
+    public static readonly Color SandyBrown = FromPixel(new Rgba32(244, 164, 96, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #2E8B57.
     /// </summary>
-    public static readonly Color SeaGreen = FromRgba(46, 139, 87, 255);
+    public static readonly Color SeaGreen = FromPixel(new Rgba32(46, 139, 87, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFF5EE.
     /// </summary>
-    public static readonly Color SeaShell = FromRgba(255, 245, 238, 255);
+    public static readonly Color SeaShell = FromPixel(new Rgba32(255, 245, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #A0522D.
     /// </summary>
-    public static readonly Color Sienna = FromRgba(160, 82, 45, 255);
+    public static readonly Color Sienna = FromPixel(new Rgba32(160, 82, 45, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #C0C0C0.
     /// </summary>
-    public static readonly Color Silver = FromRgba(192, 192, 192, 255);
+    public static readonly Color Silver = FromPixel(new Rgba32(192, 192, 192, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #87CEEB.
     /// </summary>
-    public static readonly Color SkyBlue = FromRgba(135, 206, 235, 255);
+    public static readonly Color SkyBlue = FromPixel(new Rgba32(135, 206, 235, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #6A5ACD.
     /// </summary>
-    public static readonly Color SlateBlue = FromRgba(106, 90, 205, 255);
+    public static readonly Color SlateBlue = FromPixel(new Rgba32(106, 90, 205, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #708090.
     /// </summary>
-    public static readonly Color SlateGray = FromRgba(112, 128, 144, 255);
+    public static readonly Color SlateGray = FromPixel(new Rgba32(112, 128, 144, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #708090.
@@ -684,81 +686,80 @@ public readonly partial struct Color
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFAFA.
     /// </summary>
-    public static readonly Color Snow = FromRgba(255, 250, 250, 255);
+    public static readonly Color Snow = FromPixel(new Rgba32(255, 250, 250, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00FF7F.
     /// </summary>
-    public static readonly Color SpringGreen = FromRgba(0, 255, 127, 255);
+    public static readonly Color SpringGreen = FromPixel(new Rgba32(0, 255, 127, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #4682B4.
     /// </summary>
-    public static readonly Color SteelBlue = FromRgba(70, 130, 180, 255);
+    public static readonly Color SteelBlue = FromPixel(new Rgba32(70, 130, 180, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D2B48C.
     /// </summary>
-    public static readonly Color Tan = FromRgba(210, 180, 140, 255);
+    public static readonly Color Tan = FromPixel(new Rgba32(210, 180, 140, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #008080.
     /// </summary>
-    public static readonly Color Teal = FromRgba(0, 128, 128, 255);
+    public static readonly Color Teal = FromPixel(new Rgba32(0, 128, 128, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #D8BFD8.
     /// </summary>
-    public static readonly Color Thistle = FromRgba(216, 191, 216, 255);
+    public static readonly Color Thistle = FromPixel(new Rgba32(216, 191, 216, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FF6347.
     /// </summary>
-    public static readonly Color Tomato = FromRgba(255, 99, 71, 255);
+    public static readonly Color Tomato = FromPixel(new Rgba32(255, 99, 71, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #00000000.
     /// </summary>
-    public static readonly Color Transparent = FromRgba(0, 0, 0, 0);
+    public static readonly Color Transparent = FromPixel(new Rgba32(0, 0, 0, 0));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #40E0D0.
     /// </summary>
-    public static readonly Color Turquoise = FromRgba(64, 224, 208, 255);
+    public static readonly Color Turquoise = FromPixel(new Rgba32(64, 224, 208, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #EE82EE.
     /// </summary>
-    public static readonly Color Violet = FromRgba(238, 130, 238, 255);
+    public static readonly Color Violet = FromPixel(new Rgba32(238, 130, 238, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5DEB3.
     /// </summary>
-    public static readonly Color Wheat = FromRgba(245, 222, 179, 255);
+    public static readonly Color Wheat = FromPixel(new Rgba32(245, 222, 179, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFFFF.
     /// </summary>
-    public static readonly Color White = FromRgba(255, 255, 255, 255);
+    public static readonly Color White = FromPixel(new Rgba32(255, 255, 255, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #F5F5F5.
     /// </summary>
-    public static readonly Color WhiteSmoke = FromRgba(245, 245, 245, 255);
+    public static readonly Color WhiteSmoke = FromPixel(new Rgba32(245, 245, 245, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #FFFF00.
     /// </summary>
-    public static readonly Color Yellow = FromRgba(255, 255, 0, 255);
+    public static readonly Color Yellow = FromPixel(new Rgba32(255, 255, 0, 255));
 
     /// <summary>
     /// Represents a <see paramref="Color"/> matching the W3C definition that has an hex value of #9ACD32.
     /// </summary>
-    public static readonly Color YellowGreen = FromRgba(154, 205, 50, 255);
+    public static readonly Color YellowGreen = FromPixel(new Rgba32(154, 205, 50, 255));
 
     private static Dictionary<string, Color> CreateNamedColorsLookup()
-    {
-        return new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase)
+        => new(StringComparer.OrdinalIgnoreCase)
         {
             { nameof(AliceBlue), AliceBlue },
             { nameof(AntiqueWhite), AntiqueWhite },
@@ -910,5 +911,4 @@ public readonly partial struct Color
             { nameof(Yellow), Yellow },
             { nameof(YellowGreen), YellowGreen }
         };
-    }
 }
diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index 711009050..ec19a86eb 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp;
@@ -19,33 +18,24 @@ namespace SixLabors.ImageSharp;
 /// </remarks>
 public readonly partial struct Color : IEquatable<Color>
 {
-    private readonly Rgba64 data;
+    private readonly Vector4 data;
     private readonly IPixel? boxedHighPrecisionPixel;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Color"/> struct.
+    /// </summary>
+    /// <param name="vector">The <see cref="Vector4"/> containing the color information.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    private Color(byte r, byte g, byte b, byte a)
-    {
-        this.data = new Rgba64(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(r),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(g),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(b),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(a));
-
-        this.boxedHighPrecisionPixel = null;
-    }
-
-    [MethodImpl(InliningOptions.ShortMethod)]
-    private Color(byte r, byte g, byte b)
+    private Color(Vector4 vector)
     {
-        this.data = new Rgba64(
-            ColorNumerics.UpscaleFrom8BitTo16Bit(r),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(g),
-            ColorNumerics.UpscaleFrom8BitTo16Bit(b),
-            ushort.MaxValue);
-
+        this.data = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
         this.boxedHighPrecisionPixel = null;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Color"/> struct.
+    /// </summary>
+    /// <param name="pixel">The pixel containing color information.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
     private Color(IPixel pixel)
     {
@@ -53,6 +43,21 @@ public readonly partial struct Color : IEquatable<Color>
         this.data = default;
     }
 
+    /// <summary>
+    /// Converts a <see cref="Color"/> to <see cref="Vector4"/>.
+    /// </summary>
+    /// <param name="color">The <see cref="Color"/>.</param>
+    /// <returns>The <see cref="Vector4"/>.</returns>
+    public static explicit operator Vector4(Color color) => color.ToScaledVector4();
+
+    /// <summary>
+    /// Converts an <see cref="Vector4"/> to <see cref="Color"/>.
+    /// </summary>
+    /// <param name="source">The <see cref="Vector4"/>.</param>
+    /// <returns>The <see cref="Color"/>.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static explicit operator Color(Vector4 source) => new(source);
+
     /// <summary>
     /// Checks whether two <see cref="Color"/> structures are equal.
     /// </summary>
@@ -77,27 +82,6 @@ public readonly partial struct Color : IEquatable<Color>
     [MethodImpl(InliningOptions.ShortMethod)]
     public static bool operator !=(Color left, Color right) => !left.Equals(right);
 
-    /// <summary>
-    /// Creates a <see cref="Color"/> from RGBA bytes.
-    /// </summary>
-    /// <param name="r">The red component (0-255).</param>
-    /// <param name="g">The green component (0-255).</param>
-    /// <param name="b">The blue component (0-255).</param>
-    /// <param name="a">The alpha component (0-255).</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static Color FromRgba(byte r, byte g, byte b, byte a) => new(r, g, b, a);
-
-    /// <summary>
-    /// Creates a <see cref="Color"/> from RGB bytes.
-    /// </summary>
-    /// <param name="r">The red component (0-255).</param>
-    /// <param name="g">The green component (0-255).</param>
-    /// <param name="b">The blue component (0-255).</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static Color FromRgb(byte r, byte g, byte b) => new(r, g, b);
-
     /// <summary>
     /// Creates a <see cref="Color"/> from the given <typeparamref name="TPixel"/>.
     /// </summary>
@@ -108,34 +92,45 @@ public readonly partial struct Color : IEquatable<Color>
     public static Color FromPixel<TPixel>(TPixel pixel)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        // Avoid boxing in case we can convert to Rgba64 safely and efficiently
-        if (typeof(TPixel) == typeof(Rgba64))
-        {
-            return new((Rgba64)(object)pixel);
-        }
-        else if (typeof(TPixel) == typeof(Rgb48))
-        {
-            return new((Rgb48)(object)pixel);
-        }
-        else if (typeof(TPixel) == typeof(La32))
+        // Avoid boxing in case we can convert to Vector4 safely and efficiently
+        PixelTypeInfo info = TPixel.GetPixelTypeInfo();
+        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentPrecision.Float)
         {
-            return new((La32)(object)pixel);
+            return new(pixel.ToScaledVector4());
         }
-        else if (typeof(TPixel) == typeof(L16))
+        else
         {
-            return new((L16)(object)pixel);
+            return new(pixel);
         }
+    }
 
+    /// <summary>
+    /// Bulk converts a span of a specified <typeparamref name="TPixel"/> type to a span of <see cref="Color"/>.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel type to convert to.</typeparam>
+    /// <param name="source">The source pixel span.</param>
+    /// <param name="destination">The destination color span.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static void FromPixel<TPixel>(ReadOnlySpan<TPixel> source, Span<Color> destination)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // Avoid boxing in case we can convert to Vector4 safely and efficiently
         PixelTypeInfo info = TPixel.GetPixelTypeInfo();
-        if (info.MaxComponentPrecision <= PixelComponentPrecision.Byte)
+        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentPrecision.Float)
         {
-            Rgba32 p = default;
-            pixel.ToRgba32(ref p);
-            return new(p);
+            for (int i = 0; i < destination.Length; i++)
+            {
+                destination[i] = new(source[i].ToScaledVector4());
+            }
         }
         else
         {
-            return new(pixel);
+            for (int i = 0; i < destination.Length; i++)
+            {
+                destination[i] = new(source[i]);
+            }
         }
     }
 
@@ -154,8 +149,7 @@ public readonly partial struct Color : IEquatable<Color>
     public static Color ParseHex(string hex)
     {
         Rgba32 rgba = Rgba32.ParseHex(hex);
-
-        return new Color(rgba);
+        return FromPixel(rgba);
     }
 
     /// <summary>
@@ -177,7 +171,7 @@ public readonly partial struct Color : IEquatable<Color>
 
         if (Rgba32.TryParseHex(hex, out Rgba32 rgba))
         {
-            result = new Color(rgba);
+            result = FromPixel(rgba);
             return true;
         }
 
@@ -256,14 +250,15 @@ public readonly partial struct Color : IEquatable<Color>
     [MethodImpl(InliningOptions.ShortMethod)]
     public string ToHex()
     {
+        Rgba32 rgba = default;
         if (this.boxedHighPrecisionPixel is not null)
         {
-            Rgba32 rgba = default;
             this.boxedHighPrecisionPixel.ToRgba32(ref rgba);
             return rgba.ToHex();
         }
 
-        return this.data.ToRgba32().ToHex();
+        rgba.FromScaledVector4(this.data);
+        return rgba.ToHex();
     }
 
     /// <inheritdoc />
@@ -286,7 +281,7 @@ public readonly partial struct Color : IEquatable<Color>
         if (this.boxedHighPrecisionPixel is null)
         {
             pixel = default;
-            pixel.FromRgba64(this.data);
+            pixel.FromScaledVector4(this.data);
             return pixel;
         }
 
@@ -305,7 +300,8 @@ public readonly partial struct Color : IEquatable<Color>
     public static void ToPixel<TPixel>(ReadOnlySpan<Color> source, Span<TPixel> destination)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        // TODO: Investigate bulk operations utilizing configuration parameter here.
+        // We cannot use bulk pixel operations here as there is no guarantee that the source colors are
+        // created from pixel formats which fit into the unboxed vector data.
         Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
         for (int i = 0; i < source.Length; i++)
         {
@@ -319,7 +315,7 @@ public readonly partial struct Color : IEquatable<Color>
     {
         if (this.boxedHighPrecisionPixel is null && other.boxedHighPrecisionPixel is null)
         {
-            return this.data.PackedValue == other.data.PackedValue;
+            return this.data == other.data;
         }
 
         return this.boxedHighPrecisionPixel?.Equals(other.boxedHighPrecisionPixel) == true;
@@ -334,9 +330,20 @@ public readonly partial struct Color : IEquatable<Color>
     {
         if (this.boxedHighPrecisionPixel is null)
         {
-            return this.data.PackedValue.GetHashCode();
+            return this.data.GetHashCode();
         }
 
         return this.boxedHighPrecisionPixel.GetHashCode();
     }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private Vector4 ToScaledVector4()
+    {
+        if (this.boxedHighPrecisionPixel is null)
+        {
+            return this.data;
+        }
+
+        return this.boxedHighPrecisionPixel.ToScaledVector4();
+    }
 }
diff --git a/src/ImageSharp/Formats/AnimationUtilities.cs b/src/ImageSharp/Formats/AnimationUtilities.cs
index 288f3d132..4605d4daa 100644
--- a/src/ImageSharp/Formats/AnimationUtilities.cs
+++ b/src/ImageSharp/Formats/AnimationUtilities.cs
@@ -50,7 +50,7 @@ internal static class AnimationUtilities
         Span<Rgba32> next = buffers.GetSpan().Slice(currentFrame.Width * 2, currentFrame.Width);
         Span<Rgba32> result = buffers.GetSpan()[(currentFrame.Width * 3)..];
 
-        Rgba32 bg = replacement;
+        Rgba32 bg = replacement.ToPixel<Rgba32>();
 
         int top = int.MinValue;
         int bottom = int.MaxValue;
@@ -232,7 +232,7 @@ internal static class AnimationUtilities
                 ref Rgba32 r = ref Unsafe.Add(ref MemoryMarshal.GetReference(result), x);
 
                 bool peq = c.Rgba == (previousFrame != null ? p.Rgba : bg.Rgba);
-                Rgba32 val = (blend & peq) ? replacement : c;
+                Rgba32 val = (blend & peq) ? bg : c;
 
                 peq &= nextFrame == null || (n.Rgba >> 24 >= c.Rgba >> 24);
                 r = val;
diff --git a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
index aecbbbbc7..8916da6e0 100644
--- a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
@@ -711,10 +711,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
 
             Color[] colorTable = new Color[this.imageDescriptor.LocalColorTableSize];
             ReadOnlySpan<Rgb24> rgbTable = MemoryMarshal.Cast<byte, Rgb24>(this.currentLocalColorTable!.GetSpan()[..this.currentLocalColorTableSize]);
-            for (int i = 0; i < colorTable.Length; i++)
-            {
-                colorTable[i] = new Color(rgbTable[i]);
-            }
+            Color.FromPixel(rgbTable, colorTable);
 
             gifMeta.LocalColorTable = colorTable;
         }
@@ -789,10 +786,7 @@ internal sealed class GifDecoderCore : IImageDecoderInternals
 
                 Color[] colorTable = new Color[this.logicalScreenDescriptor.GlobalColorTableSize];
                 ReadOnlySpan<Rgb24> rgbTable = MemoryMarshal.Cast<byte, Rgb24>(globalColorTableSpan);
-                for (int i = 0; i < colorTable.Length; i++)
-                {
-                    colorTable[i] = new Color(rgbTable[i]);
-                }
+                Color.FromPixel(rgbTable, colorTable);
 
                 this.gifMetadata.GlobalColorTable = colorTable;
             }
diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 3eabbdef0..4178d2820 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -1240,10 +1240,7 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
 
         Color[] colorTable = new Color[palette.Length / Unsafe.SizeOf<Rgb24>()];
         ReadOnlySpan<Rgb24> rgbTable = MemoryMarshal.Cast<byte, Rgb24>(palette);
-        for (int i = 0; i < colorTable.Length; i++)
-        {
-            colorTable[i] = new Color(rgbTable[i]);
-        }
+        Color.FromPixel(rgbTable, colorTable);
 
         if (alpha.Length > 0)
         {
@@ -1276,14 +1273,14 @@ internal sealed class PngDecoderCore : IImageDecoderInternals
                     ushort gc = BinaryPrimitives.ReadUInt16LittleEndian(alpha.Slice(2, 2));
                     ushort bc = BinaryPrimitives.ReadUInt16LittleEndian(alpha.Slice(4, 2));
 
-                    pngMetadata.TransparentColor = new(new Rgb48(rc, gc, bc));
+                    pngMetadata.TransparentColor = Color.FromPixel(new Rgb48(rc, gc, bc));
                     return;
                 }
 
                 byte r = ReadByteLittleEndian(alpha, 0);
                 byte g = ReadByteLittleEndian(alpha, 2);
                 byte b = ReadByteLittleEndian(alpha, 4);
-                pngMetadata.TransparentColor = new(new Rgb24(r, g, b));
+                pngMetadata.TransparentColor = Color.FromPixel(new Rgb24(r, g, b));
             }
         }
         else if (this.pngColorType == PngColorType.Grayscale)
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index e348d7467..8bf8be2ad 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -329,7 +329,7 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
         {
             // TODO: We should be able to speed this up with SIMD and masking.
             Rgba32 rgba32 = default;
-            Rgba32 transparent = Color.Transparent;
+            Rgba32 transparent = Color.Transparent.ToPixel<Rgba32>();
             for (int y = 0; y < accessor.Height; y++)
             {
                 Span<TPixel> span = accessor.GetRowSpan(y);
@@ -1066,7 +1066,7 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
             else
             {
                 alpha.Clear();
-                Rgb24 rgb = pngMetadata.TransparentColor.Value.ToRgb24();
+                Rgb24 rgb = pngMetadata.TransparentColor.Value.ToPixel<Rgb24>();
                 alpha[1] = rgb.R;
                 alpha[3] = rgb.G;
                 alpha[5] = rgb.B;
diff --git a/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs b/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
index f217515e3..39b3fff27 100644
--- a/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
+++ b/src/ImageSharp/Formats/Png/PngScanlineProcessor.cs
@@ -202,7 +202,7 @@ internal static class PngScanlineProcessor
         for (nuint x = pixelOffset, o = 0; x < frameControl.XMax; x += increment, o++)
         {
             uint index = Unsafe.Add(ref scanlineSpanRef, o);
-            pixel.FromRgba32(Unsafe.Add(ref paletteBase, index).ToRgba32());
+            pixel.FromRgba32(Unsafe.Add(ref paletteBase, index).ToPixel<Rgba32>());
             Unsafe.Add(ref rowSpanRef, x) = pixel;
         }
     }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs
index a8a70f727..89d1b9d20 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor{TPixel}.cs
@@ -22,8 +22,8 @@ internal class BlackIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
         TPixel colorBlack = default;
         TPixel colorWhite = default;
 
-        colorBlack.FromRgba32(Color.Black);
-        colorWhite.FromRgba32(Color.White);
+        colorBlack.FromRgba32(Color.Black.ToPixel<Rgba32>());
+        colorWhite.FromRgba32(Color.White.ToPixel<Rgba32>());
         ref byte dataRef = ref MemoryMarshal.GetReference(data);
         for (nuint y = (uint)top; y < (uint)(top + height); y++)
         {
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs
index c5b662979..4cba8f2d7 100644
--- a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs
+++ b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor{TPixel}.cs
@@ -21,8 +21,8 @@ internal class WhiteIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel>
         var colorBlack = default(TPixel);
         var colorWhite = default(TPixel);
 
-        colorBlack.FromRgba32(Color.Black);
-        colorWhite.FromRgba32(Color.White);
+        colorBlack.FromRgba32(Color.Black.ToPixel<Rgba32>());
+        colorWhite.FromRgba32(Color.White.ToPixel<Rgba32>());
         ref byte dataRef = ref MemoryMarshal.GetReference(data);
         for (nuint y = (uint)top; y < (uint)(top + height); y++)
         {
diff --git a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
index 9ffda0f51..c98be1fcd 100644
--- a/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
+++ b/src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs
@@ -6,6 +6,7 @@ using SixLabors.ImageSharp.Formats.Webp.Chunks;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
 using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Webp.BitWriter;
 
@@ -157,7 +158,7 @@ internal abstract class BitWriterBase
     /// <param name="loopCount">The number of times to loop the animation. If it is 0, this means infinitely.</param>
     public static void WriteAnimationParameter(Stream stream, Color background, ushort loopCount)
     {
-        WebpAnimationParameter chunk = new(background.ToBgra32().PackedValue, loopCount);
+        WebpAnimationParameter chunk = new(background.ToPixel<Bgra32>().PackedValue, loopCount);
         chunk.WriteTo(stream);
     }
 
diff --git a/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs b/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
index 65f1a4da4..70372fe98 100644
--- a/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
+++ b/src/ImageSharp/Formats/Webp/WebpAnimationDecoder.cs
@@ -102,7 +102,7 @@ internal class WebpAnimationDecoder : IDisposable
             {
                 case WebpChunkType.FrameData:
                     Color backgroundColor = this.backgroundColorHandling == BackgroundColorHandling.Ignore
-                        ? new Color(new Bgra32(0, 0, 0, 0))
+                        ? Color.FromPixel(new Bgra32(0, 0, 0, 0))
                         : features.AnimationBackgroundColor!.Value;
                     uint dataSize = this.ReadFrame(stream, ref image, ref previousFrame, width, height, backgroundColor);
                     remainingBytes -= (int)dataSize;
diff --git a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
index 69a0afcd9..2991f355f 100644
--- a/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Webp/WebpDecoderCore.cs
@@ -438,7 +438,7 @@ internal sealed class WebpDecoderCore : IImageDecoderInternals, IDisposable
         byte green = (byte)stream.ReadByte();
         byte red = (byte)stream.ReadByte();
         byte alpha = (byte)stream.ReadByte();
-        features.AnimationBackgroundColor = new Color(new Rgba32(red, green, blue, alpha));
+        features.AnimationBackgroundColor = Color.FromPixel(new Rgba32(red, green, blue, alpha));
         int bytesRead = stream.Read(buffer, 0, 2);
         if (bytesRead != 2)
         {
diff --git a/src/ImageSharp/ImageInfo.cs b/src/ImageSharp/ImageInfo.cs
index 00319e9b5..c0d1f27ca 100644
--- a/src/ImageSharp/ImageInfo.cs
+++ b/src/ImageSharp/ImageInfo.cs
@@ -1,8 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp;
 
diff --git a/src/ImageSharp/Image{TPixel}.cs b/src/ImageSharp/Image{TPixel}.cs
index 38f0b94d6..e12631cbd 100644
--- a/src/ImageSharp/Image{TPixel}.cs
+++ b/src/ImageSharp/Image{TPixel}.cs
@@ -4,7 +4,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Metadata;
 using SixLabors.ImageSharp.PixelFormats;
diff --git a/src/ImageSharp/PixelFormats/IPixel.cs b/src/ImageSharp/PixelFormats/IPixel.cs
index adbf68861..b28911a90 100644
--- a/src/ImageSharp/PixelFormats/IPixel.cs
+++ b/src/ImageSharp/PixelFormats/IPixel.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
diff --git a/src/ImageSharp/PixelFormats/PixelComponentInfo.cs b/src/ImageSharp/PixelFormats/PixelComponentInfo.cs
new file mode 100644
index 000000000..a76105414
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelComponentInfo.cs
@@ -0,0 +1,111 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Represents pixel component information within a pixel format.
+/// </summary>
+public readonly struct PixelComponentInfo
+{
+    private readonly long precisionData1;
+    private readonly long precisionData2;
+
+    private PixelComponentInfo(int count, int padding, long precisionData1, long precisionData2)
+    {
+        this.ComponentCount = count;
+        this.Padding = padding;
+        this.precisionData1 = precisionData1;
+        this.precisionData2 = precisionData2;
+    }
+
+    /// <summary>
+    /// Gets the number of components within the pixel.
+    /// </summary>
+    public int ComponentCount { get; }
+
+    /// <summary>
+    /// Gets the number of bytes of padding within the pixel.
+    /// </summary>
+    public int Padding { get; }
+
+    /// <summary>
+    /// Creates a new <see cref="PixelComponentInfo"/> instance.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of pixel format.</typeparam>
+    /// <param name="count">The number of components within the pixel format.</param>
+    /// <param name="precision">The precision in bits of each component.</param>
+    /// <returns>The <see cref="PixelComponentInfo"/>.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">The component precision and index cannot exceed the component range.</exception>
+    public static PixelComponentInfo Create<TPixel>(int count, params int[] precision)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        if (precision.Length != count || precision.Length > 16)
+        {
+            throw new ArgumentException($"Count must match the length of precision array and cannot exceed 16.");
+        }
+
+        long precisionData1 = 0;
+        long precisionData2 = 0;
+        int sum = 0;
+        for (int i = 0; i < precision.Length; i++)
+        {
+            int p = precision[i];
+            if (p is < 0 or > 255)
+            {
+                throw new ArgumentException("Precision must be between 0 and 255.");
+            }
+
+            if (i < 8)
+            {
+                precisionData1 |= ((long)p) << (8 * i);
+            }
+            else
+            {
+                precisionData2 |= ((long)p) << (8 * (i - 8));
+            }
+
+            sum += p;
+        }
+
+        return new PixelComponentInfo(count, (Unsafe.SizeOf<TPixel>() * 8) - sum, precisionData1, precisionData2);
+    }
+
+    /// <summary>
+    /// Returns the precision of the component in bits at the given index.
+    /// </summary>
+    /// <param name="componentIndex">The component index.</param>
+    /// <returns>The <see cref="int"/>.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">The component index cannot exceed the component range.</exception>
+    public int GetComponentPrecision(int componentIndex)
+    {
+        if (componentIndex < 0 || componentIndex >= this.ComponentCount)
+        {
+            throw new ArgumentOutOfRangeException($"Component index must be between 0 and {this.ComponentCount - 1} inclusive.");
+        }
+
+        long selectedPrecisionData = componentIndex < 8 ? this.precisionData1 : this.precisionData2;
+        return (int)((selectedPrecisionData >> (8 * (componentIndex & 7))) & 0xFF);
+    }
+
+    /// <summary>
+    /// Returns the maximum precision in bits of all components.
+    /// </summary>
+    /// <returns>The <see cref="int"/>.</returns>
+    public int GetMaximumComponentPrecision()
+    {
+        int maxPrecision = 0;
+        for (int i = 0; i < this.ComponentCount; i++)
+        {
+            int componentPrecision = this.GetComponentPrecision(i);
+            if (componentPrecision > maxPrecision)
+            {
+                maxPrecision = componentPrecision;
+            }
+        }
+
+        return maxPrecision;
+    }
+}
diff --git a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
index 3480ac76e..2f15b7fad 100644
--- a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
+++ b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
@@ -4,47 +4,67 @@
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
-/// Provides enumeration of the precision of individual components within a pixel format.
+/// Provides enumeration of the precision in bits of individual components within a pixel format.
 /// </summary>
 public enum PixelComponentPrecision
 {
     /// <summary>
     /// 8-bit signed integer.
     /// </summary>
-    SByte,
+    SByte = sizeof(sbyte) * 8,
 
     /// <summary>
     /// 8-bit unsigned integer.
     /// </summary>
-    Byte,
+    Byte = sizeof(byte) * 8,
 
     /// <summary>
     /// 16-bit signed integer.
     /// </summary>
-    Short,
+    Short = sizeof(short) * 8,
 
     /// <summary>
     /// 16-bit unsigned integer.
     /// </summary>
-    UShort,
+    UShort = sizeof(ushort) * 8,
 
     /// <summary>
     /// 32-bit signed integer.
     /// </summary>
-    Int,
+    Int = sizeof(int) * 8,
 
     /// <summary>
     /// 32-bit unsigned integer.
     /// </summary>
-    UInt,
+    UInt = sizeof(uint) * 8,
+
+    /// <summary>
+    /// 64-bit signed integer.
+    /// </summary>
+    Long = sizeof(long) * 8,
+
+    /// <summary>
+    /// 64-bit unsigned integer.
+    /// </summary>
+    ULong = sizeof(ulong) * 8,
 
     /// <summary>
     /// 16-bit floating point.
     /// </summary>
-    Half,
+    Half = (sizeof(float) * 8) / 2,
 
     /// <summary>
     /// 32-bit floating point.
     /// </summary>
-    Float
+    Float = sizeof(float) * 8,
+
+    /// <summary>
+    /// 64-bit floating point.
+    /// </summary>
+    Double = sizeof(double) * 8,
+
+    /// <summary>
+    /// 128-bit floating point.
+    /// </summary>
+    Decimal = sizeof(decimal) * 8,
 }
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index 33fa62d1a..abae4f246 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -57,7 +56,7 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(1, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(PixelComponentInfo.Create<A8>(1, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<A8> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index 66523f040..e1399f05c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -146,22 +145,6 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
         set => this.Abgr = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Abgr32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Abgr32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Abgr32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Abgr32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Abgr32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Abgr32(Color color) => color.ToAbgr32();
-
     /// <summary>
     /// Compares two <see cref="Argb32"/> objects for equality.
     /// </summary>
@@ -185,7 +168,7 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(PixelComponentInfo.Create<Abgr32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Abgr32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index d3375f65f..2b7bcf913 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -146,22 +145,6 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
         set => this.Argb = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Argb32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Argb32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Argb32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Argb32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Argb32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Argb32(Color color) => color.ToArgb32();
-
     /// <summary>
     /// Compares two <see cref="Argb32"/> objects for equality.
     /// </summary>
@@ -185,7 +168,7 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(PixelComponentInfo.Create<Argb32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Argb32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index 9d0186c83..c9c324680 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -50,22 +49,6 @@ public partial struct Bgr24 : IPixel<Bgr24>
         this.B = b;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Bgr24"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Bgr24"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Bgr24 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Bgr24"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Bgr24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Bgr24(Color color) => color.ToBgr24();
-
     /// <summary>
     /// Compares two <see cref="Bgr24"/> objects for equality.
     /// </summary>
@@ -89,7 +72,7 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(3, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(PixelComponentInfo.Create<Bgr24>(3, 8, 8, 8), PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Bgr24> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index 6135ab3e7..d020cf025 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -61,7 +60,7 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(3, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(PixelComponentInfo.Create<Bgr565>(3, 5, 6, 5), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgr565> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index 7da4fad4f..b3a96523e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -99,22 +98,6 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
         set => this.Bgra = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Bgra32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Bgra32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Bgra32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Bgra32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Bgra32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Bgra32(Color color) => color.ToBgra32();
-
     /// <summary>
     /// Compares two <see cref="Bgra32"/> objects for equality.
     /// </summary>
@@ -138,7 +121,7 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(PixelComponentInfo.Create<Bgra32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Bgra32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index effc0d6e5..510d6666f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -59,7 +58,7 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(PixelComponentInfo.Create<Bgra4444>(4, 4, 4, 4, 4), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgra4444> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index 14110b1d1..68dbd9544 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -62,7 +61,7 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(PixelComponentInfo.Create<Bgra5551>(4, 5, 5, 5, 1), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index f9a36305d..fbe7a0c52 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -62,7 +61,7 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(PixelComponentInfo.Create<Byte4>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Byte4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index 7e1997251..aca64ae7a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -47,7 +46,7 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(1, PixelComponentPrecision.Half, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(PixelComponentInfo.Create<HalfSingle>(1, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public PixelOperations<HalfSingle> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 1e3854feb..5a25d523b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -54,7 +53,7 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(2, PixelComponentPrecision.Half, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(PixelComponentInfo.Create<HalfVector2>(2, 16, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index 233160579..7ad7b07f4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -59,7 +58,7 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(4, PixelComponentPrecision.Half, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(PixelComponentInfo.Create<HalfVector4>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index fa07d650b..0c58fb1fd 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -49,7 +48,7 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(1, PixelComponentPrecision.UShort, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(PixelComponentInfo.Create<L16>(1, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<L16> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index 28fb7ec72..2cd8b20e7 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -50,7 +49,7 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(1, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(PixelComponentInfo.Create<L8>(1, 8), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<L8> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index 99203518a..b811df4b4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -73,7 +72,7 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(2, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(PixelComponentInfo.Create<La16>(2, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<La16> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index a8c0dcd94..e6a63f5ec 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -75,7 +74,7 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(2, PixelComponentPrecision.UShort, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(PixelComponentInfo.Create<La32>(2, 16, 16), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<La32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index 5db53e853..f7427e65c 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -62,7 +61,7 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(2, PixelComponentPrecision.SByte, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(PixelComponentInfo.Create<NormalizedByte2>(2, 8, 8), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index 4c850e426..beeae655a 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -64,7 +63,7 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(4, PixelComponentPrecision.SByte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(PixelComponentInfo.Create<NormalizedByte4>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index 7fd299d6d..8152c89d3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -63,7 +62,7 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(2, PixelComponentPrecision.Short, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(PixelComponentInfo.Create<NormalizedShort2>(2, 16, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index ff5cd6a98..3f37cb80f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -65,7 +64,7 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(4, PixelComponentPrecision.Short, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(PixelComponentInfo.Create<NormalizedShort4>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 9a2753341..594bdd9a1 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -59,7 +58,7 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(2, PixelComponentPrecision.UShort, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(PixelComponentInfo.Create<Rg32>(2, 16, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rg32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index f4c907abf..8d0c7cd48 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -53,22 +52,6 @@ public partial struct Rgb24 : IPixel<Rgb24>
         this.B = b;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Rgb24"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Rgb24"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Rgb24 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Rgb24"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Rgb24"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgb24(Color color) => color.ToRgb24();
-
     /// <summary>
     /// Allows the implicit conversion of an instance of <see cref="ColorSpaces.Rgb"/> to a
     /// <see cref="Rgb24"/>.
@@ -108,7 +91,7 @@ public partial struct Rgb24 : IPixel<Rgb24>
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(3, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(PixelComponentInfo.Create<Rgb24>(3, 8, 8, 8), PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Rgb24> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index 642883ff0..f7aac32f4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -71,7 +70,7 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(3, PixelComponentPrecision.UShort, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(PixelComponentInfo.Create<Rgb48>(3, 16, 16, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgb48> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 5f289577f..84482a7aa 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -62,7 +61,7 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(4, PixelComponentPrecision.UShort, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(PixelComponentInfo.Create<Rgba1010102>(4, 10, 10, 10, 2), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba1010102> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index f775e8ae1..f391e6474 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -6,7 +6,6 @@ using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -175,22 +174,6 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
         set => this.Rgba = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Rgba32"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Rgba32"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Rgba32 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Rgba32"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Rgba32"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgba32(Color color) => color.ToRgba32();
-
     /// <summary>
     /// Allows the implicit conversion of an instance of <see cref="ColorSpaces.Rgb"/> to a
     /// <see cref="Rgba32"/>.
@@ -288,7 +271,7 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     }
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(4, PixelComponentPrecision.Byte, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(PixelComponentInfo.Create<Rgba32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index 84860d66d..47062779b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -4,7 +4,6 @@
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -169,22 +168,6 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
         set => Unsafe.As<Rgba64, ulong>(ref this) = value;
     }
 
-    /// <summary>
-    /// Converts an <see cref="Rgba64"/> to <see cref="Color"/>.
-    /// </summary>
-    /// <param name="source">The <see cref="Rgba64"/>.</param>
-    /// <returns>The <see cref="Color"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Color(Rgba64 source) => new(source);
-
-    /// <summary>
-    /// Converts a <see cref="Color"/> to <see cref="Rgba64"/>.
-    /// </summary>
-    /// <param name="color">The <see cref="Color"/>.</param>
-    /// <returns>The <see cref="Rgba64"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static implicit operator Rgba64(Color color) => color.ToPixel<Rgba64>();
-
     /// <summary>
     /// Compares two <see cref="Rgba64"/> objects for equality.
     /// </summary>
@@ -208,7 +191,7 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(4, PixelComponentPrecision.UShort, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(PixelComponentInfo.Create<Rgba64>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba64> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index 064064f73..ce1c6d572 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -5,7 +5,6 @@ using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -98,7 +97,7 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(4, PixelComponentPrecision.Float, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(PixelComponentInfo.Create<RgbaVector>(4, 32, 32, 32, 32), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<RgbaVector> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 8af952b18..786c98ee4 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -66,7 +65,7 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(2, PixelComponentPrecision.Short, PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(PixelComponentInfo.Create<Short2>(2, 16, 16), PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Short2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index 4c60887df..890e66299 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.PixelFormats;
 
@@ -68,7 +67,7 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(4, PixelComponentPrecision.Short, PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(PixelComponentInfo.Create<Short4>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Short4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
index cf3707f9e..4d3f9e22d 100644
--- a/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelOperations{TPixel}.cs
@@ -5,7 +5,6 @@ using System.Buffers;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.PixelFormats;
diff --git a/src/ImageSharp/Formats/PixelTypeInfo.cs b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
similarity index 65%
rename from src/ImageSharp/Formats/PixelTypeInfo.cs
rename to src/ImageSharp/PixelFormats/PixelTypeInfo.cs
index 170ffcfae..e209b21e1 100644
--- a/src/ImageSharp/Formats/PixelTypeInfo.cs
+++ b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
@@ -2,12 +2,11 @@
 // Licensed under the Six Labors Split License.
 
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
 
 // TODO: Review this type as it's used to represent 2 different things.
 // 1.The encoded image pixel format.
 // 2. The pixel format of the decoded image.
-namespace SixLabors.ImageSharp.Formats;
+namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
 /// Contains information about the pixels that make up an images visual data.
@@ -23,15 +22,10 @@ public readonly struct PixelTypeInfo(int bitsPerPixel)
     /// </summary>
     public int BitsPerPixel { get; init; } = bitsPerPixel;
 
-    /// <summary>
-    /// Gets the count of the color components
-    /// </summary>
-    public int ComponentCount { get; init; }
-
     /// <summary>
     /// Gets the maximum precision of components within the pixel.
     /// </summary>
-    public PixelComponentPrecision? MaxComponentPrecision { get; init; }
+    public PixelComponentInfo? ComponentInfo { get; init; }
 
     /// <summary>
     /// Gets the pixel alpha transparency behavior.
@@ -39,16 +33,21 @@ public readonly struct PixelTypeInfo(int bitsPerPixel)
     /// </summary>
     public PixelAlphaRepresentation? AlphaRepresentation { get; init; }
 
-    internal static PixelTypeInfo Create<TPixel>(
-        byte componentCount,
-        PixelComponentPrecision componentPrecision,
-        PixelAlphaRepresentation pixelAlphaRepresentation)
+    /// <summary>
+    /// Creates a new <see cref="PixelTypeInfo"/> instance.
+    /// </summary>
+    /// <typeparam name="TPixel">The type of pixel format.</typeparam>
+    /// <param name="info">The pixel component info.</param>
+    /// <param name="alphaRepresentation">The pixel alpha representation.</param>
+    /// <returns>The <see cref="PixelComponentInfo"/>.</returns>
+    public static PixelTypeInfo Create<TPixel>(
+        PixelComponentInfo info,
+        PixelAlphaRepresentation alphaRepresentation)
         where TPixel : unmanaged, IPixel<TPixel>
         => new()
         {
             BitsPerPixel = Unsafe.SizeOf<TPixel>() * 8,
-            ComponentCount = componentCount,
-            MaxComponentPrecision = componentPrecision,
-            AlphaRepresentation = pixelAlphaRepresentation
+            ComponentInfo = info,
+            AlphaRepresentation = alphaRepresentation
         };
 }
diff --git a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
index 4a02642fd..c8a381d59 100644
--- a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters;
 internal class LomographProcessor<TPixel> : FilterProcessor<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private static readonly Color VeryDarkGreen = Color.FromRgba(0, 10, 0, 255);
+    private static readonly Color VeryDarkGreen = Color.FromPixel(new Rgba32(0, 10, 0, 255));
     private readonly LomographProcessor definition;
 
     /// <summary>
diff --git a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
index c1b79d10a..84c0364fa 100644
--- a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
@@ -12,8 +12,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters;
 internal class PolaroidProcessor<TPixel> : FilterProcessor<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private static readonly Color LightOrange = Color.FromRgba(255, 153, 102, 128);
-    private static readonly Color VeryDarkOrange = Color.FromRgb(102, 34, 0);
+    private static readonly Color LightOrange = Color.FromPixel(new Rgba32(255, 153, 102, 128));
+    private static readonly Color VeryDarkOrange = Color.FromPixel(new Rgb24(102, 34, 0));
     private readonly PolaroidProcessor definition;
 
     /// <summary>
diff --git a/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs b/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs
index a6aac20c3..5ba7809e1 100644
--- a/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs
+++ b/tests/ImageSharp.Benchmarks/General/GetSetPixel.cs
@@ -21,7 +21,7 @@ public class GetSetPixel
     public Rgba32 GetSetImageSharp()
     {
         using Image<Rgba32> image = new(400, 400);
-        image[200, 200] = Color.White;
+        image[200, 200] = Color.White.ToPixel<Rgba32>();
         return image[200, 200];
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs b/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs
index 58c23d2fe..82fce7dad 100644
--- a/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/BokehBlur.cs
@@ -13,7 +13,7 @@ public class BokehBlur
     [Benchmark]
     public void Blur()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.White);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.White.ToPixel<Rgba32>());
         image.Mutate(c => c.BokehBlur());
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs b/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs
index bf760aa2d..fae80fe84 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Diffuse.cs
@@ -13,7 +13,7 @@ public class Diffuse
     [Benchmark]
     public Size DoDiffuse()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Dither(KnownDitherings.FloydSteinberg));
 
         return image.Size;
@@ -22,7 +22,7 @@ public class Diffuse
     [Benchmark]
     public Size DoDither()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 800, 800, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Dither());
 
         return image.Size;
diff --git a/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs b/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs
index 160df21e6..462d83488 100644
--- a/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/GaussianBlur.cs
@@ -13,7 +13,7 @@ public class GaussianBlur
     [Benchmark]
     public void Blur()
     {
-        using var image = new Image<Rgba32>(Configuration.Default, 400, 400, Color.White);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.White.ToPixel<Rgba32>());
         image.Mutate(c => c.GaussianBlur());
     }
 }
diff --git a/tests/ImageSharp.Benchmarks/Processing/Rotate.cs b/tests/ImageSharp.Benchmarks/Processing/Rotate.cs
index 89d2966d7..b041a9d57 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Rotate.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Rotate.cs
@@ -13,7 +13,7 @@ public class Rotate
     [Benchmark]
     public Size DoRotate()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Rotate(37.5F));
 
         return image.Size;
diff --git a/tests/ImageSharp.Benchmarks/Processing/Skew.cs b/tests/ImageSharp.Benchmarks/Processing/Skew.cs
index baeff29a8..9f0103fa6 100644
--- a/tests/ImageSharp.Benchmarks/Processing/Skew.cs
+++ b/tests/ImageSharp.Benchmarks/Processing/Skew.cs
@@ -13,7 +13,7 @@ public class Skew
     [Benchmark]
     public Size DoSkew()
     {
-        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond);
+        using Image<Rgba32> image = new(Configuration.Default, 400, 400, Color.BlanchedAlmond.ToPixel<Rgba32>());
         image.Mutate(x => x.Skew(20, 10));
 
         return image.Size;
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs b/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs
index 4091e0cd4..2eb821b61 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.CastFrom.cs
@@ -12,10 +12,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba64()
         {
-            var source = new Rgba64(100, 2222, 3333, 4444);
+            Rgba64 source = new(100, 2222, 3333, 4444);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba64 data = color.ToPixel<Rgba64>();
@@ -25,10 +25,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba32()
         {
-            var source = new Rgba32(1, 22, 33, 231);
+            Rgba32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba32 data = color.ToPixel<Rgba32>();
@@ -38,10 +38,10 @@ public partial class ColorTests
         [Fact]
         public void Argb32()
         {
-            var source = new Argb32(1, 22, 33, 231);
+            Argb32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Argb32 data = color.ToPixel<Argb32>();
@@ -51,10 +51,10 @@ public partial class ColorTests
         [Fact]
         public void Bgra32()
         {
-            var source = new Bgra32(1, 22, 33, 231);
+            Bgra32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgra32 data = color.ToPixel<Bgra32>();
@@ -64,10 +64,10 @@ public partial class ColorTests
         [Fact]
         public void Abgr32()
         {
-            var source = new Abgr32(1, 22, 33, 231);
+            Abgr32 source = new(1, 22, 33, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Abgr32 data = color.ToPixel<Abgr32>();
@@ -77,10 +77,10 @@ public partial class ColorTests
         [Fact]
         public void Rgb24()
         {
-            var source = new Rgb24(1, 22,  231);
+            Rgb24 source = new(1, 22, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgb24 data = color.ToPixel<Rgb24>();
@@ -90,10 +90,10 @@ public partial class ColorTests
         [Fact]
         public void Bgr24()
         {
-            var source = new Bgr24(1, 22,  231);
+            Bgr24 source = new(1, 22, 231);
 
             // Act:
-            Color color = source;
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgr24 data = color.ToPixel<Bgr24>();
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs b/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
index dacec7144..14a5a44f1 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.CastTo.cs
@@ -16,10 +16,10 @@ public partial class ColorTests
             var source = new Rgba64(100, 2222, 3333, 4444);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Rgba64 data = color;
+            Rgba64 data = color.ToPixel<Rgba64>();
             Assert.Equal(source, data);
         }
 
@@ -29,10 +29,10 @@ public partial class ColorTests
             var source = new Rgba32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Rgba32 data = color;
+            Rgba32 data = color.ToPixel<Rgba32>();
             Assert.Equal(source, data);
         }
 
@@ -42,10 +42,10 @@ public partial class ColorTests
             var source = new Argb32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Argb32 data = color;
+            Argb32 data = color.ToPixel<Argb32>();
             Assert.Equal(source, data);
         }
 
@@ -55,10 +55,10 @@ public partial class ColorTests
             var source = new Bgra32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Bgra32 data = color;
+            Bgra32 data = color.ToPixel<Bgra32>();
             Assert.Equal(source, data);
         }
 
@@ -68,10 +68,10 @@ public partial class ColorTests
             var source = new Abgr32(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Abgr32 data = color;
+            Abgr32 data = color.ToPixel<Abgr32>();
             Assert.Equal(source, data);
         }
 
@@ -81,10 +81,10 @@ public partial class ColorTests
             var source = new Rgb24(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Rgb24 data = color;
+            Rgb24 data = color.ToPixel<Rgb24>();
             Assert.Equal(source, data);
         }
 
@@ -94,10 +94,10 @@ public partial class ColorTests
             var source = new Bgr24(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            var color = Color.FromPixel(source);
 
             // Assert:
-            Bgr24 data = color;
+            Bgr24 data = color.ToPixel<Bgr24>();
             Assert.Equal(source, data);
         }
 
@@ -105,7 +105,7 @@ public partial class ColorTests
         public void Vector4Constructor()
         {
             // Act:
-            Color color = new(Vector4.One);
+            Color color = (Color)Vector4.One;
 
             // Assert:
             Assert.Equal(new RgbaVector(1, 1, 1, 1), color.ToPixel<RgbaVector>());
@@ -117,7 +117,7 @@ public partial class ColorTests
         [Fact]
         public void GenericPixelRoundTrip()
         {
-            AssertGenericPixelRoundTrip(new RgbaVector(float.Epsilon, 2 * float.Epsilon, float.MaxValue, float.MinValue));
+            AssertGenericPixelRoundTrip(new RgbaVector(0.5f, 0.75f, 1, 0));
             AssertGenericPixelRoundTrip(new Rgba64(1, 2, ushort.MaxValue, ushort.MaxValue - 1));
             AssertGenericPixelRoundTrip(new Rgb48(1, 2, ushort.MaxValue - 1));
             AssertGenericPixelRoundTrip(new La32(1, ushort.MaxValue - 1));
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs b/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs
index 3ea8623d9..9126543e5 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.ConstructFrom.cs
@@ -12,10 +12,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba64()
         {
-            var source = new Rgba64(100, 2222, 3333, 4444);
+            Rgba64 source = new(100, 2222, 3333, 4444);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba64 data = color.ToPixel<Rgba64>();
@@ -25,10 +25,10 @@ public partial class ColorTests
         [Fact]
         public void Rgba32()
         {
-            var source = new Rgba32(1, 22, 33, 231);
+            Rgba32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgba32 data = color.ToPixel<Rgba32>();
@@ -38,10 +38,10 @@ public partial class ColorTests
         [Fact]
         public void Argb32()
         {
-            var source = new Argb32(1, 22, 33, 231);
+            Argb32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Argb32 data = color.ToPixel<Argb32>();
@@ -51,10 +51,10 @@ public partial class ColorTests
         [Fact]
         public void Bgra32()
         {
-            var source = new Bgra32(1, 22, 33, 231);
+            Bgra32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgra32 data = color.ToPixel<Bgra32>();
@@ -64,10 +64,10 @@ public partial class ColorTests
         [Fact]
         public void Abgr32()
         {
-            var source = new Abgr32(1, 22, 33, 231);
+            Abgr32 source = new(1, 22, 33, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Abgr32 data = color.ToPixel<Abgr32>();
@@ -77,10 +77,10 @@ public partial class ColorTests
         [Fact]
         public void Rgb24()
         {
-            var source = new Rgb24(1, 22,  231);
+            Rgb24 source = new(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Rgb24 data = color.ToPixel<Rgb24>();
@@ -90,10 +90,10 @@ public partial class ColorTests
         [Fact]
         public void Bgr24()
         {
-            var source = new Bgr24(1, 22,  231);
+            Bgr24 source = new(1, 22, 231);
 
             // Act:
-            var color = new Color(source);
+            Color color = Color.FromPixel(source);
 
             // Assert:
             Bgr24 data = color.ToPixel<Bgr24>();
diff --git a/tests/ImageSharp.Tests/Color/ColorTests.cs b/tests/ImageSharp.Tests/Color/ColorTests.cs
index f7e209217..d430df5b4 100644
--- a/tests/ImageSharp.Tests/Color/ColorTests.cs
+++ b/tests/ImageSharp.Tests/Color/ColorTests.cs
@@ -10,12 +10,12 @@ public partial class ColorTests
     [Fact]
     public void WithAlpha()
     {
-        var c1 = Color.FromRgba(111, 222, 55, 255);
+        Color c1 = Color.FromPixel(new Rgba32(111, 222, 55, 255));
         Color c2 = c1.WithAlpha(0.5f);
 
-        var expected = new Rgba32(111, 222, 55, 128);
+        Rgba32 expected = new(111, 222, 55, 128);
 
-        Assert.Equal(expected, (Rgba32)c2);
+        Assert.Equal(expected, c2.ToPixel<Rgba32>());
     }
 
     [Theory]
@@ -23,13 +23,13 @@ public partial class ColorTests
     [InlineData(true)]
     public void Equality_WhenTrue(bool highPrecision)
     {
-        Color c1 = new Rgba64(100, 2000, 3000, 40000);
-        Color c2 = new Rgba64(100, 2000, 3000, 40000);
+        Color c1 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40000));
+        Color c2 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40000));
 
         if (highPrecision)
         {
-            c1 = Color.FromPixel(c1.ToPixel<RgbaVector>());
-            c2 = Color.FromPixel(c2.ToPixel<RgbaVector>());
+            c1 = Color.FromPixel(c1.ToPixel<RgbaDouble>());
+            c2 = Color.FromPixel(c2.ToPixel<RgbaDouble>());
         }
 
         Assert.True(c1.Equals(c2));
@@ -43,15 +43,15 @@ public partial class ColorTests
     [InlineData(true)]
     public void Equality_WhenFalse(bool highPrecision)
     {
-        Color c1 = new Rgba64(100, 2000, 3000, 40000);
-        Color c2 = new Rgba64(101, 2000, 3000, 40000);
-        Color c3 = new Rgba64(100, 2000, 3000, 40001);
+        Color c1 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40000));
+        Color c2 = Color.FromPixel(new Rgba64(101, 2000, 3000, 40000));
+        Color c3 = Color.FromPixel(new Rgba64(100, 2000, 3000, 40001));
 
         if (highPrecision)
         {
-            c1 = Color.FromPixel(c1.ToPixel<RgbaVector>());
-            c2 = Color.FromPixel(c2.ToPixel<RgbaVector>());
-            c3 = Color.FromPixel(c3.ToPixel<RgbaVector>());
+            c1 = Color.FromPixel(c1.ToPixel<RgbaDouble>());
+            c2 = Color.FromPixel(c2.ToPixel<RgbaDouble>());
+            c3 = Color.FromPixel(c3.ToPixel<RgbaDouble>());
         }
 
         Assert.False(c1.Equals(c2));
@@ -74,7 +74,7 @@ public partial class ColorTests
 
         if (highPrecision)
         {
-            color = Color.FromPixel(color.ToPixel<RgbaVector>());
+            color = Color.FromPixel(color.ToPixel<RgbaDouble>());
         }
 
         string actual = color.ToHex();
@@ -84,22 +84,22 @@ public partial class ColorTests
     [Fact]
     public void WebSafePalette_IsCorrect()
     {
-        Rgba32[] actualPalette = Color.WebSafePalette.ToArray().Select(c => (Rgba32)c).ToArray();
+        Rgba32[] actualPalette = Color.WebSafePalette.ToArray().Select(c => c.ToPixel<Rgba32>()).ToArray();
 
         for (int i = 0; i < ReferencePalette.WebSafeColors.Length; i++)
         {
-            Assert.Equal((Rgba32)ReferencePalette.WebSafeColors[i], actualPalette[i]);
+            Assert.Equal(ReferencePalette.WebSafeColors[i].ToPixel<Rgba32>(), actualPalette[i]);
         }
     }
 
     [Fact]
     public void WernerPalette_IsCorrect()
     {
-        Rgba32[] actualPalette = Color.WernerPalette.ToArray().Select(c => (Rgba32)c).ToArray();
+        Rgba32[] actualPalette = Color.WernerPalette.ToArray().Select(c => c.ToPixel<Rgba32>()).ToArray();
 
         for (int i = 0; i < ReferencePalette.WernerColors.Length; i++)
         {
-            Assert.Equal((Rgba32)ReferencePalette.WernerColors[i], actualPalette[i]);
+            Assert.Equal(ReferencePalette.WernerColors[i].ToPixel<Rgba32>(), actualPalette[i]);
         }
     }
 
@@ -108,66 +108,48 @@ public partial class ColorTests
         [Fact]
         public void ShortHex()
         {
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)Color.ParseHex("#fff"));
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)Color.ParseHex("fff"));
-            Assert.Equal(new Rgba32(0, 0, 0, 255), (Rgba32)Color.ParseHex("000f"));
+            Assert.Equal(new Rgb24(255, 255, 255), Color.ParseHex("#fff").ToPixel<Rgb24>());
+            Assert.Equal(new Rgb24(255, 255, 255), Color.ParseHex("fff").ToPixel<Rgb24>());
+            Assert.Equal(new Rgba32(0, 0, 0, 255), Color.ParseHex("000f").ToPixel<Rgba32>());
         }
 
         [Fact]
         public void TryShortHex()
         {
             Assert.True(Color.TryParseHex("#fff", out Color actual));
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)actual);
+            Assert.Equal(new Rgb24(255, 255, 255), actual.ToPixel<Rgb24>());
 
             Assert.True(Color.TryParseHex("fff", out actual));
-            Assert.Equal(new Rgb24(255, 255, 255), (Rgb24)actual);
+            Assert.Equal(new Rgb24(255, 255, 255), actual.ToPixel<Rgb24>());
 
             Assert.True(Color.TryParseHex("000f", out actual));
-            Assert.Equal(new Rgba32(0, 0, 0, 255), (Rgba32)actual);
+            Assert.Equal(new Rgba32(0, 0, 0, 255), actual.ToPixel<Rgba32>());
         }
 
         [Fact]
         public void LeadingPoundIsOptional()
         {
-            Assert.Equal(new Rgb24(0, 128, 128), (Rgb24)Color.ParseHex("#008080"));
-            Assert.Equal(new Rgb24(0, 128, 128), (Rgb24)Color.ParseHex("008080"));
+            Assert.Equal(new Rgb24(0, 128, 128), Color.ParseHex("#008080").ToPixel<Rgb24>());
+            Assert.Equal(new Rgb24(0, 128, 128), Color.ParseHex("008080").ToPixel<Rgb24>());
         }
 
         [Fact]
-        public void ThrowsOnEmpty()
-        {
-            Assert.Throws<ArgumentException>(() => Color.ParseHex(string.Empty));
-        }
+        public void ThrowsOnEmpty() => Assert.Throws<ArgumentException>(() => Color.ParseHex(string.Empty));
 
         [Fact]
-        public void ThrowsOnInvalid()
-        {
-            Assert.Throws<ArgumentException>(() => Color.ParseHex("!"));
-        }
+        public void ThrowsOnInvalid() => Assert.Throws<ArgumentException>(() => Color.ParseHex("!"));
 
         [Fact]
-        public void ThrowsOnNull()
-        {
-            Assert.Throws<ArgumentNullException>(() => Color.ParseHex(null));
-        }
+        public void ThrowsOnNull() => Assert.Throws<ArgumentNullException>(() => Color.ParseHex(null));
 
         [Fact]
-        public void FalseOnEmpty()
-        {
-            Assert.False(Color.TryParseHex(string.Empty, out Color _));
-        }
+        public void FalseOnEmpty() => Assert.False(Color.TryParseHex(string.Empty, out Color _));
 
         [Fact]
-        public void FalseOnInvalid()
-        {
-            Assert.False(Color.TryParseHex("!", out Color _));
-        }
+        public void FalseOnInvalid() => Assert.False(Color.TryParseHex("!", out Color _));
 
         [Fact]
-        public void FalseOnNull()
-        {
-            Assert.False(Color.TryParseHex(null, out Color _));
-        }
+        public void FalseOnNull() => Assert.False(Color.TryParseHex(null, out Color _));
     }
 
     public class FromString
@@ -177,10 +159,10 @@ public partial class ColorTests
         {
             foreach (string name in ReferencePalette.ColorNames.Keys)
             {
-                Rgba32 expected = ReferencePalette.ColorNames[name];
-                Assert.Equal(expected, (Rgba32)Color.Parse(name));
-                Assert.Equal(expected, (Rgba32)Color.Parse(name.ToLowerInvariant()));
-                Assert.Equal(expected, (Rgba32)Color.Parse(expected.ToHex()));
+                Rgba32 expected = ReferencePalette.ColorNames[name].ToPixel<Rgba32>();
+                Assert.Equal(expected, Color.Parse(name).ToPixel<Rgba32>());
+                Assert.Equal(expected, Color.Parse(name.ToLowerInvariant()).ToPixel<Rgba32>());
+                Assert.Equal(expected, Color.Parse(expected.ToHex()).ToPixel<Rgba32>());
             }
         }
 
@@ -189,53 +171,35 @@ public partial class ColorTests
         {
             foreach (string name in ReferencePalette.ColorNames.Keys)
             {
-                Rgba32 expected = ReferencePalette.ColorNames[name];
+                Rgba32 expected = ReferencePalette.ColorNames[name].ToPixel<Rgba32>();
 
                 Assert.True(Color.TryParse(name, out Color actual));
-                Assert.Equal(expected, (Rgba32)actual);
+                Assert.Equal(expected, actual.ToPixel<Rgba32>());
 
                 Assert.True(Color.TryParse(name.ToLowerInvariant(), out actual));
-                Assert.Equal(expected, (Rgba32)actual);
+                Assert.Equal(expected, actual.ToPixel<Rgba32>());
 
                 Assert.True(Color.TryParse(expected.ToHex(), out actual));
-                Assert.Equal(expected, (Rgba32)actual);
+                Assert.Equal(expected, actual.ToPixel<Rgba32>());
             }
         }
 
         [Fact]
-        public void ThrowsOnEmpty()
-        {
-            Assert.Throws<ArgumentException>(() => Color.Parse(string.Empty));
-        }
+        public void ThrowsOnEmpty() => Assert.Throws<ArgumentException>(() => Color.Parse(string.Empty));
 
         [Fact]
-        public void ThrowsOnInvalid()
-        {
-            Assert.Throws<ArgumentException>(() => Color.Parse("!"));
-        }
+        public void ThrowsOnInvalid() => Assert.Throws<ArgumentException>(() => Color.Parse("!"));
 
         [Fact]
-        public void ThrowsOnNull()
-        {
-            Assert.Throws<ArgumentNullException>(() => Color.Parse(null));
-        }
+        public void ThrowsOnNull() => Assert.Throws<ArgumentNullException>(() => Color.Parse(null));
 
         [Fact]
-        public void FalseOnEmpty()
-        {
-            Assert.False(Color.TryParse(string.Empty, out Color _));
-        }
+        public void FalseOnEmpty() => Assert.False(Color.TryParse(string.Empty, out Color _));
 
         [Fact]
-        public void FalseOnInvalid()
-        {
-            Assert.False(Color.TryParse("!", out Color _));
-        }
+        public void FalseOnInvalid() => Assert.False(Color.TryParse("!", out Color _));
 
         [Fact]
-        public void FalseOnNull()
-        {
-            Assert.False(Color.TryParse(null, out Color _));
-        }
+        public void FalseOnNull() => Assert.False(Color.TryParse(null, out Color _));
     }
 }
diff --git a/tests/ImageSharp.Tests/Color/RgbaDouble.cs b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
new file mode 100644
index 000000000..476ff0336
--- /dev/null
+++ b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
@@ -0,0 +1,180 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Tests;
+
+/// <summary>
+/// Unpacked pixel type containing four 64-bit floating-point values typically ranging from 0 to 1.
+/// The color components are stored in red, green, blue, and alpha order.
+/// <para>
+/// Ranges from [0, 0, 0, 0] to [1, 1, 1, 1] in vector form.
+/// </para>
+/// </summary>
+/// <remarks>
+/// This struct is fully mutable. This is done (against the guidelines) for the sake of performance,
+/// as it avoids the need to create new values for modification operations.
+/// </remarks>
+/// <remarks>
+/// Initializes a new instance of the <see cref="RgbaDouble"/> struct.
+/// </remarks>
+/// <param name="r">The red component.</param>
+/// <param name="g">The green component.</param>
+/// <param name="b">The blue component.</param>
+/// <param name="a">The alpha component.</param>
+[StructLayout(LayoutKind.Sequential)]
+[method: MethodImpl(InliningOptions.ShortMethod)]
+public partial struct RgbaDouble(double r, double g, double b, double a = 1) : IPixel<RgbaDouble>
+{
+    /// <summary>
+    /// Gets or sets the red component.
+    /// </summary>
+    public double R = r;
+
+    /// <summary>
+    /// Gets or sets the green component.
+    /// </summary>
+    public double G = g;
+
+    /// <summary>
+    /// Gets or sets the blue component.
+    /// </summary>
+    public double B = b;
+
+    /// <summary>
+    /// Gets or sets the alpha component.
+    /// </summary>
+    public double A = a;
+
+    private const float MaxBytes = byte.MaxValue;
+    private static readonly Vector4 Max = new(MaxBytes);
+    private static readonly Vector4 Half = new(0.5F);
+
+    /// <summary>
+    /// Compares two <see cref="RgbaDouble"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="RgbaDouble"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="RgbaDouble"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator ==(RgbaDouble left, RgbaDouble right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="RgbaDouble"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="RgbaDouble"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="RgbaDouble"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator !=(RgbaDouble left, RgbaDouble right) => !left.Equals(right);
+
+    /// <inheritdoc />
+    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaDouble>(PixelComponentInfo.Create<RgbaDouble>(4, 64, 64, 64, 64), PixelAlphaRepresentation.Unassociated);
+
+    /// <inheritdoc />
+    public readonly PixelOperations<RgbaDouble> CreatePixelOperations() => new();
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromScaledVector4(Vector4 vector) => this.FromVector4(vector);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly Vector4 ToScaledVector4() => this.ToVector4();
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromVector4(Vector4 vector)
+    {
+        vector = Numerics.Clamp(vector, Vector4.Zero, Vector4.One);
+        this.R = vector.X;
+        this.G = vector.Y;
+        this.B = vector.Z;
+        this.A = vector.W;
+    }
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly Vector4 ToVector4() => new((float)this.R, (float)this.G, (float)this.B, (float)this.A);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromBgr24(Bgr24 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromBgra32(Bgra32 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromAbgr32(Abgr32 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromBgra5551(Bgra5551 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromL8(L8 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromL16(L16 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromLa16(La16 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromLa32(La32 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromRgb24(Rgb24 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromRgba32(Rgba32 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void ToRgba32(ref Rgba32 dest) => dest.FromScaledVector4(this.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromRgb48(Rgb48 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void FromRgba64(Rgba64 source) => this.FromScaledVector4(source.ToScaledVector4());
+
+    /// <inheritdoc/>
+    public override readonly bool Equals(object obj) => obj is RgbaDouble other && this.Equals(other);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public readonly bool Equals(RgbaDouble other) =>
+        this.R.Equals(other.R)
+        && this.G.Equals(other.G)
+        && this.B.Equals(other.B)
+        && this.A.Equals(other.A);
+
+    /// <inheritdoc/>
+    public override readonly string ToString() => FormattableString.Invariant($"RgbaDouble({this.R:#0.##}, {this.G:#0.##}, {this.B:#0.##}, {this.A:#0.##})");
+
+    /// <inheritdoc/>
+    public override readonly int GetHashCode() => HashCode.Combine(this.R, this.G, this.B, this.A);
+}
diff --git a/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs b/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
index 533f0c6de..88f4cde7a 100644
--- a/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
+++ b/tests/ImageSharp.Tests/Drawing/DrawImageTests.cs
@@ -119,7 +119,7 @@ public class DrawImageTests
     public void WorksWithDifferentLocations(TestImageProvider<Rgba32> provider, int x, int y)
     {
         using Image<Rgba32> background = provider.GetImage();
-        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToRgba32());
+        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToPixel<Rgba32>());
 
         background.Mutate(c => c.DrawImage(overlay, new Point(x, y), PixelColorBlendingMode.Normal, 1F));
 
@@ -144,7 +144,7 @@ public class DrawImageTests
     public void WorksWithDifferentBounds(TestImageProvider<Rgba32> provider, int width, int height)
     {
         using Image<Rgba32> background = provider.GetImage();
-        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToRgba32());
+        using Image<Rgba32> overlay = new(50, 50, Color.Black.ToPixel<Rgba32>());
 
         background.Mutate(c => c.DrawImage(overlay, new Rectangle(0, 0, width, height), PixelColorBlendingMode.Normal, 1F));
 
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
index bc277bf48..800b1fb4b 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
@@ -581,7 +581,7 @@ public partial class PngDecoderTests
         using Image<TPixel> image = provider.GetImage(PngDecoder.Instance);
         PngMetadata metadata = image.Metadata.GetPngMetadata();
         Assert.NotNull(metadata.ColorTable);
-        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToRgba32().A < 255);
+        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToPixel<Rgba32>().A < 255);
     }
 
     // https://github.com/SixLabors/ImageSharp/issues/2209
@@ -594,7 +594,7 @@ public partial class PngDecoderTests
         ImageInfo imageInfo = Image.Identify(stream);
         PngMetadata metadata = imageInfo.Metadata.GetPngMetadata();
         Assert.NotNull(metadata.ColorTable);
-        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToRgba32().A < 255);
+        Assert.Contains(metadata.ColorTable.Value.ToArray(), x => x.ToPixel<Rgba32>().A < 255);
     }
 
     // https://github.com/SixLabors/ImageSharp/issues/410
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
index e70854b08..477d88e9a 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
@@ -391,7 +391,7 @@ public partial class PngEncoderTests
             TransparentColorMode = PngTransparentColorMode.Clear,
             ColorType = colorType
         };
-        Rgba32 rgba32 = Color.Blue;
+        Rgba32 rgba32 = Color.Blue.ToPixel<Rgba32>();
         image.ProcessPixelRows(accessor =>
         {
             for (int y = 0; y < image.Height; y++)
@@ -418,7 +418,7 @@ public partial class PngEncoderTests
         // assert
         memStream.Position = 0;
         using Image<Rgba32> actual = Image.Load<Rgba32>(memStream);
-        Rgba32 expectedColor = Color.Blue;
+        Rgba32 expectedColor = Color.Blue.ToPixel<Rgba32>();
         if (colorType is PngColorType.Grayscale or PngColorType.GrayscaleWithAlpha)
         {
             byte luminance = ColorNumerics.Get8BitBT709Luminance(expectedColor.R, expectedColor.G, expectedColor.B);
@@ -427,13 +427,14 @@ public partial class PngEncoderTests
 
         actual.ProcessPixelRows(accessor =>
         {
+            Rgba32 transparent = Color.Transparent.ToPixel<Rgba32>();
             for (int y = 0; y < accessor.Height; y++)
             {
                 Span<Rgba32> rowSpan = accessor.GetRowSpan(y);
 
                 if (y > 25)
                 {
-                    expectedColor = Color.Transparent;
+                    expectedColor = transparent;
                 }
 
                 for (int x = 0; x < accessor.Width; x++)
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
index b17440383..3582dc75a 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/PhotometricInterpretation/PhotometricInterpretationTestBase.cs
@@ -47,7 +47,7 @@ public abstract class PhotometricInterpretationTestBase
 
         using (var image = new Image<Rgba32>(resultWidth, resultHeight))
         {
-            image.Mutate(x => x.BackgroundColor(DefaultColor));
+            image.Mutate(x => x.BackgroundColor(Color.FromPixel(DefaultColor)));
             Buffer2D<Rgba32> pixels = image.GetRootFramePixelBuffer();
 
             decodeAction(pixels);
diff --git a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
index b74093fcc..dce6ebc38 100644
--- a/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderMultiframeTests.cs
@@ -70,9 +70,9 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
         using Image<TPixel> image = provider.GetImage();
         Assert.Equal(1, image.Frames.Count);
 
-        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToRgba32());
+        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
 
-        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToRgba32());
+        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
 
         image.Frames.AddFrame(image1.Frames.RootFrame);
         image.Frames.AddFrame(image2.Frames.RootFrame);
@@ -97,8 +97,8 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
             ImageFrame<Rgba32> frame1 = output.Frames[1];
             ImageFrame<Rgba32> frame2 = output.Frames[2];
 
-            Assert.Equal(Color.Green.ToRgba32(), frame1[10, 10]);
-            Assert.Equal(Color.Yellow.ToRgba32(), frame2[10, 10]);
+            Assert.Equal(Color.Green.ToPixel<Rgba32>(), frame1[10, 10]);
+            Assert.Equal(Color.Yellow.ToPixel<Rgba32>(), frame2[10, 10]);
 
             Assert.Equal(TiffCompression.Deflate, frame1.Metadata.GetTiffMetadata().Compression);
             Assert.Equal(TiffCompression.Deflate, frame1.Metadata.GetTiffMetadata().Compression);
@@ -122,11 +122,11 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
     {
         using Image<TPixel> image = provider.GetImage();
 
-        using var image0 = new Image<Rgba32>(image.Width, image.Height, Color.Red.ToRgba32());
+        using var image0 = new Image<Rgba32>(image.Width, image.Height, Color.Red.ToPixel<Rgba32>());
 
-        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToRgba32());
+        using var image1 = new Image<Rgba32>(image.Width, image.Height, Color.Green.ToPixel<Rgba32>());
 
-        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToRgba32());
+        using var image2 = new Image<Rgba32>(image.Width, image.Height, Color.Yellow.ToPixel<Rgba32>());
 
         image.Frames.AddFrame(image0.Frames.RootFrame);
         image.Frames.AddFrame(image1.Frames.RootFrame);
@@ -154,9 +154,9 @@ public class TiffEncoderMultiframeTests : TiffEncoderBaseTester
             ImageFrame<Rgba32> frame1 = output.Frames[1];
             ImageFrame<Rgba32> frame2 = output.Frames[2];
 
-            Assert.Equal(Color.Red.ToRgba32(), frame0[10, 10]);
-            Assert.Equal(Color.Green.ToRgba32(), frame1[10, 10]);
-            Assert.Equal(Color.Yellow.ToRgba32(), frame2[10, 10]);
+            Assert.Equal(Color.Red.ToPixel<Rgba32>(), frame0[10, 10]);
+            Assert.Equal(Color.Green.ToPixel<Rgba32>(), frame1[10, 10]);
+            Assert.Equal(Color.Yellow.ToPixel<Rgba32>(), frame2[10, 10]);
 
             Assert.Equal(TiffCompression.Lzw, frame0.Metadata.GetTiffMetadata().Compression);
             Assert.Equal(TiffCompression.Lzw, frame1.Metadata.GetTiffMetadata().Compression);
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
index 62d1ef4db..71c9e07fc 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.Generic.cs
@@ -237,7 +237,7 @@ public abstract partial class ImageFrameCollectionTests
             using (this.Image.Frames.CreateFrame(Color.HotPink))
             {
                 Assert.Equal(2, this.Image.Frames.Count);
-                this.Image.Frames[1].ComparePixelBufferTo(Color.HotPink);
+                this.Image.Frames[1].ComparePixelBufferTo(Color.HotPink.ToPixel<Rgba32>());
             }
         }
 
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
index f9ff6ba69..a42dcc481 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameCollectionTests.NonGeneric.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -23,13 +22,13 @@ public abstract partial class ImageFrameCollectionTests
                 this.Image.Configuration,
                 this.Image.Width,
                 this.Image.Height,
-                Color.Blue))
+                Color.Blue.ToPixel<Bgra32>()))
             {
                 this.Collection.AddFrame(sourceImage.Frames.RootFrame);
             }
 
             Rgba32[] expectedAllBlue =
-                Enumerable.Repeat((Rgba32)Color.Blue, this.Image.Width * this.Image.Height).ToArray();
+                Enumerable.Repeat(Color.Blue.ToPixel<Rgba32>(), this.Image.Width * this.Image.Height).ToArray();
 
             Assert.Equal(2, this.Collection.Count);
             ImageFrame<Rgba32> actualFrame = (ImageFrame<Rgba32>)this.Collection[1];
@@ -44,13 +43,13 @@ public abstract partial class ImageFrameCollectionTests
                 this.Image.Configuration,
                 this.Image.Width,
                 this.Image.Height,
-                Color.Blue))
+                Color.Blue.ToPixel<Bgra32>()))
             {
                 this.Collection.InsertFrame(0, sourceImage.Frames.RootFrame);
             }
 
             Rgba32[] expectedAllBlue =
-                Enumerable.Repeat((Rgba32)Color.Blue, this.Image.Width * this.Image.Height).ToArray();
+                Enumerable.Repeat(Color.Blue.ToPixel<Rgba32>(), this.Image.Width * this.Image.Height).ToArray();
 
             Assert.Equal(2, this.Collection.Count);
             ImageFrame<Rgba32> actualFrame = (ImageFrame<Rgba32>)this.Collection[0];
@@ -177,7 +176,7 @@ public abstract partial class ImageFrameCollectionTests
 
             ImageFrame<Rgba32> frame = (ImageFrame<Rgba32>)this.Image.Frames[1];
 
-            frame.ComparePixelBufferTo(Color.HotPink);
+            frame.ComparePixelBufferTo(Color.HotPink.ToPixel<Rgba32>());
         }
 
         [Fact]
@@ -279,7 +278,7 @@ public abstract partial class ImageFrameCollectionTests
         {
             using Image source = provider.GetImage();
             using Image<TPixel> dest = new(source.Configuration, source.Width, source.Height);
-            
+
             // Giphy.gif has 5 frames
             ImportFrameAs<Bgra32>(source.Frames, dest.Frames, 0);
             ImportFrameAs<Argb32>(source.Frames, dest.Frames, 1);
diff --git a/tests/ImageSharp.Tests/Image/ImageFrameTests.cs b/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
index 3b9779ea4..e09ef487a 100644
--- a/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageFrameTests.cs
@@ -35,9 +35,9 @@ public class ImageFrameTests
             ImageFrame<Rgba32> frame = image.Frames.RootFrame;
             Rgba32 val = frame[3, 4];
             Assert.Equal(default(Rgba32), val);
-            frame[3, 4] = Color.Red;
+            frame[3, 4] = Color.Red.ToPixel<Rgba32>();
             val = frame[3, 4];
-            Assert.Equal(Color.Red.ToRgba32(), val);
+            Assert.Equal(Color.Red.ToPixel<Rgba32>(), val);
         }
 
         public static TheoryData<bool, int> OutOfRangeData = new TheoryData<bool, int>()
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs b/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
index 238096be4..5762264d2 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.LoadPixelData.cs
@@ -15,19 +15,17 @@ public partial class ImageTests
         [ValidateDisposedMemoryAllocations]
         public void FromPixels(bool useSpan)
         {
-            Rgba32[] data = { Color.Black, Color.White, Color.White, Color.Black, };
+            Rgba32[] data = { Color.Black.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.White.ToPixel<Rgba32>(), Color.Black.ToPixel<Rgba32>(), };
 
-            using (Image<Rgba32> img = useSpan
-                                           ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
-                                           : Image.LoadPixelData<Rgba32>(data, 2, 2))
-            {
-                Assert.NotNull(img);
-                Assert.Equal(Color.Black, (Color)img[0, 0]);
-                Assert.Equal(Color.White, (Color)img[0, 1]);
+            using Image<Rgba32> img = useSpan
+                ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
+                : Image.LoadPixelData<Rgba32>(data, 2, 2);
+            Assert.NotNull(img);
+            Assert.Equal(Color.Black, Color.FromPixel(img[0, 0]));
+            Assert.Equal(Color.White, Color.FromPixel(img[0, 1]));
 
-                Assert.Equal(Color.White, (Color)img[1, 0]);
-                Assert.Equal(Color.Black, (Color)img[1, 1]);
-            }
+            Assert.Equal(Color.White, Color.FromPixel(img[1, 0]));
+            Assert.Equal(Color.Black, Color.FromPixel(img[1, 1]));
         }
 
         [Theory]
@@ -36,23 +34,22 @@ public partial class ImageTests
         public void FromBytes(bool useSpan)
         {
             byte[] data =
-                {
-                    0, 0, 0, 255, // 0,0
-                    255, 255, 255, 255, // 0,1
-                    255, 255, 255, 255, // 1,0
-                    0, 0, 0, 255, // 1,1
-                };
-            using (Image<Rgba32> img = useSpan
-                                           ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
-                                           : Image.LoadPixelData<Rgba32>(data, 2, 2))
             {
-                Assert.NotNull(img);
-                Assert.Equal(Color.Black, (Color)img[0, 0]);
-                Assert.Equal(Color.White, (Color)img[0, 1]);
+                0, 0, 0, 255, // 0,0
+                255, 255, 255, 255, // 0,1
+                255, 255, 255, 255, // 1,0
+                0, 0, 0, 255, // 1,1
+            };
+
+            using Image<Rgba32> img = useSpan
+                ? Image.LoadPixelData<Rgba32>(data.AsSpan(), 2, 2)
+                : Image.LoadPixelData<Rgba32>(data, 2, 2);
+            Assert.NotNull(img);
+            Assert.Equal(Color.Black, Color.FromPixel(img[0, 0]));
+            Assert.Equal(Color.White, Color.FromPixel(img[0, 1]));
 
-                Assert.Equal(Color.White, (Color)img[1, 0]);
-                Assert.Equal(Color.Black, (Color)img[1, 1]);
-            }
+            Assert.Equal(Color.White, Color.FromPixel(img[1, 0]));
+            Assert.Equal(Color.Black, Color.FromPixel(img[1, 1]));
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
index 9aaefa41e..f22a55aae 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.WrapMemory.cs
@@ -154,8 +154,8 @@ public partial class ImageTests
                 using (var memoryManager = new BitmapMemoryManager(bmp))
                 {
                     Memory<Bgra32> memory = memoryManager.Memory;
-                    Bgra32 bg = Color.Red;
-                    Bgra32 fg = Color.Green;
+                    Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                    Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                     using (var image = Image.WrapMemory(memory, bmp.Width, bmp.Height))
                     {
@@ -198,8 +198,8 @@ public partial class ImageTests
             using (var bmp = new Bitmap(51, 23))
             {
                 var memoryManager = new BitmapMemoryManager(bmp);
-                Bgra32 bg = Color.Red;
-                Bgra32 fg = Color.Green;
+                Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                 using (var image = Image.WrapMemory(memoryManager, bmp.Width, bmp.Height))
                 {
@@ -258,8 +258,8 @@ public partial class ImageTests
                 {
                     Memory<Bgra32> pixelMemory = memoryManager.Memory;
                     Memory<byte> byteMemory = new CastMemoryManager<Bgra32, byte>(pixelMemory).Memory;
-                    Bgra32 bg = Color.Red;
-                    Bgra32 fg = Color.Green;
+                    Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                    Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                     using (var image = Image.WrapMemory<Bgra32>(byteMemory, bmp.Width, bmp.Height))
                     {
@@ -355,8 +355,8 @@ public partial class ImageTests
                 using (var memoryManager = new BitmapMemoryManager(bmp))
                 {
                     Memory<Bgra32> pixelMemory = memoryManager.Memory;
-                    Bgra32 bg = Color.Red;
-                    Bgra32 fg = Color.Green;
+                    Bgra32 bg = Color.Red.ToPixel<Bgra32>();
+                    Bgra32 fg = Color.Green.ToPixel<Bgra32>();
 
                     fixed (void* p = pixelMemory.Span)
                     {
diff --git a/tests/ImageSharp.Tests/Image/ImageTests.cs b/tests/ImageSharp.Tests/Image/ImageTests.cs
index ca51f7f5c..ac91ea948 100644
--- a/tests/ImageSharp.Tests/Image/ImageTests.cs
+++ b/tests/ImageSharp.Tests/Image/ImageTests.cs
@@ -61,7 +61,7 @@ public partial class ImageTests
         public void Configuration_Width_Height_BackgroundColor()
         {
             Configuration configuration = Configuration.Default.Clone();
-            Rgba32 color = Color.Aquamarine;
+            Rgba32 color = Color.Aquamarine.ToPixel<Rgba32>();
 
             using (Image<Rgba32> image = new(configuration, 11, 23, color))
             {
@@ -116,9 +116,9 @@ public partial class ImageTests
             using Image<Rgba32> image = new(this.configuration, 10, 10);
             Rgba32 val = image[3, 4];
             Assert.Equal(default(Rgba32), val);
-            image[3, 4] = Color.Red;
+            image[3, 4] = Color.Red.ToPixel<Rgba32>();
             val = image[3, 4];
-            Assert.Equal(Color.Red.ToRgba32(), val);
+            Assert.Equal(Color.Red.ToPixel<Rgba32>(), val);
         }
 
         public static TheoryData<bool, int> OutOfRangeData = new()
diff --git a/tests/ImageSharp.Tests/ImageInfoTests.cs b/tests/ImageSharp.Tests/ImageInfoTests.cs
index 73324eccd..576d14396 100644
--- a/tests/ImageSharp.Tests/ImageInfoTests.cs
+++ b/tests/ImageSharp.Tests/ImageInfoTests.cs
@@ -1,8 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests;
 
diff --git a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
index 518aa203d..ef99db498 100644
--- a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -116,8 +115,12 @@ public class A8Tests
     {
         PixelTypeInfo info = A8.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<A8>() * 8, info.BitsPerPixel);
-        Assert.Equal(1, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(1, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
index dbe02e986..de6f519e1 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -151,8 +150,15 @@ public class Abgr32Tests
     {
         PixelTypeInfo info = Abgr32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Abgr32>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
index fd8ee144b..29349b852 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -149,8 +148,15 @@ public class Argb32Tests
     {
         PixelTypeInfo info = Argb32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Argb32>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
index 78c58e5c2..519aeb6c5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -134,8 +133,14 @@ public class Bgr24Tests
     {
         PixelTypeInfo info = Bgr24.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgr24>() * 8, info.BitsPerPixel);
-        Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
index 68f953225..16e225a9b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -256,8 +255,14 @@ public class Bgr565Tests
     {
         PixelTypeInfo info = Bgr565.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgr565>() * 8, info.BitsPerPixel);
-        Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(5, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(6, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(5, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(6, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
index e92fcf1d3..c5b4325c9 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -151,8 +150,15 @@ public class Bgra32Tests
     {
         PixelTypeInfo info = Bgra32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgra32>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
index 1af84c0c8..f2e9a2291 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -252,8 +251,15 @@ public class Bgra4444Tests
     {
         PixelTypeInfo info = Bgra4444.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgra4444>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(4, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(4, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(4, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(4, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(4, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
index a0926d4dd..03b4a41c6 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -278,8 +277,15 @@ public class Bgra5551Tests
     {
         PixelTypeInfo info = Bgra5551.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgra5551>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(5, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(5, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(5, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(1, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(5, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
index 5b456459e..1434d7d93 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using SixLabors.ImageSharp.Formats;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -245,8 +244,15 @@ public class Byte4Tests
     {
         PixelTypeInfo info = Byte4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Byte4>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
index 9c546e2f0..dbd1f6917 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -74,8 +73,12 @@ public class HalfSingleTests
     {
         PixelTypeInfo info = HalfSingle.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<HalfSingle>() * 8, info.BitsPerPixel);
-        Assert.Equal(1, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Half, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(1, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
index 4f84d6087..710135ed6 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using SixLabors.ImageSharp.Formats;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -96,8 +95,13 @@ public class HalfVector2Tests
     {
         PixelTypeInfo info = HalfVector2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<HalfVector2>() * 8, info.BitsPerPixel);
-        Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Half, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
index 33f0173d2..3e3f6a2ca 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -87,8 +86,15 @@ public class HalfVector4Tests
     {
         PixelTypeInfo info = HalfVector4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<HalfVector4>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Half, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
index 0c0cdbe3b..3a8239923 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -166,8 +165,12 @@ public class L16Tests
     {
         PixelTypeInfo info = L16.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<L16>() * 8, info.BitsPerPixel);
-        Assert.Equal(1, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(1, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
index d8bce0640..631a0e234 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
@@ -261,9 +260,13 @@ public class L8Tests
         {
             PixelTypeInfo info = L8.GetPixelTypeInfo();
             Assert.Equal(Unsafe.SizeOf<L8>() * 8, info.BitsPerPixel);
-            Assert.Equal(1, info.ComponentCount);
             Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-            Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+            PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+            Assert.Equal(1, componentInfo.ComponentCount);
+            Assert.Equal(0, componentInfo.Padding);
+            Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+            Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
index 46e7457a5..9fa0e3263 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable InconsistentNaming
@@ -265,9 +264,14 @@ public class La16Tests
         {
             PixelTypeInfo info = La16.GetPixelTypeInfo();
             Assert.Equal(Unsafe.SizeOf<La16>() * 8, info.BitsPerPixel);
-            Assert.Equal(2, info.ComponentCount);
             Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-            Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+            PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+            Assert.Equal(2, componentInfo.ComponentCount);
+            Assert.Equal(0, componentInfo.Padding);
+            Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+            Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+            Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
index 65aa8b1c9..089c2076b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -172,8 +171,13 @@ public class La32Tests
     {
         PixelTypeInfo info = La32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<La32>() * 8, info.BitsPerPixel);
-        Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
index 999ddb934..9f24346a0 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using SixLabors.ImageSharp.Formats;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -88,8 +87,13 @@ public class NormalizedByte2Tests
     {
         PixelTypeInfo info = NormalizedByte2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedByte2>() * 8, info.BitsPerPixel);
-        Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.SByte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
index 64a996453..63bb9d5f5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -238,8 +237,15 @@ public class NormalizedByte4Tests
     {
         PixelTypeInfo info = NormalizedByte4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedByte4>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.SByte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
index e6d4ae98d..f262ce177 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -92,8 +91,13 @@ public class NormalizedShort2Tests
     {
         PixelTypeInfo info = NormalizedShort2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedShort2>() * 8, info.BitsPerPixel);
-        Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
index cd684311a..05058ae4d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using SixLabors.ImageSharp.Formats;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -239,8 +238,15 @@ public class NormalizedShort4Tests
     {
         PixelTypeInfo info = NormalizedShort4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedShort4>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
index 68cdf2d63..924e94d92 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
@@ -43,15 +43,15 @@ public class PixelBlenderTests
 
     public static TheoryData<Rgba32, Rgba32, float, PixelColorBlendingMode, Rgba32> ColorBlendingExpectedResults = new()
     {
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Normal, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Screen, new Rgba32(0xFFEEE7FF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.HardLight, new Rgba32(0xFFC62D32) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Overlay, new Rgba32(0xFFDDCEFF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Darken, new Rgba32(0xFF701919) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Lighten, new Rgba32(0xFFE1E4FF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Add, new Rgba32(0xFFFFFDFF) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Subtract, new Rgba32(0xFF71CBE6) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelColorBlendingMode.Multiply, new Rgba32(0xFF631619) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Normal, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Screen, new Rgba32(0xFFEEE7FF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.HardLight, new Rgba32(0xFFC62D32) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Overlay, new Rgba32(0xFFDDCEFF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Darken, new Rgba32(0xFF701919) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Lighten, new Rgba32(0xFFE1E4FF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Add, new Rgba32(0xFFFFFDFF) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Subtract, new Rgba32(0xFF71CBE6) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelColorBlendingMode.Multiply, new Rgba32(0xFF631619) },
     };
 
     [Theory]
@@ -67,18 +67,18 @@ public class PixelBlenderTests
 
     public static TheoryData<Rgba32, Rgba32, float, PixelAlphaCompositionMode, Rgba32> AlphaCompositionExpectedResults = new()
     {
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Clear, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Xor, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Dest, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestAtop, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestIn, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestOut, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.DestOver, Color.MistyRose },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.Src, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcAtop, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcIn, Color.MidnightBlue },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcOut, new Rgba32(0) },
-        { Color.MistyRose, Color.MidnightBlue, 1, PixelAlphaCompositionMode.SrcOver, Color.MidnightBlue },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Clear, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Xor, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Dest, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestAtop, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestIn, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestOut, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.DestOver, Color.MistyRose.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.Src, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcAtop, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcIn, Color.MidnightBlue.ToPixel<Rgba32>() },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcOut, new Rgba32(0) },
+        { Color.MistyRose.ToPixel<Rgba32>(), Color.MidnightBlue.ToPixel<Rgba32>(), 1, PixelAlphaCompositionMode.SrcOver, Color.MidnightBlue.ToPixel<Rgba32>() },
     };
 
     [Theory]
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
index bf3ff6416..9ab1ec963 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
@@ -2,7 +2,6 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
-using SixLabors.ImageSharp.Formats;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -90,8 +89,13 @@ public class Rg32Tests
     {
         PixelTypeInfo info = Rg32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rg32>() * 8, info.BitsPerPixel);
-        Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
index c69c757b5..ab4269d00 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -137,8 +136,14 @@ public class Rgb24Tests
     {
         PixelTypeInfo info = Rgb24.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgb24>() * 8, info.BitsPerPixel);
-        Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
index dda5af9fb..faf9bdb3c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -82,8 +81,14 @@ public class Rgb48Tests
     {
         PixelTypeInfo info = Rgb48.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgb48>() * 8, info.BitsPerPixel);
-        Assert.Equal(3, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(3, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
index 5b0e4c287..7cf8ced45 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -253,8 +252,15 @@ public class Rgba1010102Tests
     {
         PixelTypeInfo info = Rgba1010102.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgba1010102>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(10, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(10, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(10, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(2, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(10, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
index d1ad4c304..9b96aeb7b 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -313,8 +312,15 @@ public class Rgba32Tests
     {
         PixelTypeInfo info = Rgba32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgba32>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Byte, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(8, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(8, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(8, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
index 3dc580460..49336400c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -315,8 +314,15 @@ public class Rgba64Tests
     {
         PixelTypeInfo info = Rgba64.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgba64>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.UShort, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
index 968e274e2..28ee5ace5 100644
--- a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -211,8 +210,15 @@ public class RgbaVectorTests
     {
         PixelTypeInfo info = RgbaVector.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<RgbaVector>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Float, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(32, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(32, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(32, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
index 7afe61b02..d709b7605 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -167,8 +166,13 @@ public class Short2Tests
     {
         PixelTypeInfo info = Short2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Short2>() * 8, info.BitsPerPixel);
-        Assert.Equal(2, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(2, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
index bdde5cd8f..2b5760342 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
@@ -3,7 +3,6 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Tests.PixelFormats;
@@ -220,8 +219,15 @@ public class Short4Tests
     {
         PixelTypeInfo info = Short4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Short4>() * 8, info.BitsPerPixel);
-        Assert.Equal(4, info.ComponentCount);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
-        Assert.Equal(PixelComponentPrecision.Short, info.MaxComponentPrecision);
+
+        PixelComponentInfo componentInfo = info.ComponentInfo.Value;
+        Assert.Equal(4, componentInfo.ComponentCount);
+        Assert.Equal(0, componentInfo.Padding);
+        Assert.Equal(16, componentInfo.GetComponentPrecision(0));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(1));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(2));
+        Assert.Equal(16, componentInfo.GetComponentPrecision(3));
+        Assert.Equal(16, componentInfo.GetMaximumComponentPrecision());
     }
 }
diff --git a/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs b/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
index d6b1f1f98..ccb79debd 100644
--- a/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
+++ b/tests/ImageSharp.Tests/Quantization/WuQuantizerTests.cs
@@ -14,7 +14,7 @@ public class WuQuantizerTests
         Configuration config = Configuration.Default;
         var quantizer = new WuQuantizer(new QuantizerOptions { Dither = null });
 
-        using var image = new Image<Rgba32>(config, 1, 1, Color.Black);
+        using var image = new Image<Rgba32>(config, 1, 1, Color.Black.ToPixel<Rgba32>());
         ImageFrame<Rgba32> frame = image.Frames.RootFrame;
 
         using IQuantizer<Rgba32> frameQuantizer = quantizer.CreatePixelSpecificQuantizer<Rgba32>(config);
@@ -24,7 +24,7 @@ public class WuQuantizerTests
         Assert.Equal(1, result.Width);
         Assert.Equal(1, result.Height);
 
-        Assert.Equal(Color.Black, (Color)result.Palette.Span[0]);
+        Assert.Equal(Color.Black, Color.FromPixel(result.Palette.Span[0]));
         Assert.Equal(0, result.DangerousGetRowSpan(0)[0]);
     }
 
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs
index a4232a968..495f5f9f6 100644
--- a/tests/ImageSharp.Tests/TestFormat.cs
+++ b/tests/ImageSharp.Tests/TestFormat.cs
@@ -263,7 +263,7 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public struct TestPixelForAgnosticDecode : IPixel<TestPixelForAgnosticDecode>
     {
-        public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(2, PixelComponentPrecision.Byte, PixelAlphaRepresentation.None);
+        public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(PixelComponentInfo.Create<TestPixelForAgnosticDecode>(2, 8, 8), PixelAlphaRepresentation.None);
 
         public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
index 8c5101013..d78edf5bc 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
@@ -51,7 +51,7 @@ public abstract partial class TestImageProvider<TPixel> : IXunitSerializable
         public override Image<TPixel> GetImage()
         {
             Image<TPixel> image = base.GetImage();
-            Color color = new Rgba32(this.r, this.g, this.b, this.a);
+            Color color = Color.FromPixel(new Rgba32(this.r, this.g, this.b, this.a));
 
             image.GetRootFramePixelBuffer().FastMemoryGroup.Fill(color.ToPixel<TPixel>());
             return image;

From 1d352513e5436014894d48cbb239516b39bceae6 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 5 Jan 2024 18:52:39 +1000
Subject: [PATCH 12/14] Add PixelColorType

---
 src/ImageSharp/PixelFormats/PixelColorType.cs | 46 +++++++++++++++++++
 .../PixelFormats/PixelImplementations/A8.cs   |  6 ++-
 .../PixelImplementations/Abgr32.cs            |  6 ++-
 .../PixelImplementations/Argb32.cs            |  6 ++-
 .../PixelImplementations/Bgr24.cs             |  6 ++-
 .../PixelImplementations/Bgr565.cs            |  6 ++-
 .../PixelImplementations/Bgra32.cs            |  6 ++-
 .../PixelImplementations/Bgra4444.cs          |  6 ++-
 .../PixelImplementations/Bgra5551.cs          |  6 ++-
 .../PixelImplementations/Byte4.cs             |  6 ++-
 .../PixelImplementations/HalfSingle.cs        |  6 ++-
 .../PixelImplementations/HalfVector2.cs       |  6 ++-
 .../PixelImplementations/HalfVector4.cs       |  6 ++-
 .../PixelFormats/PixelImplementations/L16.cs  |  6 ++-
 .../PixelFormats/PixelImplementations/L8.cs   |  6 ++-
 .../PixelFormats/PixelImplementations/La16.cs |  6 ++-
 .../PixelFormats/PixelImplementations/La32.cs |  6 ++-
 .../PixelImplementations/NormalizedByte2.cs   |  6 ++-
 .../PixelImplementations/NormalizedByte4.cs   |  6 ++-
 .../PixelImplementations/NormalizedShort2.cs  |  6 ++-
 .../PixelImplementations/NormalizedShort4.cs  |  6 ++-
 .../PixelFormats/PixelImplementations/Rg32.cs |  6 ++-
 .../PixelImplementations/Rgb24.cs             |  6 ++-
 .../PixelImplementations/Rgb48.cs             |  6 ++-
 .../PixelImplementations/Rgba1010102.cs       |  6 ++-
 .../PixelImplementations/Rgba32.cs            |  6 ++-
 .../PixelImplementations/Rgba64.cs            |  6 ++-
 .../PixelImplementations/RgbaVector.cs        |  6 ++-
 .../PixelImplementations/Short2.cs            |  6 ++-
 .../PixelImplementations/Short4.cs            |  6 ++-
 src/ImageSharp/PixelFormats/PixelTypeInfo.cs  | 10 +++-
 tests/ImageSharp.Tests/Color/RgbaDouble.cs    |  6 ++-
 .../ImageSharp.Tests/PixelFormats/A8Tests.cs  |  1 +
 .../PixelFormats/Abgr32Tests.cs               |  1 +
 .../PixelFormats/Argb32Tests.cs               |  1 +
 .../PixelFormats/Bgr24Tests.cs                |  1 +
 .../PixelFormats/Bgr565Tests.cs               |  1 +
 .../PixelFormats/Bgra32Tests.cs               |  1 +
 .../PixelFormats/Bgra4444Tests.cs             |  1 +
 .../PixelFormats/Bgra5551Tests.cs             |  1 +
 .../PixelFormats/Byte4Tests.cs                |  1 +
 .../PixelFormats/HalfSingleTests.cs           |  1 +
 .../PixelFormats/HalfVector2Tests.cs          |  1 +
 .../PixelFormats/HalfVector4Tests.cs          |  1 +
 .../ImageSharp.Tests/PixelFormats/L16Tests.cs |  1 +
 .../ImageSharp.Tests/PixelFormats/L8Tests.cs  |  1 +
 .../PixelFormats/La16Tests.cs                 |  1 +
 .../PixelFormats/La32Tests.cs                 |  1 +
 .../PixelFormats/NormalizedByte2Tests.cs      |  1 +
 .../PixelFormats/NormalizedByte4Tests.cs      |  1 +
 .../PixelFormats/NormalizedShort2Tests.cs     |  1 +
 .../PixelFormats/NormalizedShort4Tests.cs     |  1 +
 .../PixelFormats/Rg32Tests.cs                 |  1 +
 .../PixelFormats/Rgb24Tests.cs                |  1 +
 .../PixelFormats/Rgb48Tests.cs                |  1 +
 .../PixelFormats/Rgba1010102Tests.cs          |  1 +
 .../PixelFormats/Rgba32Tests.cs               |  1 +
 .../PixelFormats/Rgba64Tests.cs               |  1 +
 .../PixelFormats/RgbaVectorTests.cs           |  1 +
 .../PixelFormats/Short2Tests.cs               |  1 +
 .../PixelFormats/Short4Tests.cs               |  1 +
 tests/ImageSharp.Tests/TestFormat.cs          |  6 ++-
 62 files changed, 239 insertions(+), 32 deletions(-)
 create mode 100644 src/ImageSharp/PixelFormats/PixelColorType.cs

diff --git a/src/ImageSharp/PixelFormats/PixelColorType.cs b/src/ImageSharp/PixelFormats/PixelColorType.cs
new file mode 100644
index 000000000..9ac2c308c
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelColorType.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Represents the color type and format of a pixel.
+/// </summary>
+[Flags]
+public enum PixelColorType
+{
+    /// <summary>
+    /// Represents the Red component of the color.
+    /// </summary>
+    Red = 1 << 0,
+
+    /// <summary>
+    /// Represents the Green component of the color.
+    /// </summary>
+    Green = 1 << 1,
+
+    /// <summary>
+    /// Represents the Blue component of the color.
+    /// </summary>
+    Blue = 1 << 2,
+
+    /// <summary>
+    /// Represents the Alpha component of the color for transparency.
+    /// </summary>
+    Alpha = 1 << 3,
+
+    /// <summary>
+    /// Indicates that the color is in grayscale.
+    /// </summary>
+    Grayscale = 1 << 4,
+
+    /// <summary>
+    /// Indicates that the color is in RGB (Red, Green, Blue) format.
+    /// </summary>
+    RGB = Red | Green | Blue | (1 << 5),
+
+    /// <summary>
+    /// Indicates that the color is in BGR (Blue, Green, Red) format.
+    /// </summary>
+    BGR = Blue | Green | Red | (1 << 6)
+}
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
index abae4f246..23dae82ab 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/A8.cs
@@ -56,7 +56,11 @@ public partial struct A8 : IPixel<A8>, IPackedVector<byte>
     public static bool operator !=(A8 left, A8 right) => !left.Equals(right);
 
     /// <inheritdoc/>
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<A8>(PixelComponentInfo.Create<A8>(1, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<A8>(
+            PixelComponentInfo.Create<A8>(1, 8),
+            PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<A8> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
index e1399f05c..742f27cc0 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Abgr32.cs
@@ -168,7 +168,11 @@ public partial struct Abgr32 : IPixel<Abgr32>, IPackedVector<uint>
     public static bool operator !=(Abgr32 left, Abgr32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Abgr32>(PixelComponentInfo.Create<Abgr32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Abgr32>(
+            PixelComponentInfo.Create<Abgr32>(4, 8, 8, 8, 8),
+            PixelColorType.Alpha | PixelColorType.BGR,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Abgr32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
index 2b7bcf913..7a8ee2a63 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Argb32.cs
@@ -168,7 +168,11 @@ public partial struct Argb32 : IPixel<Argb32>, IPackedVector<uint>
     public static bool operator !=(Argb32 left, Argb32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Argb32>(PixelComponentInfo.Create<Argb32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Argb32>(
+            PixelComponentInfo.Create<Argb32>(4, 8, 8, 8, 8),
+            PixelColorType.Alpha | PixelColorType.RGB,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Argb32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
index c9c324680..bdf7d1a7e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr24.cs
@@ -72,7 +72,11 @@ public partial struct Bgr24 : IPixel<Bgr24>
     public static bool operator !=(Bgr24 left, Bgr24 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr24>(PixelComponentInfo.Create<Bgr24>(3, 8, 8, 8), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgr24>(
+            PixelComponentInfo.Create<Bgr24>(3, 8, 8, 8),
+            PixelColorType.BGR,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Bgr24> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
index d020cf025..0874eb825 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgr565.cs
@@ -60,7 +60,11 @@ public partial struct Bgr565 : IPixel<Bgr565>, IPackedVector<ushort>
     public static bool operator !=(Bgr565 left, Bgr565 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgr565>(PixelComponentInfo.Create<Bgr565>(3, 5, 6, 5), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgr565>(
+            PixelComponentInfo.Create<Bgr565>(3, 5, 6, 5),
+            PixelColorType.BGR,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgr565> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
index b3a96523e..f50846357 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra32.cs
@@ -121,7 +121,11 @@ public partial struct Bgra32 : IPixel<Bgra32>, IPackedVector<uint>
     public static bool operator !=(Bgra32 left, Bgra32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra32>(PixelComponentInfo.Create<Bgra32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgra32>(
+            PixelComponentInfo.Create<Bgra32>(4, 8, 8, 8, 8),
+            PixelColorType.BGR | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Bgra32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
index 510d6666f..4bb3f8a0e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra4444.cs
@@ -58,7 +58,11 @@ public partial struct Bgra4444 : IPixel<Bgra4444>, IPackedVector<ushort>
     public static bool operator !=(Bgra4444 left, Bgra4444 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra4444>(PixelComponentInfo.Create<Bgra4444>(4, 4, 4, 4, 4), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgra4444>(
+            PixelComponentInfo.Create<Bgra4444>(4, 4, 4, 4, 4),
+            PixelColorType.BGR | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgra4444> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
index 68dbd9544..d57545dee 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Bgra5551.cs
@@ -61,7 +61,11 @@ public partial struct Bgra5551 : IPixel<Bgra5551>, IPackedVector<ushort>
     public static bool operator !=(Bgra5551 left, Bgra5551 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Bgra5551>(PixelComponentInfo.Create<Bgra5551>(4, 5, 5, 5, 1), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Bgra5551>(
+            PixelComponentInfo.Create<Bgra5551>(4, 5, 5, 5, 1),
+            PixelColorType.BGR | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Bgra5551> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
index fbe7a0c52..d8f1dd0ac 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Byte4.cs
@@ -61,7 +61,11 @@ public partial struct Byte4 : IPixel<Byte4>, IPackedVector<uint>
     public static bool operator !=(Byte4 left, Byte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Byte4>(PixelComponentInfo.Create<Byte4>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Byte4>(
+            PixelComponentInfo.Create<Byte4>(4, 8, 8, 8, 8),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Byte4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
index aca64ae7a..01ae9fc5f 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfSingle.cs
@@ -46,7 +46,11 @@ public partial struct HalfSingle : IPixel<HalfSingle>, IPackedVector<ushort>
     public static bool operator !=(HalfSingle left, HalfSingle right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfSingle>(PixelComponentInfo.Create<HalfSingle>(1, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<HalfSingle>(
+            PixelComponentInfo.Create<HalfSingle>(1, 16),
+            PixelColorType.Red,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public PixelOperations<HalfSingle> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
index 5a25d523b..d591dd855 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector2.cs
@@ -53,7 +53,11 @@ public partial struct HalfVector2 : IPixel<HalfVector2>, IPackedVector<uint>
     public static bool operator !=(HalfVector2 left, HalfVector2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector2>(PixelComponentInfo.Create<HalfVector2>(2, 16, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<HalfVector2>(
+            PixelComponentInfo.Create<HalfVector2>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
index 7ad7b07f4..ca6bff230 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/HalfVector4.cs
@@ -58,7 +58,11 @@ public partial struct HalfVector4 : IPixel<HalfVector4>, IPackedVector<ulong>
     public static bool operator !=(HalfVector4 left, HalfVector4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<HalfVector4>(PixelComponentInfo.Create<HalfVector4>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<HalfVector4>(
+            PixelComponentInfo.Create<HalfVector4>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<HalfVector4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
index 0c58fb1fd..8522da3fb 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L16.cs
@@ -48,7 +48,11 @@ public partial struct L16 : IPixel<L16>, IPackedVector<ushort>
     public static bool operator !=(L16 left, L16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L16>(PixelComponentInfo.Create<L16>(1, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<L16>(
+            PixelComponentInfo.Create<L16>(1, 16),
+            PixelColorType.Grayscale,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<L16> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
index 2cd8b20e7..706fc1101 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/L8.cs
@@ -49,7 +49,11 @@ public partial struct L8 : IPixel<L8>, IPackedVector<byte>
     public static bool operator !=(L8 left, L8 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<L8>(PixelComponentInfo.Create<L8>(1, 8), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<L8>(
+            PixelComponentInfo.Create<L8>(1, 8),
+            PixelColorType.Grayscale,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<L8> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
index b811df4b4..e30673153 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La16.cs
@@ -72,7 +72,11 @@ public partial struct La16 : IPixel<La16>, IPackedVector<ushort>
     public static bool operator !=(La16 left, La16 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La16>(PixelComponentInfo.Create<La16>(2, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<La16>(
+            PixelComponentInfo.Create<La16>(2, 8, 8),
+            PixelColorType.Grayscale | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<La16> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
index e6a63f5ec..867bfacd3 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/La32.cs
@@ -74,7 +74,11 @@ public partial struct La32 : IPixel<La32>, IPackedVector<uint>
     public static bool operator !=(La32 left, La32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<La32>(PixelComponentInfo.Create<La32>(2, 16, 16), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<La32>(
+            PixelComponentInfo.Create<La32>(2, 16, 16),
+            PixelColorType.Grayscale | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc/>
     public readonly PixelOperations<La32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
index f7427e65c..c5eb2c2de 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte2.cs
@@ -61,7 +61,11 @@ public partial struct NormalizedByte2 : IPixel<NormalizedByte2>, IPackedVector<u
     public static bool operator !=(NormalizedByte2 left, NormalizedByte2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte2>(PixelComponentInfo.Create<NormalizedByte2>(2, 8, 8), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedByte2>(
+            PixelComponentInfo.Create<NormalizedByte2>(2, 8, 8),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
index beeae655a..6cf92688e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedByte4.cs
@@ -63,7 +63,11 @@ public partial struct NormalizedByte4 : IPixel<NormalizedByte4>, IPackedVector<u
     public static bool operator !=(NormalizedByte4 left, NormalizedByte4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedByte4>(PixelComponentInfo.Create<NormalizedByte4>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedByte4>(
+            PixelComponentInfo.Create<NormalizedByte4>(4, 8, 8, 8, 8),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedByte4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
index 8152c89d3..03fa2737e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort2.cs
@@ -62,7 +62,11 @@ public partial struct NormalizedShort2 : IPixel<NormalizedShort2>, IPackedVector
     public static bool operator !=(NormalizedShort2 left, NormalizedShort2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort2>(PixelComponentInfo.Create<NormalizedShort2>(2, 16, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedShort2>(
+            PixelComponentInfo.Create<NormalizedShort2>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
index 3f37cb80f..89ba2a23b 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/NormalizedShort4.cs
@@ -64,7 +64,11 @@ public partial struct NormalizedShort4 : IPixel<NormalizedShort4>, IPackedVector
     public static bool operator !=(NormalizedShort4 left, NormalizedShort4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<NormalizedShort4>(PixelComponentInfo.Create<NormalizedShort4>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<NormalizedShort4>(
+            PixelComponentInfo.Create<NormalizedShort4>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<NormalizedShort4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
index 594bdd9a1..8f2e19840 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rg32.cs
@@ -58,7 +58,11 @@ public partial struct Rg32 : IPixel<Rg32>, IPackedVector<uint>
     public static bool operator !=(Rg32 left, Rg32 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rg32>(PixelComponentInfo.Create<Rg32>(2, 16, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rg32>(
+            PixelComponentInfo.Create<Rg32>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rg32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
index 8d0c7cd48..008de06bf 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb24.cs
@@ -91,7 +91,11 @@ public partial struct Rgb24 : IPixel<Rgb24>
     public static bool operator !=(Rgb24 left, Rgb24 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb24>(PixelComponentInfo.Create<Rgb24>(3, 8, 8, 8), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgb24>(
+            PixelComponentInfo.Create<Rgb24>(3, 8, 8, 8),
+            PixelColorType.RGB,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc/>
     public readonly PixelOperations<Rgb24> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
index f7aac32f4..ae4d6dc01 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgb48.cs
@@ -70,7 +70,11 @@ public partial struct Rgb48 : IPixel<Rgb48>
     public static bool operator !=(Rgb48 left, Rgb48 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgb48>(PixelComponentInfo.Create<Rgb48>(3, 16, 16, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgb48>(
+            PixelComponentInfo.Create<Rgb48>(3, 16, 16, 16),
+            PixelColorType.RGB,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgb48> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
index 84482a7aa..ac1eedb07 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba1010102.cs
@@ -61,7 +61,11 @@ public partial struct Rgba1010102 : IPixel<Rgba1010102>, IPackedVector<uint>
     public static bool operator !=(Rgba1010102 left, Rgba1010102 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba1010102>(PixelComponentInfo.Create<Rgba1010102>(4, 10, 10, 10, 2), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgba1010102>(
+            PixelComponentInfo.Create<Rgba1010102>(4, 10, 10, 10, 2),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba1010102> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
index f391e6474..8b2a078db 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.cs
@@ -271,7 +271,11 @@ public partial struct Rgba32 : IPixel<Rgba32>, IPackedVector<uint>
     }
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba32>(PixelComponentInfo.Create<Rgba32>(4, 8, 8, 8, 8), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgba32>(
+            PixelComponentInfo.Create<Rgba32>(4, 8, 8, 8, 8),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba32> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
index 47062779b..b71ec5f35 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba64.cs
@@ -191,7 +191,11 @@ public partial struct Rgba64 : IPixel<Rgba64>, IPackedVector<ulong>
     public static bool operator !=(Rgba64 left, Rgba64 right) => left.PackedValue != right.PackedValue;
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Rgba64>(PixelComponentInfo.Create<Rgba64>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Rgba64>(
+            PixelComponentInfo.Create<Rgba64>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Rgba64> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
index ce1c6d572..cd61b13b2 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/RgbaVector.cs
@@ -97,7 +97,11 @@ public partial struct RgbaVector : IPixel<RgbaVector>
     public static RgbaVector FromHex(string hex) => Color.ParseHex(hex).ToPixel<RgbaVector>();
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaVector>(PixelComponentInfo.Create<RgbaVector>(4, 32, 32, 32, 32), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<RgbaVector>(
+            PixelComponentInfo.Create<RgbaVector>(4, 32, 32, 32, 32),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<RgbaVector> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
index 786c98ee4..c8819337e 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short2.cs
@@ -65,7 +65,11 @@ public partial struct Short2 : IPixel<Short2>, IPackedVector<uint>
     public static bool operator !=(Short2 left, Short2 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short2>(PixelComponentInfo.Create<Short2>(2, 16, 16), PixelAlphaRepresentation.None);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Short2>(
+            PixelComponentInfo.Create<Short2>(2, 16, 16),
+            PixelColorType.Red | PixelColorType.Green,
+            PixelAlphaRepresentation.None);
 
     /// <inheritdoc />
     public readonly PixelOperations<Short2> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
index 890e66299..cfd9ce0bf 100644
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Short4.cs
@@ -67,7 +67,11 @@ public partial struct Short4 : IPixel<Short4>, IPackedVector<ulong>
     public static bool operator !=(Short4 left, Short4 right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<Short4>(PixelComponentInfo.Create<Short4>(4, 16, 16, 16, 16), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<Short4>(
+            PixelComponentInfo.Create<Short4>(4, 16, 16, 16, 16),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<Short4> CreatePixelOperations() => new PixelOperations();
diff --git a/src/ImageSharp/PixelFormats/PixelTypeInfo.cs b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
index e209b21e1..81c70a18f 100644
--- a/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
+++ b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
@@ -23,10 +23,15 @@ public readonly struct PixelTypeInfo(int bitsPerPixel)
     public int BitsPerPixel { get; init; } = bitsPerPixel;
 
     /// <summary>
-    /// Gets the maximum precision of components within the pixel.
+    /// Gets the component bit depth and padding within the pixel.
     /// </summary>
     public PixelComponentInfo? ComponentInfo { get; init; }
 
+    /// <summary>
+    /// Gets the pixel color type.
+    /// </summary>
+    public PixelColorType? ColorType { get; init; }
+
     /// <summary>
     /// Gets the pixel alpha transparency behavior.
     /// <see langword="null"/> means unknown, unspecified.
@@ -38,16 +43,19 @@ public readonly struct PixelTypeInfo(int bitsPerPixel)
     /// </summary>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
     /// <param name="info">The pixel component info.</param>
+    /// <param name="colorType">The pixel color type.</param>
     /// <param name="alphaRepresentation">The pixel alpha representation.</param>
     /// <returns>The <see cref="PixelComponentInfo"/>.</returns>
     public static PixelTypeInfo Create<TPixel>(
         PixelComponentInfo info,
+        PixelColorType colorType,
         PixelAlphaRepresentation alphaRepresentation)
         where TPixel : unmanaged, IPixel<TPixel>
         => new()
         {
             BitsPerPixel = Unsafe.SizeOf<TPixel>() * 8,
             ComponentInfo = info,
+            ColorType = colorType,
             AlphaRepresentation = alphaRepresentation
         };
 }
diff --git a/tests/ImageSharp.Tests/Color/RgbaDouble.cs b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
index 476ff0336..fdd736930 100644
--- a/tests/ImageSharp.Tests/Color/RgbaDouble.cs
+++ b/tests/ImageSharp.Tests/Color/RgbaDouble.cs
@@ -77,7 +77,11 @@ public partial struct RgbaDouble(double r, double g, double b, double a = 1) : I
     public static bool operator !=(RgbaDouble left, RgbaDouble right) => !left.Equals(right);
 
     /// <inheritdoc />
-    public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<RgbaDouble>(PixelComponentInfo.Create<RgbaDouble>(4, 64, 64, 64, 64), PixelAlphaRepresentation.Unassociated);
+    public static PixelTypeInfo GetPixelTypeInfo()
+        => PixelTypeInfo.Create<RgbaDouble>(
+            PixelComponentInfo.Create<RgbaDouble>(4, 64, 64, 64, 64),
+            PixelColorType.RGB | PixelColorType.Alpha,
+            PixelAlphaRepresentation.Unassociated);
 
     /// <inheritdoc />
     public readonly PixelOperations<RgbaDouble> CreatePixelOperations() => new();
diff --git a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
index ef99db498..b7a86d488 100644
--- a/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/A8Tests.cs
@@ -116,6 +116,7 @@ public class A8Tests
         PixelTypeInfo info = A8.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<A8>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(1, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
index de6f519e1..7f584b1bf 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Abgr32Tests.cs
@@ -151,6 +151,7 @@ public class Abgr32Tests
         PixelTypeInfo info = Abgr32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Abgr32>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Alpha | PixelColorType.BGR, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
index 29349b852..42b940845 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
@@ -149,6 +149,7 @@ public class Argb32Tests
         PixelTypeInfo info = Argb32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Argb32>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Alpha | PixelColorType.RGB, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
index 519aeb6c5..239e88396 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
@@ -134,6 +134,7 @@ public class Bgr24Tests
         PixelTypeInfo info = Bgr24.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgr24>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(3, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
index 16e225a9b..2ad4f4cf7 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
@@ -256,6 +256,7 @@ public class Bgr565Tests
         PixelTypeInfo info = Bgr565.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgr565>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(3, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
index c5b4325c9..df8d1199f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
@@ -151,6 +151,7 @@ public class Bgra32Tests
         PixelTypeInfo info = Bgra32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgra32>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
index f2e9a2291..ef587f301 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
@@ -252,6 +252,7 @@ public class Bgra4444Tests
         PixelTypeInfo info = Bgra4444.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgra4444>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
index 03b4a41c6..5140cfda1 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
@@ -278,6 +278,7 @@ public class Bgra5551Tests
         PixelTypeInfo info = Bgra5551.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Bgra5551>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.BGR | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
index 1434d7d93..a61318db7 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
@@ -245,6 +245,7 @@ public class Byte4Tests
         PixelTypeInfo info = Byte4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Byte4>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
index dbd1f6917..3e84da723 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
@@ -74,6 +74,7 @@ public class HalfSingleTests
         PixelTypeInfo info = HalfSingle.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<HalfSingle>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(1, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
index 710135ed6..04e3ee35f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
@@ -96,6 +96,7 @@ public class HalfVector2Tests
         PixelTypeInfo info = HalfVector2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<HalfVector2>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
index 3e3f6a2ca..e8420ddd0 100644
--- a/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
@@ -87,6 +87,7 @@ public class HalfVector4Tests
         PixelTypeInfo info = HalfVector4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<HalfVector4>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
index 3a8239923..337d02084 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L16Tests.cs
@@ -166,6 +166,7 @@ public class L16Tests
         PixelTypeInfo info = L16.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<L16>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Grayscale, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(1, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
index 631a0e234..81f4d61fb 100644
--- a/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/L8Tests.cs
@@ -261,6 +261,7 @@ public class L8Tests
             PixelTypeInfo info = L8.GetPixelTypeInfo();
             Assert.Equal(Unsafe.SizeOf<L8>() * 8, info.BitsPerPixel);
             Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+            Assert.Equal(PixelColorType.Grayscale, info.ColorType);
 
             PixelComponentInfo componentInfo = info.ComponentInfo.Value;
             Assert.Equal(1, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
index 9fa0e3263..612d0f81a 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La16Tests.cs
@@ -265,6 +265,7 @@ public class La16Tests
             PixelTypeInfo info = La16.GetPixelTypeInfo();
             Assert.Equal(Unsafe.SizeOf<La16>() * 8, info.BitsPerPixel);
             Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+            Assert.Equal(PixelColorType.Grayscale | PixelColorType.Alpha, info.ColorType);
 
             PixelComponentInfo componentInfo = info.ComponentInfo.Value;
             Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
index 089c2076b..f55707c05 100644
--- a/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/La32Tests.cs
@@ -172,6 +172,7 @@ public class La32Tests
         PixelTypeInfo info = La32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<La32>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Grayscale | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
index 9f24346a0..89c0ae69f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
@@ -88,6 +88,7 @@ public class NormalizedByte2Tests
         PixelTypeInfo info = NormalizedByte2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedByte2>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
index 63bb9d5f5..297438c65 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
@@ -238,6 +238,7 @@ public class NormalizedByte4Tests
         PixelTypeInfo info = NormalizedByte4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedByte4>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
index f262ce177..4b912d866 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
@@ -92,6 +92,7 @@ public class NormalizedShort2Tests
         PixelTypeInfo info = NormalizedShort2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedShort2>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
index 05058ae4d..0d9765888 100644
--- a/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
@@ -239,6 +239,7 @@ public class NormalizedShort4Tests
         PixelTypeInfo info = NormalizedShort4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<NormalizedShort4>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
index 9ab1ec963..fac767812 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
@@ -90,6 +90,7 @@ public class Rg32Tests
         PixelTypeInfo info = Rg32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rg32>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
index ab4269d00..385126a65 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
@@ -137,6 +137,7 @@ public class Rgb24Tests
         PixelTypeInfo info = Rgb24.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgb24>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(3, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
index faf9bdb3c..625a9187f 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
@@ -82,6 +82,7 @@ public class Rgb48Tests
         PixelTypeInfo info = Rgb48.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgb48>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(3, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
index 7cf8ced45..a8243064d 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
@@ -253,6 +253,7 @@ public class Rgba1010102Tests
         PixelTypeInfo info = Rgba1010102.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgba1010102>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
index 9b96aeb7b..35fab151c 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba32Tests.cs
@@ -313,6 +313,7 @@ public class Rgba32Tests
         PixelTypeInfo info = Rgba32.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgba32>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
index 49336400c..4f335b1e8 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
@@ -315,6 +315,7 @@ public class Rgba64Tests
         PixelTypeInfo info = Rgba64.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Rgba64>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
index 28ee5ace5..b263bf8ea 100644
--- a/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/RgbaVectorTests.cs
@@ -211,6 +211,7 @@ public class RgbaVectorTests
         PixelTypeInfo info = RgbaVector.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<RgbaVector>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
index d709b7605..1143925cb 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short2Tests.cs
@@ -167,6 +167,7 @@ public class Short2Tests
         PixelTypeInfo info = Short2.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Short2>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.None, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.Red | PixelColorType.Green, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(2, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
index 2b5760342..ab3cc3b6e 100644
--- a/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/Short4Tests.cs
@@ -220,6 +220,7 @@ public class Short4Tests
         PixelTypeInfo info = Short4.GetPixelTypeInfo();
         Assert.Equal(Unsafe.SizeOf<Short4>() * 8, info.BitsPerPixel);
         Assert.Equal(PixelAlphaRepresentation.Unassociated, info.AlphaRepresentation);
+        Assert.Equal(PixelColorType.RGB | PixelColorType.Alpha, info.ColorType);
 
         PixelComponentInfo componentInfo = info.ComponentInfo.Value;
         Assert.Equal(4, componentInfo.ComponentCount);
diff --git a/tests/ImageSharp.Tests/TestFormat.cs b/tests/ImageSharp.Tests/TestFormat.cs
index 495f5f9f6..983cf4d46 100644
--- a/tests/ImageSharp.Tests/TestFormat.cs
+++ b/tests/ImageSharp.Tests/TestFormat.cs
@@ -263,7 +263,11 @@ public class TestFormat : IImageFormatConfigurationModule, IImageFormat
 
     public struct TestPixelForAgnosticDecode : IPixel<TestPixelForAgnosticDecode>
     {
-        public static PixelTypeInfo GetPixelTypeInfo() => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(PixelComponentInfo.Create<TestPixelForAgnosticDecode>(2, 8, 8), PixelAlphaRepresentation.None);
+        public static PixelTypeInfo GetPixelTypeInfo()
+            => PixelTypeInfo.Create<TestPixelForAgnosticDecode>(
+                PixelComponentInfo.Create<TestPixelForAgnosticDecode>(2, 8, 8),
+                PixelColorType.Red | PixelColorType.Green,
+                PixelAlphaRepresentation.None);
 
         public PixelOperations<TestPixelForAgnosticDecode> CreatePixelOperations() => new();
 

From 057edd8ddd010f3f83446568c54c6565a9c4a171 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 5 Jan 2024 20:05:06 +1000
Subject: [PATCH 13/14] Use the new metadata

---
 src/ImageSharp/Color/Color.cs                 |   4 +-
 src/ImageSharp/Formats/Png/PngBitDepth.cs     |   2 +-
 src/ImageSharp/Formats/Png/PngEncoderCore.cs  | 104 ++++++++++--------
 .../PixelFormats/PixelComponentBitDepth.cs    |  50 +++++++++
 .../PixelFormats/PixelComponentPrecision.cs   |  70 ------------
 src/ImageSharp/PixelFormats/PixelTypeInfo.cs  |   3 +-
 .../Formats/Png/PngEncoderTests.cs            |  20 ++--
 7 files changed, 125 insertions(+), 128 deletions(-)
 create mode 100644 src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs
 delete mode 100644 src/ImageSharp/PixelFormats/PixelComponentPrecision.cs

diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index ec19a86eb..e61abf86f 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -94,7 +94,7 @@ public readonly partial struct Color : IEquatable<Color>
     {
         // Avoid boxing in case we can convert to Vector4 safely and efficiently
         PixelTypeInfo info = TPixel.GetPixelTypeInfo();
-        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentPrecision.Float)
+        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentBitDepth.Bit32)
         {
             return new(pixel.ToScaledVector4());
         }
@@ -118,7 +118,7 @@ public readonly partial struct Color : IEquatable<Color>
 
         // Avoid boxing in case we can convert to Vector4 safely and efficiently
         PixelTypeInfo info = TPixel.GetPixelTypeInfo();
-        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentPrecision.Float)
+        if (info.ComponentInfo.HasValue && info.ComponentInfo.Value.GetMaximumComponentPrecision() <= (int)PixelComponentBitDepth.Bit32)
         {
             for (int i = 0; i < destination.Length; i++)
             {
diff --git a/src/ImageSharp/Formats/Png/PngBitDepth.cs b/src/ImageSharp/Formats/Png/PngBitDepth.cs
index 452839d1d..a5cd2026b 100644
--- a/src/ImageSharp/Formats/Png/PngBitDepth.cs
+++ b/src/ImageSharp/Formats/Png/PngBitDepth.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // Note the value assignment, This will allow us to add 1, 2, and 4 bit encoding when we support it.
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index 8bf8be2ad..aa3603cfb 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -1466,23 +1466,48 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
 
         // Use options, then check metadata, if nothing set there then we suggest
         // a sensible default based upon the pixel format.
-        this.colorType = encoder.ColorType ?? pngMetadata.ColorType ?? SuggestColorType<TPixel>();
-        if (!encoder.FilterMethod.HasValue)
+        PngColorType? colorType = encoder.ColorType ?? pngMetadata.ColorType;
+        byte? bits = (byte?)(encoder.BitDepth ?? pngMetadata.BitDepth);
+
+        if (colorType is null || bits is null)
         {
-            // Specification recommends default filter method None for paletted images and Paeth for others.
-            this.filterMethod = this.colorType is PngColorType.Palette ? PngFilterMethod.None : PngFilterMethod.Paeth;
+            PixelTypeInfo info = TPixel.GetPixelTypeInfo();
+            PixelComponentInfo? componentInfo = info.ComponentInfo;
+
+            colorType ??= SuggestColorType<TPixel>(in info);
+
+            if (bits is null)
+            {
+                // TODO: Update once we stop abusing PixelTypeInfo in decoders.
+                if (componentInfo.HasValue)
+                {
+                    PixelComponentInfo c = componentInfo.Value;
+                    bits = (byte)SuggestBitDepth<TPixel>(in c);
+                }
+                else
+                {
+                    bits = (byte)PngBitDepth.Bit8;
+                }
+            }
         }
 
         // Ensure bit depth and color type are a supported combination.
         // Bit8 is the only bit depth supported by all color types.
-        byte bits = (byte)(encoder.BitDepth ?? pngMetadata.BitDepth ?? SuggestBitDepth<TPixel>());
-        byte[] validBitDepths = PngConstants.ColorTypes[this.colorType];
+        byte[] validBitDepths = PngConstants.ColorTypes[colorType.Value];
         if (Array.IndexOf(validBitDepths, bits) == -1)
         {
             bits = (byte)PngBitDepth.Bit8;
         }
 
-        this.bitDepth = bits;
+        this.colorType = colorType.Value;
+        this.bitDepth = bits.Value;
+
+        if (!encoder.FilterMethod.HasValue)
+        {
+            // Specification recommends default filter method None for paletted images and Paeth for others.
+            this.filterMethod = this.colorType is PngColorType.Palette ? PngFilterMethod.None : PngFilterMethod.Paeth;
+        }
+
         use16Bit = bits == (byte)PngBitDepth.Bit16;
         bytesPerPixel = CalculateBytesPerPixel(this.colorType, use16Bit);
 
@@ -1611,53 +1636,44 @@ internal sealed class PngEncoderCore : IImageEncoderInternals, IDisposable
 
     /// <summary>
     /// Returns a suggested <see cref="PngColorType"/> for the given <typeparamref name="TPixel"/>
-    /// This is not exhaustive but covers many common pixel formats.
     /// </summary>
+    /// <param name="info">The pixel type info.</param>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
-    private static PngColorType SuggestColorType<TPixel>()
+    private static PngColorType SuggestColorType<TPixel>(in PixelTypeInfo info)
         where TPixel : unmanaged, IPixel<TPixel>
-        => default(TPixel) switch
-        {
-            A8 => PngColorType.GrayscaleWithAlpha,
-            Argb32 => PngColorType.RgbWithAlpha,
-            Bgr24 => PngColorType.Rgb,
-            Bgra32 => PngColorType.RgbWithAlpha,
-            L8 => PngColorType.Grayscale,
-            L16 => PngColorType.Grayscale,
-            La16 => PngColorType.GrayscaleWithAlpha,
-            La32 => PngColorType.GrayscaleWithAlpha,
-            Rgb24 => PngColorType.Rgb,
-            Rgba32 => PngColorType.RgbWithAlpha,
-            Rgb48 => PngColorType.Rgb,
-            Rgba64 => PngColorType.RgbWithAlpha,
-            RgbaVector => PngColorType.RgbWithAlpha,
-            _ => PngColorType.RgbWithAlpha
+    {
+        if (info.AlphaRepresentation == PixelAlphaRepresentation.None)
+        {
+            return info.ColorType switch
+            {
+                PixelColorType.Grayscale => PngColorType.Grayscale,
+                _ => PngColorType.Rgb,
+            };
+        }
+
+        return info.ColorType switch
+        {
+            PixelColorType.Grayscale | PixelColorType.Alpha or PixelColorType.Alpha => PngColorType.GrayscaleWithAlpha,
+            _ => PngColorType.RgbWithAlpha,
         };
+    }
 
     /// <summary>
     /// Returns a suggested <see cref="PngBitDepth"/> for the given <typeparamref name="TPixel"/>
-    /// This is not exhaustive but covers many common pixel formats.
     /// </summary>
+    /// <param name="info">The pixel type info.</param>
     /// <typeparam name="TPixel">The type of pixel format.</typeparam>
-    private static PngBitDepth SuggestBitDepth<TPixel>()
+    private static PngBitDepth SuggestBitDepth<TPixel>(in PixelComponentInfo info)
         where TPixel : unmanaged, IPixel<TPixel>
-        => default(TPixel) switch
-        {
-            A8 => PngBitDepth.Bit8,
-            Argb32 => PngBitDepth.Bit8,
-            Bgr24 => PngBitDepth.Bit8,
-            Bgra32 => PngBitDepth.Bit8,
-            L8 => PngBitDepth.Bit8,
-            L16 => PngBitDepth.Bit16,
-            La16 => PngBitDepth.Bit8,
-            La32 => PngBitDepth.Bit16,
-            Rgb24 => PngBitDepth.Bit8,
-            Rgba32 => PngBitDepth.Bit8,
-            Rgb48 => PngBitDepth.Bit16,
-            Rgba64 => PngBitDepth.Bit16,
-            RgbaVector => PngBitDepth.Bit16,
-            _ => PngBitDepth.Bit8
-        };
+    {
+        int bits = info.GetMaximumComponentPrecision();
+        if (bits > (int)PixelComponentBitDepth.Bit8)
+        {
+            return PngBitDepth.Bit16;
+        }
+
+        return PngBitDepth.Bit8;
+    }
 
     private unsafe struct ScratchBuffer
     {
diff --git a/src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs b/src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs
new file mode 100644
index 000000000..674c9363b
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelComponentBitDepth.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.PixelFormats;
+
+/// <summary>
+/// Provides enumeration of the precision in bits of individual components within a pixel format.
+/// </summary>
+public enum PixelComponentBitDepth
+{
+    /// <summary>
+    /// 1 bit per component.
+    /// </summary>
+    Bit1 = 1,
+
+    /// <summary>
+    /// 2 bits per component.
+    /// </summary>
+    Bit2 = 2,
+
+    /// <summary>
+    /// 4 bits per component.
+    /// </summary>
+    Bit4 = 4,
+
+    /// <summary>
+    /// 8 bits per component.
+    /// </summary>
+    Bit8 = 8,
+
+    /// <summary>
+    /// 16 bits per component.
+    /// </summary>
+    Bit16 = 16,
+
+    /// <summary>
+    /// 32 bits per component.
+    /// </summary>
+    Bit32 = 32,
+
+    /// <summary>
+    /// 64 bits per component.
+    /// </summary>
+    Bit64 = 64,
+
+    /// <summary>
+    /// 128 bits per component.
+    /// </summary>
+    Bit128 = 128
+}
diff --git a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs b/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
deleted file mode 100644
index 2f15b7fad..000000000
--- a/src/ImageSharp/PixelFormats/PixelComponentPrecision.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-namespace SixLabors.ImageSharp.PixelFormats;
-
-/// <summary>
-/// Provides enumeration of the precision in bits of individual components within a pixel format.
-/// </summary>
-public enum PixelComponentPrecision
-{
-    /// <summary>
-    /// 8-bit signed integer.
-    /// </summary>
-    SByte = sizeof(sbyte) * 8,
-
-    /// <summary>
-    /// 8-bit unsigned integer.
-    /// </summary>
-    Byte = sizeof(byte) * 8,
-
-    /// <summary>
-    /// 16-bit signed integer.
-    /// </summary>
-    Short = sizeof(short) * 8,
-
-    /// <summary>
-    /// 16-bit unsigned integer.
-    /// </summary>
-    UShort = sizeof(ushort) * 8,
-
-    /// <summary>
-    /// 32-bit signed integer.
-    /// </summary>
-    Int = sizeof(int) * 8,
-
-    /// <summary>
-    /// 32-bit unsigned integer.
-    /// </summary>
-    UInt = sizeof(uint) * 8,
-
-    /// <summary>
-    /// 64-bit signed integer.
-    /// </summary>
-    Long = sizeof(long) * 8,
-
-    /// <summary>
-    /// 64-bit unsigned integer.
-    /// </summary>
-    ULong = sizeof(ulong) * 8,
-
-    /// <summary>
-    /// 16-bit floating point.
-    /// </summary>
-    Half = (sizeof(float) * 8) / 2,
-
-    /// <summary>
-    /// 32-bit floating point.
-    /// </summary>
-    Float = sizeof(float) * 8,
-
-    /// <summary>
-    /// 64-bit floating point.
-    /// </summary>
-    Double = sizeof(double) * 8,
-
-    /// <summary>
-    /// 128-bit floating point.
-    /// </summary>
-    Decimal = sizeof(decimal) * 8,
-}
diff --git a/src/ImageSharp/PixelFormats/PixelTypeInfo.cs b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
index 81c70a18f..7cd1284f4 100644
--- a/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
+++ b/src/ImageSharp/PixelFormats/PixelTypeInfo.cs
@@ -4,8 +4,9 @@
 using System.Runtime.CompilerServices;
 
 // TODO: Review this type as it's used to represent 2 different things.
-// 1.The encoded image pixel format.
+// 1. The encoded image pixel format.
 // 2. The pixel format of the decoded image.
+// Only the bits per pixel is used by the decoder, we should make it a property of the image metadata.
 namespace SixLabors.ImageSharp.PixelFormats;
 
 /// <summary>
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
index 477d88e9a..825becb36 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
@@ -256,21 +256,21 @@ public partial class PngEncoderTests
     [Theory]
     [WithBlankImages(1, 1, PixelTypes.A8, PngColorType.GrayscaleWithAlpha, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Argb32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Bgr565, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.Bgr565, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Bgra4444, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Byte4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.HalfSingle, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.HalfVector2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.HalfVector4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.NormalizedByte2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.HalfSingle, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.HalfVector2, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.HalfVector4, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.NormalizedByte2, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.NormalizedByte4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.NormalizedShort4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Rg32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Rgba1010102, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.NormalizedShort4, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.Rg32, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.Rgba1010102, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
     [WithBlankImages(1, 1, PixelTypes.Rgba32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.RgbaVector, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
-    [WithBlankImages(1, 1, PixelTypes.Short2, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
-    [WithBlankImages(1, 1, PixelTypes.Short4, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]
+    [WithBlankImages(1, 1, PixelTypes.Short2, PngColorType.Rgb, PngBitDepth.Bit16)]
+    [WithBlankImages(1, 1, PixelTypes.Short4, PngColorType.RgbWithAlpha, PngBitDepth.Bit16)]
     [WithBlankImages(1, 1, PixelTypes.Rgb24, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Bgr24, PngColorType.Rgb, PngBitDepth.Bit8)]
     [WithBlankImages(1, 1, PixelTypes.Bgra32, PngColorType.RgbWithAlpha, PngBitDepth.Bit8)]

From 029381e2d3b15743b615db80d5fdbf4f5275a259 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 5 Jan 2024 20:26:32 +1000
Subject: [PATCH 14/14] Remove outdated rule overrides.

---
 shared-infrastructure  | 2 +-
 src/ImageSharp.ruleset | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/shared-infrastructure b/shared-infrastructure
index 1c526a97e..d65232bbb 160000
--- a/shared-infrastructure
+++ b/shared-infrastructure
@@ -1 +1 @@
-Subproject commit 1c526a97eea8bcbc7c79de095676f7fb975a9fb1
+Subproject commit d65232bbbfe55a9a153b4058139dda5230e6eb4f
diff --git a/src/ImageSharp.ruleset b/src/ImageSharp.ruleset
index 6c291bfb1..f29278c95 100644
--- a/src/ImageSharp.ruleset
+++ b/src/ImageSharp.ruleset
@@ -2,7 +2,5 @@
 <RuleSet Name="ImageSharp" ToolsVersion="17.0">
   <Include Path="..\shared-infrastructure\sixlabors.ruleset" Action="Default" />
   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
-    <Rule Id="SA1011" Action="None" />
-    <Rule Id="SA1648" Action="None" /> <!--https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3595-->
   </Rules>
 </RuleSet>