Remove JpegSubsample and use JpegColorType instead

Author: brianpopow

src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs

@@ -16,13 +16,7 @@ internal interface IJpegEncoderOptions
         public int? Quality { get; set; }
 
         /// <summary>
-        /// Gets the subsample ration, that will be used to encode the image.
-        /// </summary>
-        /// <value>The subsample ratio of the jpg image.</value>
-        JpegSubsample? Subsample { get; }
-
-        /// <summary>
-        /// Gets the color type.
+        /// Gets the color type, that will be used to encode the image.
         /// </summary>
         JpegColorType? ColorType { get; }
     }

src/ImageSharp/Formats/Jpeg/JpegColorType.cs

@@ -10,12 +10,26 @@ public enum JpegColorType : byte
     {
         /// <summary>
         /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.
+        /// Medium Quality - The horizontal sampling is halved and the Cb and Cr channels are only
+        /// sampled on each alternate line.
         /// </summary>
-        YCbCr = 0,
+        YCbCrRatio420 = 0,
+
+        /// <summary>
+        /// YCbCr (luminance, blue chroma, red chroma) color as defined in the ITU-T T.871 specification.
+        /// High Quality - Each of the three Y'CbCr components have the same sample rate,
+        /// thus there is no chroma subsampling.
+        /// </summary>
+        YCbCrRatio444 = 1,
 
         /// <summary>
         /// Single channel, luminance.
         /// </summary>
-        Luminance = 1
+        Luminance = 2,
+
+        /// <summary>
+        /// The pixel data will be preserved as RGB without any sub sampling.
+        /// </summary>
+        Rgb,
     }
 }

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -312,7 +312,7 @@ internal void ParseStream(BufferedReadStream stream, HuffmanScanDecoder scanDeco
                         case JpegConstants.Markers.SOS:
                             if (!metadataOnly)
                             {
-                                this.ProcessStartOfScanMarker(stream, remaining, cancellationToken);
+                                this.ProcessStartOfScanMarker(stream, remaining);
                                 break;
                             }
                             else
@@ -953,7 +953,18 @@ private void ProcessStartOfFrameMarker(BufferedReadStream stream, int remaining,
 
             this.ColorSpace = this.DeduceJpegColorSpace(componentCount, this.Frame.Components);
 
-            this.Metadata.GetJpegMetadata().ColorType = this.ColorSpace == JpegColorSpace.Grayscale ? JpegColorType.Luminance : JpegColorType.YCbCr;
+            switch (this.ColorSpace)
+            {
+                case JpegColorSpace.Grayscale:
+                    this.Metadata.GetJpegMetadata().ColorType = JpegColorType.Luminance;
+                    break;
+                case JpegColorSpace.RGB:
+                    this.Metadata.GetJpegMetadata().ColorType = JpegColorType.Rgb;
+                    break;
+                default:
+                    this.Metadata.GetJpegMetadata().ColorType = JpegColorType.YCbCrRatio420;
+                    break;
+            }
 
             if (!metadataOnly)
             {
@@ -1051,7 +1062,7 @@ private void ProcessDefineRestartIntervalMarker(BufferedReadStream stream, int r
         /// <summary>
         /// Processes the SOS (Start of scan marker).
         /// </summary>
-        private void ProcessStartOfScanMarker(BufferedReadStream stream, int remaining, CancellationToken cancellationToken)
+        private void ProcessStartOfScanMarker(BufferedReadStream stream, int remaining)
         {
             if (this.Frame is null)
             {

src/ImageSharp/Formats/Jpeg/JpegEncoder.cs

@@ -16,14 +16,7 @@ public sealed class JpegEncoder : IImageEncoder, IJpegEncoderOptions
         /// <inheritdoc/>
         public int? Quality { get; set; }
 
-        /// <summary>
-        /// Gets or sets the subsample ration, that will be used to encode the image.
-        /// </summary>
-        public JpegSubsample? Subsample { get; set; }
-
-        /// <summary>
-        /// Gets or sets the color type, that will be used to encode the image.
-        /// </summary>
+        /// <inheritdoc/>
         public JpegColorType? ColorType { get; set; }
 
         /// <summary>
@@ -36,7 +29,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
         where TPixel : unmanaged, IPixel<TPixel>
         {
             var encoder = new JpegEncoderCore(this);
-            this.InitializeColorType<TPixel>(image);
+            this.InitializeColorType(image);
             encoder.Encode(image, stream);
         }
 
@@ -52,7 +45,7 @@ public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, Cancellation
             where TPixel : unmanaged, IPixel<TPixel>
         {
             var encoder = new JpegEncoderCore(this);
-            this.InitializeColorType<TPixel>(image);
+            this.InitializeColorType(image);
             return encoder.EncodeAsync(image, stream, cancellationToken);
         }
 
@@ -75,7 +68,7 @@ private void InitializeColorType<TPixel>(Image<TPixel> image)
                 bool isGrayscale =
                     typeof(TPixel) == typeof(L8) || typeof(TPixel) == typeof(L16) ||
                     typeof(TPixel) == typeof(La16) || typeof(TPixel) == typeof(La32);
-                this.ColorType = isGrayscale ? JpegColorType.Luminance : JpegColorType.YCbCr;
+                this.ColorType = isGrayscale ? JpegColorType.Luminance : JpegColorType.YCbCrRatio420;
             }
         }
     }

src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs

@@ -33,20 +33,15 @@ internal sealed unsafe class JpegEncoderCore : IImageEncoderInternals
         /// </summary>
         private readonly byte[] buffer = new byte[20];
 
-        /// <summary>
-        /// Gets or sets the subsampling method to use.
-        /// </summary>
-        private JpegSubsample? subsample;
-
         /// <summary>
         /// The quality, that will be used to encode the image.
         /// </summary>
         private readonly int? quality;
 
         /// <summary>
-        /// Gets or sets the subsampling method to use.
+        /// Gets or sets the colorspace to use.
         /// </summary>
-        private readonly JpegColorType? colorType;
+        private JpegColorType? colorType;
 
         /// <summary>
         /// The output stream. All attempted writes after the first error become no-ops.
@@ -56,11 +51,10 @@ internal sealed unsafe class JpegEncoderCore : IImageEncoderInternals
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegEncoderCore"/> class.
         /// </summary>
-        /// <param name="options">The options</param>
+        /// <param name="options">The options.</param>
         public JpegEncoderCore(IJpegEncoderOptions options)
         {
             this.quality = options.Quality;
-            this.subsample = options.Subsample;
             this.colorType = options.ColorType;
         }
 
@@ -118,21 +112,22 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
             var scanEncoder = new HuffmanScanEncoder(stream);
             if (this.colorType == JpegColorType.Luminance)
             {
-                // luminance quantization table only
+                // luminance quantization table only.
                 scanEncoder.EncodeGrayscale(image, ref luminanceQuantTable, cancellationToken);
             }
             else
             {
-                // luminance and chrominance quantization tables
-                switch (this.subsample)
+                // luminance and chrominance quantization tables.
+                switch (this.colorType)
                 {
-                    case JpegSubsample.Ratio444:
+                    case JpegColorType.YCbCrRatio444:
+                    case JpegColorType.Luminance:
                         scanEncoder.Encode444(image, ref luminanceQuantTable, ref chrominanceQuantTable, cancellationToken);
                         break;
-                    case JpegSubsample.Ratio420:
+                    case JpegColorType.YCbCrRatio420:
                         scanEncoder.Encode420(image, ref luminanceQuantTable, ref chrominanceQuantTable, cancellationToken);
                         break;
-                    case JpegSubsample.Rgb:
+                    case JpegColorType.Rgb:
                         scanEncoder.EncodeRgb(image, ref luminanceQuantTable, ref chrominanceQuantTable, cancellationToken);
                         break;
                 }
@@ -151,7 +146,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken
         /// <returns>The component Ids.</returns>
         private byte[] GetComponentIds()
         {
-            if (this.subsample == JpegSubsample.Rgb)
+            if (this.colorType == JpegColorType.Rgb)
             {
                 return new byte[] { 82, 71, 66 };
             }
@@ -268,7 +263,7 @@ private void WriteDefineHuffmanTables(int componentCount)
         /// </summary>
         private void WriteDefineQuantizationTables(ref Block8x8F luminanceQuantTable, ref Block8x8F chrominanceQuantTable)
         {
-            // Marker + quantization table lengths
+            // Marker + quantization table lengths.
             int markerlen = 2 + (QuantizationTableCount * (1 + Block8x8F.Size));
             this.WriteMarkerHeader(JpegConstants.Markers.DQT, markerlen);
 
@@ -404,7 +399,7 @@ private void WriteAppHeader(int length, byte appMarker)
         /// </summary>
         /// <param name="iccProfile">The ICC profile to write.</param>
         /// <exception cref="ImageFormatException">
-        /// Thrown if any of the ICC profiles size exceeds the limit
+        /// Thrown if any of the ICC profiles size exceeds the limit.
         /// </exception>
         private void WriteIccProfile(IccProfile iccProfile)
         {
@@ -424,7 +419,7 @@ private void WriteIccProfile(IccProfile iccProfile)
                 return;
             }
 
-            // Calculate the number of markers we'll need, rounding up of course
+            // Calculate the number of markers we'll need, rounding up of course.
             int dataLength = data.Length;
             int count = dataLength / MaxData;
 
@@ -531,18 +526,18 @@ private void WriteStartOfFrame(int width, int height, int componentCount, byte[]
             }
             else
             {
-                switch (this.subsample)
+                switch (this.colorType)
                 {
-                    case JpegSubsample.Rgb:
-                    case JpegSubsample.Ratio444:
+                    case JpegColorType.YCbCrRatio444:
+                    case JpegColorType.Rgb:
                         subsamples = stackalloc byte[]
                         {
                             0x11,
                             0x11,
                             0x11
                         };
                         break;
-                    case JpegSubsample.Ratio420:
+                    case JpegColorType.YCbCrRatio420:
                         subsamples = stackalloc byte[]
                         {
                             0x22,
@@ -685,9 +680,9 @@ private void InitQuantizationTables(int componentCount, JpegMetadata metadata, o
                 chromaQuality = Numerics.Clamp(chromaQuality, 1, 100);
                 chrominanceQuantTable = Quantization.ScaleChrominanceTable(chromaQuality);
 
-                if (!this.subsample.HasValue)
+                if (!this.colorType.HasValue)
                 {
-                    this.subsample = chromaQuality >= 91 ? JpegSubsample.Ratio444 : JpegSubsample.Ratio420;
+                    this.colorType = chromaQuality >= 91 ? JpegColorType.YCbCrRatio444 : JpegColorType.YCbCrRatio420;
                 }
             }
         }

src/ImageSharp/Formats/Jpeg/JpegSubsample.cs

@@ -35,7 +35,7 @@ public override void CompressStrip(Span<byte> rows, int height)
             var image = Image.LoadPixelData<Rgb24>(rows, width, height);
             image.Save(memoryStream, new JpegEncoder()
             {
-                Subsample = JpegSubsample.Rgb
+                ColorType = JpegColorType.Rgb
             });
             memoryStream.Position = 0;
             memoryStream.WriteTo(this.Output);

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

@@ -40,8 +40,8 @@ public void ReadImages()
 
                 this.bmpCore = Image.Load<Rgba32>(this.bmpStream);
                 this.bmpCore.Metadata.ExifProfile = null;
-                this.encoder420 = new JpegEncoder { Quality = this.Quality, Subsample = JpegSubsample.Ratio420 };
-                this.encoder444 = new JpegEncoder { Quality = this.Quality, Subsample = JpegSubsample.Ratio444 };
+                this.encoder420 = new JpegEncoder { Quality = this.Quality, ColorType = JpegColorType.YCbCrRatio420 };
+                this.encoder444 = new JpegEncoder { Quality = this.Quality, ColorType = JpegColorType.YCbCrRatio444 };
 
                 this.bmpStream.Position = 0;
                 this.bmpDrawing = SDImage.FromStream(this.bmpStream);