Add YCbCr conversion

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzRgb.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+internal static class ColorProfileConverterExtensionsCieXyzRgb
+{
+    public static TTo Convert<TFrom, TTo>(this ColorProfileConverter converter, TFrom source)
+        where TFrom : struct, IColorProfile<TFrom, CieXyz>
+        where TTo : struct, IColorProfile<TTo, Rgb>
+    {
+        ColorConversionOptions options = converter.Options;
+
+        // Convert to input PCS
+        CieXyz pcsFrom = source.ToProfileConnectingSpace(options);
+
+        // Adapt to target white point
+        pcsFrom = VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, in pcsFrom);
+
+        // Convert between PCS
+        Rgb pcsTo = Rgb.FromProfileConnectingSpace(options, in pcsFrom);
+
+        // Convert to output from PCS
+        return TTo.FromProfileConnectingSpace(options, pcsTo);
+    }
+
+    public static void Convert<TFrom, TTo>(this ColorProfileConverter converter, ReadOnlySpan<TFrom> source, Span<TTo> destination)
+        where TFrom : struct, IColorProfile<TFrom, CieXyz>
+        where TTo : struct, IColorProfile<TTo, Rgb>
+    {
+        ColorConversionOptions options = converter.Options;
+
+        // Convert to input PCS.
+        using IMemoryOwner<CieXyz> pcsFromOwner = options.MemoryAllocator.Allocate<CieXyz>(source.Length);
+        Span<CieXyz> pcsFrom = pcsFromOwner.GetSpan();
+        TFrom.ToProfileConnectionSpace(options, source, pcsFrom);
+
+        // Adapt to target white point
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, pcsFrom, pcsFrom);
+
+        // Convert between PCS.
+        using IMemoryOwner<Rgb> pcsToOwner = options.MemoryAllocator.Allocate<Rgb>(source.Length);
+        Span<Rgb> pcsTo = pcsToOwner.GetSpan();
+        Rgb.FromProfileConnectionSpace(options, pcsFrom, pcsTo);
+
+        // Convert to output from PCS
+        TTo.FromProfileConnectionSpace(options, pcsTo, destination);
+    }
+}

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsRgbCieXyz.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Buffers;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+internal static class ColorProfileConverterExtensionsRgbCieXyz
+{
+    public static TTo Convert<TFrom, TTo>(this ColorProfileConverter converter, TFrom source)
+        where TFrom : struct, IColorProfile<TFrom, Rgb>
+        where TTo : struct, IColorProfile<TTo, CieXyz>
+    {
+        ColorConversionOptions options = converter.Options;
+
+        // Convert to input PCS
+        Rgb pcsFrom = source.ToProfileConnectingSpace(options);
+
+        // Convert between PCS
+        CieXyz pcsTo = pcsFrom.ToProfileConnectingSpace(options);
+
+        // Adapt to target white point
+        pcsTo = VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, in pcsTo);
+
+        // Convert to output from PCS
+        return TTo.FromProfileConnectingSpace(options, pcsTo);
+    }
+
+    public static void Convert<TFrom, TTo>(this ColorProfileConverter converter, ReadOnlySpan<TFrom> source, Span<TTo> destination)
+        where TFrom : struct, IColorProfile<TFrom, Rgb>
+        where TTo : struct, IColorProfile<TTo, CieXyz>
+    {
+        ColorConversionOptions options = converter.Options;
+
+        // Convert to input PCS.
+        using IMemoryOwner<Rgb> pcsFromOwner = options.MemoryAllocator.Allocate<Rgb>(source.Length);
+        Span<Rgb> pcsFrom = pcsFromOwner.GetSpan();
+        TFrom.ToProfileConnectionSpace(options, source, pcsFrom);
+
+        // Convert between PCS.
+        using IMemoryOwner<CieXyz> pcsToOwner = options.MemoryAllocator.Allocate<CieXyz>(source.Length);
+        Span<CieXyz> pcsTo = pcsToOwner.GetSpan();
+        Rgb.ToProfileConnectionSpace(options, pcsFrom, pcsTo);
+
+        // Adapt to target white point
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, pcsTo, pcsTo);
+
+        // Convert to output from PCS
+        TTo.FromProfileConnectionSpace(options, pcsTo, destination);
+    }
+}

src/ImageSharp/ColorProfiles/Rgb.cs

@@ -7,7 +7,10 @@ using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
 
 namespace SixLabors.ImageSharp.ColorProfiles;
 
-internal readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
+/// <summary>
+/// Represents an RGB (red, green, blue) color profile.
+/// </summary>
+public readonly struct Rgb : IProfileConnectingSpace<Rgb, CieXyz>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="Rgb"/> struct.

src/ImageSharp/ColorProfiles/YCbCr.cs

@@ -0,0 +1,158 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Represents an YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification for the JFIF use with Jpeg.
+/// <see href="http://en.wikipedia.org/wiki/YCbCr"/>
+/// <see href="http://www.ijg.org/files/T-REC-T.871-201105-I!!PDF-E.pdf"/>
+/// </summary>
+public readonly struct YCbCr : IColorProfile<YCbCr, Rgb>
+{
+    private static readonly Vector3 Min = Vector3.Zero;
+    private static readonly Vector3 Max = new(255);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YCbCr"/> struct.
+    /// </summary>
+    /// <param name="y">The y luminance component.</param>
+    /// <param name="cb">The cb chroma component.</param>
+    /// <param name="cr">The cr chroma component.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public YCbCr(float y, float cb, float cr)
+        : this(new Vector3(y, cb, cr))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="YCbCr"/> struct.
+    /// </summary>
+    /// <param name="vector">The vector representing the y, cb, cr components.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public YCbCr(Vector3 vector)
+    {
+        vector = Vector3.Clamp(vector, Min, Max);
+        this.Y = vector.X;
+        this.Cb = vector.Y;
+        this.Cr = vector.Z;
+    }
+
+    /// <summary>
+    /// Gets the Y luminance component.
+    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// </summary>
+    public readonly float Y { get; }
+
+    /// <summary>
+    /// Gets the Cb chroma component.
+    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// </summary>
+    public readonly float Cb { get; }
+
+    /// <summary>
+    /// Gets the Cr chroma component.
+    /// <remarks>A value ranging between 0 and 255.</remarks>
+    /// </summary>
+    public readonly float Cr { get; }
+
+    /// <summary>
+    /// Compares two <see cref="YCbCr"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="YCbCr"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="YCbCr"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    public static bool operator ==(YCbCr left, YCbCr right) => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="YCbCr"/> objects for inequality.
+    /// </summary>
+    /// <param name="left">The <see cref="YCbCr"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="YCbCr"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator !=(YCbCr left, YCbCr right) => !left.Equals(right);
+
+    /// <inheritdoc/>
+    public static YCbCr FromProfileConnectingSpace(ColorConversionOptions options, in Rgb source)
+    {
+        Vector3 rgb = source.ToScaledVector3() * Max;
+        float r = rgb.X;
+        float g = rgb.Y;
+        float b = rgb.Z;
+
+        float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
+        float cb = 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b));
+        float cr = 128F + ((0.5F * r) - (0.418688F * g) - (0.081312F * b));
+
+        return new YCbCr(y, cb, cr);
+    }
+
+    /// <inheritdoc/>
+    public static void FromProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<Rgb> source, Span<YCbCr> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            Rgb rgb = source[i];
+            destination[i] = FromProfileConnectingSpace(options, in rgb);
+        }
+    }
+
+    /// <inheritdoc/>
+    public Rgb ToProfileConnectingSpace(ColorConversionOptions options)
+    {
+        float y = this.Y;
+        float cb = this.Cb - 128F;
+        float cr = this.Cr - 128F;
+
+        float r = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero);
+        float g = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero);
+        float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
+
+        return Rgb.FromScaledVector3(new Vector3(r, g, b) / Max);
+    }
+
+    /// <inheritdoc/>
+    public static void ToProfileConnectionSpace(ColorConversionOptions options, ReadOnlySpan<YCbCr> source, Span<Rgb> destination)
+    {
+        Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
+
+        // TODO: We can optimize this by using SIMD
+        for (int i = 0; i < source.Length; i++)
+        {
+            YCbCr ycbcr = source[i];
+            destination[i] = ycbcr.ToProfileConnectingSpace(options);
+        }
+    }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource()
+        => ChromaticAdaptionWhitePointSource.RgbWorkingSpace;
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public override int GetHashCode() => HashCode.Combine(this.Y, this.Cb, this.Cr);
+
+    /// <inheritdoc/>
+    public override string ToString() => FormattableString.Invariant($"YCbCr({this.Y}, {this.Cb}, {this.Cr})");
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj) => obj is YCbCr other && this.Equals(other);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public bool Equals(YCbCr other)
+        => this.Y.Equals(other.Y)
+        && this.Cb.Equals(other.Cb)
+        && this.Cr.Equals(other.Cr);
+}

tests/ImageSharp.Tests/ColorProfiles/ApproximateColorProfileComparer.cs

@@ -14,7 +14,8 @@ internal readonly struct ApproximateColorProfileComparer :
     IEqualityComparer<CieXyz>,
     IEqualityComparer<Lms>,
     IEqualityComparer<CieLch>,
-    IEqualityComparer<Rgb>
+    IEqualityComparer<Rgb>,
+    IEqualityComparer<YCbCr>
 {
     private readonly float epsilon;
 
@@ -34,6 +35,8 @@ internal readonly struct ApproximateColorProfileComparer :
 
     public bool Equals(Rgb x, Rgb y) => this.Equals(x.R, y.R) && this.Equals(x.G, y.G) && this.Equals(x.B, y.B);
 
+    public bool Equals(YCbCr x, YCbCr y) => this.Equals(x.Y, y.Y) && this.Equals(x.Cb, y.Cb) && this.Equals(x.Cr, y.Cr);
+
     public int GetHashCode([DisallowNull] CieLab obj) => obj.GetHashCode();
 
     public int GetHashCode([DisallowNull] CieXyz obj) => obj.GetHashCode();
@@ -44,6 +47,8 @@ internal readonly struct ApproximateColorProfileComparer :
 
     public int GetHashCode([DisallowNull] Rgb obj) => obj.GetHashCode();
 
+    public int GetHashCode([DisallowNull] YCbCr obj) => obj.GetHashCode();
+
     private bool Equals(float x, float y)
     {
         float d = x - y;

tests/ImageSharp.Tests/ColorProfiles/RgbAndYCbCrConversionTest.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.ColorProfiles;
+
+namespace SixLabors.ImageSharp.Tests.ColorProfiles.Conversion;
+
+/// <summary>
+/// Tests <see cref="Rgb"/>-<see cref="YCbCr"/> conversions.
+/// </summary>
+/// <remarks>
+/// Test data generated mathematically
+/// </remarks>
+public class RgbAndYCbCrConversionTest
+{
+    private static readonly ApproximateColorProfileComparer Comparer = new(.001F);
+
+    [Theory]
+    [InlineData(255, 128, 128, 1, 1, 1)]
+    [InlineData(0, 128, 128, 0, 0, 0)]
+    [InlineData(128, 128, 128, 0.502, 0.502, 0.502)]
+    public void Convert_YCbCr_To_Rgb(float y, float cb, float cr, float r, float g, float b)
+    {
+        // Arrange
+        YCbCr input = new(y, cb, cr);
+        Rgb expected = new(r, g, b);
+        ColorProfileConverter converter = new();
+
+        Span<YCbCr> inputSpan = new YCbCr[5];
+        inputSpan.Fill(input);
+
+        Span<Rgb> actualSpan = new Rgb[5];
+
+        // Act
+        Rgb actual = converter.Convert<YCbCr, Rgb>(input);
+        converter.Convert<YCbCr, Rgb>(inputSpan, actualSpan);
+
+        // Assert
+        Assert.Equal(expected, actual, Comparer);
+
+        for (int i = 0; i < actualSpan.Length; i++)
+        {
+            Assert.Equal(expected, actualSpan[i], Comparer);
+        }
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0, 0, 128, 128)]
+    [InlineData(1, 1, 1, 255, 128, 128)]
+    [InlineData(0.5, 0.5, 0.5, 127.5, 128, 128)]
+    [InlineData(1, 0, 0, 76.245, 84.972, 255)]
+    public void Convert_Rgb_To_YCbCr(float r, float g, float b, float y, float cb, float cr)
+    {
+        // Arrange
+        Rgb input = new(r, g, b);
+        YCbCr expected = new(y, cb, cr);
+        ColorProfileConverter converter = new();
+
+        Span<Rgb> inputSpan = new Rgb[5];
+        inputSpan.Fill(input);
+
+        Span<YCbCr> actualSpan = new YCbCr[5];
+
+        // Act
+        YCbCr actual = converter.Convert<Rgb, YCbCr>(input);
+        converter.Convert<Rgb, YCbCr>(inputSpan, actualSpan);
+
+        // Assert
+        Assert.Equal(expected, actual, Comparer);
+
+        for (int i = 0; i < actualSpan.Length; i++)
+        {
+            Assert.Equal(expected, actualSpan[i], Comparer);
+        }
+    }
+}