Add YCbCr

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLab.cs

@@ -149,5 +149,18 @@ namespace ImageSharp.ColorSpaces.Conversion
             CieXyz xyzColor = this.ToCieXyz(color);
             return this.ToCieLab(xyzColor);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="CieLab"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLab"/></returns>
+        public CieLab ToCieLab(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLab(xyzColor);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLch.cs

@@ -136,5 +136,18 @@ namespace ImageSharp.ColorSpaces.Conversion
             CieXyz xyzColor = this.ToCieXyz(color);
             return this.ToCieLch(xyzColor);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="CieLch"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLch"/></returns>
+        public CieLch ToCieLch(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLch(xyzColor);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieXyy.cs

@@ -137,5 +137,19 @@ namespace ImageSharp.ColorSpaces.Conversion
 
             return this.ToCieXyy(xyzColor);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="CieXyy"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieXyy"/></returns>
+        public CieXyy ToCieXyy(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToCieXyy(xyzColor);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieXyz.cs

@@ -166,6 +166,21 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieXyz(linear);
         }
 
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="CieXyz"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieXyz"/></returns>
+        public CieXyz ToCieXyz(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Conversion
+            Rgb rgb = this.ToRgb(color);
+
+            return this.ToCieXyz(rgb);
+        }
+
         /// <summary>
         /// Gets the correct converter for the given rgb working space.
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Cmyk.cs

@@ -138,5 +138,19 @@ namespace ImageSharp.ColorSpaces.Conversion
 
             return CmykAndRgbConverter.Convert(color);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="Cmyk"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Cmyk"/></returns>
+        public Cmyk ToCmyk(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return CmykAndRgbConverter.Convert(rgb);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Hsl.cs

@@ -138,5 +138,19 @@ namespace ImageSharp.ColorSpaces.Conversion
 
             return HslAndRgbConverter.Convert(color);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="Hsl"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsl"/></returns>
+        public Hsl ToHsl(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HslAndRgbConverter.Convert(rgb);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.HunterLab.cs

@@ -133,5 +133,18 @@ namespace ImageSharp.ColorSpaces.Conversion
             CieXyz xyzColor = this.ToCieXyz(color);
             return this.ToHunterLab(xyzColor);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="HunterLab"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="HunterLab"/></returns>
+        public HunterLab ToHunterLab(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToHunterLab(xyzColor);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.LinearRgb.cs

@@ -139,6 +139,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return RgbToLinearRgbConverter.Convert(color);
         }
 
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="LinearRgb"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="LinearRgb"/></returns>
+        public LinearRgb ToLinearRgb(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+            return this.ToLinearRgb(rgb);
+        }
+
         /// <summary>
         /// Gets the correct converter for the given rgb working space.
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Lms.cs

@@ -128,5 +128,18 @@ namespace ImageSharp.ColorSpaces.Conversion
             CieXyz xyzColor = this.ToCieXyz(color);
             return this.ToLms(xyzColor);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="Lms"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Lms"/></returns>
+        public Lms ToLms(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToLms(xyzColor);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Rgb.cs

@@ -133,5 +133,18 @@ namespace ImageSharp.ColorSpaces.Conversion
             CieXyz xyzColor = this.ToCieXyz(color);
             return this.ToRgb(xyzColor);
         }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="Rgb"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Rgb"/></returns>
+        public Rgb ToRgb(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Conversion
+            return YCbCrAndRgbConverter.Convert(color);
+        }
     }
 }

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.YCbCr.cs

@@ -0,0 +1,156 @@
+// <copyright file="ColorSpaceConverter.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces.Conversion
+{
+    using ImageSharp.ColorSpaces;
+    using ImageSharp.ColorSpaces.Conversion.Implementation.YCbCr;
+
+    /// <summary>
+    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
+    /// </summary>
+    public partial class ColorSpaceConverter
+    {
+        private static readonly YCbCrAndRgbConverter YCbCrAndRgbConverter = new YCbCrAndRgbConverter();
+
+        /// <summary>
+        /// Converts a <see cref="CieLab"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(CieLab color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToYCbCr(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieLch"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(CieLch color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToYCbCr(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieXyy"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(CieXyy color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToYCbCr(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieXyz"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(CieXyz color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return YCbCrAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Cmyk"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(Cmyk color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return YCbCrAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Hsl"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(Hsl color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return YCbCrAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="HunterLab"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(HunterLab color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToYCbCr(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="LinearRgb"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(LinearRgb color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return YCbCrAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Lms"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(Lms color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToYCbCr(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Rgb"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(Rgb color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            return YCbCrAndRgbConverter.Convert(color);
+        }
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/YCbCr/YCbCrAndRgbConverter.cs

@@ -0,0 +1,52 @@
+// <copyright file="YCbCrAndRgbConverter .cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces.Conversion.Implementation.YCbCr
+{
+    using System;
+    using System.Numerics;
+    using System.Runtime.CompilerServices;
+
+    using ImageSharp.ColorSpaces;
+
+    /// <summary>
+    /// Color converter between YCbCr and Rgb
+    /// See <see href="https://en.wikipedia.org/wiki/YCbCr#JPEG_conversion"/> for formulas.
+    /// </summary>
+    internal class YCbCrAndRgbConverter : IColorConversion<YCbCr, Rgb>, IColorConversion<Rgb, YCbCr>
+    {
+        private static readonly Vector3 MaxBytes = new Vector3(255F);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Rgb Convert(YCbCr input)
+        {
+            DebugGuard.NotNull(input, nameof(input));
+
+            float y = input.Y;
+            float cb = input.Cb - 128F;
+            float cr = input.Cr - 128F;
+
+
+            return new Rgb(new Vector3(r, g, b) / MaxBytes);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public YCbCr Convert(Rgb input)
+        {
+            DebugGuard.NotNull(input, nameof(input));
+
+            Vector3 rgb = input.Vector * MaxBytes;
+            float r = rgb.X;
+            float g = rgb.Y;
+            float b = rgb.Z;
+
+            float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
+
+            return new YCbCr(y, cb, cr);
+        }
+    }
+}

src/ImageSharp/ColorSpaces/YCbCr.cs

@@ -0,0 +1,183 @@
+// <copyright file="YCbCr.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces
+{
+    using System;
+    using System.ComponentModel;
+    using System.Numerics;
+    using System.Runtime.CompilerServices;
+
+    /// <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 struct YCbCr : IColorVector, IEquatable<YCbCr>, IAlmostEquatable<YCbCr, float>
+    {
+        /// <summary>
+        /// Represents a <see cref="YCbCr"/> that has Y, Cb, and Cr values set to zero.
+        /// </summary>
+        public static readonly YCbCr Empty = default(YCbCr);
+
+        /// <summary>
+        /// Vector which is used in clamping to the max value
+        /// </summary>
+        private static readonly Vector3 VectorMax = new Vector3(255F);
+
+        /// <summary>
+        /// The backing vector for SIMD support.
+        /// </summary>
+        private readonly Vector3 backingVector;
+
+        /// <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(MethodImplOptions.AggressiveInlining)]
+        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(MethodImplOptions.AggressiveInlining)]
+        public YCbCr(Vector3 vector)
+        {
+            this.backingVector = Vector3.Clamp(vector, Vector3.Zero, VectorMax);
+        }
+
+        /// <summary>
+        /// Gets the Y luminance component.
+        /// <remarks>A value ranging between 0 and 255.</remarks>
+        /// </summary>
+        public float Y
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.X;
+        }
+
+        /// <summary>
+        /// Gets the Cb chroma component.
+        /// <remarks>A value ranging between 0 and 255.</remarks>
+        /// </summary>
+        public float Cb
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.Y;
+        }
+
+        /// <summary>
+        /// Gets the Cr chroma component.
+        /// <remarks>A value ranging between 0 and 255.</remarks>
+        /// </summary>
+        public float Cr
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.Z;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="YCbCr"/> is empty.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool IsEmpty => this.Equals(Empty);
+
+        /// <inheritdoc/>
+        public Vector3 Vector
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector;
+        }
+
+        /// <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>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator ==(YCbCr left, YCbCr right)
+        {
+            return 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(MethodImplOptions.AggressiveInlining)]
+        public static bool operator !=(YCbCr left, YCbCr right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return this.backingVector.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            if (this.IsEmpty)
+            {
+                return "YCbCr [ Empty ]";
+            }
+
+            return $"YCbCr [ Y={this.Y}, Cb={this.Cb}, Cr={this.Cr} ]";
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override bool Equals(object obj)
+        {
+            if (obj is YCbCr)
+            {
+                return this.Equals((YCbCr)obj);
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(YCbCr other)
+        {
+            return this.backingVector.Equals(other.backingVector);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool AlmostEquals(YCbCr other, float precision)
+        {
+            Vector3 result = Vector3.Abs(this.backingVector - other.backingVector);
+
+            return result.X <= precision
+                   && result.Y <= precision
+                   && result.Z <= precision;
+        }
+    }
+}

src/ImageSharp/Common/Helpers/MathF.cs

@@ -201,6 +201,25 @@ namespace ImageSharp
             return (float)Math.Round(f);
         }
 
+        /// <summary>
+        /// Rounds a single-precision floating-point value to the nearest integer.
+        /// A parameter specifies how to round the value if it is midway between two numbers.
+        /// </summary>
+        /// <param name="f">A single-precision floating-point number to be rounded. </param>
+        /// <param name="mode">Specification for how to round <paramref name="f" /> if it is midway between two other numbers.</param>
+        /// <returns>
+        /// The integer nearest <paramref name="f" />. If <paramref name="f" /> is halfway between two integers, one of which is even
+        /// and the other odd, then <paramref name="mode" /> determines which of the two is returned.
+        /// Note that this method returns a <see cref="T:System.Single" /> instead of an integral type.
+        /// </returns>
+        /// <exception cref="T:System.ArgumentException">
+        /// <paramref name="mode" /> is not a valid value of <see cref="T:System.MidpointRounding" />.</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Round(float f, MidpointRounding mode)
+        {
+            return (float)Math.Round(f, mode);
+        }
+
         /// <summary>
         /// Returns the sine of the specified angle.
         /// </summary>

tests/ImageSharp.Tests/Colors/Colorspaces/ColorSpaceEqualityTests.cs

@@ -27,7 +27,8 @@ namespace ImageSharp.Tests.Colors
                     Lms.Empty,
                     LinearRgb.Empty,
                     Rgb.Empty,
-                    Hsl.Empty
+                    Hsl.Empty,
+                    YCbCr.Empty
                 };
 
         public static readonly TheoryData<object, object, Type> EqualityData =
@@ -42,6 +43,7 @@ namespace ImageSharp.Tests.Colors
                { new LinearRgb(Vector3.One), new LinearRgb(Vector3.One), typeof(LinearRgb) },
                { new Rgb(Vector3.One), new Rgb(Vector3.One), typeof(Rgb) },
                { new Hsl(Vector3.One), new Hsl(Vector3.One), typeof(Hsl) },
+               { new YCbCr(Vector3.One), new YCbCr(Vector3.One), typeof(YCbCr) },
            };
 
         public static readonly TheoryData<object, object, Type> NotEqualityDataNulls =
@@ -57,6 +59,7 @@ namespace ImageSharp.Tests.Colors
                { new LinearRgb(Vector3.One), null, typeof(LinearRgb) },
                { new Rgb(Vector3.One), null, typeof(Rgb) },
                { new Hsl(Vector3.One), null, typeof(Hsl) },
+               { new YCbCr(Vector3.One), null, typeof(YCbCr) },
             };
 
         public static readonly TheoryData<object, object, Type> NotEqualityDataDifferentObjects =
@@ -68,6 +71,7 @@ namespace ImageSharp.Tests.Colors
                 { new Rgb(Vector3.One), new LinearRgb(Vector3.Zero), null },
                 { new Rgb(Vector3.One), new Lms(Vector3.Zero), null },
                 { new Cmyk(Vector4.One), new Hsl(Vector3.Zero), null },
+                { new YCbCr(Vector3.One), new CieXyy(Vector3.Zero), null },
            };
 
         public static readonly TheoryData<object, object, Type> NotEqualityData =
@@ -84,6 +88,7 @@ namespace ImageSharp.Tests.Colors
                { new Rgb(Vector3.One), new Rgb(Vector3.Zero), typeof(Rgb) },
                { new Cmyk(Vector4.One), new Cmyk(Vector4.Zero), typeof(Cmyk) },
                { new Hsl(Vector3.One), new Hsl(Vector3.Zero), typeof(Hsl) },
+               { new YCbCr(Vector3.One), new YCbCr(Vector3.Zero), typeof(YCbCr) },
            };
 
         public static readonly TheoryData<object, object, Type, float> AlmostEqualsData =
@@ -101,6 +106,7 @@ namespace ImageSharp.Tests.Colors
                 { new CieXyz(380F, 380F, 380F), new CieXyz(380F, 380.001F, 380F), typeof(CieXyz), .01F },
                 { new CieXyz(380F, 380F, 380F), new CieXyz(380F, 380F, 380.001F), typeof(CieXyz), .01F },
                 { new Cmyk(1, 1, 1, 1), new Cmyk(1, 1, 1, .99F), typeof(Cmyk), .01F },
+                { new YCbCr(255F, 128F, 128F), new YCbCr(255F, 128F, 128.001F), typeof(YCbCr), .01F },
             };
 
         public static readonly TheoryData<object, object, Type, float> AlmostNotEqualsData =

tests/ImageSharp.Tests/Colors/Colorspaces/RgbAndYCbCrConversionTest.cs

@@ -0,0 +1,66 @@
+namespace ImageSharp.Tests.Colors.Colorspaces
+{
+    using System.Collections.Generic;
+
+    using ImageSharp.ColorSpaces;
+    using ImageSharp.ColorSpaces.Conversion;
+
+    using Xunit;
+
+    /// <summary>
+    /// Tests <see cref="Rgb"/>-<see cref="YCbCr"/> conversions.
+    /// </summary>
+    /// <remarks>
+    /// Test data generated mathematically
+    /// </remarks>
+    public class RgbAndYCbCrConversionTest
+    {
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(3);
+
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="YCbCr"/> to <see cref="Rgb"/>.
+        /// </summary>
+        [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 YCbCr(y, cb, cr);
+
+            // Act
+            Rgb output = Converter.ToRgb(input);
+
+            // Assert
+            Assert.Equal(Rgb.DefaultWorkingSpace, output.WorkingSpace);
+            Assert.Equal(r, output.R, FloatRoundingComparer);
+            Assert.Equal(g, output.G, FloatRoundingComparer);
+            Assert.Equal(b, output.B, FloatRoundingComparer);
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Rgb"/> to <see cref="YCbCr"/>.
+        /// </summary>
+        [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 Rgb(r, g, b);
+
+            // Act
+            YCbCr output = Converter.ToYCbCr(input);
+
+            // Assert
+            Assert.Equal(y, output.Y, FloatRoundingComparer);
+            Assert.Equal(cb, output.Cb, FloatRoundingComparer);
+            Assert.Equal(cr, output.Cr, FloatRoundingComparer);
+        }
+    }
+}

tests/ImageSharp.Tests/Helpers/MathFTests.cs

@@ -66,12 +66,44 @@
             Assert.Equal(MathF.Pow(1.2345F, 5.4321F), (float)Math.Pow(1.2345F, 5.4321F));
         }
 
+        [Fact]
+        public void MathF_Round_Is_Equal()
+        {
+            Assert.Equal(MathF.Round(1.2345F), (float)Math.Round(1.2345F));
+        }
+
+        [Fact]
+        public void MathF_Round_With_Midpoint_Is_Equal()
+        {
+            Assert.Equal(MathF.Round(1.2345F, MidpointRounding.AwayFromZero), (float)Math.Round(1.2345F, MidpointRounding.AwayFromZero));
+        }
+
         [Fact]
         public void MathF_Sin_Is_Equal()
         {
             Assert.Equal(MathF.Sin(1.2345F), (float)Math.Sin(1.2345F));
         }
 
+        [Fact]
+        public void MathF_SinC_Is_Equal()
+        {
+            float f = 1.2345F;
+            float expected;
+            if (Math.Abs(f) > Constants.Epsilon)
+            {
+                f *= (float)Math.PI;
+                float sinC = (float)Math.Sin(f) / f;
+
+                expected = Math.Abs(sinC) < Constants.Epsilon ? 0F : sinC;
+            }
+            else
+            {
+                expected = 1F;
+            }
+
+            Assert.Equal(MathF.SinC(1.2345F), expected);
+        }
+
         [Fact]
         public void MathF_Sqrt_Is_Equal()
         {