mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
9 years ago
committed by
GitHub
GitHub
24 changed files with 418 additions and 137 deletions
@ -1,11 +1,14 @@ |
|||
using System; |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder |
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters |
|||
{ |
|||
internal abstract partial class JpegColorConverter |
|||
{ |
|||
internal class FromCmyk : JpegColorConverter |
|||
internal class FromCmyk : ColorConverters.JpegColorConverter |
|||
{ |
|||
public FromCmyk() |
|||
: base(JpegColorSpace.Cmyk) |
|||
@ -1,11 +1,14 @@ |
|||
using System; |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder |
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters |
|||
{ |
|||
internal abstract partial class JpegColorConverter |
|||
{ |
|||
internal class FromGrayScale : JpegColorConverter |
|||
internal class FromGrayScale : ColorConverters.JpegColorConverter |
|||
{ |
|||
public FromGrayScale() |
|||
: base(JpegColorSpace.GrayScale) |
|||
@ -1,11 +1,14 @@ |
|||
using System; |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder |
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters |
|||
{ |
|||
internal abstract partial class JpegColorConverter |
|||
{ |
|||
internal class FromRgb : JpegColorConverter |
|||
internal class FromRgb : ColorConverters.JpegColorConverter |
|||
{ |
|||
public FromRgb() |
|||
: base(JpegColorSpace.RGB) |
|||
@ -0,0 +1,51 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters |
|||
{ |
|||
internal abstract partial class JpegColorConverter |
|||
{ |
|||
internal class FromYCbCrBasic : ColorConverters.JpegColorConverter |
|||
{ |
|||
public FromYCbCrBasic() |
|||
: base(JpegColorSpace.YCbCr) |
|||
{ |
|||
} |
|||
|
|||
public override void ConvertToRGBA(ComponentValues values, Span<Vector4> result) |
|||
{ |
|||
ConvertCore(values, result); |
|||
} |
|||
|
|||
internal static void ConvertCore(ComponentValues values, Span<Vector4> result) |
|||
{ |
|||
// TODO: We can optimize a lot here with Vector<float> and SRCS.Unsafe()!
|
|||
ReadOnlySpan<float> yVals = values.Component0; |
|||
ReadOnlySpan<float> cbVals = values.Component1; |
|||
ReadOnlySpan<float> crVals = values.Component2; |
|||
|
|||
var v = new Vector4(0, 0, 0, 1); |
|||
|
|||
var scale = new Vector4(1 / 255F, 1 / 255F, 1 / 255F, 1F); |
|||
|
|||
for (int i = 0; i < result.Length; i++) |
|||
{ |
|||
float y = yVals[i]; |
|||
float cb = cbVals[i] - 128F; |
|||
float cr = crVals[i] - 128F; |
|||
|
|||
v.X = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero); |
|||
v.Y = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero); |
|||
v.Z = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero); |
|||
|
|||
v *= scale; |
|||
|
|||
result[i] = v; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,108 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
using SixLabors.ImageSharp.Common.Tuples; |
|||
|
|||
// ReSharper disable ImpureMethodCallOnReadonlyValueField
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters |
|||
{ |
|||
internal abstract partial class JpegColorConverter |
|||
{ |
|||
internal class FromYCbCrSimdAvx2 : ColorConverters.JpegColorConverter |
|||
{ |
|||
public FromYCbCrSimdAvx2() |
|||
: base(JpegColorSpace.YCbCr) |
|||
{ |
|||
} |
|||
|
|||
public static bool IsAvailable => Vector.IsHardwareAccelerated && SimdUtils.IsAvx2CompatibleArchitecture; |
|||
|
|||
public override void ConvertToRGBA(ComponentValues values, Span<Vector4> result) |
|||
{ |
|||
int remainder = result.Length % 8; |
|||
int simdCount = result.Length - remainder; |
|||
if (simdCount > 0) |
|||
{ |
|||
ConvertCore(values.Slice(0, simdCount), result.Slice(0, simdCount)); |
|||
} |
|||
|
|||
FromYCbCrBasic.ConvertCore(values.Slice(simdCount, remainder), result.Slice(simdCount, remainder)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// SIMD convert using buffers of sizes divisable by 8.
|
|||
/// </summary>
|
|||
internal static void ConvertCore(ComponentValues values, Span<Vector4> result) |
|||
{ |
|||
// This implementation is actually AVX specific.
|
|||
// An AVX register is capable of storing 8 float-s.
|
|||
if (!IsAvailable) |
|||
{ |
|||
throw new InvalidOperationException( |
|||
"JpegColorConverter.FromYCbCrSimd256 can be used only on architecture having 256 byte floating point SIMD registers!"); |
|||
} |
|||
|
|||
ref Vector<float> yBase = |
|||
ref Unsafe.As<float, Vector<float>>(ref values.Component0.DangerousGetPinnableReference()); |
|||
ref Vector<float> cbBase = |
|||
ref Unsafe.As<float, Vector<float>>(ref values.Component1.DangerousGetPinnableReference()); |
|||
ref Vector<float> crBase = |
|||
ref Unsafe.As<float, Vector<float>>(ref values.Component2.DangerousGetPinnableReference()); |
|||
|
|||
ref Vector4Octet resultBase = |
|||
ref Unsafe.As<Vector4, Vector4Octet>(ref result.DangerousGetPinnableReference()); |
|||
|
|||
var chromaOffset = new Vector<float>(-128f); |
|||
|
|||
// Walking 8 elements at one step:
|
|||
int n = result.Length / 8; |
|||
|
|||
var rr = default(Vector4Pair); |
|||
var gg = default(Vector4Pair); |
|||
var bb = default(Vector4Pair); |
|||
|
|||
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 / 255f); |
|||
|
|||
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.Collect(ref rr, ref gg, ref bb); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,7 +1,10 @@ |
|||
using System; |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder |
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters |
|||
{ |
|||
internal abstract partial class JpegColorConverter |
|||
{ |
|||
@ -0,0 +1,86 @@ |
|||
namespace SixLabors.ImageSharp.Benchmarks.Image.Jpeg |
|||
{ |
|||
using System; |
|||
using System.Numerics; |
|||
|
|||
using BenchmarkDotNet.Attributes; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder; |
|||
using SixLabors.ImageSharp.Formats.Jpeg.Common.Decoder.ColorConverters; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
[Config(typeof(Config.ShortClr))] |
|||
public class YCbCrColorConversion |
|||
{ |
|||
private Buffer2D<float>[] input; |
|||
|
|||
private Vector4[] output; |
|||
|
|||
public const int Count = 128; |
|||
|
|||
[GlobalSetup] |
|||
public void Setup() |
|||
{ |
|||
this.input = CreateRandomValues(3, Count); |
|||
this.output = new Vector4[Count]; |
|||
} |
|||
|
|||
[GlobalCleanup] |
|||
public void Cleanup() |
|||
{ |
|||
foreach (Buffer2D<float> buffer in this.input) |
|||
{ |
|||
buffer.Dispose(); |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Baseline = true)] |
|||
public void Scalar() |
|||
{ |
|||
var values = new JpegColorConverter.ComponentValues(this.input, 0); |
|||
|
|||
JpegColorConverter.FromYCbCrBasic.ConvertCore(values, this.output); |
|||
} |
|||
|
|||
[Benchmark] |
|||
public void SimdVector4() |
|||
{ |
|||
var values = new JpegColorConverter.ComponentValues(this.input, 0); |
|||
|
|||
JpegColorConverter.FromYCbCrSimd.ConvertCore(values, this.output); |
|||
} |
|||
|
|||
[Benchmark] |
|||
public void SimdAvx2() |
|||
{ |
|||
var values = new JpegColorConverter.ComponentValues(this.input, 0); |
|||
|
|||
JpegColorConverter.FromYCbCrSimdAvx2.ConvertCore(values, this.output); |
|||
} |
|||
|
|||
private static Buffer2D<float>[] CreateRandomValues( |
|||
int componentCount, |
|||
int inputBufferLength, |
|||
float minVal = 0f, |
|||
float maxVal = 255f) |
|||
{ |
|||
var rnd = new Random(42); |
|||
Buffer2D<float>[] buffers = new Buffer2D<float>[componentCount]; |
|||
for (int i = 0; i < componentCount; i++) |
|||
{ |
|||
float[] values = new float[inputBufferLength]; |
|||
|
|||
for (int j = 0; j < inputBufferLength; j++) |
|||
{ |
|||
values[j] = (float)rnd.NextDouble() * (maxVal - minVal) + minVal; |
|||
} |
|||
|
|||
// no need to dispose when buffer is not array owner
|
|||
buffers[i] = new Buffer2D<float>(values, values.Length, 1); |
|||
} |
|||
|
|||
return buffers; |
|||
} |
|||
|
|||
} |
|||
} |
|||
Loading…
Reference in new issue