Moved color convertes to 'Components' folder

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromCmykAvx.cs

@@ -7,7 +7,7 @@ using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykScalar.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromCmykScalar.cs

@@ -3,7 +3,7 @@
 
 using System;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmykVector.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromCmykVector.cs

@@ -5,7 +5,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromGrayScaleAvx.cs

@@ -7,7 +7,7 @@ using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleScalar.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromGrayScaleScalar.cs

@@ -5,7 +5,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScaleVector.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromGrayScaleVector.cs

@@ -5,7 +5,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromRgbAvx.cs

@@ -7,7 +7,7 @@ using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbScalar.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromRgbScalar.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgbVector.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromRgbVector.cs

@@ -5,7 +5,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromYCbCrAvx.cs

@@ -9,7 +9,7 @@ using System.Runtime.Intrinsics.X86;
 using static SixLabors.ImageSharp.SimdUtils;
 
 // ReSharper disable ImpureMethodCallOnReadonlyValueField
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrScalar.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromYCbCrScalar.cs

@@ -3,7 +3,7 @@
 
 using System;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrVector.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromYCbCrVector.cs

@@ -6,7 +6,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 // ReSharper disable ImpureMethodCallOnReadonlyValueField
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromYccKAvx.cs

@@ -8,7 +8,7 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using static SixLabors.ImageSharp.SimdUtils;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKScalar.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromYccKScalar.cs

@@ -3,7 +3,7 @@
 
 using System;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccKVector.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.FromYccKVector.cs

@@ -5,7 +5,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterAvx.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterAvx.cs

@@ -3,7 +3,7 @@
 #if SUPPORTS_RUNTIME_INTRINSICS
 using System.Runtime.Intrinsics.X86;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterBase.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using SixLabors.ImageSharp.Memory;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     /// <summary>
     /// Encapsulates the conversion of color channels from jpeg image to RGB channels.
@@ -110,9 +110,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         private static IEnumerable<JpegColorConverterBase> GetYCbCrConverters(int precision)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             yield return new FromYCbCrAvx(precision);
-#endif
             yield return new FromYCbCrVector(precision);
             yield return new FromYCbCrScalar(precision);
         }
@@ -122,9 +120,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         private static IEnumerable<JpegColorConverterBase> GetYccKConverters(int precision)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             yield return new FromYccKAvx(precision);
-#endif
             yield return new FromYccKVector(precision);
             yield return new FromYccKScalar(precision);
         }
@@ -134,9 +130,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         private static IEnumerable<JpegColorConverterBase> GetCmykConverters(int precision)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             yield return new FromCmykAvx(precision);
-#endif
             yield return new FromCmykVector(precision);
             yield return new FromCmykScalar(precision);
         }
@@ -146,9 +140,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         private static IEnumerable<JpegColorConverterBase> GetGrayScaleConverters(int precision)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             yield return new FromGrayscaleAvx(precision);
-#endif
             yield return new FromGrayScaleVector(precision);
             yield return new FromGrayscaleScalar(precision);
         }
@@ -158,9 +150,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         private static IEnumerable<JpegColorConverterBase> GetRgbConverters(int precision)
         {
-#if SUPPORTS_RUNTIME_INTRINSICS
             yield return new FromRgbAvx(precision);
-#endif
             yield return new FromRgbVector(precision);
             yield return new FromRgbScalar(precision);
         }
@@ -221,7 +211,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// </summary>
             /// <param name="processors">List of component color processors.</param>
             /// <param name="row">Row to convert</param>
-            public ComponentValues(IReadOnlyList<JpegComponentPostProcessor> processors, int row)
+            public ComponentValues(IReadOnlyList<Decoder.JpegComponentPostProcessor> processors, int row)
             {
                 DebugGuard.MustBeGreaterThan(processors.Count, 0, nameof(processors));
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterScalar.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterScalar.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterVector.cs → src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterVector.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Numerics;
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     internal abstract partial class JpegColorConverterBase
     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
-
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
     /// <summary>

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs

@@ -5,7 +5,6 @@ using System;
 using System.Buffers;
 using System.Linq;
 using System.Threading;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 

src/ImageSharp/Formats/Jpeg/Components/Encoder/JpegFrame.cs

@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
     /// </summary>
     internal sealed class JpegFrame : IDisposable
     {
-        public JpegFrame(JpegFrameConfig frameConfig, MemoryAllocator allocator, Image image, Decoder.JpegColorSpace colorSpace)
+        public JpegFrame(JpegFrameConfig frameConfig, MemoryAllocator allocator, Image image, JpegColorSpace colorSpace)
         {
             this.ColorSpace = colorSpace;
 
@@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             }
         }
 
-        public Decoder.JpegColorSpace ColorSpace { get; }
+        public JpegColorSpace ColorSpace { get; }
 
         public int PixelHeight { get; private set; }
 

src/ImageSharp/Formats/Jpeg/Components/Encoder/SpectralConverter{TPixel}.cs

@@ -27,7 +27,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
 
         private int alignedPixelWidth;
 
-        private Decoder.ColorConverters.JpegColorConverterBase colorConverter;
+        private JpegColorConverterBase colorConverter;
 
         public SpectralConverter(Configuration configuration) =>
             this.configuration = configuration;
@@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             this.rgbBuffer = allocator.Allocate<byte>(this.alignedPixelWidth * 3);
 
             // color converter from Rgb24 to YCbCr
-            this.colorConverter = Decoder.ColorConverters.JpegColorConverterBase.GetConverter(colorSpace: frame.ColorSpace, precision: 8);
+            this.colorConverter = JpegColorConverterBase.GetConverter(colorSpace: frame.ColorSpace, precision: 8);
         }
 
         public void ConvertStrideBaseline()
@@ -95,7 +95,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
                 Span<TPixel> sourceRow = this.pixelBuffer.DangerousGetRowSpan(yy);
                 PixelOperations<TPixel>.Instance.UnpackIntoRgbPlanes(this.configuration, r, g, b, sourceRow);
 
-                var values = new Decoder.ColorConverters.JpegColorConverterBase.ComponentValues(this.componentProcessors, y);
+                var values = new JpegColorConverterBase.ComponentValues(this.componentProcessors, y);
 
                 SimdUtils.ByteToNormalizedFloat(r, values.Component0);
                 SimdUtils.ByteToNormalizedFloat(g, values.Component1);

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegColorSpace.cs → src/ImageSharp/Formats/Jpeg/Components/JpegColorSpace.cs

@@ -1,15 +1,13 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
     /// <summary>
     /// Identifies the colorspace of a Jpeg image.
     /// </summary>
     internal enum JpegColorSpace
     {
-        Undefined = 0,
-
         /// <summary>
         /// Color space with 1 component.
         /// </summary>

src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs

@@ -18,6 +18,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Gets the color type, that will be used to encode the image.
         /// </summary>
-        JpegColorType? ColorType { get; }
+        JpegEncodingMode? ColorType { get; }
     }
 }

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -545,57 +545,57 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// Returns the jpeg color type based on the colorspace and subsampling used.
         /// </summary>
         /// <returns>Jpeg color type.</returns>
-        private JpegColorType DeduceJpegColorType()
+        private JpegEncodingMode DeduceJpegColorType()
         {
             switch (this.ColorSpace)
             {
                 case JpegColorSpace.Grayscale:
-                    return JpegColorType.Luminance;
+                    return JpegEncodingMode.Luminance;
 
                 case JpegColorSpace.RGB:
-                    return JpegColorType.Rgb;
+                    return JpegEncodingMode.Rgb;
 
                 case JpegColorSpace.YCbCr:
                     if (this.Frame.Components[0].HorizontalSamplingFactor == 1 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio444;
+                        return JpegEncodingMode.YCbCrRatio444;
                     }
                     else if (this.Frame.Components[0].HorizontalSamplingFactor == 2 && this.Frame.Components[0].VerticalSamplingFactor == 2 &&
                         this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio420;
+                        return JpegEncodingMode.YCbCrRatio420;
                     }
                     else if (this.Frame.Components[0].HorizontalSamplingFactor == 1 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
                         this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 2 &&
                         this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 2)
                     {
-                        return JpegColorType.YCbCrRatio422;
+                        return JpegEncodingMode.YCbCrRatio422;
                     }
                     else if (this.Frame.Components[0].HorizontalSamplingFactor == 4 && this.Frame.Components[0].VerticalSamplingFactor == 1 &&
                              this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                              this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio411;
+                        return JpegEncodingMode.YCbCrRatio411;
                     }
                     else if (this.Frame.Components[0].HorizontalSamplingFactor == 4 && this.Frame.Components[0].VerticalSamplingFactor == 2 &&
                              this.Frame.Components[1].HorizontalSamplingFactor == 1 && this.Frame.Components[1].VerticalSamplingFactor == 1 &&
                              this.Frame.Components[2].HorizontalSamplingFactor == 1 && this.Frame.Components[2].VerticalSamplingFactor == 1)
                     {
-                        return JpegColorType.YCbCrRatio410;
+                        return JpegEncodingMode.YCbCrRatio410;
                     }
                     else
                     {
-                        return JpegColorType.YCbCrRatio420;
+                        return JpegEncodingMode.YCbCrRatio420;
                     }
 
                 case JpegColorSpace.Cmyk:
-                    return JpegColorType.Cmyk;
+                    return JpegEncodingMode.Cmyk;
 
                 default:
-                    return JpegColorType.YCbCrRatio420;
+                    return JpegEncodingMode.YCbCrRatio420;
             }
         }
 

src/ImageSharp/Formats/Jpeg/JpegEncoder.cs

@@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public int? Quality { get; set; }
 
         /// <inheritdoc/>
-        public JpegColorType? ColorType { get; set; }
+        public JpegEncodingMode? ColorType { get; set; }
 
         public JpegFrameConfig JpegFrameConfig { get; set; }
 
@@ -53,28 +53,27 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
     public class JpegFrameConfig
     {
-        public JpegFrameConfig(JpegColorType colorType)
+        public JpegFrameConfig(JpegEncodingMode colorType)
         {
             this.ColorType = colorType;
 
             int componentCount = GetComponentCountFromColorType(colorType);
             this.Components = new JpegComponentConfig[componentCount];
 
-            static int GetComponentCountFromColorType(JpegColorType colorType)
+            static int GetComponentCountFromColorType(JpegEncodingMode colorType)
             {
                 switch (colorType)
                 {
-                    case JpegColorType.Luminance:
+                    case JpegEncodingMode.Luminance:
                         return 1;
-                    case JpegColorType.YCbCrRatio444:
+                    case JpegEncodingMode.YCbCrRatio444:
-                    case JpegColorType.YCbCrRatio422:
+                    case JpegEncodingMode.YCbCrRatio422:
-                    case JpegColorType.YCbCrRatio420:
+                    case JpegEncodingMode.YCbCrRatio420:
-                    case JpegColorType.YCbCrRatio411:
+                    case JpegEncodingMode.YCbCrRatio411:
-                    case JpegColorType.YCbCrRatio410:
+                    case JpegEncodingMode.YCbCrRatio410:
-                    case JpegColorType.Rgb:
+                    case JpegEncodingMode.Rgb:
                         return 3;
-                    case JpegColorType.Cmyk:
+                    case JpegEncodingMode.Cmyk:
-                    case JpegColorType.YccK:
                         return 4;
                     default:
                         throw new ArgumentException($"Unknown jpeg color space: {colorType}");
@@ -82,7 +81,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
         }
 
-        public JpegColorType ColorType { get; }
+        public JpegEncodingMode ColorType { get; }
 
         public JpegComponentConfig[] Components { get; }
 

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -42,7 +42,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Gets or sets the colorspace to use.
         /// </summary>
-        private JpegColorType? colorType;
+        private JpegEncodingMode? colorType;
 
         private JpegFrameConfig frameConfig;
 
@@ -95,7 +95,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.WriteStartOfImage();
 
             // Do not write APP0 marker for RGB colorspace.
-            if (this.colorType != JpegColorType.Rgb)
+            if (this.colorType != JpegEncodingMode.Rgb)
             {
                 this.WriteJfifApplicationHeader(metadata);
             }
@@ -103,7 +103,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             // Write Exif, XMP, ICC and IPTC profiles
             this.WriteProfiles(metadata);
 
-            if (this.colorType == JpegColorType.Rgb)
+            if (this.colorType == JpegEncodingMode.Rgb)
             {
                 // Write App14 marker to indicate RGB color space.
                 this.WriteApp14Marker();
@@ -130,21 +130,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
             stream.Flush();
 
-            static JpegColorSpace GetTargetColorSpace(JpegColorType colorType)
+            static JpegColorSpace GetTargetColorSpace(JpegEncodingMode colorType)
             {
                 switch (colorType)
                 {
-                    case JpegColorType.YCbCrRatio444:
+                    case JpegEncodingMode.YCbCrRatio444:
-                    case JpegColorType.YCbCrRatio422:
+                    case JpegEncodingMode.YCbCrRatio422:
-                    case JpegColorType.YCbCrRatio420:
+                    case JpegEncodingMode.YCbCrRatio420:
-                    case JpegColorType.YCbCrRatio411:
+                    case JpegEncodingMode.YCbCrRatio411:
-                    case JpegColorType.YCbCrRatio410:
+                    case JpegEncodingMode.YCbCrRatio410:
                         return JpegColorSpace.YCbCr;
-                    case JpegColorType.Rgb:
+                    case JpegEncodingMode.Rgb:
                         return JpegColorSpace.RGB;
-                    case JpegColorType.Cmyk:
+                    case JpegEncodingMode.Cmyk:
                         return JpegColorSpace.Cmyk;
-                    case JpegColorType.Luminance:
+                    case JpegEncodingMode.Luminance:
                         return JpegColorSpace.Grayscale;
                     default:
                         throw new NotImplementedException($"Unknown output color space: {colorType}");
@@ -158,11 +158,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// returns <see langword="null"/> defering the field assignment
         /// to <see cref="InitQuantizationTables(int, JpegMetadata, out Block8x8F, out Block8x8F)"/>.
         /// </summary>
-        private static JpegColorType? GetFallbackColorType<TPixel>(Image<TPixel> image)
+        private static JpegEncodingMode? GetFallbackColorType<TPixel>(Image<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // First inspect the image metadata.
-            JpegColorType? colorType = null;
+            JpegEncodingMode? colorType = null;
             JpegMetadata metadata = image.Metadata.GetJpegMetadata();
             if (IsSupportedColorType(metadata.ColorType))
             {
@@ -179,7 +179,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             // the quality in InitQuantizationTables.
             if (isGrayscale)
             {
-                colorType = JpegColorType.Luminance;
+                colorType = JpegEncodingMode.Luminance;
             }
 
             return colorType;
@@ -190,11 +190,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         /// <param name="colorType">The color type.</param>
         /// <returns>true, if color type is supported.</returns>
-        private static bool IsSupportedColorType(JpegColorType? colorType)
+        private static bool IsSupportedColorType(JpegEncodingMode? colorType)
-            => colorType == JpegColorType.YCbCrRatio444
+            => colorType == JpegEncodingMode.YCbCrRatio444
-            || colorType == JpegColorType.YCbCrRatio420
+            || colorType == JpegEncodingMode.YCbCrRatio420
-            || colorType == JpegColorType.Luminance
+            || colorType == JpegEncodingMode.Luminance
-            || colorType == JpegColorType.Rgb;
+            || colorType == JpegEncodingMode.Rgb;
 
         /// <summary>
         /// Writes data to "Define Quantization Tables" block for QuantIndex.
@@ -783,7 +783,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
                 if (!this.colorType.HasValue)
                 {
-                    this.colorType = chromaQuality >= 91 ? JpegColorType.YCbCrRatio444 : JpegColorType.YCbCrRatio420;
+                    this.colorType = chromaQuality >= 91 ? JpegEncodingMode.YCbCrRatio444 : JpegEncodingMode.YCbCrRatio420;
                 }
             }
         }

src/ImageSharp/Formats/Jpeg/JpegColorType.cs → src/ImageSharp/Formats/Jpeg/JpegEncodingMode.cs

@@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// <summary>
     /// Provides enumeration of available JPEG color types.
     /// </summary>
-    public enum JpegColorType : byte
+    public enum JpegEncodingMode : byte
     {
         /// <summary>
         /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.

src/ImageSharp/Formats/Jpeg/JpegMetadata.cs

@@ -108,7 +108,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Gets or sets the color type.
         /// </summary>
-        public JpegColorType? ColorType { get; set; }
+        public JpegEncodingMode? ColorType { get; set; }
 
         /// <inheritdoc/>
         public IDeepCloneable DeepClone() => new JpegMetadata(this);

src/ImageSharp/Formats/Tiff/Compression/Compressors/TiffJpegCompressor.cs

@@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors
             var image = Image.LoadPixelData<Rgb24>(rows, width, height);
             image.Save(memoryStream, new JpegEncoder()
             {
-                ColorType = JpegColorType.Rgb
+                ColorType = JpegEncodingMode.Rgb
             });
             memoryStream.Position = 0;
             memoryStream.WriteTo(this.Output);

src/ImageSharp/Formats/Tiff/Compression/Decompressors/GrayJpegSpectralConverter.cs

@@ -1,8 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors

src/ImageSharp/Formats/Tiff/Compression/Decompressors/RgbJpegSpectralConverter.cs

@@ -1,8 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors

tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpegComparison.cs

@@ -42,7 +42,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
             using FileStream imageBinaryStream = File.OpenRead(Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImage));
 
             this.imageImageSharp = Image.Load<Rgba32>(imageBinaryStream);
-            this.encoderImageSharp = new JpegEncoder { Quality = this.Quality, ColorType = JpegColorType.YCbCrRatio420 };
+            this.encoderImageSharp = new JpegEncoder { Quality = this.Quality, ColorType = JpegEncodingMode.YCbCrRatio420 };
 
             this.destinationStream = new MemoryStream();
         }

tests/ImageSharp.Benchmarks/Codecs/Jpeg/EncodeJpegFeatures.cs

@@ -22,14 +22,14 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
         // No metadata
         private const string TestImage = TestImages.Jpeg.Baseline.Calliphora;
 
-        public static IEnumerable<JpegColorType> ColorSpaceValues =>
+        public static IEnumerable<JpegEncodingMode> ColorSpaceValues =>
-            new[] { JpegColorType.Luminance, JpegColorType.Rgb, JpegColorType.YCbCrRatio420, JpegColorType.YCbCrRatio444 };
+            new[] { JpegEncodingMode.Luminance, JpegEncodingMode.Rgb, JpegEncodingMode.YCbCrRatio420, JpegEncodingMode.YCbCrRatio444 };
 
         [Params(75, 90, 100)]
         public int Quality;
 
         [ParamsSource(nameof(ColorSpaceValues), Priority = -100)]
-        public JpegColorType TargetColorSpace;
+        public JpegEncodingMode TargetColorSpace;
 
         private Image<Rgb24> bmpCore;
         private JpegEncoder encoder;

tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs

@@ -2,11 +2,9 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Numerics;
 using SixLabors.ImageSharp.ColorSpaces;
 using SixLabors.ImageSharp.ColorSpaces.Conversion;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.Tests.Colorspaces.Conversion;
 using SixLabors.ImageSharp.Tests.TestUtilities;
@@ -46,7 +44,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [Fact]
         public void GetConverterThrowsExceptionOnInvalidColorSpace()
         {
-            Assert.Throws<Exception>(() => JpegColorConverterBase.GetConverter(JpegColorSpace.Undefined, 8));
+            var invalidColorSpace = (JpegColorSpace)(-1);
+            Assert.Throws<Exception>(() => JpegColorConverterBase.GetConverter(invalidColorSpace, 8));
         }
 
         [Fact]
@@ -357,7 +356,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 case JpegColorSpace.YCbCr:
                     ValidateYCbCr(original, result, i);
                     break;
-                case JpegColorSpace.Undefined:
                 default:
                     Assert.True(false, $"Invalid Colorspace enum value: {colorSpace}.");
                     break;

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Metadata.cs

@@ -139,15 +139,15 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         }
 
         [Theory]
-        [InlineData(TestImages.Jpeg.Baseline.Floorplan, JpegColorType.Luminance)]
+        [InlineData(TestImages.Jpeg.Baseline.Floorplan, JpegEncodingMode.Luminance)]
-        [InlineData(TestImages.Jpeg.Baseline.Jpeg420Small, JpegColorType.YCbCrRatio420)]
+        [InlineData(TestImages.Jpeg.Baseline.Jpeg420Small, JpegEncodingMode.YCbCrRatio420)]
-        [InlineData(TestImages.Jpeg.Baseline.Jpeg444, JpegColorType.YCbCrRatio444)]
+        [InlineData(TestImages.Jpeg.Baseline.Jpeg444, JpegEncodingMode.YCbCrRatio444)]
-        [InlineData(TestImages.Jpeg.Baseline.JpegRgb, JpegColorType.Rgb)]
+        [InlineData(TestImages.Jpeg.Baseline.JpegRgb, JpegEncodingMode.Rgb)]
-        [InlineData(TestImages.Jpeg.Baseline.Cmyk, JpegColorType.Cmyk)]
+        [InlineData(TestImages.Jpeg.Baseline.Cmyk, JpegEncodingMode.Cmyk)]
-        [InlineData(TestImages.Jpeg.Baseline.Jpeg410, JpegColorType.YCbCrRatio410)]
+        [InlineData(TestImages.Jpeg.Baseline.Jpeg410, JpegEncodingMode.YCbCrRatio410)]
-        [InlineData(TestImages.Jpeg.Baseline.Jpeg422, JpegColorType.YCbCrRatio422)]
+        [InlineData(TestImages.Jpeg.Baseline.Jpeg422, JpegEncodingMode.YCbCrRatio422)]
-        [InlineData(TestImages.Jpeg.Baseline.Jpeg411, JpegColorType.YCbCrRatio411)]
+        [InlineData(TestImages.Jpeg.Baseline.Jpeg411, JpegEncodingMode.YCbCrRatio411)]
-        public void Identify_DetectsCorrectColorType(string imagePath, JpegColorType expectedColorType)
+        public void Identify_DetectsCorrectColorType(string imagePath, JpegEncodingMode expectedColorType)
         {
             var testFile = TestFile.Create(imagePath);
             using (var stream = new MemoryStream(testFile.Bytes, false))
@@ -159,12 +159,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         }
 
         [Theory]
-        [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgb24, JpegColorType.Luminance)]
+        [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgb24, JpegEncodingMode.Luminance)]
-        [WithFile(TestImages.Jpeg.Baseline.Jpeg420Small, PixelTypes.Rgb24, JpegColorType.YCbCrRatio420)]
+        [WithFile(TestImages.Jpeg.Baseline.Jpeg420Small, PixelTypes.Rgb24, JpegEncodingMode.YCbCrRatio420)]
-        [WithFile(TestImages.Jpeg.Baseline.Jpeg444, PixelTypes.Rgb24, JpegColorType.YCbCrRatio444)]
+        [WithFile(TestImages.Jpeg.Baseline.Jpeg444, PixelTypes.Rgb24, JpegEncodingMode.YCbCrRatio444)]
-        [WithFile(TestImages.Jpeg.Baseline.JpegRgb, PixelTypes.Rgb24, JpegColorType.Rgb)]
+        [WithFile(TestImages.Jpeg.Baseline.JpegRgb, PixelTypes.Rgb24, JpegEncodingMode.Rgb)]
-        [WithFile(TestImages.Jpeg.Baseline.Cmyk, PixelTypes.Rgb24, JpegColorType.Cmyk)]
+        [WithFile(TestImages.Jpeg.Baseline.Cmyk, PixelTypes.Rgb24, JpegEncodingMode.Cmyk)]
-        public void Decode_DetectsCorrectColorType<TPixel>(TestImageProvider<TPixel> provider, JpegColorType expectedColorType)
+        public void Decode_DetectsCorrectColorType<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode expectedColorType)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage(JpegDecoder))

tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs

@@ -33,18 +33,18 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 { TestImages.Jpeg.Progressive.Fb, 75 }
             };
 
-        public static readonly TheoryData<JpegColorType, int> BitsPerPixel_Quality =
+        public static readonly TheoryData<JpegEncodingMode, int> BitsPerPixel_Quality =
             new()
             {
-                { JpegColorType.YCbCrRatio420, 40 },
+                { JpegEncodingMode.YCbCrRatio420, 40 },
-                { JpegColorType.YCbCrRatio420, 60 },
+                { JpegEncodingMode.YCbCrRatio420, 60 },
-                { JpegColorType.YCbCrRatio420, 100 },
+                { JpegEncodingMode.YCbCrRatio420, 100 },
-                { JpegColorType.YCbCrRatio444, 40 },
+                { JpegEncodingMode.YCbCrRatio444, 40 },
-                { JpegColorType.YCbCrRatio444, 60 },
+                { JpegEncodingMode.YCbCrRatio444, 60 },
-                { JpegColorType.YCbCrRatio444, 100 },
+                { JpegEncodingMode.YCbCrRatio444, 100 },
-                { JpegColorType.Rgb, 40 },
+                { JpegEncodingMode.Rgb, 40 },
-                { JpegColorType.Rgb, 60 },
+                { JpegEncodingMode.Rgb, 60 },
-                { JpegColorType.Rgb, 100 }
+                { JpegEncodingMode.Rgb, 100 }
             };
 
         public static readonly TheoryData<int> Grayscale_Quality =
@@ -64,11 +64,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             };
 
         [Theory]
-        [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgba32, JpegColorType.Luminance)]
+        [WithFile(TestImages.Jpeg.Baseline.Floorplan, PixelTypes.Rgba32, JpegEncodingMode.Luminance)]
-        [WithFile(TestImages.Jpeg.Baseline.Jpeg444, PixelTypes.Rgba32, JpegColorType.YCbCrRatio444)]
+        [WithFile(TestImages.Jpeg.Baseline.Jpeg444, PixelTypes.Rgba32, JpegEncodingMode.YCbCrRatio444)]
-        [WithFile(TestImages.Jpeg.Baseline.Jpeg420Small, PixelTypes.Rgba32, JpegColorType.YCbCrRatio420)]
+        [WithFile(TestImages.Jpeg.Baseline.Jpeg420Small, PixelTypes.Rgba32, JpegEncodingMode.YCbCrRatio420)]
-        [WithFile(TestImages.Jpeg.Baseline.JpegRgb, PixelTypes.Rgba32, JpegColorType.Rgb)]
+        [WithFile(TestImages.Jpeg.Baseline.JpegRgb, PixelTypes.Rgba32, JpegEncodingMode.Rgb)]
-        public void Encode_PreservesColorType<TPixel>(TestImageProvider<TPixel> provider, JpegColorType expectedColorType)
+        public void Encode_PreservesColorType<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode expectedColorType)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             // arrange
@@ -107,15 +107,15 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             memoryStream.Position = 0;
             using var output = Image.Load<Rgba32>(memoryStream);
             JpegMetadata meta = output.Metadata.GetJpegMetadata();
-            Assert.Equal(JpegColorType.YCbCrRatio420, meta.ColorType);
+            Assert.Equal(JpegEncodingMode.YCbCrRatio420, meta.ColorType);
         }
 
         [Theory]
-        [InlineData(JpegColorType.Cmyk)]
+        [InlineData(JpegEncodingMode.Cmyk)]
-        [InlineData(JpegColorType.YCbCrRatio410)]
+        [InlineData(JpegEncodingMode.YCbCrRatio410)]
-        [InlineData(JpegColorType.YCbCrRatio411)]
+        [InlineData(JpegEncodingMode.YCbCrRatio411)]
-        [InlineData(JpegColorType.YCbCrRatio422)]
+        [InlineData(JpegEncodingMode.YCbCrRatio422)]
-        public void Encode_WithUnsupportedColorType_DefaultsToYCbCr420(JpegColorType colorType)
+        public void Encode_WithUnsupportedColorType_DefaultsToYCbCr420(JpegEncodingMode colorType)
         {
             // arrange
             var jpegEncoder = new JpegEncoder() { ColorType = colorType };
@@ -129,7 +129,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             memoryStream.Position = 0;
             using var output = Image.Load<Rgba32>(memoryStream);
             JpegMetadata meta = output.Metadata.GetJpegMetadata();
-            Assert.Equal(JpegColorType.YCbCrRatio420, meta.ColorType);
+            Assert.Equal(JpegEncodingMode.YCbCrRatio420, meta.ColorType);
         }
 
         [Theory]
@@ -155,7 +155,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 
         [Theory]
         [WithFile(TestImages.Png.CalliphoraPartial, nameof(BitsPerPixel_Quality), PixelTypes.Rgba32)]
-        public void EncodeBaseline_CalliphoraPartial<TPixel>(TestImageProvider<TPixel> provider, JpegColorType colorType, int quality)
+        public void EncodeBaseline_CalliphoraPartial<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode colorType, int quality)
             where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, colorType, quality);
 
         [Theory]
@@ -164,7 +164,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 153, 21, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 600, 400, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 138, 24, PixelTypes.Rgba32)]
-        public void EncodeBaseline_WorksWithDifferentSizes<TPixel>(TestImageProvider<TPixel> provider, JpegColorType colorType, int quality)
+        public void EncodeBaseline_WorksWithDifferentSizes<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode colorType, int quality)
             where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, colorType, quality);
 
         [Theory]
@@ -177,7 +177,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 48, 24, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 46, 8, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 51, 7, PixelTypes.Rgba32)]
-        public void EncodeBaseline_WithSmallImages_WorksWithDifferentSizes<TPixel>(TestImageProvider<TPixel> provider, JpegColorType colorType, int quality)
+        public void EncodeBaseline_WithSmallImages_WorksWithDifferentSizes<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode colorType, int quality)
             where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, colorType, quality, comparer: ImageComparer.Tolerant(0.12f));
 
         [Theory]
@@ -188,27 +188,27 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [WithSolidFilledImages(1, 1, 100, 100, 100, 255, PixelTypes.La16, 100)]
         [WithSolidFilledImages(1, 1, 100, 100, 100, 255, PixelTypes.La32, 100)]
         public void EncodeBaseline_Grayscale<TPixel>(TestImageProvider<TPixel> provider, int quality)
-            where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, JpegColorType.Luminance, quality);
+            where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, JpegEncodingMode.Luminance, quality);
 
         [Theory]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 96, 96, PixelTypes.Rgba32 | PixelTypes.Bgra32)]
-        public void EncodeBaseline_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, JpegColorType colorType, int quality)
+        public void EncodeBaseline_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode colorType, int quality)
             where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, colorType, quality);
 
         [Theory]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 48, 48, PixelTypes.Rgba32 | PixelTypes.Bgra32)]
-        public void EncodeBaseline_WithSmallImages_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, JpegColorType colorType, int quality)
+        public void EncodeBaseline_WithSmallImages_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode colorType, int quality)
             where TPixel : unmanaged, IPixel<TPixel> => TestJpegEncoderCore(provider, colorType, quality, comparer: ImageComparer.Tolerant(0.06f));
 
         [Theory]
-        [WithFile(TestImages.Png.CalliphoraPartial, PixelTypes.Rgba32, JpegColorType.YCbCrRatio444)]
+        [WithFile(TestImages.Png.CalliphoraPartial, PixelTypes.Rgba32, JpegEncodingMode.YCbCrRatio444)]
-        [WithTestPatternImages(587, 821, PixelTypes.Rgba32, JpegColorType.YCbCrRatio444)]
+        [WithTestPatternImages(587, 821, PixelTypes.Rgba32, JpegEncodingMode.YCbCrRatio444)]
-        [WithTestPatternImages(677, 683, PixelTypes.Bgra32, JpegColorType.YCbCrRatio420)]
+        [WithTestPatternImages(677, 683, PixelTypes.Bgra32, JpegEncodingMode.YCbCrRatio420)]
-        [WithSolidFilledImages(400, 400, "Red", PixelTypes.Bgr24, JpegColorType.YCbCrRatio420)]
+        [WithSolidFilledImages(400, 400, "Red", PixelTypes.Bgr24, JpegEncodingMode.YCbCrRatio420)]
-        public void EncodeBaseline_WorksWithDiscontiguousBuffers<TPixel>(TestImageProvider<TPixel> provider, JpegColorType colorType)
+        public void EncodeBaseline_WorksWithDiscontiguousBuffers<TPixel>(TestImageProvider<TPixel> provider, JpegEncodingMode colorType)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            ImageComparer comparer = colorType == JpegColorType.YCbCrRatio444
+            ImageComparer comparer = colorType == JpegEncodingMode.YCbCrRatio444
                 ? ImageComparer.TolerantPercentage(0.1f)
                 : ImageComparer.TolerantPercentage(5f);
 
@@ -219,7 +219,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         /// <summary>
         /// Anton's SUPER-SCIENTIFIC tolerance threshold calculation
         /// </summary>
-        private static ImageComparer GetComparer(int quality, JpegColorType? colorType)
+        private static ImageComparer GetComparer(int quality, JpegEncodingMode? colorType)
         {
             float tolerance = 0.015f; // ~1.5%
 
@@ -227,10 +227,10 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             {
                 tolerance *= 4.5f;
             }
-            else if (quality < 75 || colorType == JpegColorType.YCbCrRatio420)
+            else if (quality < 75 || colorType == JpegEncodingMode.YCbCrRatio420)
             {
                 tolerance *= 2.0f;
-                if (colorType == JpegColorType.YCbCrRatio420)
+                if (colorType == JpegEncodingMode.YCbCrRatio420)
                 {
                     tolerance *= 2.0f;
                 }
@@ -241,7 +241,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 
         private static void TestJpegEncoderCore<TPixel>(
             TestImageProvider<TPixel> provider,
-            JpegColorType colorType = JpegColorType.YCbCrRatio420,
+            JpegEncodingMode colorType = JpegEncodingMode.YCbCrRatio420,
             int quality = 100,
             ImageComparer comparer = null)
             where TPixel : unmanaged, IPixel<TPixel>
@@ -396,9 +396,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         }
 
         [Theory]
-        [InlineData(JpegColorType.YCbCrRatio420)]
+        [InlineData(JpegEncodingMode.YCbCrRatio420)]
-        [InlineData(JpegColorType.YCbCrRatio444)]
+        [InlineData(JpegEncodingMode.YCbCrRatio444)]
-        public async Task Encode_IsCancellable(JpegColorType colorType)
+        public async Task Encode_IsCancellable(JpegEncodingMode colorType)
         {
             var cts = new CancellationTokenSource();
             using var pausedStream = new PausedStream(new MemoryStream());

tests/ImageSharp.Tests/Formats/Jpg/JpegMetadataTests.cs

@@ -12,11 +12,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [Fact]
         public void CloneIsDeep()
         {
-            var meta = new JpegMetadata { Quality = 50, ColorType = JpegColorType.Luminance };
+            var meta = new JpegMetadata { Quality = 50, ColorType = JpegEncodingMode.Luminance };
             var clone = (JpegMetadata)meta.DeepClone();
 
             clone.Quality = 99;
-            clone.ColorType = JpegColorType.YCbCrRatio420;
+            clone.ColorType = JpegEncodingMode.YCbCrRatio420;
 
             Assert.False(meta.Quality.Equals(clone.Quality));
             Assert.False(meta.ColorType.Equals(clone.ColorType));

tests/ImageSharp.Tests/ProfilingBenchmarks/JpegProfilingBenchmarks.cs

@@ -91,11 +91,11 @@ namespace SixLabors.ImageSharp.Tests.ProfilingBenchmarks
 
         // Benchmark, enable manually!
         [Theory(Skip = ProfilingSetup.SkipProfilingTests)]
-        [InlineData(1, 75, JpegColorType.YCbCrRatio420)]
+        [InlineData(1, 75, JpegEncodingMode.YCbCrRatio420)]
-        [InlineData(30, 75, JpegColorType.YCbCrRatio420)]
+        [InlineData(30, 75, JpegEncodingMode.YCbCrRatio420)]
-        [InlineData(30, 75, JpegColorType.YCbCrRatio444)]
+        [InlineData(30, 75, JpegEncodingMode.YCbCrRatio444)]
-        [InlineData(30, 100, JpegColorType.YCbCrRatio444)]
+        [InlineData(30, 100, JpegEncodingMode.YCbCrRatio444)]
-        public void EncodeJpeg(int executionCount, int quality, JpegColorType colorType)
+        public void EncodeJpeg(int executionCount, int quality, JpegEncodingMode colorType)
         {
             // do not run this on CI even by accident
             if (TestEnvironment.RunsOnCI)