Work on 12-bit support

src/ImageSharp/Common/Tuples/Vector4Pair.cs

@@ -37,12 +37,12 @@ namespace SixLabors.ImageSharp.Tuples
             this.B += other.B;
         }
 
-        /// <summary>
+        /// <summary>. Works only if Ve
-        /// Downscale method, specific to Jpeg color conversion. Works only if Vector{float}.Count == 4!
+        /// Downscale method, specific to Jpeg color conversctor{float}.Count == 4!
         /// TODO: Move it somewhere else.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void RoundAndDownscalePreAvx2()
+        internal void RoundAndDownscalePreAvx2(float downscaleFactor)
         {
             ref Vector<float> a = ref Unsafe.As<Vector4, Vector<float>>(ref this.A);
             a = a.FastRound();
@@ -50,8 +50,8 @@ namespace SixLabors.ImageSharp.Tuples
             ref Vector<float> b = ref Unsafe.As<Vector4, Vector<float>>(ref this.B);
             b = b.FastRound();
 
-            // Downscale by 1/255
+            // Downscale by 1/factor
-            var scale = new Vector4(1 / 255f);
+            var scale = new Vector4(1 / downscaleFactor);
             this.A *= scale;
             this.B *= scale;
         }
@@ -61,14 +61,14 @@ namespace SixLabors.ImageSharp.Tuples
         /// TODO: Move it somewhere else.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void RoundAndDownscaleAvx2()
+        internal void RoundAndDownscaleAvx2(float downscaleFactor)
         {
             ref Vector<float> self = ref Unsafe.As<Vector4Pair, Vector<float>>(ref this);
             Vector<float> v = self;
             v = v.FastRound();
 
-            // Downscale by 1/255
+            // Downscale by 1/factor
-            v *= new Vector<float>(1 / 255f);
+            v *= new Vector<float>(1 / downscaleFactor);
             self = v;
         }
 

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.cs

@@ -9,10 +9,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
 	internal partial struct Block8x8F
     {
-        private static readonly Vector4 CMin4 = new Vector4(0F);
-        private static readonly Vector4 CMax4 = new Vector4(255F);
-        private static readonly Vector4 COff4 = new Vector4(128F);
-
 		/// <summary>
         /// Transpose the block into the destination block.
         /// </summary>
@@ -94,10 +90,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         }
 
 		/// <summary>
-        /// Level shift by +128, clip to [0, 255]
+        /// Level shift by +maximum/2, clip to [0, maximum]
         /// </summary>
-        public void NormalizeColorsInplace()
+        public void NormalizeColorsInplace(float maximum)
         {
+            Vector4 CMin4 = new Vector4(0F);
+            Vector4 CMax4 = new Vector4(maximum);
+            Vector4 COff4 = new Vector4(maximum/2 + 1);
+
             this.V0L = Vector4.Clamp(this.V0L + COff4, CMin4, CMax4);
             this.V0R = Vector4.Clamp(this.V0R + COff4, CMin4, CMax4);
             this.V1L = Vector4.Clamp(this.V1L + COff4, CMin4, CMax4);
@@ -120,10 +120,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// AVX2-only variant for executing <see cref="NormalizeColorsInplace"/> and <see cref="RoundInplace"/> in one step.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void NormalizeColorsAndRoundInplaceAvx2()
+        public void NormalizeColorsAndRoundInplaceAvx2(float maximum)
         {
-            Vector<float> off = new Vector<float>(128f);
+            Vector<float> off = new Vector<float>(maximum/2 +1);
-            Vector<float> max = new Vector<float>(255F);
+            Vector<float> max = new Vector<float>(maximum);
             
             ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V0L);
             row0 = NormalizeAndRound(row0, off, max);

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt

@@ -22,10 +22,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
 {
 	internal partial struct Block8x8F
     {
-        private static readonly Vector4 CMin4 = new Vector4(0F);
-        private static readonly Vector4 CMax4 = new Vector4(255F);
-        private static readonly Vector4 COff4 = new Vector4(128F);
-
 		/// <summary>
         /// Transpose the block into the destination block.
         /// </summary>
@@ -59,10 +55,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         }
 
 		/// <summary>
-        /// Level shift by +128, clip to [0, 255]
+        /// Level shift by +maximum/2, clip to [0, maximum]
         /// </summary>
-        public void NormalizeColorsInplace()
+        public void NormalizeColorsInplace(float maximum)
         {
+            Vector4 CMin4 = new Vector4(0F);
+            Vector4 CMax4 = new Vector4(maximum);
+            Vector4 COff4 = new Vector4(maximum/2 + 1);
+
             <#
 
 			PushIndent("            ");
@@ -83,10 +83,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// AVX2-only variant for executing <see cref="NormalizeColorsInplace"/> and <see cref="RoundInplace"/> in one step.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void NormalizeColorsAndRoundInplaceAvx2()
+        public void NormalizeColorsAndRoundInplaceAvx2(float maximum)
         {
-            Vector<float> off = new Vector<float>(128f);
+            Vector<float> off = new Vector<float>(maximum/2 +1);
-            Vector<float> max = new Vector<float>(255F);
+            Vector<float> max = new Vector<float>(maximum);
             <#
 
             for (int i = 0; i < 8; i++)

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs

@@ -467,17 +467,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         }
 
         /// <summary>
-        /// Level shift by +128, clip to [0..255], and round all the values in the block.
+        /// Level shift by +maximum/2, clip to [0..maximum], and round all the values in the block.
         /// </summary>
-        public void NormalizeColorsAndRoundInplace()
+        public void NormalizeColorsAndRoundInplace(float maximum)
         {
             if (SimdUtils.IsAvx2CompatibleArchitecture)
             {
-                this.NormalizeColorsAndRoundInplaceAvx2();
+                this.NormalizeColorsAndRoundInplaceAvx2(maximum);
             }
             else
             {
-                this.NormalizeColorsInplace();
+                this.NormalizeColorsInplace(maximum);
                 this.RoundInplace();
             }
         }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmyk.cs

@@ -10,8 +10,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromCmyk : JpegColorConverter
         {
-            public FromCmyk()
+            public FromCmyk(int precision)
-                : base(JpegColorSpace.Cmyk)
+                : base(JpegColorSpace.Cmyk, precision)
             {
             }
 
@@ -25,14 +25,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
                 var v = new Vector4(0, 0, 0, 1F);
 
-                var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F);
+                var scale = new Vector4(1 / this.MaximumValue, 
+                                        1 / this.MaximumValue, 
+                                        1 / this.MaximumValue, 
+                                        1F);
 
                 for (int i = 0; i < result.Length; i++)
                 {
                     float c = cVals[i];
                     float m = mVals[i];
                     float y = yVals[i];
-                    float k = kVals[i] / 255F;
+                    float k = kVals[i] / this.MaximumValue;
 
                     v.X = c * k;
                     v.Y = m * k;

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScale.cs

@@ -12,14 +12,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromGrayscale : JpegColorConverter
         {
-            public FromGrayscale()
+            public FromGrayscale(int precision)
-                : base(JpegColorSpace.Grayscale)
+                : base(JpegColorSpace.Grayscale, precision)
             {
             }
 
             public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
-                var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F);
+                var scale = new Vector4(1 / this.MaximumValue,
+                                        1 / this.MaximumValue,
+                                        1 / this.MaximumValue,
+                                        1F);
 
                 ref float sBase = ref MemoryMarshal.GetReference(values.Component0);
                 ref Vector4 dBase = ref MemoryMarshal.GetReference(result);

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgb.cs

@@ -10,8 +10,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromRgb : JpegColorConverter
         {
-            public FromRgb()
+            public FromRgb(int precision)
-                : base(JpegColorSpace.RGB)
+                : base(JpegColorSpace.RGB, precision)
             {
             }
 
@@ -24,7 +24,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
                 var v = new Vector4(0, 0, 0, 1);
 
-                var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F);
+                var scale = new Vector4(1 / this.MaximumValue,
+                                        1 / this.MaximumValue,
+                                        1 / this.MaximumValue,
+                                        1F);
 
                 for (int i = 0; i < result.Length; i++)
                 {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrBasic.cs

@@ -10,8 +10,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromYCbCrBasic : JpegColorConverter
         {
-            public FromYCbCrBasic()
+            public FromYCbCrBasic(int precision)
-                : base(JpegColorSpace.YCbCr)
+                : base(JpegColorSpace.YCbCr, precision)
             {
             }
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs

@@ -14,8 +14,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromYCbCrSimd : JpegColorConverter
         {
-            public FromYCbCrSimd()
+            public FromYCbCrSimd(int precision)
-                : base(JpegColorSpace.YCbCr)
+                : base(JpegColorSpace.YCbCr, precision)
             {
             }
 
@@ -25,7 +25,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 int simdCount = result.Length - remainder;
                 if (simdCount > 0)
                 {
-                    ConvertCore(values.Slice(0, simdCount), result.Slice(0, simdCount));
+                    ConvertCore(values.Slice(0, simdCount), result.Slice(0, simdCount), this.MaximumValue, this.HalfValue);
                 }
 
                 FromYCbCrBasic.ConvertCore(values.Slice(simdCount, remainder), result.Slice(simdCount, remainder));
@@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// <summary>
             /// SIMD convert using buffers of sizes divisible by 8.
             /// </summary>
-            internal static void ConvertCore(in ComponentValues values, Span<Vector4> result)
+            internal static void ConvertCore(in ComponentValues values, Span<Vector4> result, float maxValue, float halfValue)
             {
                 DebugGuard.IsTrue(result.Length % 8 == 0, nameof(result), "result.Length should be divisible by 8!");
 
@@ -48,7 +48,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 ref Vector4Octet resultBase =
                     ref Unsafe.As<Vector4, Vector4Octet>(ref MemoryMarshal.GetReference(result));
 
-                var chromaOffset = new Vector4(-128f);
+                var chromaOffset = new Vector4(-halfValue);
 
                 // Walking 8 elements at one step:
                 int n = result.Length / 8;
@@ -58,11 +58,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     // y = yVals[i];
                     Vector4Pair y = Unsafe.Add(ref yBase, i);
 
-                    // cb = cbVals[i] - 128F;
+                    // cb = cbVals[i] - halfValue);
                     Vector4Pair cb = Unsafe.Add(ref cbBase, i);
                     cb.AddInplace(chromaOffset);
 
-                    // cr = crVals[i] - 128F;
+                    // cr = crVals[i] - halfValue;
                     Vector4Pair cr = Unsafe.Add(ref crBase, i);
                     cr.AddInplace(chromaOffset);
 
@@ -90,15 +90,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                     if (Vector<float>.Count == 4)
                     {
                         // TODO: Find a way to properly run & test this path on AVX2 PC-s! (Have I already mentioned that Vector<T> is terrible?)
-                        r.RoundAndDownscalePreAvx2();
+                        r.RoundAndDownscalePreAvx2(maxValue);
-                        g.RoundAndDownscalePreAvx2();
+                        g.RoundAndDownscalePreAvx2(maxValue);
-                        b.RoundAndDownscalePreAvx2();
+                        b.RoundAndDownscalePreAvx2(maxValue);
                     }
                     else if (SimdUtils.IsAvx2CompatibleArchitecture)
                     {
-                        r.RoundAndDownscaleAvx2();
+                        r.RoundAndDownscaleAvx2(maxValue);
-                        g.RoundAndDownscaleAvx2();
+                        g.RoundAndDownscaleAvx2(maxValue);
-                        b.RoundAndDownscaleAvx2();
+                        b.RoundAndDownscaleAvx2(maxValue);
                     }
                     else
                     {

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs

@@ -15,8 +15,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromYCbCrSimdAvx2 : JpegColorConverter
         {
-            public FromYCbCrSimdAvx2()
+            public FromYCbCrSimdAvx2(int precision)
-                : base(JpegColorSpace.YCbCr)
+                : base(JpegColorSpace.YCbCr, precision)
             {
             }
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccK.cs

@@ -10,8 +10,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
     {
         internal class FromYccK : JpegColorConverter
         {
-            public FromYccK()
+            public FromYccK(int precision)
-                : base(JpegColorSpace.Ycck)
+                : base(JpegColorSpace.Ycck, precision)
             {
             }
 
@@ -25,18 +25,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
                 var v = new Vector4(0, 0, 0, 1F);
 
-                var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F);
+                var scale = new Vector4(1 / this.MaximumValue,
+                                        1 / this.MaximumValue,
+                                        1 / this.MaximumValue,
+                                        1F);
 
                 for (int i = 0; i < result.Length; i++)
                 {
                     float y = yVals[i];
-                    float cb = cbVals[i] - 128F;
+                    float cb = cbVals[i] - this.HalfValue;
-                    float cr = crVals[i] - 128F;
+                    float cr = crVals[i] - this.HalfValue;
-                    float k = kVals[i] / 255F;
+                    float k = kVals[i] / this.MaximumValue;
 
-                    v.X = (255F - MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero)) * k;
+                    v.X = (this.MaximumValue - MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero)) * k;
-                    v.Y = (255F - MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero)) * k;
+                    v.Y = (this.MaximumValue - MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero)) * k;
-                    v.Z = (255F - MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero)) * k;
+                    v.Z = (this.MaximumValue - MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero)) * k;
                     v.W = 1F;
 
                     v *= scale;

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

@@ -22,15 +22,29 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         private static readonly JpegColorConverter[] Converters =
             {
-                GetYCbCrConverter(), new FromYccK(), new FromCmyk(), new FromGrayscale(), new FromRgb()
+                // 8-bit converters
+                GetYCbCrConverter(8),
+                new FromYccK(8),
+                new FromCmyk(8),
+                new FromGrayscale(8),
+                new FromRgb(8),
+                // 12-bit converters
+                GetYCbCrConverter(12),
+                new FromYccK(12),
+                new FromCmyk(12),
+                new FromGrayscale(12),
+                new FromRgb(12),
             };
 
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegColorConverter"/> class.
         /// </summary>
-        protected JpegColorConverter(JpegColorSpace colorSpace)
+        protected JpegColorConverter(JpegColorSpace colorSpace, int precision)
         {
             this.ColorSpace = colorSpace;
+            this.Precision = precision;
+            this.MaximumValue = (float)Math.Pow(2, precision) - 1;
+            this.HalfValue = (float)Math.Ceiling(this.MaximumValue / 2);
         }
 
         /// <summary>
@@ -38,12 +52,28 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         public JpegColorSpace ColorSpace { get; }
 
+        /// <summary>
+        /// Gets the Precision of this converter in bits.
+        /// </summary>
+        public int Precision { get; }
+
+        /// <summary>
+        /// Gets the maximum value of a sample
+        /// </summary>
+        private float MaximumValue { get; }
+
+        /// <summary>
+        /// Gets the maximum value of a sample
+        /// </summary>
+        private float HalfValue { get; }
+
         /// <summary>
         /// Returns the <see cref="JpegColorConverter"/> corresponding to the given <see cref="JpegColorSpace"/>
         /// </summary>
-        public static JpegColorConverter GetConverter(JpegColorSpace colorSpace)
+        public static JpegColorConverter GetConverter(JpegColorSpace colorSpace, float precision)
         {
-            JpegColorConverter converter = Converters.FirstOrDefault(c => c.ColorSpace == colorSpace);
+            JpegColorConverter converter = Converters.FirstOrDefault(c => c.ColorSpace == colorSpace &&
+                                                                          c.Precision == precision);
 
             if (converter is null)
             {
@@ -63,8 +93,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// <summary>
         /// Returns the <see cref="JpegColorConverter"/> for the YCbCr colorspace that matches the current CPU architecture.
         /// </summary>
-        private static JpegColorConverter GetYCbCrConverter() =>
+        private static JpegColorConverter GetYCbCrConverter(int precision) =>
-            FromYCbCrSimdAvx2.IsAvailable ? (JpegColorConverter)new FromYCbCrSimdAvx2() : new FromYCbCrSimd();
+            FromYCbCrSimdAvx2.IsAvailable ? (JpegColorConverter)new FromYCbCrSimdAvx2(precision) : new FromYCbCrSimd(precision);
 
         /// <summary>
         /// A stack-only struct to reference the input buffers using <see cref="ReadOnlySpan{T}"/>-s.

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

@@ -29,6 +29,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         JpegColorSpace ColorSpace { get; }
 
+        /// <summary>
+        /// Gets the number of bits used for precision.
+        /// </summary>
+        int Precision { get; }
+
         /// <summary>
         /// Gets the components.
         /// </summary>

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

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.Primitives;
@@ -38,6 +39,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         private Size subSamplingDivisors;
 
+        /// <summary>
+        /// Defines the maximum value derived from the bitdepth
+        /// </summary>
+        private int maximumValue;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegBlockPostProcessor"/> struct.
         /// </summary>
@@ -48,6 +54,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             int qtIndex = component.QuantizationTableIndex;
             this.DequantiazationTable = ZigZag.CreateDequantizationTable(ref decoder.QuantizationTables[qtIndex]);
             this.subSamplingDivisors = component.SubSamplingDivisors;
+            this.maximumValue = (int)Math.Pow(2, decoder.Precision) - 1;
 
             this.SourceBlock = default;
             this.WorkspaceBlock1 = default;
@@ -65,7 +72,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <param name="destArea">The destination buffer area.</param>
         public void ProcessBlockColorsInto(
             ref Block8x8 sourceBlock,
-            in BufferArea<float> destArea)
+            in BufferArea<float> destArea,
+            float maximumValue)
         {
             ref Block8x8F b = ref this.SourceBlock;
             b.LoadFrom(ref sourceBlock);
@@ -78,7 +86,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             // To conform better to libjpeg we actually NEED TO loose precision here.
             // This is because they store blocks as Int16 between all the operations.
             // To be "more accurate", we need to emulate this by rounding!
-            this.WorkspaceBlock1.NormalizeColorsAndRoundInplace();
+            this.WorkspaceBlock1.NormalizeColorsAndRoundInplace(maximumValue);
 
             this.WorkspaceBlock1.CopyTo(destArea, this.subSamplingDivisors.Width, this.subSamplingDivisors.Height);
         }

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

@@ -78,6 +78,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         public void CopyBlocksToColorBuffer()
         {
             var blockPp = new JpegBlockPostProcessor(this.ImagePostProcessor.RawJpeg, this.Component);
+            float maximumValue = (float)Math.Pow(2,this.ImagePostProcessor.RawJpeg.Precision) - 1;
 
             for (int y = 0; y < this.BlockRowsPerStep; y++)
             {
@@ -105,7 +106,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                         this.blockAreaSize.Width,
                         this.blockAreaSize.Height);
 
-                    blockPp.ProcessBlockColorsInto(ref block, destArea);
+                    blockPp.ProcessBlockColorsInto(ref block, destArea, maximumValue);
                 }
             }
 

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

@@ -64,7 +64,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
             this.ComponentProcessors = rawJpeg.Components.Select(c => new JpegComponentPostProcessor(memoryAllocator, this, c)).ToArray();
             this.rgbaBuffer = memoryAllocator.Allocate<Vector4>(rawJpeg.ImageSizeInPixels.Width);
-            this.colorConverter = JpegColorConverter.GetConverter(rawJpeg.ColorSpace);
+            this.colorConverter = JpegColorConverter.GetConverter(rawJpeg.ColorSpace, rawJpeg.Precision);
         }
 
         /// <summary>

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -160,6 +160,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <inheritdoc/>
         public JpegColorSpace ColorSpace { get; private set; }
 
+        /// <inheritdoc/>
+        public int Precision { get; private set; }
+
         /// <summary>
         /// Gets the components.
         /// </summary>
@@ -721,11 +724,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.InputStream.Read(this.temp, 0, remaining);
 
             // We only support 8-bit and 12-bit precision.
-            if (!SupportedPrecisions.Contains(this.temp[0]))
+            if (!this.SupportedPrecisions.Contains(this.temp[0]))
             {
                 throw new ImageFormatException("Only 8-Bit and 12-Bit precision supported.");
             }
 
+            this.Precision = this.temp[0];
+
             this.Frame = new JpegFrame
             {
                 Extended = frameMarker.Marker == JpegConstants.Markers.SOF1,

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

@@ -228,7 +228,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             this.PrintLinearData(input);
 
             Block8x8F dest = block;
-            dest.NormalizeColorsInplace();
+            dest.NormalizeColorsInplace(255);
 
             float[] array = new float[64];
             dest.CopyTo(array);
@@ -253,11 +253,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             Block8x8F source = CreateRandomFloatBlock(-200, 200, seed);
 
             Block8x8F expected = source;
-            expected.NormalizeColorsInplace();
+            expected.NormalizeColorsInplace(255);
             expected.RoundInplace();
 
             Block8x8F actual = source;
-            actual.NormalizeColorsAndRoundInplaceAvx2();
+            actual.NormalizeColorsAndRoundInplaceAvx2(255);
 
             this.Output.WriteLine(expected.ToString());
             this.Output.WriteLine(actual.ToString());

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

@@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         public void ConvertFromYCbCrBasic(int inputBufferLength, int resultBufferLength, int seed)
         {
             ValidateRgbToYCbCrConversion(
-                new JpegColorConverter.FromYCbCrBasic(),
+                new JpegColorConverter.FromYCbCrBasic(8),
                 3,
                 inputBufferLength,
                 resultBufferLength,
@@ -75,7 +75,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             JpegColorConverter.ComponentValues values = CreateRandomValues(3, size, seed);
             var result = new Vector4[size];
 
-            JpegColorConverter.FromYCbCrSimd.ConvertCore(values, result);
+            JpegColorConverter.FromYCbCrSimd.ConvertCore(values, result, 255, 128);
 
             for (int i = 0; i < size; i++)
             {
@@ -88,7 +88,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         public void FromYCbCrSimd(int inputBufferLength, int resultBufferLength, int seed)
         {
             ValidateRgbToYCbCrConversion(
-                new JpegColorConverter.FromYCbCrSimd(),
+                new JpegColorConverter.FromYCbCrSimd(8),
                 3,
                 inputBufferLength,
                 resultBufferLength,
@@ -108,7 +108,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             //JpegColorConverter.FromYCbCrSimdAvx2.LogPlz = s => this.Output.WriteLine(s);
 
             ValidateRgbToYCbCrConversion(
-                new JpegColorConverter.FromYCbCrSimdAvx2(),
+                new JpegColorConverter.FromYCbCrSimdAvx2(8),
                 3,
                 inputBufferLength,
                 resultBufferLength,
@@ -140,7 +140,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             JpegColorConverter.ComponentValues values = CreateRandomValues(3, count, 1);
             var result = new Vector4[count];
 
-            JpegColorConverter converter = simd ? (JpegColorConverter)new JpegColorConverter.FromYCbCrSimd() : new JpegColorConverter.FromYCbCrBasic();
+            JpegColorConverter converter = simd ? (JpegColorConverter)new JpegColorConverter.FromYCbCrSimd(8) : new JpegColorConverter.FromYCbCrBasic(8);
 
             // Warm up:
             converter.ConvertToRgba(values, result);
@@ -161,7 +161,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             var v = new Vector4(0, 0, 0, 1F);
             var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F);
 
-            var converter = JpegColorConverter.GetConverter(JpegColorSpace.Cmyk);
+            var converter = JpegColorConverter.GetConverter(JpegColorSpace.Cmyk, 8);
             JpegColorConverter.ComponentValues values = CreateRandomValues(4, inputBufferLength, seed);
             var result = new Vector4[resultBufferLength];
 
@@ -194,7 +194,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [MemberData(nameof(CommonConversionData))]
         public void ConvertFromGrayScale(int inputBufferLength, int resultBufferLength, int seed)
         {
-            var converter = JpegColorConverter.GetConverter(JpegColorSpace.Grayscale);
+            var converter = JpegColorConverter.GetConverter(JpegColorSpace.Grayscale, 8);
             JpegColorConverter.ComponentValues values = CreateRandomValues(1, inputBufferLength, seed);
             var result = new Vector4[resultBufferLength];
 
@@ -216,7 +216,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [MemberData(nameof(CommonConversionData))]
         public void ConvertFromRgb(int inputBufferLength, int resultBufferLength, int seed)
         {
-            var converter = JpegColorConverter.GetConverter(JpegColorSpace.RGB);
+            var converter = JpegColorConverter.GetConverter(JpegColorSpace.RGB, 8);
             JpegColorConverter.ComponentValues values = CreateRandomValues(3, inputBufferLength, seed);
             var result = new Vector4[resultBufferLength];
 
@@ -243,7 +243,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             var v = new Vector4(0, 0, 0, 1F);
             var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F);
 
-            var converter = JpegColorConverter.GetConverter(JpegColorSpace.Ycck);
+            var converter = JpegColorConverter.GetConverter(JpegColorSpace.Ycck, 8);
             JpegColorConverter.ComponentValues values = CreateRandomValues(4, inputBufferLength, seed);
             var result = new Vector4[resultBufferLength];
 
@@ -308,7 +308,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             int seed)
         {
             ValidateRgbToYCbCrConversion(
-                JpegColorConverter.GetConverter(colorSpace),
+                JpegColorConverter.GetConverter(colorSpace,8),
                 componentCount,
                 inputBufferLength,
                 resultBufferLength,