From 60c39bbd9ffaccb2c118458b87b9bf1e5eda7772 Mon Sep 17 00:00:00 2001 From: Stefan Nikolei Date: Sun, 26 Mar 2023 14:35:26 +0200 Subject: [PATCH] Port YCCK to arm --- .../JpegColorConverter.YccKArm64.cs | 133 ++++++++++++++++++ .../ColorConverters/JpegColorConverterBase.cs | 5 + .../ColorConversion/YccKColorConverter.cs | 8 ++ .../Formats/Jpg/JpegColorConverterTests.cs | 17 +++ 4 files changed, 163 insertions(+) create mode 100644 src/ImageSharp/Formats/Jpeg/Components/ColorConverters/JpegColorConverter.YccKArm64.cs 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,