diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs
new file mode 100644
index 000000000..285ba62cf
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs
@@ -0,0 +1,133 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;
+using static SixLabors.ImageSharp.SimdUtils;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+internal abstract partial class JpegColorConverterBase
+{
+ internal sealed class YccKArm64 : JpegColorConverterArm64
+ {
+ public YccKArm64(int precision)
+ : base(JpegColorSpace.Ycck, precision)
+ {
+ }
+
+ ///
+ public override void ConvertToRgbInplace(in ComponentValues values)
+ {
+ ref Vector128 c0Base =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component0));
+ ref Vector128 c1Base =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component1));
+ ref Vector128 c2Base =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component2));
+ ref Vector128 kBase =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component3));
+
+ // Used for the color conversion
+ var chromaOffset = Vector128.Create(-this.HalfValue);
+ var scale = Vector128.Create(1 / (this.MaximumValue * this.MaximumValue));
+ var max = Vector128.Create(this.MaximumValue);
+ var rCrMult = Vector128.Create(YCbCrScalar.RCrMult);
+ var gCbMult = Vector128.Create(-YCbCrScalar.GCbMult);
+ var gCrMult = Vector128.Create(-YCbCrScalar.GCrMult);
+ var bCbMult = Vector128.Create(YCbCrScalar.BCbMult);
+
+ // Walking 8 elements at one step:
+ nuint n = (uint)values.Component0.Length / (uint)Vector128.Count;
+ for (nuint i = 0; i < n; i++)
+ {
+ // y = yVals[i];
+ // cb = cbVals[i] - 128F;
+ // cr = crVals[i] - 128F;
+ // k = kVals[i] / 256F;
+ ref Vector128 c0 = ref Unsafe.Add(ref c0Base, i);
+ ref Vector128 c1 = ref Unsafe.Add(ref c1Base, i);
+ ref Vector128 c2 = ref Unsafe.Add(ref c2Base, i);
+ Vector128 y = c0;
+ Vector128 cb = AdvSimd.Add(c1, chromaOffset);
+ Vector128 cr = AdvSimd.Add(c2, chromaOffset);
+ Vector128 scaledK = AdvSimd.Multiply(Unsafe.Add(ref kBase, i), scale);
+
+ // r = y + (1.402F * cr);
+ // g = y - (0.344136F * cb) - (0.714136F * cr);
+ // b = y + (1.772F * cb);
+ Vector128 r = HwIntrinsics.MultiplyAdd(y, cr, rCrMult);
+ Vector128 g =
+ HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(y, cb, gCbMult), cr, gCrMult);
+ Vector128 b = HwIntrinsics.MultiplyAdd(y, cb, bCbMult);
+
+ r = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(r));
+ g = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(g));
+ b = AdvSimd.Subtract(max, AdvSimd.RoundToNearest(b));
+
+ r = AdvSimd.Multiply(r, scaledK);
+ g = AdvSimd.Multiply(g, scaledK);
+ b = AdvSimd.Multiply(b, scaledK);
+
+ c0 = r;
+ c1 = g;
+ c2 = b;
+ }
+ }
+
+ ///
+ public override void ConvertFromRgb(in ComponentValues values, Span rLane, Span gLane, Span bLane)
+ {
+ // rgb -> cmyk
+ CmykArm64.ConvertFromRgb(in values, this.MaximumValue, rLane, gLane, bLane);
+
+ // cmyk -> ycck
+ ref Vector128 destY =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component0));
+ ref Vector128 destCb =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component1));
+ ref Vector128 destCr =
+ ref Unsafe.As>(ref MemoryMarshal.GetReference(values.Component2));
+
+ ref Vector128 srcR = ref destY;
+ ref Vector128 srcG = ref destCb;
+ ref Vector128 srcB = ref destCr;
+
+ // Used for the color conversion
+ var maxSampleValue = Vector128.Create(this.MaximumValue);
+
+ var chromaOffset = Vector128.Create(this.HalfValue);
+
+ var f0299 = Vector128.Create(0.299f);
+ var f0587 = Vector128.Create(0.587f);
+ var f0114 = Vector128.Create(0.114f);
+ var fn0168736 = Vector128.Create(-0.168736f);
+ var fn0331264 = Vector128.Create(-0.331264f);
+ var fn0418688 = Vector128.Create(-0.418688f);
+ var fn0081312F = Vector128.Create(-0.081312F);
+ var f05 = Vector128.Create(0.5f);
+
+ nuint n = (uint)values.Component0.Length / (uint)Vector128.Count;
+ for (nuint i = 0; i < n; i++)
+ {
+ Vector128 r = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcR, i));
+ Vector128 g = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcG, i));
+ Vector128 b = AdvSimd.Subtract(maxSampleValue, Unsafe.Add(ref srcB, i));
+
+ // y = 0 + (0.299 * r) + (0.587 * g) + (0.114 * b)
+ // cb = 128 - (0.168736 * r) - (0.331264 * g) + (0.5 * b)
+ // cr = 128 + (0.5 * r) - (0.418688 * g) - (0.081312 * b)
+ Vector128 y = HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f0114, b), f0587, g), f0299, r);
+ Vector128 cb = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(f05, b), fn0331264, g), fn0168736, r));
+ Vector128 cr = AdvSimd.Add(chromaOffset, HwIntrinsics.MultiplyAdd(HwIntrinsics.MultiplyAdd(AdvSimd.Multiply(fn0081312F, b), fn0418688, g), f05, r));
+
+ Unsafe.Add(ref destY, i) = y;
+ Unsafe.Add(ref destCb, i) = cb;
+ Unsafe.Add(ref destCr, i) = cr;
+ }
+ }
+ }
+}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs
index 10d80ddb2..90b55eb87 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverterBase.cs
@@ -167,6 +167,11 @@ internal abstract partial class JpegColorConverterBase
return new YccKVector(precision);
}
+ if (JpegColorConverterArm64.IsSupported)
+ {
+ return new YccKArm64(precision);
+ }
+
return new YccKScalar(precision);
}
diff --git a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs
index 991d3b0d0..136182936 100644
--- a/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs
+++ b/tests/ImageSharp.Benchmarks/Codecs/Jpeg/ColorConversion/YccKColorConverter.cs
@@ -37,4 +37,12 @@ public class YccKColorConverter : ColorConversionBenchmark
new JpegColorConverterBase.YccKAvx(8).ConvertToRgbInplace(values);
}
+
+ [Benchmark]
+ public void SimdVectorArm64()
+ {
+ var values = new JpegColorConverterBase.ComponentValues(this.Input, 0);
+
+ new JpegColorConverterBase.YccKArm64(8).ConvertToRgbInplace(values);
+ }
}
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
index fac08ee3d..b2db5b4bc 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
@@ -374,6 +374,23 @@ public class JpegColorConverterTests
new JpegColorConverterBase.YccKScalar(8),
precísion: 4);
+ [Theory]
+ [MemberData(nameof(Seeds))]
+ public void FromYccKArm64(int seed) =>
+ this.TestConversionToRgb( new JpegColorConverterBase.YccKArm64(8),
+ 4,
+ seed,
+ new JpegColorConverterBase.YccKScalar(8));
+
+ [Theory]
+ [MemberData(nameof(Seeds))]
+ public void FromRgbToYccKArm64(int seed) =>
+ this.TestConversionFromRgb(new JpegColorConverterBase.YccKArm64(8),
+ 4,
+ seed,
+ new JpegColorConverterBase.YccKScalar(8),
+ precísion: 4);
+
private void TestConversionToRgb(
JpegColorConverterBase converter,
int componentCount,