remove old JpegColorConverter methods

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

@@ -22,58 +22,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                ref Vector256<float> cBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector256<float> mBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector256<float> yBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-                ref Vector256<float> kBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-                ref Vector256<float> resultBase =
-                    ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(result));
-
-                // Used for the color conversion
-                var scale = Vector256.Create(1 / this.MaximumValue);
-                var one = Vector256.Create(1F);
-
-                // Used for packing
-                ref byte control = ref MemoryMarshal.GetReference(HwIntrinsics.PermuteMaskEvenOdd8x32);
-                Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
-
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    Vector256<float> k = Avx2.PermuteVar8x32(Unsafe.Add(ref kBase, i), vcontrol);
-                    Vector256<float> c = Avx2.PermuteVar8x32(Unsafe.Add(ref cBase, i), vcontrol);
-                    Vector256<float> m = Avx2.PermuteVar8x32(Unsafe.Add(ref mBase, i), vcontrol);
-                    Vector256<float> y = Avx2.PermuteVar8x32(Unsafe.Add(ref yBase, i), vcontrol);
-
-                    k = Avx.Multiply(k, scale);
-
-                    c = Avx.Multiply(Avx.Multiply(c, k), scale);
-                    m = Avx.Multiply(Avx.Multiply(m, k), scale);
-                    y = Avx.Multiply(Avx.Multiply(y, k), scale);
-
-                    Vector256<float> cmLo = Avx.UnpackLow(c, m);
-                    Vector256<float> yoLo = Avx.UnpackLow(y, one);
-                    Vector256<float> cmHi = Avx.UnpackHigh(c, m);
-                    Vector256<float> yoHi = Avx.UnpackHigh(y, one);
-
-                    ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
-
-                    destination = Avx.Shuffle(cmLo, yoLo, 0b01_00_01_00);
-                    Unsafe.Add(ref destination, 1) = Avx.Shuffle(cmLo, yoLo, 0b11_10_11_10);
-                    Unsafe.Add(ref destination, 2) = Avx.Shuffle(cmHi, yoHi, 0b01_00_01_00);
-                    Unsafe.Add(ref destination, 3) = Avx.Shuffle(cmHi, yoHi, 0b11_10_11_10);
-                }
-#endif
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
                 #if SUPPORTS_RUNTIME_INTRINSICS
@@ -105,9 +53,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 #endif
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromCmykBasic.ConvertCore(values, result, this.MaximumValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromCmykBasic.ConvertCoreInplace(values, this.MaximumValue);
         }

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

@@ -15,11 +15,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
-            {
-                ConvertCore(values, result, this.MaximumValue);
-            }
-
             public override void ConvertToRgbInplace(in ComponentValues values) =>
                 ConvertCoreInplace(values, this.MaximumValue);
 

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

@@ -18,52 +18,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-                ref Vector<float> cBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector<float> mBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector<float> yBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-                ref Vector<float> kBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-                ref Vector4Octet resultBase =
-                    ref Unsafe.As<Vector4, Vector4Octet>(ref MemoryMarshal.GetReference(result));
-
-                Vector4Pair cc = default;
-                Vector4Pair mm = default;
-                Vector4Pair yy = default;
-                ref Vector<float> ccRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref cc);
-                ref Vector<float> mmRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref mm);
-                ref Vector<float> yyRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref yy);
-
-                var scale = new Vector<float>(1 / this.MaximumValue);
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    Vector<float> c = Unsafe.Add(ref cBase, i);
-                    Vector<float> m = Unsafe.Add(ref mBase, i);
-                    Vector<float> y = Unsafe.Add(ref yBase, i);
-                    Vector<float> k = Unsafe.Add(ref kBase, i) * scale;
-
-                    c = (c * k) * scale;
-                    m = (m * k) * scale;
-                    y = (y * k) * scale;
-
-                    ccRefAsVector = c;
-                    mmRefAsVector = m;
-                    yyRefAsVector = y;
-
-                    // Collect (c0,c1...c8) (m0,m1...m8) (y0,y1...y8) vector values in the expected (r0,g0,g1,1), (r1,g1,g2,1) ... order:
-                    ref Vector4Octet destination = ref Unsafe.Add(ref resultBase, i);
-                    destination.Pack(ref cc, ref mm, ref yy);
-                }
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
                 ref Vector<float> cBase =
@@ -92,9 +46,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 }
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromCmykBasic.ConvertCore(values, result, this.MaximumValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromCmykBasic.ConvertCoreInplace(values, this.MaximumValue);
         }

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

@@ -22,40 +22,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                ref Vector256<float> gBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-
-                ref Vector256<float> resultBase =
-                    ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(result));
-
-                // Used for the color conversion
-                var scale = Vector256.Create(1 / this.MaximumValue);
-                var one = Vector256.Create(1F);
-
-                // Used for packing
-                ref byte control = ref MemoryMarshal.GetReference(HwIntrinsics.PermuteMaskEvenOdd8x32);
-                Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
-
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    Vector256<float> g = Avx.Multiply(Unsafe.Add(ref gBase, i), scale);
-
-                    g = Avx2.PermuteVar8x32(g, vcontrol);
-
-                    ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
-
-                    destination = Avx.Blend(Avx.Permute(g, 0b00_00_00_00), one, 0b1000_1000);
-                    Unsafe.Add(ref destination, 1) = Avx.Blend(Avx.Shuffle(g, g, 0b01_01_01_01), one, 0b1000_1000);
-                    Unsafe.Add(ref destination, 2) = Avx.Blend(Avx.Shuffle(g, g, 0b10_10_10_10), one, 0b1000_1000);
-                    Unsafe.Add(ref destination, 3) = Avx.Blend(Avx.Shuffle(g, g, 0b11_11_11_11), one, 0b1000_1000);
-                }
-#endif
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
 #if SUPPORTS_RUNTIME_INTRINSICS
@@ -74,9 +40,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 #endif
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromGrayscaleBasic.ConvertCore(values, result, this.MaximumValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromGrayscaleBasic.ScaleValues(values.Component0, this.MaximumValue);
         }

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

@@ -17,11 +17,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
-            {
-                ConvertCore(values, result, this.MaximumValue);
-            }
-
             public override void ConvertToRgbInplace(in ComponentValues values) =>
                 ScaleValues(values.Component0, this.MaximumValue);
 

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

@@ -22,49 +22,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                ref Vector256<float> rBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector256<float> gBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector256<float> bBase =
-                                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-                ref Vector256<float> resultBase =
-                    ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(result));
-
-                // Used for the color conversion
-                var scale = Vector256.Create(1 / this.MaximumValue);
-                var one = Vector256.Create(1F);
-
-                // Used for packing
-                ref byte control = ref MemoryMarshal.GetReference(HwIntrinsics.PermuteMaskEvenOdd8x32);
-                Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
-
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    Vector256<float> r = Avx.Multiply(Avx2.PermuteVar8x32(Unsafe.Add(ref rBase, i), vcontrol), scale);
-                    Vector256<float> g = Avx.Multiply(Avx2.PermuteVar8x32(Unsafe.Add(ref gBase, i), vcontrol), scale);
-                    Vector256<float> b = Avx.Multiply(Avx2.PermuteVar8x32(Unsafe.Add(ref bBase, i), vcontrol), scale);
-
-                    Vector256<float> rgLo = Avx.UnpackLow(r, g);
-                    Vector256<float> boLo = Avx.UnpackLow(b, one);
-                    Vector256<float> rgHi = Avx.UnpackHigh(r, g);
-                    Vector256<float> boHi = Avx.UnpackHigh(b, one);
-
-                    ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
-
-                    destination = Avx.Shuffle(rgLo, boLo, 0b01_00_01_00);
-                    Unsafe.Add(ref destination, 1) = Avx.Shuffle(rgLo, boLo, 0b11_10_11_10);
-                    Unsafe.Add(ref destination, 2) = Avx.Shuffle(rgHi, boHi, 0b01_00_01_00);
-                    Unsafe.Add(ref destination, 3) = Avx.Shuffle(rgHi, boHi, 0b11_10_11_10);
-                }
-#endif
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
 #if SUPPORTS_RUNTIME_INTRINSICS
@@ -90,9 +47,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 #endif
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromRgbBasic.ConvertCore(values, result, this.MaximumValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromRgbBasic.ConvertCoreInplace(values, this.MaximumValue);
         }

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

@@ -16,11 +16,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
-            {
-                ConvertCore(values, result, this.MaximumValue);
-            }
-
             public override void ConvertToRgbInplace(in ComponentValues values)
             {
                 ConvertCoreInplace(values, this.MaximumValue);

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

@@ -18,48 +18,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-                ref Vector<float> rBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector<float> gBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector<float> bBase =
-                                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-                ref Vector4Octet resultBase =
-                    ref Unsafe.As<Vector4, Vector4Octet>(ref MemoryMarshal.GetReference(result));
-
-                Vector4Pair rr = default;
-                Vector4Pair gg = default;
-                Vector4Pair bb = default;
-                ref Vector<float> rrRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref rr);
-                ref Vector<float> ggRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref gg);
-                ref Vector<float> bbRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref bb);
-
-                var scale = new Vector<float>(1 / this.MaximumValue);
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    Vector<float> r = Unsafe.Add(ref rBase, i);
-                    Vector<float> g = Unsafe.Add(ref gBase, i);
-                    Vector<float> b = Unsafe.Add(ref bBase, i);
-                    r *= scale;
-                    g *= scale;
-                    b *= scale;
-
-                    rrRefAsVector = r;
-                    ggRefAsVector = g;
-                    bbRefAsVector = b;
-
-                    // Collect (r0,r1...r8) (g0,g1...g8) (b0,b1...b8) vector values in the expected (r0,g0,g1,1), (r1,g1,g2,1) ... order:
-                    ref Vector4Octet destination = ref Unsafe.Add(ref resultBase, i);
-                    destination.Pack(ref rr, ref gg, ref bb);
-                }
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
                 ref Vector<float> rBase =
@@ -84,9 +42,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 }
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromRgbBasic.ConvertCore(values, result, this.MaximumValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromRgbBasic.ConvertCoreInplace(values, this.MaximumValue);
         }

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

@@ -23,77 +23,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                ref Vector256<float> yBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector256<float> cbBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector256<float> crBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-                ref Vector256<float> resultBase =
-                    ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(result));
-
-                // Used for the color conversion
-                var chromaOffset = Vector256.Create(-this.HalfValue);
-                var scale = Vector256.Create(1 / this.MaximumValue);
-                var rCrMult = Vector256.Create(1.402F);
-                var gCbMult = Vector256.Create(-0.344136F);
-                var gCrMult = Vector256.Create(-0.714136F);
-                var bCbMult = Vector256.Create(1.772F);
-
-                // Used for packing.
-                var va = Vector256.Create(1F);
-                ref byte control = ref MemoryMarshal.GetReference(HwIntrinsics.PermuteMaskEvenOdd8x32);
-                Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    Vector256<float> y = Unsafe.Add(ref yBase, i);
-                    Vector256<float> cb = Avx.Add(Unsafe.Add(ref cbBase, i), chromaOffset);
-                    Vector256<float> cr = Avx.Add(Unsafe.Add(ref crBase, i), chromaOffset);
-
-                    y = Avx2.PermuteVar8x32(y, vcontrol);
-                    cb = Avx2.PermuteVar8x32(cb, vcontrol);
-                    cr = Avx2.PermuteVar8x32(cr, vcontrol);
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
-                    Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                    Vector256<float> g = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                    Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
-
-                    // TODO: We should be saving to RGBA not Vector4
-                    r = Avx.Multiply(Avx.RoundToNearestInteger(r), scale);
-                    g = Avx.Multiply(Avx.RoundToNearestInteger(g), scale);
-                    b = Avx.Multiply(Avx.RoundToNearestInteger(b), scale);
-
-                    Vector256<float> vte = Avx.UnpackLow(r, b);
-                    Vector256<float> vto = Avx.UnpackLow(g, va);
-
-                    ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
-
-                    destination = Avx.UnpackLow(vte, vto);
-                    Unsafe.Add(ref destination, 1) = Avx.UnpackHigh(vte, vto);
-
-                    vte = Avx.UnpackHigh(r, b);
-                    vto = Avx.UnpackHigh(g, va);
-
-                    Unsafe.Add(ref destination, 2) = Avx.UnpackLow(vte, vto);
-                    Unsafe.Add(ref destination, 3) = Avx.UnpackHigh(vte, vto);
-                }
-#endif
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
 #if SUPPORTS_RUNTIME_INTRINSICS
@@ -151,9 +80,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 #endif
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromYCbCrBasic.ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromYCbCrBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }

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

@@ -15,11 +15,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
-            {
-                ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-            }
-
             public override void ConvertToRgbInplace(in ComponentValues values)
                 => ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
 

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

@@ -20,71 +20,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
             protected override bool IsAvailable => SimdUtils.HasVector4;
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-                // TODO: Find a way to properly run & test this path on AVX2 PC-s! (Have I already mentioned that Vector<T> is terrible?)
-                DebugGuard.IsTrue(result.Length % 8 == 0, nameof(result), "result.Length should be divisible by 8!");
-
-                ref Vector4Pair yBase =
-                    ref Unsafe.As<float, Vector4Pair>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector4Pair cbBase =
-                    ref Unsafe.As<float, Vector4Pair>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector4Pair crBase =
-                    ref Unsafe.As<float, Vector4Pair>(ref MemoryMarshal.GetReference(values.Component2));
-
-                ref Vector4Octet resultBase =
-                    ref Unsafe.As<Vector4, Vector4Octet>(ref MemoryMarshal.GetReference(result));
-
-                var chromaOffset = new Vector4(-this.HalfValue);
-                var maxValue = this.MaximumValue;
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-
-                for (int i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    Vector4Pair y = Unsafe.Add(ref yBase, i);
-
-                    // cb = cbVals[i] - halfValue);
-                    Vector4Pair cb = Unsafe.Add(ref cbBase, i);
-                    cb.AddInplace(chromaOffset);
-
-                    // cr = crVals[i] - halfValue;
-                    Vector4Pair cr = Unsafe.Add(ref crBase, i);
-                    cr.AddInplace(chromaOffset);
-
-                    // r = y + (1.402F * cr);
-                    Vector4Pair r = y;
-                    Vector4Pair tmp = cr;
-                    tmp.MultiplyInplace(1.402F);
-                    r.AddInplace(ref tmp);
-
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    Vector4Pair g = y;
-                    tmp = cb;
-                    tmp.MultiplyInplace(-0.344136F);
-                    g.AddInplace(ref tmp);
-                    tmp = cr;
-                    tmp.MultiplyInplace(-0.714136F);
-                    g.AddInplace(ref tmp);
-
-                    // b = y + (1.772F * cb);
-                    Vector4Pair b = y;
-                    tmp = cb;
-                    tmp.MultiplyInplace(1.772F);
-                    b.AddInplace(ref tmp);
-
-                    r.RoundAndDownscalePreVector8(maxValue);
-                    g.RoundAndDownscalePreVector8(maxValue);
-                    b.RoundAndDownscalePreVector8(maxValue);
-
-                    // Collect (r0,r1...r8) (g0,g1...g8) (b0,b1...b8) vector values in the expected (r0,g0,g1,1), (r1,g1,g2,1) ... order:
-                    ref Vector4Octet destination = ref Unsafe.Add(ref resultBase, i);
-                    destination.Pack(ref r, ref g, ref b);
-                }
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
                 DebugGuard.IsTrue(values.Component0.Length % 8 == 0, nameof(values), "Length should be divisible by 8!");
@@ -146,9 +81,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 }
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromYCbCrBasic.ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values)
                 => FromYCbCrBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }

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

@@ -19,67 +19,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-                ref Vector<float> yBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector<float> cbBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector<float> crBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-
-                ref Vector4Octet resultBase =
-                    ref Unsafe.As<Vector4, Vector4Octet>(ref MemoryMarshal.GetReference(result));
-
-                var chromaOffset = new Vector<float>(-this.HalfValue);
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-
-                Vector4Pair rr = default;
-                Vector4Pair gg = default;
-                Vector4Pair bb = default;
-
-                ref Vector<float> rrRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref rr);
-                ref Vector<float> ggRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref gg);
-                ref Vector<float> bbRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref bb);
-
-                var scale = new Vector<float>(1 / this.MaximumValue);
-
-                for (int i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    Vector<float> y = Unsafe.Add(ref yBase, i);
-                    Vector<float> cb = Unsafe.Add(ref cbBase, i) + chromaOffset;
-                    Vector<float> cr = Unsafe.Add(ref crBase, i) + chromaOffset;
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
-                    Vector<float> r = y + (cr * new Vector<float>(1.402F));
-                    Vector<float> g = y - (cb * new Vector<float>(0.344136F)) - (cr * new Vector<float>(0.714136F));
-                    Vector<float> b = y + (cb * new Vector<float>(1.772F));
-
-                    r = r.FastRound();
-                    g = g.FastRound();
-                    b = b.FastRound();
-                    r *= scale;
-                    g *= scale;
-                    b *= scale;
-
-                    rrRefAsVector = r;
-                    ggRefAsVector = g;
-                    bbRefAsVector = b;
-
-                    // Collect (r0,r1...r8) (g0,g1...g8) (b0,b1...b8) vector values in the expected (r0,g0,g1,1), (r1,g1,g2,1) ... order:
-                    ref Vector4Octet destination = ref Unsafe.Add(ref resultBase, i);
-                    destination.Pack(ref rr, ref gg, ref bb);
-                }
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
                 ref Vector<float> c0Base =
@@ -128,9 +67,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 }
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromYCbCrBasic.ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromYCbCrBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }

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

@@ -22,87 +22,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-#if SUPPORTS_RUNTIME_INTRINSICS
-                ref Vector256<float> yBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector256<float> cbBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector256<float> crBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component2));
-                ref Vector256<float> kBase =
-                    ref Unsafe.As<float, Vector256<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-                ref Vector256<float> resultBase =
-                    ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(result));
-
-                // Used for the color conversion
-                var chromaOffset = Vector256.Create(-this.HalfValue);
-                var scale = Vector256.Create(1 / this.MaximumValue);
-                var max = Vector256.Create(this.MaximumValue);
-                var rCrMult = Vector256.Create(1.402F);
-                var gCbMult = Vector256.Create(-0.344136F);
-                var gCrMult = Vector256.Create(-0.714136F);
-                var bCbMult = Vector256.Create(1.772F);
-
-                // Used for packing.
-                var va = Vector256.Create(1F);
-                ref byte control = ref MemoryMarshal.GetReference(HwIntrinsics.PermuteMaskEvenOdd8x32);
-                Vector256<int> vcontrol = Unsafe.As<byte, Vector256<int>>(ref control);
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-                for (int i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    // k = kVals[i] / 256F;
-                    Vector256<float> y = Unsafe.Add(ref yBase, i);
-                    Vector256<float> cb = Avx.Add(Unsafe.Add(ref cbBase, i), chromaOffset);
-                    Vector256<float> cr = Avx.Add(Unsafe.Add(ref crBase, i), chromaOffset);
-                    Vector256<float> k = Avx.Divide(Unsafe.Add(ref kBase, i), max);
-
-                    y = Avx2.PermuteVar8x32(y, vcontrol);
-                    cb = Avx2.PermuteVar8x32(cb, vcontrol);
-                    cr = Avx2.PermuteVar8x32(cr, vcontrol);
-                    k = Avx2.PermuteVar8x32(k, vcontrol);
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
-                    Vector256<float> r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
-                    Vector256<float> g =
-                        HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
-                    Vector256<float> b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
-
-                    r = Avx.Subtract(max, Avx.RoundToNearestInteger(r));
-                    g = Avx.Subtract(max, Avx.RoundToNearestInteger(g));
-                    b = Avx.Subtract(max, Avx.RoundToNearestInteger(b));
-
-                    r = Avx.Multiply(Avx.Multiply(r, k), scale);
-                    g = Avx.Multiply(Avx.Multiply(g, k), scale);
-                    b = Avx.Multiply(Avx.Multiply(b, k), scale);
-
-                    Vector256<float> vte = Avx.UnpackLow(r, b);
-                    Vector256<float> vto = Avx.UnpackLow(g, va);
-
-                    ref Vector256<float> destination = ref Unsafe.Add(ref resultBase, i * 4);
-
-                    destination = Avx.UnpackLow(vte, vto);
-                    Unsafe.Add(ref destination, 1) = Avx.UnpackHigh(vte, vto);
-
-                    vte = Avx.UnpackHigh(r, b);
-                    vto = Avx.UnpackHigh(g, va);
-
-                    Unsafe.Add(ref destination, 2) = Avx.UnpackLow(vte, vto);
-                    Unsafe.Add(ref destination, 3) = Avx.UnpackHigh(vte, vto);
-                }
-#endif
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
 #if SUPPORTS_RUNTIME_INTRINSICS
@@ -164,9 +83,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 #endif
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromYccKBasic.ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromYccKBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }

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

@@ -15,11 +15,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
-            {
-                ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-            }
-
             public override void ConvertToRgbInplace(in ComponentValues values) =>
                 ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
 

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

@@ -18,72 +18,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            protected override void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result)
-            {
-                ref Vector<float> yBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component0));
-                ref Vector<float> cbBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component1));
-                ref Vector<float> crBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component2));
-                ref Vector<float> kBase =
-                    ref Unsafe.As<float, Vector<float>>(ref MemoryMarshal.GetReference(values.Component3));
-
-                ref Vector4Octet resultBase =
-                    ref Unsafe.As<Vector4, Vector4Octet>(ref MemoryMarshal.GetReference(result));
-
-                var chromaOffset = new Vector<float>(-this.HalfValue);
-
-                // Walking 8 elements at one step:
-                int n = result.Length / 8;
-
-                Vector4Pair rr = default;
-                Vector4Pair gg = default;
-                Vector4Pair bb = default;
-
-                ref Vector<float> rrRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref rr);
-                ref Vector<float> ggRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref gg);
-                ref Vector<float> bbRefAsVector = ref Unsafe.As<Vector4Pair, Vector<float>>(ref bb);
-
-                var scale = new Vector<float>(1 / this.MaximumValue);
-                var max = new Vector<float>(this.MaximumValue);
-
-                for (int i = 0; i < n; i++)
-                {
-                    // y = yVals[i];
-                    // cb = cbVals[i] - 128F;
-                    // cr = crVals[i] - 128F;
-                    // k = kVals[i] / 256F;
-                    Vector<float> y = Unsafe.Add(ref yBase, i);
-                    Vector<float> cb = Unsafe.Add(ref cbBase, i) + chromaOffset;
-                    Vector<float> cr = Unsafe.Add(ref crBase, i) + chromaOffset;
-                    Vector<float> k = Unsafe.Add(ref kBase, i) / max;
-
-                    // r = y + (1.402F * cr);
-                    // g = y - (0.344136F * cb) - (0.714136F * cr);
-                    // b = y + (1.772F * cb);
-                    // Adding & multiplying 8 elements at one time:
-                    Vector<float> r = y + (cr * new Vector<float>(1.402F));
-                    Vector<float> g = y - (cb * new Vector<float>(0.344136F)) - (cr * new Vector<float>(0.714136F));
-                    Vector<float> b = y + (cb * new Vector<float>(1.772F));
-
-                    r = (max - r.FastRound()) * k;
-                    g = (max - g.FastRound()) * k;
-                    b = (max - b.FastRound()) * k;
-                    r *= scale;
-                    g *= scale;
-                    b *= scale;
-
-                    rrRefAsVector = r;
-                    ggRefAsVector = g;
-                    bbRefAsVector = b;
-
-                    // Collect (r0,r1...r8) (g0,g1...g8) (b0,b1...b8) vector values in the expected (r0,g0,g1,1), (r1,g1,g2,1) ... order:
-                    ref Vector4Octet destination = ref Unsafe.Add(ref resultBase, i);
-                    destination.Pack(ref rr, ref gg, ref bb);
-                }
-            }
-
             protected override void ConvertCoreVectorizedInplace(in ComponentValues values)
             {
                 ref Vector<float> c0Base =
@@ -136,9 +70,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 }
             }
 
-            protected override void ConvertCore(in ComponentValues values, Span<Vector4> result) =>
-                FromYccKBasic.ConvertCore(values, result, this.MaximumValue, this.HalfValue);
-
             protected override void ConvertCoreInplace(in ComponentValues values) =>
                 FromYccKBasic.ConvertCoreInplace(values, this.MaximumValue, this.HalfValue);
         }

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

@@ -18,26 +18,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 this.vectorSize = vectorSize;
             }
 
-            public sealed override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
-            {
-                int remainder = result.Length % this.vectorSize;
-                int simdCount = result.Length - remainder;
-                if (simdCount > 0)
-                {
-                    // This implementation is actually AVX specific.
-                    // An AVX register is capable of storing 8 float-s.
-                    if (!this.IsAvailable)
-                    {
-                        throw new InvalidOperationException(
-                            "This converter can be used only on architecture having 256 byte floating point SIMD registers!");
-                    }
-
-                    this.ConvertCoreVectorized(values.Slice(0, simdCount), result.Slice(0, simdCount));
-                }
-
-                this.ConvertCore(values.Slice(simdCount, remainder), result.Slice(simdCount, remainder));
-            }
-
             public override void ConvertToRgbInplace(in ComponentValues values)
             {
                 int length = values.Component0.Length;
@@ -59,12 +39,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
                 this.ConvertCoreInplace(values.Slice(simdCount, remainder));
             }
 
-            protected abstract void ConvertCoreVectorized(in ComponentValues values, Span<Vector4> result);
-
             protected virtual void ConvertCoreVectorizedInplace(in ComponentValues values) => throw new NotImplementedException();
 
-            protected abstract void ConvertCore(in ComponentValues values, Span<Vector4> result);
-
             protected virtual void ConvertCoreInplace(in ComponentValues values) => throw new NotImplementedException();
         }
     }

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

@@ -76,13 +76,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         }
 
         /// <summary>
-        /// He implementation of the conversion.
+        /// Converts planar jpeg component values in <paramref name="values"/> to RGB color space inplace.
         /// </summary>
-        /// <param name="values">The input as a stack-only <see cref="ComponentValues"/> struct</param>
-        /// <param name="result">The destination buffer of <see cref="Vector4"/> values</param>
-        public abstract void ConvertToRgba(in ComponentValues values, Span<Vector4> result);
-
-        public virtual void ConvertToRgbInplace(in ComponentValues values) => throw new NotImplementedException();
+        /// <param name="values">The input/ouptut as a stack-only <see cref="ComponentValues"/> struct</param>
+        public abstract void ConvertToRgbInplace(in ComponentValues values);
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverter"/>s for all supported colorspaces and precisions.