mirror of https://github.com/SixLabors/ImageSharp
Anton Firszov
9 years ago
23 changed files with 1637 additions and 1631 deletions
@ -0,0 +1,175 @@ |
|||||
|
// ReSharper disable InconsistentNaming
|
||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg |
||||
|
{ |
||||
|
using System; |
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components; |
||||
|
using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils; |
||||
|
|
||||
|
using Xunit; |
||||
|
using Xunit.Abstractions; |
||||
|
|
||||
|
public static class DCTTests |
||||
|
{ |
||||
|
public class FastFloatingPoint : JpegUtilityTestFixture |
||||
|
{ |
||||
|
public FastFloatingPoint(ITestOutputHelper output) |
||||
|
: base(output) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
|
||||
|
[Fact] |
||||
|
public void iDCT2D8x4_LeftPart() |
||||
|
{ |
||||
|
float[] sourceArray = JpegUtilityTestFixture.Create8x8FloatData(); |
||||
|
float[] expectedDestArray = new float[64]; |
||||
|
|
||||
|
ReferenceImplementations.FastFloatingPointDCT.iDCT2D8x4_32f(sourceArray, expectedDestArray); |
||||
|
|
||||
|
Block8x8F source = new Block8x8F(); |
||||
|
source.LoadFrom(sourceArray); |
||||
|
|
||||
|
Block8x8F dest = new Block8x8F(); |
||||
|
|
||||
|
DCT.IDCT8x4_LeftPart(ref source, ref dest); |
||||
|
|
||||
|
float[] actualDestArray = new float[64]; |
||||
|
dest.CopyTo(actualDestArray); |
||||
|
|
||||
|
this.Print8x8Data(expectedDestArray); |
||||
|
this.Output.WriteLine("**************"); |
||||
|
this.Print8x8Data(actualDestArray); |
||||
|
|
||||
|
Assert.Equal(expectedDestArray, actualDestArray); |
||||
|
} |
||||
|
|
||||
|
[Fact] |
||||
|
public void iDCT2D8x4_RightPart() |
||||
|
{ |
||||
|
float[] sourceArray = JpegUtilityTestFixture.Create8x8FloatData(); |
||||
|
float[] expectedDestArray = new float[64]; |
||||
|
|
||||
|
ReferenceImplementations.FastFloatingPointDCT.iDCT2D8x4_32f(sourceArray.AsSpan().Slice(4), expectedDestArray.AsSpan().Slice(4)); |
||||
|
|
||||
|
Block8x8F source = new Block8x8F(); |
||||
|
source.LoadFrom(sourceArray); |
||||
|
|
||||
|
Block8x8F dest = new Block8x8F(); |
||||
|
|
||||
|
DCT.IDCT8x4_RightPart(ref source, ref dest); |
||||
|
|
||||
|
float[] actualDestArray = new float[64]; |
||||
|
dest.CopyTo(actualDestArray); |
||||
|
|
||||
|
this.Print8x8Data(expectedDestArray); |
||||
|
this.Output.WriteLine("**************"); |
||||
|
this.Print8x8Data(actualDestArray); |
||||
|
|
||||
|
Assert.Equal(expectedDestArray, actualDestArray); |
||||
|
} |
||||
|
|
||||
|
[Theory] |
||||
|
[InlineData(1)] |
||||
|
[InlineData(2)] |
||||
|
[InlineData(3)] |
||||
|
public void TransformIDCT(int seed) |
||||
|
{ |
||||
|
Span<float> sourceArray = JpegUtilityTestFixture.Create8x8RandomFloatData(-200, 200, seed); |
||||
|
float[] expectedDestArray = new float[64]; |
||||
|
float[] tempArray = new float[64]; |
||||
|
|
||||
|
ReferenceImplementations.FastFloatingPointDCT.iDCT2D_llm(sourceArray, expectedDestArray, tempArray); |
||||
|
|
||||
|
// ReferenceImplementations.iDCT8x8_llm_sse(sourceArray, expectedDestArray, tempArray);
|
||||
|
Block8x8F source = new Block8x8F(); |
||||
|
source.LoadFrom(sourceArray); |
||||
|
|
||||
|
Block8x8F dest = new Block8x8F(); |
||||
|
Block8x8F tempBuffer = new Block8x8F(); |
||||
|
|
||||
|
DCT.TransformIDCT(ref source, ref dest, ref tempBuffer); |
||||
|
|
||||
|
float[] actualDestArray = new float[64]; |
||||
|
dest.CopyTo(actualDestArray); |
||||
|
|
||||
|
this.Print8x8Data(expectedDestArray); |
||||
|
this.Output.WriteLine("**************"); |
||||
|
this.Print8x8Data(actualDestArray); |
||||
|
Assert.Equal(expectedDestArray, actualDestArray, new ApproximateFloatComparer(1f)); |
||||
|
Assert.Equal(expectedDestArray, actualDestArray, new ApproximateFloatComparer(1f)); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
[Theory] |
||||
|
[InlineData(1)] |
||||
|
[InlineData(2)] |
||||
|
public void FDCT8x4_LeftPart(int seed) |
||||
|
{ |
||||
|
Span<float> src = JpegUtilityTestFixture.Create8x8RandomFloatData(-200, 200, seed); |
||||
|
Block8x8F srcBlock = new Block8x8F(); |
||||
|
srcBlock.LoadFrom(src); |
||||
|
|
||||
|
Block8x8F destBlock = new Block8x8F(); |
||||
|
|
||||
|
float[] expectedDest = new float[64]; |
||||
|
|
||||
|
ReferenceImplementations.FastFloatingPointDCT.fDCT2D8x4_32f(src, expectedDest); |
||||
|
DCT.FDCT8x4_LeftPart(ref srcBlock, ref destBlock); |
||||
|
|
||||
|
float[] actualDest = new float[64]; |
||||
|
destBlock.CopyTo(actualDest); |
||||
|
|
||||
|
Assert.Equal(actualDest, expectedDest, new ApproximateFloatComparer(1f)); |
||||
|
} |
||||
|
|
||||
|
[Theory] |
||||
|
[InlineData(1)] |
||||
|
[InlineData(2)] |
||||
|
public void FDCT8x4_RightPart(int seed) |
||||
|
{ |
||||
|
Span<float> src = JpegUtilityTestFixture.Create8x8RandomFloatData(-200, 200, seed); |
||||
|
Block8x8F srcBlock = new Block8x8F(); |
||||
|
srcBlock.LoadFrom(src); |
||||
|
|
||||
|
Block8x8F destBlock = new Block8x8F(); |
||||
|
|
||||
|
float[] expectedDest = new float[64]; |
||||
|
|
||||
|
ReferenceImplementations.FastFloatingPointDCT.fDCT2D8x4_32f(src.Slice(4), expectedDest.AsSpan().Slice(4)); |
||||
|
DCT.FDCT8x4_RightPart(ref srcBlock, ref destBlock); |
||||
|
|
||||
|
float[] actualDest = new float[64]; |
||||
|
destBlock.CopyTo(actualDest); |
||||
|
|
||||
|
Assert.Equal(actualDest, expectedDest, new ApproximateFloatComparer(1f)); |
||||
|
} |
||||
|
|
||||
|
[Theory] |
||||
|
[InlineData(1)] |
||||
|
[InlineData(2)] |
||||
|
public void TransformFDCT(int seed) |
||||
|
{ |
||||
|
Span<float> src = JpegUtilityTestFixture.Create8x8RandomFloatData(-200, 200, seed); |
||||
|
Block8x8F srcBlock = new Block8x8F(); |
||||
|
srcBlock.LoadFrom(src); |
||||
|
|
||||
|
Block8x8F destBlock = new Block8x8F(); |
||||
|
|
||||
|
float[] expectedDest = new float[64]; |
||||
|
float[] temp1 = new float[64]; |
||||
|
Block8x8F temp2 = new Block8x8F(); |
||||
|
|
||||
|
ReferenceImplementations.FastFloatingPointDCT.fDCT2D_llm(src, expectedDest, temp1, downscaleBy8: true); |
||||
|
DCT.TransformFDCT(ref srcBlock, ref destBlock, ref temp2, false); |
||||
|
|
||||
|
float[] actualDest = new float[64]; |
||||
|
destBlock.CopyTo(actualDest); |
||||
|
|
||||
|
Assert.Equal(actualDest, expectedDest, new ApproximateFloatComparer(1f)); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,483 +0,0 @@ |
|||||
namespace SixLabors.ImageSharp.Tests |
|
||||
{ |
|
||||
using System; |
|
||||
using System.Collections.Generic; |
|
||||
using System.Diagnostics; |
|
||||
using System.IO; |
|
||||
using System.Linq; |
|
||||
using System.Numerics; |
|
||||
using System.Reflection; |
|
||||
|
|
||||
using SixLabors.ImageSharp.Formats.Jpeg; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; |
|
||||
using SixLabors.ImageSharp.Memory; |
|
||||
using SixLabors.ImageSharp.PixelFormats; |
|
||||
using SixLabors.Primitives; |
|
||||
|
|
||||
using Xunit; |
|
||||
|
|
||||
internal static class LibJpegTools |
|
||||
{ |
|
||||
public class SpectralData : IEquatable<SpectralData> |
|
||||
{ |
|
||||
public int ComponentCount { get; private set; } |
|
||||
|
|
||||
public ComponentData[] Components { get; private set; } |
|
||||
|
|
||||
private SpectralData(Array wholeImage) |
|
||||
{ |
|
||||
this.ComponentCount = 0; |
|
||||
|
|
||||
for (int i = 0; i < wholeImage.Length && wholeImage.GetValue(i) != null; i++) |
|
||||
{ |
|
||||
this.ComponentCount++; |
|
||||
} |
|
||||
|
|
||||
this.Components = new ComponentData[this.ComponentCount]; |
|
||||
|
|
||||
for (int i = 0; i < this.ComponentCount; i++) |
|
||||
{ |
|
||||
object jVirtArray = wholeImage.GetValue(i); |
|
||||
Array bloxSource = (Array)GetNonPublicMember(jVirtArray, "m_buffer"); |
|
||||
|
|
||||
this.Components[i] = ComponentData.Load(bloxSource, i); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
internal SpectralData(ComponentData[] components) |
|
||||
{ |
|
||||
this.ComponentCount = components.Length; |
|
||||
this.Components = components; |
|
||||
} |
|
||||
|
|
||||
public static SpectralData LoadFromImageSharpDecoder(JpegDecoderCore decoder) |
|
||||
{ |
|
||||
FrameComponent[] srcComponents = decoder.Frame.Components; |
|
||||
ComponentData[] destComponents = srcComponents.Select(ComponentData.Load).ToArray(); |
|
||||
|
|
||||
return new SpectralData(destComponents); |
|
||||
} |
|
||||
|
|
||||
public static SpectralData LoadFromImageSharpDecoder(OldJpegDecoderCore decoder) |
|
||||
{ |
|
||||
OldComponent[] srcComponents = decoder.Components; |
|
||||
ComponentData[] destComponents = srcComponents.Select(ComponentData.Load).ToArray(); |
|
||||
|
|
||||
return new SpectralData(destComponents); |
|
||||
} |
|
||||
|
|
||||
public Image<Rgba32> TryCreateRGBSpectralImage() |
|
||||
{ |
|
||||
if (this.ComponentCount != 3) return null; |
|
||||
|
|
||||
ComponentData c0 = this.Components[0]; |
|
||||
ComponentData c1 = this.Components[1]; |
|
||||
ComponentData c2 = this.Components[2]; |
|
||||
|
|
||||
if (c0.Size != c1.Size || c1.Size != c2.Size) |
|
||||
{ |
|
||||
return null; |
|
||||
} |
|
||||
|
|
||||
Image<Rgba32> result = new Image<Rgba32>(c0.WidthInBlocks * 8, c0.HeightInBlocks * 8); |
|
||||
|
|
||||
for (int by = 0; by < c0.HeightInBlocks; by++) |
|
||||
{ |
|
||||
for (int bx = 0; bx < c0.WidthInBlocks; bx++) |
|
||||
{ |
|
||||
this.WriteToImage(bx, by, result); |
|
||||
} |
|
||||
} |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
internal void WriteToImage(int bx, int by, Image<Rgba32> image) |
|
||||
{ |
|
||||
ComponentData c0 = this.Components[0]; |
|
||||
ComponentData c1 = this.Components[1]; |
|
||||
ComponentData c2 = this.Components[2]; |
|
||||
|
|
||||
Block8x8 block0 = c0.Blocks[bx, by]; |
|
||||
Block8x8 block1 = c1.Blocks[bx, by]; |
|
||||
Block8x8 block2 = c2.Blocks[bx, by]; |
|
||||
|
|
||||
float d0 = (c0.MaxVal - c0.MinVal); |
|
||||
float d1 = (c1.MaxVal - c1.MinVal); |
|
||||
float d2 = (c2.MaxVal - c2.MinVal); |
|
||||
|
|
||||
for (int y = 0; y < 8; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < 8; x++) |
|
||||
{ |
|
||||
float val0 = c0.GetBlockValue(block0, x, y); |
|
||||
float val1 = c0.GetBlockValue(block1, x, y); |
|
||||
float val2 = c0.GetBlockValue(block2, x, y); |
|
||||
|
|
||||
Vector4 v = new Vector4(val0, val1, val2, 1); |
|
||||
Rgba32 color = default(Rgba32); |
|
||||
color.PackFromVector4(v); |
|
||||
|
|
||||
int yy = by * 8 + y; |
|
||||
int xx = bx * 8 + x; |
|
||||
image[xx, yy] = color; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public bool Equals(SpectralData other) |
|
||||
{ |
|
||||
if (ReferenceEquals(null, other)) return false; |
|
||||
if (ReferenceEquals(this, other)) return true; |
|
||||
if (this.ComponentCount != other.ComponentCount) |
|
||||
{ |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
for (int i = 0; i < this.ComponentCount; i++) |
|
||||
{ |
|
||||
ComponentData a = this.Components[i]; |
|
||||
ComponentData b = other.Components[i]; |
|
||||
if (!a.Equals(b)) return false; |
|
||||
} |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
public override bool Equals(object obj) |
|
||||
{ |
|
||||
if (ReferenceEquals(null, obj)) return false; |
|
||||
if (ReferenceEquals(this, obj)) return true; |
|
||||
if (obj.GetType() != this.GetType()) return false; |
|
||||
return Equals((SpectralData)obj); |
|
||||
} |
|
||||
|
|
||||
public override int GetHashCode() |
|
||||
{ |
|
||||
unchecked |
|
||||
{ |
|
||||
return (this.ComponentCount * 397) ^ (this.Components != null ? this.Components[0].GetHashCode() : 0); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public static bool operator ==(SpectralData left, SpectralData right) |
|
||||
{ |
|
||||
return Equals(left, right); |
|
||||
} |
|
||||
|
|
||||
public static bool operator !=(SpectralData left, SpectralData right) |
|
||||
{ |
|
||||
return !Equals(left, right); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public class ComponentData : IEquatable<ComponentData>, IJpegComponent |
|
||||
{ |
|
||||
public ComponentData(int heightInBlocks, int widthInBlocks, int index) |
|
||||
{ |
|
||||
this.HeightInBlocks = heightInBlocks; |
|
||||
this.WidthInBlocks = widthInBlocks; |
|
||||
this.Index = index; |
|
||||
this.Blocks = new Buffer2D<Block8x8>(this.WidthInBlocks, this.HeightInBlocks); |
|
||||
} |
|
||||
|
|
||||
public Size Size => new Size(this.WidthInBlocks, this.HeightInBlocks); |
|
||||
|
|
||||
public int Index { get; } |
|
||||
|
|
||||
public int HeightInBlocks { get; } |
|
||||
|
|
||||
public int WidthInBlocks { get; } |
|
||||
|
|
||||
public Buffer2D<Block8x8> Blocks { get; private set; } |
|
||||
|
|
||||
public short MinVal { get; private set; } = short.MaxValue; |
|
||||
|
|
||||
public short MaxVal { get; private set; } = short.MinValue; |
|
||||
|
|
||||
public static ComponentData Load(Array bloxSource, int index) |
|
||||
{ |
|
||||
int yCount = bloxSource.Length; |
|
||||
Array row0 = (Array)bloxSource.GetValue(0); |
|
||||
int xCount = row0.Length; |
|
||||
ComponentData result = new ComponentData(yCount, xCount, index); |
|
||||
result.Init(bloxSource); |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
private void Init(Array bloxSource) |
|
||||
{ |
|
||||
for (int y = 0; y < bloxSource.Length; y++) |
|
||||
{ |
|
||||
Array row = (Array)bloxSource.GetValue(y); |
|
||||
for (int x = 0; x < row.Length; x++) |
|
||||
{ |
|
||||
object jBlock = row.GetValue(x); |
|
||||
short[] data = (short[])GetNonPublicMember(jBlock, "data"); |
|
||||
this.MakeBlock(data, y, x); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
internal void MakeBlock(short[] data, int y, int x) |
|
||||
{ |
|
||||
this.MinVal = Math.Min(this.MinVal, data.Min()); |
|
||||
this.MaxVal = Math.Max(this.MaxVal, data.Max()); |
|
||||
this.Blocks[x, y] = new Block8x8(data); |
|
||||
} |
|
||||
|
|
||||
public static ComponentData Load(FrameComponent c, int index) |
|
||||
{ |
|
||||
var result = new ComponentData( |
|
||||
c.BlocksPerColumnForMcu, |
|
||||
c.BlocksPerLineForMcu, |
|
||||
index |
|
||||
); |
|
||||
|
|
||||
for (int y = 0; y < result.HeightInBlocks; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < result.WidthInBlocks; x++) |
|
||||
{ |
|
||||
short[] data = c.GetBlockBuffer(y, x).ToArray(); |
|
||||
result.MakeBlock(data, y, x); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
public static ComponentData Load(OldComponent c) |
|
||||
{ |
|
||||
var result = new ComponentData( |
|
||||
c.HeightInBlocks, |
|
||||
c.WidthInBlocks, |
|
||||
c.Index |
|
||||
); |
|
||||
|
|
||||
for (int y = 0; y < result.HeightInBlocks; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < result.WidthInBlocks; x++) |
|
||||
{ |
|
||||
short[] data = c.GetBlockReference(x, y).ToArray(); |
|
||||
result.MakeBlock(data, y, x); |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
public Image<Rgba32> CreateGrayScaleImage() |
|
||||
{ |
|
||||
Image<Rgba32> result = new Image<Rgba32>(this.WidthInBlocks * 8, this.HeightInBlocks * 8); |
|
||||
|
|
||||
for (int by = 0; by < this.HeightInBlocks; by++) |
|
||||
{ |
|
||||
for (int bx = 0; bx < this.WidthInBlocks; bx++) |
|
||||
{ |
|
||||
this.WriteToImage(bx, by, result); |
|
||||
} |
|
||||
} |
|
||||
return result; |
|
||||
} |
|
||||
|
|
||||
internal void WriteToImage(int bx, int by, Image<Rgba32> image) |
|
||||
{ |
|
||||
Block8x8 block = this.Blocks[bx, by]; |
|
||||
|
|
||||
for (int y = 0; y < 8; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < 8; x++) |
|
||||
{ |
|
||||
var val = this.GetBlockValue(block, x, y); |
|
||||
|
|
||||
Vector4 v = new Vector4(val, val, val, 1); |
|
||||
Rgba32 color = default(Rgba32); |
|
||||
color.PackFromVector4(v); |
|
||||
|
|
||||
int yy = by * 8 + y; |
|
||||
int xx = bx * 8 + x; |
|
||||
image[xx, yy] = color; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
internal float GetBlockValue(Block8x8 block, int x, int y) |
|
||||
{ |
|
||||
float d = (this.MaxVal - this.MinVal); |
|
||||
float val = block.GetValueAt(x, y); |
|
||||
val -= this.MinVal; |
|
||||
val /= d; |
|
||||
return val; |
|
||||
} |
|
||||
|
|
||||
public bool Equals(ComponentData other) |
|
||||
{ |
|
||||
if (ReferenceEquals(null, other)) return false; |
|
||||
if (ReferenceEquals(this, other)) return true; |
|
||||
bool ok = this.Index == other.Index && this.HeightInBlocks == other.HeightInBlocks |
|
||||
&& this.WidthInBlocks == other.WidthInBlocks; |
|
||||
//&& this.MinVal == other.MinVal
|
|
||||
//&& this.MaxVal == other.MaxVal;
|
|
||||
if (!ok) return false; |
|
||||
|
|
||||
for (int y = 0; y < this.HeightInBlocks; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < this.WidthInBlocks; x++) |
|
||||
{ |
|
||||
Block8x8 a = this.Blocks[x, y]; |
|
||||
Block8x8 b = other.Blocks[x, y]; |
|
||||
if (!a.Equals(b)) return false; |
|
||||
} |
|
||||
} |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
public override bool Equals(object obj) |
|
||||
{ |
|
||||
if (ReferenceEquals(null, obj)) return false; |
|
||||
if (ReferenceEquals(this, obj)) return true; |
|
||||
if (obj.GetType() != this.GetType()) return false; |
|
||||
return Equals((ComponentData)obj); |
|
||||
} |
|
||||
|
|
||||
public override int GetHashCode() |
|
||||
{ |
|
||||
unchecked |
|
||||
{ |
|
||||
var hashCode = this.Index; |
|
||||
hashCode = (hashCode * 397) ^ this.HeightInBlocks; |
|
||||
hashCode = (hashCode * 397) ^ this.WidthInBlocks; |
|
||||
hashCode = (hashCode * 397) ^ this.MinVal.GetHashCode(); |
|
||||
hashCode = (hashCode * 397) ^ this.MaxVal.GetHashCode(); |
|
||||
return hashCode; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
public static bool operator ==(ComponentData left, ComponentData right) |
|
||||
{ |
|
||||
return Equals(left, right); |
|
||||
} |
|
||||
|
|
||||
public static bool operator !=(ComponentData left, ComponentData right) |
|
||||
{ |
|
||||
return !Equals(left, right); |
|
||||
} |
|
||||
|
|
||||
|
|
||||
} |
|
||||
|
|
||||
internal static FieldInfo GetNonPublicField(object obj, string fieldName) |
|
||||
{ |
|
||||
Type type = obj.GetType(); |
|
||||
return type.GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic); |
|
||||
} |
|
||||
|
|
||||
internal static object GetNonPublicMember(object obj, string fieldName) |
|
||||
{ |
|
||||
FieldInfo fi = GetNonPublicField(obj, fieldName); |
|
||||
return fi.GetValue(obj); |
|
||||
} |
|
||||
|
|
||||
public static (double total, double average) CalculateDifference(ComponentData expected, ComponentData actual) |
|
||||
{ |
|
||||
BigInteger totalDiff = 0; |
|
||||
if (actual.WidthInBlocks < expected.WidthInBlocks) |
|
||||
{ |
|
||||
throw new Exception("actual.WidthInBlocks < expected.WidthInBlocks"); |
|
||||
} |
|
||||
|
|
||||
if (actual.HeightInBlocks < expected.HeightInBlocks) |
|
||||
{ |
|
||||
throw new Exception("actual.HeightInBlocks < expected.HeightInBlocks"); |
|
||||
} |
|
||||
|
|
||||
int w = expected.WidthInBlocks; |
|
||||
int h = expected.HeightInBlocks; |
|
||||
for (int y = 0; y < h; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < w; x++) |
|
||||
{ |
|
||||
Block8x8 aa = expected.Blocks[x, y]; |
|
||||
Block8x8 bb = actual.Blocks[x, y]; |
|
||||
|
|
||||
long diff = Block8x8.TotalDifference(ref aa, ref bb); |
|
||||
totalDiff += diff; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
int count = w * h; |
|
||||
double total = (double)totalDiff; |
|
||||
double average = (double)totalDiff / (count * Block8x8.Size); |
|
||||
return (total, average); |
|
||||
} |
|
||||
|
|
||||
private static string DumpToolFullPath => Path.Combine( |
|
||||
TestEnvironment.ToolsDirectoryFullPath, |
|
||||
@"jpeg\dump-jpeg-coeffs.exe"); |
|
||||
|
|
||||
public static void RunDumpJpegCoeffsTool(string sourceFile, string destFile) |
|
||||
{ |
|
||||
string args = $@"""{sourceFile}"" ""{destFile}"""; |
|
||||
var process = Process.Start(DumpToolFullPath, args); |
|
||||
process.WaitForExit(); |
|
||||
} |
|
||||
|
|
||||
public static SpectralData ExtractSpectralData(string inputFile) |
|
||||
{ |
|
||||
TestFile testFile = TestFile.Create(inputFile); |
|
||||
|
|
||||
string outDir = TestEnvironment.CreateOutputDirectory(".Temp", $"JpegCoeffs"); |
|
||||
string fn = $"{Path.GetFileName(inputFile)}-{new Random().Next(1000)}.dctcoeffs"; |
|
||||
string coeffFileFullPath = Path.Combine(outDir, fn); |
|
||||
|
|
||||
try |
|
||||
{ |
|
||||
RunDumpJpegCoeffsTool(testFile.FullPath, coeffFileFullPath); |
|
||||
|
|
||||
using (var dumpStream = new FileStream(coeffFileFullPath, FileMode.Open)) |
|
||||
using (var rdr = new BinaryReader(dumpStream)) |
|
||||
{ |
|
||||
int componentCount = rdr.ReadInt16(); |
|
||||
ComponentData[] result = new ComponentData[componentCount]; |
|
||||
|
|
||||
for (int i = 0; i < componentCount; i++) |
|
||||
{ |
|
||||
int widthInBlocks = rdr.ReadInt16(); |
|
||||
int heightInBlocks = rdr.ReadInt16(); |
|
||||
ComponentData resultComponent = new ComponentData(heightInBlocks, widthInBlocks, i); |
|
||||
result[i] = resultComponent; |
|
||||
} |
|
||||
|
|
||||
byte[] buffer = new byte[64*sizeof(short)]; |
|
||||
|
|
||||
for (int i = 0; i < result.Length; i++) |
|
||||
{ |
|
||||
ComponentData c = result[i]; |
|
||||
|
|
||||
for (int y = 0; y < c.HeightInBlocks; y++) |
|
||||
{ |
|
||||
for (int x = 0; x < c.WidthInBlocks; x++) |
|
||||
{ |
|
||||
rdr.Read(buffer, 0, buffer.Length); |
|
||||
|
|
||||
short[] block = buffer.AsSpan().NonPortableCast<byte, short>().ToArray(); |
|
||||
c.MakeBlock(block, y, x); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return new SpectralData(result); |
|
||||
} |
|
||||
} |
|
||||
finally |
|
||||
{ |
|
||||
if (File.Exists(coeffFileFullPath)) |
|
||||
{ |
|
||||
File.Delete(coeffFileFullPath); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,918 +0,0 @@ |
|||||
// 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.Formats; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
|
||||
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Utils; |
|
||||
|
|
||||
// ReSharper disable InconsistentNaming
|
|
||||
|
|
||||
namespace SixLabors.ImageSharp.Tests |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// This class contains simplified (unefficient) reference implementations to produce verification data for unit tests
|
|
||||
/// Floating point DCT code Ported from https://github.com/norishigefukushima/dct_simd
|
|
||||
/// </summary>
|
|
||||
internal static class ReferenceImplementations |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Transpose 8x8 block stored linearly in a <see cref="MutableSpan{T}"/> (inplace)
|
|
||||
/// </summary>
|
|
||||
/// <param name="data"></param>
|
|
||||
internal static void Transpose8x8(Span<float> data) |
|
||||
{ |
|
||||
for (int i = 1; i < 8; i++) |
|
||||
{ |
|
||||
int i8 = i * 8; |
|
||||
for (int j = 0; j < i; j++) |
|
||||
{ |
|
||||
float tmp = data[i8 + j]; |
|
||||
data[i8 + j] = data[j * 8 + i]; |
|
||||
data[j * 8 + i] = tmp; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Transpose 8x8 block stored linearly in a <see cref="MutableSpan{T}"/>
|
|
||||
/// </summary>
|
|
||||
internal static void Transpose8x8(Span<float> src, Span<float> dest) |
|
||||
{ |
|
||||
for (int i = 0; i < 8; i++) |
|
||||
{ |
|
||||
int i8 = i * 8; |
|
||||
for (int j = 0; j < 8; j++) |
|
||||
{ |
|
||||
dest[j * 8 + i] = src[i8 + j]; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The "original" libjpeg/golang based DCT implementation is used as reference implementation for tests.
|
|
||||
/// </summary>
|
|
||||
public static class IntegerReferenceDCT |
|
||||
{ |
|
||||
private const int fix_0_298631336 = 2446; |
|
||||
private const int fix_0_390180644 = 3196; |
|
||||
private const int fix_0_541196100 = 4433; |
|
||||
private const int fix_0_765366865 = 6270; |
|
||||
private const int fix_0_899976223 = 7373; |
|
||||
private const int fix_1_175875602 = 9633; |
|
||||
private const int fix_1_501321110 = 12299; |
|
||||
private const int fix_1_847759065 = 15137; |
|
||||
private const int fix_1_961570560 = 16069; |
|
||||
private const int fix_2_053119869 = 16819; |
|
||||
private const int fix_2_562915447 = 20995; |
|
||||
private const int fix_3_072711026 = 25172; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The number of bits
|
|
||||
/// </summary>
|
|
||||
private const int Bits = 13; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The number of bits to shift by on the first pass.
|
|
||||
/// </summary>
|
|
||||
private const int Pass1Bits = 2; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// The value to shift by
|
|
||||
/// </summary>
|
|
||||
private const int CenterJSample = 128; |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Performs a forward DCT on an 8x8 block of coefficients, including a level shift.
|
|
||||
/// Leave results scaled up by an overall factor of 8.
|
|
||||
/// </summary>
|
|
||||
/// <param name="block">The block of coefficients.</param>
|
|
||||
public static void TransformFDCTInplace(Span<int> block) |
|
||||
{ |
|
||||
// Pass 1: process rows.
|
|
||||
for (int y = 0; y < 8; y++) |
|
||||
{ |
|
||||
int y8 = y * 8; |
|
||||
|
|
||||
int x0 = block[y8]; |
|
||||
int x1 = block[y8 + 1]; |
|
||||
int x2 = block[y8 + 2]; |
|
||||
int x3 = block[y8 + 3]; |
|
||||
int x4 = block[y8 + 4]; |
|
||||
int x5 = block[y8 + 5]; |
|
||||
int x6 = block[y8 + 6]; |
|
||||
int x7 = block[y8 + 7]; |
|
||||
|
|
||||
int tmp0 = x0 + x7; |
|
||||
int tmp1 = x1 + x6; |
|
||||
int tmp2 = x2 + x5; |
|
||||
int tmp3 = x3 + x4; |
|
||||
|
|
||||
int tmp10 = tmp0 + tmp3; |
|
||||
int tmp12 = tmp0 - tmp3; |
|
||||
int tmp11 = tmp1 + tmp2; |
|
||||
int tmp13 = tmp1 - tmp2; |
|
||||
|
|
||||
tmp0 = x0 - x7; |
|
||||
tmp1 = x1 - x6; |
|
||||
tmp2 = x2 - x5; |
|
||||
tmp3 = x3 - x4; |
|
||||
|
|
||||
block[y8] = (tmp10 + tmp11 - (8 * CenterJSample)) << Pass1Bits; |
|
||||
block[y8 + 4] = (tmp10 - tmp11) << Pass1Bits; |
|
||||
int z1 = (tmp12 + tmp13) * fix_0_541196100; |
|
||||
z1 += 1 << (Bits - Pass1Bits - 1); |
|
||||
block[y8 + 2] = (z1 + (tmp12 * fix_0_765366865)) >> (Bits - Pass1Bits); |
|
||||
block[y8 + 6] = (z1 - (tmp13 * fix_1_847759065)) >> (Bits - Pass1Bits); |
|
||||
|
|
||||
tmp10 = tmp0 + tmp3; |
|
||||
tmp11 = tmp1 + tmp2; |
|
||||
tmp12 = tmp0 + tmp2; |
|
||||
tmp13 = tmp1 + tmp3; |
|
||||
z1 = (tmp12 + tmp13) * fix_1_175875602; |
|
||||
z1 += 1 << (Bits - Pass1Bits - 1); |
|
||||
tmp0 = tmp0 * fix_1_501321110; |
|
||||
tmp1 = tmp1 * fix_3_072711026; |
|
||||
tmp2 = tmp2 * fix_2_053119869; |
|
||||
tmp3 = tmp3 * fix_0_298631336; |
|
||||
tmp10 = tmp10 * -fix_0_899976223; |
|
||||
tmp11 = tmp11 * -fix_2_562915447; |
|
||||
tmp12 = tmp12 * -fix_0_390180644; |
|
||||
tmp13 = tmp13 * -fix_1_961570560; |
|
||||
|
|
||||
tmp12 += z1; |
|
||||
tmp13 += z1; |
|
||||
block[y8 + 1] = (tmp0 + tmp10 + tmp12) >> (Bits - Pass1Bits); |
|
||||
block[y8 + 3] = (tmp1 + tmp11 + tmp13) >> (Bits - Pass1Bits); |
|
||||
block[y8 + 5] = (tmp2 + tmp11 + tmp12) >> (Bits - Pass1Bits); |
|
||||
block[y8 + 7] = (tmp3 + tmp10 + tmp13) >> (Bits - Pass1Bits); |
|
||||
} |
|
||||
|
|
||||
// Pass 2: process columns.
|
|
||||
// We remove pass1Bits scaling, but leave results scaled up by an overall factor of 8.
|
|
||||
for (int x = 0; x < 8; x++) |
|
||||
{ |
|
||||
int tmp0 = block[x] + block[56 + x]; |
|
||||
int tmp1 = block[8 + x] + block[48 + x]; |
|
||||
int tmp2 = block[16 + x] + block[40 + x]; |
|
||||
int tmp3 = block[24 + x] + block[32 + x]; |
|
||||
|
|
||||
int tmp10 = tmp0 + tmp3 + (1 << (Pass1Bits - 1)); |
|
||||
int tmp12 = tmp0 - tmp3; |
|
||||
int tmp11 = tmp1 + tmp2; |
|
||||
int tmp13 = tmp1 - tmp2; |
|
||||
|
|
||||
tmp0 = block[x] - block[56 + x]; |
|
||||
tmp1 = block[8 + x] - block[48 + x]; |
|
||||
tmp2 = block[16 + x] - block[40 + x]; |
|
||||
tmp3 = block[24 + x] - block[32 + x]; |
|
||||
|
|
||||
block[x] = (tmp10 + tmp11) >> Pass1Bits; |
|
||||
block[32 + x] = (tmp10 - tmp11) >> Pass1Bits; |
|
||||
|
|
||||
int z1 = (tmp12 + tmp13) * fix_0_541196100; |
|
||||
z1 += 1 << (Bits + Pass1Bits - 1); |
|
||||
block[16 + x] = (z1 + (tmp12 * fix_0_765366865)) >> (Bits + Pass1Bits); |
|
||||
block[48 + x] = (z1 - (tmp13 * fix_1_847759065)) >> (Bits + Pass1Bits); |
|
||||
|
|
||||
tmp10 = tmp0 + tmp3; |
|
||||
tmp11 = tmp1 + tmp2; |
|
||||
tmp12 = tmp0 + tmp2; |
|
||||
tmp13 = tmp1 + tmp3; |
|
||||
z1 = (tmp12 + tmp13) * fix_1_175875602; |
|
||||
z1 += 1 << (Bits + Pass1Bits - 1); |
|
||||
tmp0 = tmp0 * fix_1_501321110; |
|
||||
tmp1 = tmp1 * fix_3_072711026; |
|
||||
tmp2 = tmp2 * fix_2_053119869; |
|
||||
tmp3 = tmp3 * fix_0_298631336; |
|
||||
tmp10 = tmp10 * -fix_0_899976223; |
|
||||
tmp11 = tmp11 * -fix_2_562915447; |
|
||||
tmp12 = tmp12 * -fix_0_390180644; |
|
||||
tmp13 = tmp13 * -fix_1_961570560; |
|
||||
|
|
||||
tmp12 += z1; |
|
||||
tmp13 += z1; |
|
||||
block[8 + x] = (tmp0 + tmp10 + tmp12) >> (Bits + Pass1Bits); |
|
||||
block[24 + x] = (tmp1 + tmp11 + tmp13) >> (Bits + Pass1Bits); |
|
||||
block[40 + x] = (tmp2 + tmp11 + tmp12) >> (Bits + Pass1Bits); |
|
||||
block[56 + x] = (tmp3 + tmp10 + tmp13) >> (Bits + Pass1Bits); |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
private const int w1 = 2841; // 2048*sqrt(2)*cos(1*pi/16)
|
|
||||
private const int w2 = 2676; // 2048*sqrt(2)*cos(2*pi/16)
|
|
||||
private const int w3 = 2408; // 2048*sqrt(2)*cos(3*pi/16)
|
|
||||
private const int w5 = 1609; // 2048*sqrt(2)*cos(5*pi/16)
|
|
||||
private const int w6 = 1108; // 2048*sqrt(2)*cos(6*pi/16)
|
|
||||
private const int w7 = 565; // 2048*sqrt(2)*cos(7*pi/16)
|
|
||||
|
|
||||
private const int w1pw7 = w1 + w7; |
|
||||
private const int w1mw7 = w1 - w7; |
|
||||
private const int w2pw6 = w2 + w6; |
|
||||
private const int w2mw6 = w2 - w6; |
|
||||
private const int w3pw5 = w3 + w5; |
|
||||
private const int w3mw5 = w3 - w5; |
|
||||
|
|
||||
private const int r2 = 181; // 256/sqrt(2)
|
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Performs a 2-D Inverse Discrete Cosine Transformation.
|
|
||||
/// <para>
|
|
||||
/// The input coefficients should already have been multiplied by the
|
|
||||
/// appropriate quantization table. We use fixed-point computation, with the
|
|
||||
/// number of bits for the fractional component varying over the intermediate
|
|
||||
/// stages.
|
|
||||
/// </para>
|
|
||||
/// For more on the actual algorithm, see Z. Wang, "Fast algorithms for the
|
|
||||
/// discrete W transform and for the discrete Fourier transform", IEEE Trans. on
|
|
||||
/// ASSP, Vol. ASSP- 32, pp. 803-816, Aug. 1984.
|
|
||||
/// </summary>
|
|
||||
/// <param name="src">The source block of coefficients</param>
|
|
||||
public static void TransformIDCTInplace(Span<int> src) |
|
||||
{ |
|
||||
// Horizontal 1-D IDCT.
|
|
||||
for (int y = 0; y < 8; y++) |
|
||||
{ |
|
||||
int y8 = y * 8; |
|
||||
|
|
||||
// If all the AC components are zero, then the IDCT is trivial.
|
|
||||
if (src[y8 + 1] == 0 && src[y8 + 2] == 0 && src[y8 + 3] == 0 && |
|
||||
src[y8 + 4] == 0 && src[y8 + 5] == 0 && src[y8 + 6] == 0 && src[y8 + 7] == 0) |
|
||||
{ |
|
||||
int dc = src[y8 + 0] << 3; |
|
||||
src[y8 + 0] = dc; |
|
||||
src[y8 + 1] = dc; |
|
||||
src[y8 + 2] = dc; |
|
||||
src[y8 + 3] = dc; |
|
||||
src[y8 + 4] = dc; |
|
||||
src[y8 + 5] = dc; |
|
||||
src[y8 + 6] = dc; |
|
||||
src[y8 + 7] = dc; |
|
||||
continue; |
|
||||
} |
|
||||
|
|
||||
// Prescale.
|
|
||||
int x0 = (src[y8 + 0] << 11) + 128; |
|
||||
int x1 = src[y8 + 4] << 11; |
|
||||
int x2 = src[y8 + 6]; |
|
||||
int x3 = src[y8 + 2]; |
|
||||
int x4 = src[y8 + 1]; |
|
||||
int x5 = src[y8 + 7]; |
|
||||
int x6 = src[y8 + 5]; |
|
||||
int x7 = src[y8 + 3]; |
|
||||
|
|
||||
// Stage 1.
|
|
||||
int x8 = w7 * (x4 + x5); |
|
||||
x4 = x8 + (w1mw7 * x4); |
|
||||
x5 = x8 - (w1pw7 * x5); |
|
||||
x8 = w3 * (x6 + x7); |
|
||||
x6 = x8 - (w3mw5 * x6); |
|
||||
x7 = x8 - (w3pw5 * x7); |
|
||||
|
|
||||
// Stage 2.
|
|
||||
x8 = x0 + x1; |
|
||||
x0 -= x1; |
|
||||
x1 = w6 * (x3 + x2); |
|
||||
x2 = x1 - (w2pw6 * x2); |
|
||||
x3 = x1 + (w2mw6 * x3); |
|
||||
x1 = x4 + x6; |
|
||||
x4 -= x6; |
|
||||
x6 = x5 + x7; |
|
||||
x5 -= x7; |
|
||||
|
|
||||
// Stage 3.
|
|
||||
x7 = x8 + x3; |
|
||||
x8 -= x3; |
|
||||
x3 = x0 + x2; |
|
||||
x0 -= x2; |
|
||||
x2 = ((r2 * (x4 + x5)) + 128) >> 8; |
|
||||
x4 = ((r2 * (x4 - x5)) + 128) >> 8; |
|
||||
|
|
||||
// Stage 4.
|
|
||||
src[y8 + 0] = (x7 + x1) >> 8; |
|
||||
src[y8 + 1] = (x3 + x2) >> 8; |
|
||||
src[y8 + 2] = (x0 + x4) >> 8; |
|
||||
src[y8 + 3] = (x8 + x6) >> 8; |
|
||||
src[y8 + 4] = (x8 - x6) >> 8; |
|
||||
src[y8 + 5] = (x0 - x4) >> 8; |
|
||||
src[y8 + 6] = (x3 - x2) >> 8; |
|
||||
src[y8 + 7] = (x7 - x1) >> 8; |
|
||||
} |
|
||||
|
|
||||
// Vertical 1-D IDCT.
|
|
||||
for (int x = 0; x < 8; x++) |
|
||||
{ |
|
||||
// Similar to the horizontal 1-D IDCT case, if all the AC components are zero, then the IDCT is trivial.
|
|
||||
// However, after performing the horizontal 1-D IDCT, there are typically non-zero AC components, so
|
|
||||
// we do not bother to check for the all-zero case.
|
|
||||
|
|
||||
// Prescale.
|
|
||||
int y0 = (src[x] << 8) + 8192; |
|
||||
int y1 = src[32 + x] << 8; |
|
||||
int y2 = src[48 + x]; |
|
||||
int y3 = src[16 + x]; |
|
||||
int y4 = src[8 + x]; |
|
||||
int y5 = src[56 + x]; |
|
||||
int y6 = src[40 + x]; |
|
||||
int y7 = src[24 + x]; |
|
||||
|
|
||||
// Stage 1.
|
|
||||
int y8 = (w7 * (y4 + y5)) + 4; |
|
||||
y4 = (y8 + (w1mw7 * y4)) >> 3; |
|
||||
y5 = (y8 - (w1pw7 * y5)) >> 3; |
|
||||
y8 = (w3 * (y6 + y7)) + 4; |
|
||||
y6 = (y8 - (w3mw5 * y6)) >> 3; |
|
||||
y7 = (y8 - (w3pw5 * y7)) >> 3; |
|
||||
|
|
||||
// Stage 2.
|
|
||||
y8 = y0 + y1; |
|
||||
y0 -= y1; |
|
||||
y1 = (w6 * (y3 + y2)) + 4; |
|
||||
y2 = (y1 - (w2pw6 * y2)) >> 3; |
|
||||
y3 = (y1 + (w2mw6 * y3)) >> 3; |
|
||||
y1 = y4 + y6; |
|
||||
y4 -= y6; |
|
||||
y6 = y5 + y7; |
|
||||
y5 -= y7; |
|
||||
|
|
||||
// Stage 3.
|
|
||||
y7 = y8 + y3; |
|
||||
y8 -= y3; |
|
||||
y3 = y0 + y2; |
|
||||
y0 -= y2; |
|
||||
y2 = ((r2 * (y4 + y5)) + 128) >> 8; |
|
||||
y4 = ((r2 * (y4 - y5)) + 128) >> 8; |
|
||||
|
|
||||
// Stage 4.
|
|
||||
src[x] = (y7 + y1) >> 14; |
|
||||
src[8 + x] = (y3 + y2) >> 14; |
|
||||
src[16 + x] = (y0 + y4) >> 14; |
|
||||
src[24 + x] = (y8 + y6) >> 14; |
|
||||
src[32 + x] = (y8 - y6) >> 14; |
|
||||
src[40 + x] = (y0 - y4) >> 14; |
|
||||
src[48 + x] = (y3 - y2) >> 14; |
|
||||
src[56 + x] = (y7 - y1) >> 14; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L200
|
|
||||
/// </summary>
|
|
||||
/// <param name="y"></param>
|
|
||||
/// <param name="x"></param>
|
|
||||
private static void iDCT1Dllm_32f(Span<float> y, Span<float> x) |
|
||||
{ |
|
||||
float a0, a1, a2, a3, b0, b1, b2, b3; |
|
||||
float z0, z1, z2, z3, z4; |
|
||||
|
|
||||
//float r0 = 1.414214f;
|
|
||||
float r1 = 1.387040f; |
|
||||
float r2 = 1.306563f; |
|
||||
float r3 = 1.175876f; |
|
||||
//float r4 = 1.000000f;
|
|
||||
float r5 = 0.785695f; |
|
||||
float r6 = 0.541196f; |
|
||||
float r7 = 0.275899f; |
|
||||
|
|
||||
z0 = y[1] + y[7]; |
|
||||
z1 = y[3] + y[5]; |
|
||||
z2 = y[3] + y[7]; |
|
||||
z3 = y[1] + y[5]; |
|
||||
z4 = (z0 + z1) * r3; |
|
||||
|
|
||||
z0 = z0 * (-r3 + r7); |
|
||||
z1 = z1 * (-r3 - r1); |
|
||||
z2 = z2 * (-r3 - r5) + z4; |
|
||||
z3 = z3 * (-r3 + r5) + z4; |
|
||||
|
|
||||
b3 = y[7] * (-r1 + r3 + r5 - r7) + z0 + z2; |
|
||||
b2 = y[5] * (r1 + r3 - r5 + r7) + z1 + z3; |
|
||||
b1 = y[3] * (r1 + r3 + r5 - r7) + z1 + z2; |
|
||||
b0 = y[1] * (r1 + r3 - r5 - r7) + z0 + z3; |
|
||||
|
|
||||
z4 = (y[2] + y[6]) * r6; |
|
||||
z0 = y[0] + y[4]; |
|
||||
z1 = y[0] - y[4]; |
|
||||
z2 = z4 - y[6] * (r2 + r6); |
|
||||
z3 = z4 + y[2] * (r2 - r6); |
|
||||
a0 = z0 + z3; |
|
||||
a3 = z0 - z3; |
|
||||
a1 = z1 + z2; |
|
||||
a2 = z1 - z2; |
|
||||
|
|
||||
x[0] = a0 + b0; |
|
||||
x[7] = a0 - b0; |
|
||||
x[1] = a1 + b1; |
|
||||
x[6] = a1 - b1; |
|
||||
x[2] = a2 + b2; |
|
||||
x[5] = a2 - b2; |
|
||||
x[3] = a3 + b3; |
|
||||
x[4] = a3 - b3; |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Original: https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L239
|
|
||||
/// Applyies IDCT transformation on "s" copying transformed values to "d", using temporal block "temp"
|
|
||||
/// </summary>
|
|
||||
/// <param name="s"></param>
|
|
||||
/// <param name="d"></param>
|
|
||||
/// <param name="temp"></param>
|
|
||||
internal static void iDCT2D_llm(Span<float> s, Span<float> d, Span<float> temp) |
|
||||
{ |
|
||||
int j; |
|
||||
|
|
||||
for (j = 0; j < 8; j++) |
|
||||
{ |
|
||||
iDCT1Dllm_32f(s.Slice(j * 8), temp.Slice(j * 8)); |
|
||||
} |
|
||||
|
|
||||
Transpose8x8(temp, d); |
|
||||
|
|
||||
for (j = 0; j < 8; j++) |
|
||||
{ |
|
||||
iDCT1Dllm_32f(d.Slice(j * 8), temp.Slice(j * 8)); |
|
||||
} |
|
||||
|
|
||||
Transpose8x8(temp, d); |
|
||||
|
|
||||
for (j = 0; j < 64; j++) |
|
||||
{ |
|
||||
d[j] *= 0.125f; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Original:
|
|
||||
/// <see>
|
|
||||
/// <cref>https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L15</cref>
|
|
||||
/// </see>
|
|
||||
/// </summary>
|
|
||||
/// <param name="s">Source</param>
|
|
||||
/// <param name="d">Destination</param>
|
|
||||
public static void fDCT2D8x4_32f(Span<float> s, Span<float> d) |
|
||||
{ |
|
||||
Vector4 c0 = _mm_load_ps(s, 0); |
|
||||
Vector4 c1 = _mm_load_ps(s, 56); |
|
||||
Vector4 t0 = (c0 + c1); |
|
||||
Vector4 t7 = (c0 - c1); |
|
||||
|
|
||||
c1 = _mm_load_ps(s, 48); |
|
||||
c0 = _mm_load_ps(s, 8); |
|
||||
Vector4 t1 = (c0 + c1); |
|
||||
Vector4 t6 = (c0 - c1); |
|
||||
|
|
||||
c1 = _mm_load_ps(s, 40); |
|
||||
c0 = _mm_load_ps(s, 16); |
|
||||
Vector4 t2 = (c0 + c1); |
|
||||
Vector4 t5 = (c0 - c1); |
|
||||
|
|
||||
c0 = _mm_load_ps(s, 24); |
|
||||
c1 = _mm_load_ps(s, 32); |
|
||||
Vector4 t3 = (c0 + c1); |
|
||||
Vector4 t4 = (c0 - c1); |
|
||||
|
|
||||
/* |
|
||||
c1 = x[0]; c2 = x[7]; t0 = c1 + c2; t7 = c1 - c2; |
|
||||
c1 = x[1]; c2 = x[6]; t1 = c1 + c2; t6 = c1 - c2; |
|
||||
c1 = x[2]; c2 = x[5]; t2 = c1 + c2; t5 = c1 - c2; |
|
||||
c1 = x[3]; c2 = x[4]; t3 = c1 + c2; t4 = c1 - c2; |
|
||||
*/ |
|
||||
|
|
||||
c0 = (t0 + t3); |
|
||||
Vector4 c3 = (t0 - t3); |
|
||||
c1 = (t1 + t2); |
|
||||
Vector4 c2 = (t1 - t2); |
|
||||
|
|
||||
/* |
|
||||
c0 = t0 + t3; c3 = t0 - t3; |
|
||||
c1 = t1 + t2; c2 = t1 - t2; |
|
||||
*/ |
|
||||
|
|
||||
_mm_store_ps(d, 0, (c0 + c1)); |
|
||||
|
|
||||
_mm_store_ps(d, 32, (c0 - c1)); |
|
||||
|
|
||||
/*y[0] = c0 + c1; |
|
||||
y[4] = c0 - c1;*/ |
|
||||
|
|
||||
Vector4 w0 = new Vector4(0.541196f); |
|
||||
Vector4 w1 = new Vector4(1.306563f); |
|
||||
|
|
||||
_mm_store_ps(d, 16, ((w0 * c2) + (w1 * c3))); |
|
||||
|
|
||||
_mm_store_ps(d, 48, ((w0 * c3) - (w1 * c2))); |
|
||||
/* |
|
||||
y[2] = c2 * r[6] + c3 * r[2]; |
|
||||
y[6] = c3 * r[6] - c2 * r[2]; |
|
||||
*/ |
|
||||
|
|
||||
w0 = new Vector4(1.175876f); |
|
||||
w1 = new Vector4(0.785695f); |
|
||||
c3 = ((w0 * t4) + (w1 * t7)); |
|
||||
c0 = ((w0 * t7) - (w1 * t4)); |
|
||||
/* |
|
||||
c3 = t4 * r[3] + t7 * r[5]; |
|
||||
c0 = t7 * r[3] - t4 * r[5]; |
|
||||
*/ |
|
||||
|
|
||||
w0 = new Vector4(1.387040f); |
|
||||
w1 = new Vector4(0.275899f); |
|
||||
c2 = ((w0 * t5) + (w1 * t6)); |
|
||||
c1 = ((w0 * t6) - (w1 * t5)); |
|
||||
/* |
|
||||
c2 = t5 * r[1] + t6 * r[7]; |
|
||||
c1 = t6 * r[1] - t5 * r[7]; |
|
||||
*/ |
|
||||
|
|
||||
_mm_store_ps(d, 24, (c0 - c2)); |
|
||||
|
|
||||
_mm_store_ps(d, 40, (c3 - c1)); |
|
||||
//y[5] = c3 - c1; y[3] = c0 - c2;
|
|
||||
|
|
||||
Vector4 invsqrt2 = new Vector4(0.707107f); |
|
||||
c0 = ((c0 + c2) * invsqrt2); |
|
||||
c3 = ((c3 + c1) * invsqrt2); |
|
||||
//c0 = (c0 + c2) * invsqrt2;
|
|
||||
//c3 = (c3 + c1) * invsqrt2;
|
|
||||
|
|
||||
_mm_store_ps(d, 8, (c0 + c3)); |
|
||||
|
|
||||
_mm_store_ps(d, 56, (c0 - c3)); |
|
||||
//y[1] = c0 + c3; y[7] = c0 - c3;
|
|
||||
|
|
||||
/*for(i = 0;i < 8;i++) |
|
||||
{ |
|
||||
y[i] *= invsqrt2h; |
|
||||
}*/ |
|
||||
} |
|
||||
|
|
||||
public static void fDCT8x8_llm_sse(Span<float> s, Span<float> d, Span<float> temp) |
|
||||
{ |
|
||||
Transpose8x8(s, temp); |
|
||||
|
|
||||
fDCT2D8x4_32f(temp, d); |
|
||||
|
|
||||
fDCT2D8x4_32f(temp.Slice(4), d.Slice(4)); |
|
||||
|
|
||||
Transpose8x8(d, temp); |
|
||||
|
|
||||
fDCT2D8x4_32f(temp, d); |
|
||||
|
|
||||
fDCT2D8x4_32f(temp.Slice(4), d.Slice(4)); |
|
||||
|
|
||||
Vector4 c = new Vector4(0.1250f); |
|
||||
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//0
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//1
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//2
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//3
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//4
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//5
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//6
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//7
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//8
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//9
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//10
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//11
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//12
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//13
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//14
|
|
||||
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//15
|
|
||||
} |
|
||||
|
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|
||||
private static Vector4 _mm_load_ps(Span<float> src, int offset) |
|
||||
{ |
|
||||
src = src.Slice(offset); |
|
||||
return new Vector4(src[0], src[1], src[2], src[3]); |
|
||||
} |
|
||||
|
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|
||||
private static void _mm_store_ps(Span<float> dest, int offset, Vector4 src) |
|
||||
{ |
|
||||
dest = dest.Slice(offset); |
|
||||
dest[0] = src.X; |
|
||||
dest[1] = src.Y; |
|
||||
dest[2] = src.Z; |
|
||||
dest[3] = src.W; |
|
||||
} |
|
||||
|
|
||||
private static readonly Vector4 _1_175876 = new Vector4(1.175876f); |
|
||||
|
|
||||
private static readonly Vector4 _1_961571 = new Vector4(-1.961571f); |
|
||||
|
|
||||
private static readonly Vector4 _0_390181 = new Vector4(-0.390181f); |
|
||||
|
|
||||
private static readonly Vector4 _0_899976 = new Vector4(-0.899976f); |
|
||||
|
|
||||
private static readonly Vector4 _2_562915 = new Vector4(-2.562915f); |
|
||||
|
|
||||
private static readonly Vector4 _0_298631 = new Vector4(0.298631f); |
|
||||
|
|
||||
private static readonly Vector4 _2_053120 = new Vector4(2.053120f); |
|
||||
|
|
||||
private static readonly Vector4 _3_072711 = new Vector4(3.072711f); |
|
||||
|
|
||||
private static readonly Vector4 _1_501321 = new Vector4(1.501321f); |
|
||||
|
|
||||
private static readonly Vector4 _0_541196 = new Vector4(0.541196f); |
|
||||
|
|
||||
private static readonly Vector4 _1_847759 = new Vector4(-1.847759f); |
|
||||
|
|
||||
private static readonly Vector4 _0_765367 = new Vector4(0.765367f); |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Original:
|
|
||||
/// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L261
|
|
||||
/// Does a part of the IDCT job on the given parts of the blocks
|
|
||||
/// </summary>
|
|
||||
/// <param name="y"></param>
|
|
||||
/// <param name="x"></param>
|
|
||||
internal static void iDCT2D8x4_32f(Span<float> y, Span<float> x) |
|
||||
{ |
|
||||
/* |
|
||||
float a0,a1,a2,a3,b0,b1,b2,b3; float z0,z1,z2,z3,z4; float r[8]; int i; |
|
||||
for(i = 0;i < 8;i++){ r[i] = (float)(cos((double)i / 16.0 * M_PI) * M_SQRT2); } |
|
||||
*/ |
|
||||
/* |
|
||||
0: 1.414214 |
|
||||
1: 1.387040 |
|
||||
2: 1.306563 |
|
||||
3: |
|
||||
4: 1.000000 |
|
||||
5: 0.785695 |
|
||||
6: |
|
||||
7: 0.275899 |
|
||||
*/ |
|
||||
|
|
||||
Vector4 my1 = _mm_load_ps(y, 8); |
|
||||
Vector4 my7 = _mm_load_ps(y, 56); |
|
||||
Vector4 mz0 = my1 + my7; |
|
||||
|
|
||||
Vector4 my3 = _mm_load_ps(y, 24); |
|
||||
Vector4 mz2 = my3 + my7; |
|
||||
Vector4 my5 = _mm_load_ps(y, 40); |
|
||||
Vector4 mz1 = my3 + my5; |
|
||||
Vector4 mz3 = my1 + my5; |
|
||||
|
|
||||
Vector4 mz4 = ((mz0 + mz1) * _1_175876); |
|
||||
//z0 = y[1] + y[7]; z1 = y[3] + y[5]; z2 = y[3] + y[7]; z3 = y[1] + y[5];
|
|
||||
//z4 = (z0 + z1) * r[3];
|
|
||||
|
|
||||
mz2 = mz2 * _1_961571 + mz4; |
|
||||
mz3 = mz3 * _0_390181 + mz4; |
|
||||
mz0 = mz0 * _0_899976; |
|
||||
mz1 = mz1 * _2_562915; |
|
||||
|
|
||||
/* |
|
||||
-0.899976 |
|
||||
-2.562915 |
|
||||
-1.961571 |
|
||||
-0.390181 |
|
||||
z0 = z0 * (-r[3] + r[7]); |
|
||||
z1 = z1 * (-r[3] - r[1]); |
|
||||
z2 = z2 * (-r[3] - r[5]) + z4; |
|
||||
z3 = z3 * (-r[3] + r[5]) + z4;*/ |
|
||||
|
|
||||
Vector4 mb3 = my7 * _0_298631 + mz0 + mz2; |
|
||||
Vector4 mb2 = my5 * _2_053120 + mz1 + mz3; |
|
||||
Vector4 mb1 = my3 * _3_072711 + mz1 + mz2; |
|
||||
Vector4 mb0 = my1 * _1_501321 + mz0 + mz3; |
|
||||
|
|
||||
/* |
|
||||
0.298631 |
|
||||
2.053120 |
|
||||
3.072711 |
|
||||
1.501321 |
|
||||
b3 = y[7] * (-r[1] + r[3] + r[5] - r[7]) + z0 + z2; |
|
||||
b2 = y[5] * ( r[1] + r[3] - r[5] + r[7]) + z1 + z3; |
|
||||
b1 = y[3] * ( r[1] + r[3] + r[5] - r[7]) + z1 + z2; |
|
||||
b0 = y[1] * ( r[1] + r[3] - r[5] - r[7]) + z0 + z3; |
|
||||
*/ |
|
||||
|
|
||||
Vector4 my2 = _mm_load_ps(y, 16); |
|
||||
Vector4 my6 = _mm_load_ps(y, 48); |
|
||||
mz4 = (my2 + my6) * _0_541196; |
|
||||
Vector4 my0 = _mm_load_ps(y, 0); |
|
||||
Vector4 my4 = _mm_load_ps(y, 32); |
|
||||
mz0 = my0 + my4; |
|
||||
mz1 = my0 - my4; |
|
||||
|
|
||||
mz2 = mz4 + my6 * _1_847759; |
|
||||
mz3 = mz4 + my2 * _0_765367; |
|
||||
|
|
||||
my0 = mz0 + mz3; |
|
||||
my3 = mz0 - mz3; |
|
||||
my1 = mz1 + mz2; |
|
||||
my2 = mz1 - mz2; |
|
||||
/* |
|
||||
1.847759 |
|
||||
0.765367 |
|
||||
z4 = (y[2] + y[6]) * r[6]; |
|
||||
z0 = y[0] + y[4]; z1 = y[0] - y[4]; |
|
||||
z2 = z4 - y[6] * (r[2] + r[6]); |
|
||||
z3 = z4 + y[2] * (r[2] - r[6]); |
|
||||
a0 = z0 + z3; a3 = z0 - z3; |
|
||||
a1 = z1 + z2; a2 = z1 - z2; |
|
||||
*/ |
|
||||
|
|
||||
_mm_store_ps(x, 0, my0 + mb0); |
|
||||
|
|
||||
_mm_store_ps(x, 56, my0 - mb0); |
|
||||
|
|
||||
_mm_store_ps(x, 8, my1 + mb1); |
|
||||
|
|
||||
_mm_store_ps(x, 48, my1 - mb1); |
|
||||
|
|
||||
_mm_store_ps(x, 16, my2 + mb2); |
|
||||
|
|
||||
_mm_store_ps(x, 40, my2 - mb2); |
|
||||
|
|
||||
_mm_store_ps(x, 24, my3 + mb3); |
|
||||
|
|
||||
_mm_store_ps(x, 32, my3 - mb3); |
|
||||
/* |
|
||||
x[0] = a0 + b0; x[7] = a0 - b0; |
|
||||
x[1] = a1 + b1; x[6] = a1 - b1; |
|
||||
x[2] = a2 + b2; x[5] = a2 - b2; |
|
||||
x[3] = a3 + b3; x[4] = a3 - b3; |
|
||||
for(i = 0;i < 8;i++){ x[i] *= 0.353554f; } |
|
||||
*/ |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Copies color values from block to the destination image buffer.
|
|
||||
/// </summary>
|
|
||||
/// <param name="block"></param>
|
|
||||
/// <param name="buffer"></param>
|
|
||||
/// <param name="stride"></param>
|
|
||||
internal static unsafe void CopyColorsTo(ref Block8x8F block, Span<byte> buffer, int stride) |
|
||||
{ |
|
||||
fixed (Block8x8F* p = &block) |
|
||||
{ |
|
||||
float* b = (float*)p; |
|
||||
|
|
||||
for (int y = 0; y < 8; y++) |
|
||||
{ |
|
||||
int y8 = y * 8; |
|
||||
int yStride = y * stride; |
|
||||
|
|
||||
for (int x = 0; x < 8; x++) |
|
||||
{ |
|
||||
float c = b[y8 + x]; |
|
||||
|
|
||||
if (c < -128) |
|
||||
{ |
|
||||
c = 0; |
|
||||
} |
|
||||
else if (c > 127) |
|
||||
{ |
|
||||
c = 255; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
c += 128; |
|
||||
} |
|
||||
|
|
||||
buffer[yStride + x] = (byte)c; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
internal static void fDCT1Dllm_32f(Span<float> x, Span<float> y) |
|
||||
{ |
|
||||
float t0, t1, t2, t3, t4, t5, t6, t7; |
|
||||
float c0, c1, c2, c3; |
|
||||
float[] r = new float[8]; |
|
||||
|
|
||||
//for(i = 0;i < 8;i++){ r[i] = (float)(cos((double)i / 16.0 * M_PI) * M_SQRT2); }
|
|
||||
r[0] = 1.414214f; |
|
||||
r[1] = 1.387040f; |
|
||||
r[2] = 1.306563f; |
|
||||
r[3] = 1.175876f; |
|
||||
r[4] = 1.000000f; |
|
||||
r[5] = 0.785695f; |
|
||||
r[6] = 0.541196f; |
|
||||
r[7] = 0.275899f; |
|
||||
|
|
||||
const float invsqrt2 = 0.707107f; //(float)(1.0f / M_SQRT2);
|
|
||||
//const float invsqrt2h = 0.353554f; //invsqrt2*0.5f;
|
|
||||
|
|
||||
c1 = x[0]; |
|
||||
c2 = x[7]; |
|
||||
t0 = c1 + c2; |
|
||||
t7 = c1 - c2; |
|
||||
c1 = x[1]; |
|
||||
c2 = x[6]; |
|
||||
t1 = c1 + c2; |
|
||||
t6 = c1 - c2; |
|
||||
c1 = x[2]; |
|
||||
c2 = x[5]; |
|
||||
t2 = c1 + c2; |
|
||||
t5 = c1 - c2; |
|
||||
c1 = x[3]; |
|
||||
c2 = x[4]; |
|
||||
t3 = c1 + c2; |
|
||||
t4 = c1 - c2; |
|
||||
|
|
||||
c0 = t0 + t3; |
|
||||
c3 = t0 - t3; |
|
||||
c1 = t1 + t2; |
|
||||
c2 = t1 - t2; |
|
||||
|
|
||||
y[0] = c0 + c1; |
|
||||
y[4] = c0 - c1; |
|
||||
y[2] = c2 * r[6] + c3 * r[2]; |
|
||||
y[6] = c3 * r[6] - c2 * r[2]; |
|
||||
|
|
||||
c3 = t4 * r[3] + t7 * r[5]; |
|
||||
c0 = t7 * r[3] - t4 * r[5]; |
|
||||
c2 = t5 * r[1] + t6 * r[7]; |
|
||||
c1 = t6 * r[1] - t5 * r[7]; |
|
||||
|
|
||||
y[5] = c3 - c1; |
|
||||
y[3] = c0 - c2; |
|
||||
c0 = (c0 + c2) * invsqrt2; |
|
||||
c3 = (c3 + c1) * invsqrt2; |
|
||||
y[1] = c0 + c3; |
|
||||
y[7] = c0 - c3; |
|
||||
} |
|
||||
|
|
||||
internal static void fDCT2D_llm( |
|
||||
Span<float> s, |
|
||||
Span<float> d, |
|
||||
Span<float> temp, |
|
||||
bool downscaleBy8 = false, |
|
||||
bool offsetSourceByNeg128 = false) |
|
||||
{ |
|
||||
Span<float> sWorker = offsetSourceByNeg128 ? s.AddScalarToAllValues(-128f) : s; |
|
||||
|
|
||||
for (int j = 0; j < 8; j++) |
|
||||
{ |
|
||||
fDCT1Dllm_32f(sWorker.Slice(j * 8), temp.Slice(j * 8)); |
|
||||
} |
|
||||
|
|
||||
Transpose8x8(temp, d); |
|
||||
|
|
||||
for (int j = 0; j < 8; j++) |
|
||||
{ |
|
||||
fDCT1Dllm_32f(d.Slice(j * 8), temp.Slice(j * 8)); |
|
||||
} |
|
||||
|
|
||||
Transpose8x8(temp, d); |
|
||||
|
|
||||
if (downscaleBy8) |
|
||||
{ |
|
||||
for (int j = 0; j < 64; j++) |
|
||||
{ |
|
||||
d[j] *= 0.125f; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Reference implementation to test <see cref="Block8x8F.UnzigDivRound"/>.
|
|
||||
/// Rounding is done used an integer-based algorithm defined in <see cref="RationalRound"/>.
|
|
||||
/// </summary>
|
|
||||
/// <param name="src">The input block</param>
|
|
||||
/// <param name="dest">The destination block of integers</param>
|
|
||||
/// <param name="qt">The quantization table</param>
|
|
||||
/// <param name="unzigPtr">Pointer to <see cref="UnzigData.Data"/> </param>
|
|
||||
public static unsafe void UnZigDivRoundRational(Block8x8F* src, int* dest, Block8x8F* qt, int* unzigPtr) |
|
||||
{ |
|
||||
float* s = (float*)src; |
|
||||
float* q = (float*)qt; |
|
||||
|
|
||||
for (int zig = 0; zig < Block8x8F.Size; zig++) |
|
||||
{ |
|
||||
int a = (int)s[unzigPtr[zig]]; |
|
||||
int b = (int)q[zig]; |
|
||||
|
|
||||
int val = RationalRound(a, b); |
|
||||
dest[zig] = val; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Rounds a rational number defined as dividend/divisor into an integer
|
|
||||
/// </summary>
|
|
||||
/// <param name="dividend">The dividend</param>
|
|
||||
/// <param name="divisor">The divisior</param>
|
|
||||
/// <returns></returns>
|
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|
||||
private static int RationalRound(int dividend, int divisor) |
|
||||
{ |
|
||||
if (dividend >= 0) |
|
||||
{ |
|
||||
return (dividend + (divisor >> 1)) / divisor; |
|
||||
} |
|
||||
|
|
||||
return -((-dividend + (divisor >> 1)) / divisor); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,184 @@ |
|||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
|
{ |
||||
|
using System; |
||||
|
using System.Linq; |
||||
|
using System.Numerics; |
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
using SixLabors.Primitives; |
||||
|
|
||||
|
internal static partial class LibJpegTools |
||||
|
{ |
||||
|
public class ComponentData : IEquatable<ComponentData>, IJpegComponent |
||||
|
{ |
||||
|
public ComponentData(int heightInBlocks, int widthInBlocks, int index) |
||||
|
{ |
||||
|
this.HeightInBlocks = heightInBlocks; |
||||
|
this.WidthInBlocks = widthInBlocks; |
||||
|
this.Index = index; |
||||
|
this.Blocks = new Buffer2D<Block8x8>(this.WidthInBlocks, this.HeightInBlocks); |
||||
|
} |
||||
|
|
||||
|
public Size Size => new Size(this.WidthInBlocks, this.HeightInBlocks); |
||||
|
|
||||
|
public int Index { get; } |
||||
|
|
||||
|
public int HeightInBlocks { get; } |
||||
|
|
||||
|
public int WidthInBlocks { get; } |
||||
|
|
||||
|
public Buffer2D<Block8x8> Blocks { get; private set; } |
||||
|
|
||||
|
public short MinVal { get; private set; } = short.MaxValue; |
||||
|
|
||||
|
public short MaxVal { get; private set; } = short.MinValue; |
||||
|
|
||||
|
internal void MakeBlock(short[] data, int y, int x) |
||||
|
{ |
||||
|
this.MinVal = Math.Min((short)this.MinVal, data.Min()); |
||||
|
this.MaxVal = Math.Max((short)this.MaxVal, data.Max()); |
||||
|
this.Blocks[x, y] = new Block8x8(data); |
||||
|
} |
||||
|
|
||||
|
public static ComponentData Load(FrameComponent c, int index) |
||||
|
{ |
||||
|
var result = new ComponentData( |
||||
|
c.BlocksPerColumnForMcu, |
||||
|
c.BlocksPerLineForMcu, |
||||
|
index |
||||
|
); |
||||
|
|
||||
|
for (int y = 0; y < result.HeightInBlocks; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < result.WidthInBlocks; x++) |
||||
|
{ |
||||
|
short[] data = c.GetBlockBuffer(y, x).ToArray(); |
||||
|
result.MakeBlock(data, y, x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public static ComponentData Load(OldComponent c) |
||||
|
{ |
||||
|
var result = new ComponentData( |
||||
|
c.HeightInBlocks, |
||||
|
c.WidthInBlocks, |
||||
|
c.Index |
||||
|
); |
||||
|
|
||||
|
for (int y = 0; y < result.HeightInBlocks; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < result.WidthInBlocks; x++) |
||||
|
{ |
||||
|
short[] data = c.GetBlockReference(x, y).ToArray(); |
||||
|
result.MakeBlock(data, y, x); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
public Image<Rgba32> CreateGrayScaleImage() |
||||
|
{ |
||||
|
Image<Rgba32> result = new Image<Rgba32>(this.WidthInBlocks * 8, this.HeightInBlocks * 8); |
||||
|
|
||||
|
for (int by = 0; by < this.HeightInBlocks; by++) |
||||
|
{ |
||||
|
for (int bx = 0; bx < this.WidthInBlocks; bx++) |
||||
|
{ |
||||
|
this.WriteToImage(bx, by, result); |
||||
|
} |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
internal void WriteToImage(int bx, int by, Image<Rgba32> image) |
||||
|
{ |
||||
|
Block8x8 block = this.Blocks[bx, by]; |
||||
|
|
||||
|
for (int y = 0; y < 8; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < 8; x++) |
||||
|
{ |
||||
|
var val = this.GetBlockValue(block, x, y); |
||||
|
|
||||
|
Vector4 v = new Vector4(val, val, val, 1); |
||||
|
Rgba32 color = default(Rgba32); |
||||
|
color.PackFromVector4(v); |
||||
|
|
||||
|
int yy = by * 8 + y; |
||||
|
int xx = bx * 8 + x; |
||||
|
image[xx, yy] = color; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
internal float GetBlockValue(Block8x8 block, int x, int y) |
||||
|
{ |
||||
|
float d = (this.MaxVal - this.MinVal); |
||||
|
float val = block.GetValueAt(x, y); |
||||
|
val -= this.MinVal; |
||||
|
val /= d; |
||||
|
return val; |
||||
|
} |
||||
|
|
||||
|
public bool Equals(ComponentData other) |
||||
|
{ |
||||
|
if (Object.ReferenceEquals(null, other)) return false; |
||||
|
if (Object.ReferenceEquals(this, other)) return true; |
||||
|
bool ok = this.Index == other.Index && this.HeightInBlocks == other.HeightInBlocks |
||||
|
&& this.WidthInBlocks == other.WidthInBlocks; |
||||
|
//&& this.MinVal == other.MinVal
|
||||
|
//&& this.MaxVal == other.MaxVal;
|
||||
|
if (!ok) return false; |
||||
|
|
||||
|
for (int y = 0; y < this.HeightInBlocks; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < this.WidthInBlocks; x++) |
||||
|
{ |
||||
|
Block8x8 a = this.Blocks[x, y]; |
||||
|
Block8x8 b = other.Blocks[x, y]; |
||||
|
if (!a.Equals(b)) return false; |
||||
|
} |
||||
|
} |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
public override bool Equals(object obj) |
||||
|
{ |
||||
|
if (Object.ReferenceEquals(null, obj)) return false; |
||||
|
if (Object.ReferenceEquals(this, obj)) return true; |
||||
|
if (obj.GetType() != this.GetType()) return false; |
||||
|
return this.Equals((ComponentData)obj); |
||||
|
} |
||||
|
|
||||
|
public override int GetHashCode() |
||||
|
{ |
||||
|
unchecked |
||||
|
{ |
||||
|
var hashCode = this.Index; |
||||
|
hashCode = (hashCode * 397) ^ this.HeightInBlocks; |
||||
|
hashCode = (hashCode * 397) ^ this.WidthInBlocks; |
||||
|
hashCode = (hashCode * 397) ^ this.MinVal.GetHashCode(); |
||||
|
hashCode = (hashCode * 397) ^ this.MaxVal.GetHashCode(); |
||||
|
return hashCode; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static bool operator ==(ComponentData left, ComponentData right) |
||||
|
{ |
||||
|
return Object.Equals(left, right); |
||||
|
} |
||||
|
|
||||
|
public static bool operator !=(ComponentData left, ComponentData right) |
||||
|
{ |
||||
|
return !Object.Equals(left, right); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,146 @@ |
|||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
|
{ |
||||
|
using System; |
||||
|
using System.Linq; |
||||
|
using System.Numerics; |
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort; |
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components; |
||||
|
|
||||
|
internal static partial class LibJpegTools |
||||
|
{ |
||||
|
public class SpectralData : IEquatable<SpectralData> |
||||
|
{ |
||||
|
public int ComponentCount { get; private set; } |
||||
|
|
||||
|
public LibJpegTools.ComponentData[] Components { get; private set; } |
||||
|
|
||||
|
internal SpectralData(LibJpegTools.ComponentData[] components) |
||||
|
{ |
||||
|
this.ComponentCount = components.Length; |
||||
|
this.Components = components; |
||||
|
} |
||||
|
|
||||
|
public static SpectralData LoadFromImageSharpDecoder(JpegDecoderCore decoder) |
||||
|
{ |
||||
|
FrameComponent[] srcComponents = decoder.Frame.Components; |
||||
|
LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray(); |
||||
|
|
||||
|
return new SpectralData(destComponents); |
||||
|
} |
||||
|
|
||||
|
public static SpectralData LoadFromImageSharpDecoder(OldJpegDecoderCore decoder) |
||||
|
{ |
||||
|
OldComponent[] srcComponents = decoder.Components; |
||||
|
LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray(); |
||||
|
|
||||
|
return new SpectralData(destComponents); |
||||
|
} |
||||
|
|
||||
|
public Image<Rgba32> TryCreateRGBSpectralImage() |
||||
|
{ |
||||
|
if (this.ComponentCount != 3) return null; |
||||
|
|
||||
|
LibJpegTools.ComponentData c0 = this.Components[0]; |
||||
|
LibJpegTools.ComponentData c1 = this.Components[1]; |
||||
|
LibJpegTools.ComponentData c2 = this.Components[2]; |
||||
|
|
||||
|
if (c0.Size != c1.Size || c1.Size != c2.Size) |
||||
|
{ |
||||
|
return null; |
||||
|
} |
||||
|
|
||||
|
Image<Rgba32> result = new Image<Rgba32>(c0.WidthInBlocks * 8, c0.HeightInBlocks * 8); |
||||
|
|
||||
|
for (int by = 0; by < c0.HeightInBlocks; by++) |
||||
|
{ |
||||
|
for (int bx = 0; bx < c0.WidthInBlocks; bx++) |
||||
|
{ |
||||
|
this.WriteToImage(bx, by, result); |
||||
|
} |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
internal void WriteToImage(int bx, int by, Image<Rgba32> image) |
||||
|
{ |
||||
|
LibJpegTools.ComponentData c0 = this.Components[0]; |
||||
|
LibJpegTools.ComponentData c1 = this.Components[1]; |
||||
|
LibJpegTools.ComponentData c2 = this.Components[2]; |
||||
|
|
||||
|
Block8x8 block0 = c0.Blocks[bx, by]; |
||||
|
Block8x8 block1 = c1.Blocks[bx, by]; |
||||
|
Block8x8 block2 = c2.Blocks[bx, by]; |
||||
|
|
||||
|
float d0 = (c0.MaxVal - c0.MinVal); |
||||
|
float d1 = (c1.MaxVal - c1.MinVal); |
||||
|
float d2 = (c2.MaxVal - c2.MinVal); |
||||
|
|
||||
|
for (int y = 0; y < 8; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < 8; x++) |
||||
|
{ |
||||
|
float val0 = c0.GetBlockValue(block0, x, y); |
||||
|
float val1 = c0.GetBlockValue(block1, x, y); |
||||
|
float val2 = c0.GetBlockValue(block2, x, y); |
||||
|
|
||||
|
Vector4 v = new Vector4(val0, val1, val2, 1); |
||||
|
Rgba32 color = default(Rgba32); |
||||
|
color.PackFromVector4(v); |
||||
|
|
||||
|
int yy = by * 8 + y; |
||||
|
int xx = bx * 8 + x; |
||||
|
image[xx, yy] = color; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public bool Equals(SpectralData other) |
||||
|
{ |
||||
|
if (Object.ReferenceEquals(null, other)) return false; |
||||
|
if (Object.ReferenceEquals(this, other)) return true; |
||||
|
if (this.ComponentCount != other.ComponentCount) |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < this.ComponentCount; i++) |
||||
|
{ |
||||
|
LibJpegTools.ComponentData a = this.Components[i]; |
||||
|
LibJpegTools.ComponentData b = other.Components[i]; |
||||
|
if (!a.Equals(b)) return false; |
||||
|
} |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
public override bool Equals(object obj) |
||||
|
{ |
||||
|
if (Object.ReferenceEquals(null, obj)) return false; |
||||
|
if (Object.ReferenceEquals(this, obj)) return true; |
||||
|
if (obj.GetType() != this.GetType()) return false; |
||||
|
return this.Equals((SpectralData)obj); |
||||
|
} |
||||
|
|
||||
|
public override int GetHashCode() |
||||
|
{ |
||||
|
unchecked |
||||
|
{ |
||||
|
return (this.ComponentCount * 397) ^ (this.Components != null ? this.Components[0].GetHashCode() : 0); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public static bool operator ==(SpectralData left, SpectralData right) |
||||
|
{ |
||||
|
return Object.Equals(left, right); |
||||
|
} |
||||
|
|
||||
|
public static bool operator !=(SpectralData left, SpectralData right) |
||||
|
{ |
||||
|
return !Object.Equals(left, right); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,113 @@ |
|||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
|
{ |
||||
|
using System; |
||||
|
using System.Diagnostics; |
||||
|
using System.IO; |
||||
|
using System.Numerics; |
||||
|
using System.Reflection; |
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
||||
|
|
||||
|
internal static partial class LibJpegTools |
||||
|
{ |
||||
|
public static (double total, double average) CalculateDifference(ComponentData expected, ComponentData actual) |
||||
|
{ |
||||
|
BigInteger totalDiff = 0; |
||||
|
if (actual.WidthInBlocks < expected.WidthInBlocks) |
||||
|
{ |
||||
|
throw new Exception("actual.WidthInBlocks < expected.WidthInBlocks"); |
||||
|
} |
||||
|
|
||||
|
if (actual.HeightInBlocks < expected.HeightInBlocks) |
||||
|
{ |
||||
|
throw new Exception("actual.HeightInBlocks < expected.HeightInBlocks"); |
||||
|
} |
||||
|
|
||||
|
int w = expected.WidthInBlocks; |
||||
|
int h = expected.HeightInBlocks; |
||||
|
for (int y = 0; y < h; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < w; x++) |
||||
|
{ |
||||
|
Block8x8 aa = expected.Blocks[x, y]; |
||||
|
Block8x8 bb = actual.Blocks[x, y]; |
||||
|
|
||||
|
long diff = Block8x8.TotalDifference(ref aa, ref bb); |
||||
|
totalDiff += diff; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
int count = w * h; |
||||
|
double total = (double)totalDiff; |
||||
|
double average = (double)totalDiff / (count * Block8x8.Size); |
||||
|
return (total, average); |
||||
|
} |
||||
|
|
||||
|
private static string DumpToolFullPath => Path.Combine( |
||||
|
TestEnvironment.ToolsDirectoryFullPath, |
||||
|
@"jpeg\dump-jpeg-coeffs.exe"); |
||||
|
|
||||
|
public static void RunDumpJpegCoeffsTool(string sourceFile, string destFile) |
||||
|
{ |
||||
|
string args = $@"""{sourceFile}"" ""{destFile}"""; |
||||
|
var process = Process.Start(DumpToolFullPath, args); |
||||
|
process.WaitForExit(); |
||||
|
} |
||||
|
|
||||
|
public static SpectralData ExtractSpectralData(string inputFile) |
||||
|
{ |
||||
|
TestFile testFile = TestFile.Create(inputFile); |
||||
|
|
||||
|
string outDir = TestEnvironment.CreateOutputDirectory(".Temp", $"JpegCoeffs"); |
||||
|
string fn = $"{Path.GetFileName(inputFile)}-{new Random().Next(1000)}.dctcoeffs"; |
||||
|
string coeffFileFullPath = Path.Combine(outDir, fn); |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
RunDumpJpegCoeffsTool(testFile.FullPath, coeffFileFullPath); |
||||
|
|
||||
|
using (var dumpStream = new FileStream(coeffFileFullPath, FileMode.Open)) |
||||
|
using (var rdr = new BinaryReader(dumpStream)) |
||||
|
{ |
||||
|
int componentCount = rdr.ReadInt16(); |
||||
|
ComponentData[] result = new ComponentData[componentCount]; |
||||
|
|
||||
|
for (int i = 0; i < componentCount; i++) |
||||
|
{ |
||||
|
int widthInBlocks = rdr.ReadInt16(); |
||||
|
int heightInBlocks = rdr.ReadInt16(); |
||||
|
ComponentData resultComponent = new ComponentData(heightInBlocks, widthInBlocks, i); |
||||
|
result[i] = resultComponent; |
||||
|
} |
||||
|
|
||||
|
byte[] buffer = new byte[64*sizeof(short)]; |
||||
|
|
||||
|
for (int i = 0; i < result.Length; i++) |
||||
|
{ |
||||
|
ComponentData c = result[i]; |
||||
|
|
||||
|
for (int y = 0; y < c.HeightInBlocks; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < c.WidthInBlocks; x++) |
||||
|
{ |
||||
|
rdr.Read(buffer, 0, buffer.Length); |
||||
|
|
||||
|
short[] block = buffer.AsSpan().NonPortableCast<byte, short>().ToArray(); |
||||
|
c.MakeBlock(block, y, x); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return new SpectralData(result); |
||||
|
} |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
if (File.Exists(coeffFileFullPath)) |
||||
|
{ |
||||
|
File.Delete(coeffFileFullPath); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,490 @@ |
|||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
|
{ |
||||
|
using System; |
||||
|
using System.Numerics; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Utils; |
||||
|
|
||||
|
internal static partial class ReferenceImplementations |
||||
|
{ |
||||
|
internal static class FastFloatingPointDCT |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L200
|
||||
|
/// </summary>
|
||||
|
/// <param name="y"></param>
|
||||
|
/// <param name="x"></param>
|
||||
|
private static void iDCT1Dllm_32f(Span<float> y, Span<float> x) |
||||
|
{ |
||||
|
float a0, a1, a2, a3, b0, b1, b2, b3; |
||||
|
float z0, z1, z2, z3, z4; |
||||
|
|
||||
|
//float r0 = 1.414214f;
|
||||
|
float r1 = 1.387040f; |
||||
|
float r2 = 1.306563f; |
||||
|
float r3 = 1.175876f; |
||||
|
//float r4 = 1.000000f;
|
||||
|
float r5 = 0.785695f; |
||||
|
float r6 = 0.541196f; |
||||
|
float r7 = 0.275899f; |
||||
|
|
||||
|
z0 = y[1] + y[7]; |
||||
|
z1 = y[3] + y[5]; |
||||
|
z2 = y[3] + y[7]; |
||||
|
z3 = y[1] + y[5]; |
||||
|
z4 = (z0 + z1) * r3; |
||||
|
|
||||
|
z0 = z0 * (-r3 + r7); |
||||
|
z1 = z1 * (-r3 - r1); |
||||
|
z2 = z2 * (-r3 - r5) + z4; |
||||
|
z3 = z3 * (-r3 + r5) + z4; |
||||
|
|
||||
|
b3 = y[7] * (-r1 + r3 + r5 - r7) + z0 + z2; |
||||
|
b2 = y[5] * (r1 + r3 - r5 + r7) + z1 + z3; |
||||
|
b1 = y[3] * (r1 + r3 + r5 - r7) + z1 + z2; |
||||
|
b0 = y[1] * (r1 + r3 - r5 - r7) + z0 + z3; |
||||
|
|
||||
|
z4 = (y[2] + y[6]) * r6; |
||||
|
z0 = y[0] + y[4]; |
||||
|
z1 = y[0] - y[4]; |
||||
|
z2 = z4 - y[6] * (r2 + r6); |
||||
|
z3 = z4 + y[2] * (r2 - r6); |
||||
|
a0 = z0 + z3; |
||||
|
a3 = z0 - z3; |
||||
|
a1 = z1 + z2; |
||||
|
a2 = z1 - z2; |
||||
|
|
||||
|
x[0] = a0 + b0; |
||||
|
x[7] = a0 - b0; |
||||
|
x[1] = a1 + b1; |
||||
|
x[6] = a1 - b1; |
||||
|
x[2] = a2 + b2; |
||||
|
x[5] = a2 - b2; |
||||
|
x[3] = a3 + b3; |
||||
|
x[4] = a3 - b3; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Original: https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L239
|
||||
|
/// Applyies IDCT transformation on "s" copying transformed values to "d", using temporal block "temp"
|
||||
|
/// </summary>
|
||||
|
/// <param name="s"></param>
|
||||
|
/// <param name="d"></param>
|
||||
|
/// <param name="temp"></param>
|
||||
|
internal static void iDCT2D_llm(Span<float> s, Span<float> d, Span<float> temp) |
||||
|
{ |
||||
|
int j; |
||||
|
|
||||
|
for (j = 0; j < 8; j++) |
||||
|
{ |
||||
|
iDCT1Dllm_32f(s.Slice(j * 8), temp.Slice(j * 8)); |
||||
|
} |
||||
|
|
||||
|
ReferenceImplementations.Transpose8x8(temp, d); |
||||
|
|
||||
|
for (j = 0; j < 8; j++) |
||||
|
{ |
||||
|
iDCT1Dllm_32f(d.Slice(j * 8), temp.Slice(j * 8)); |
||||
|
} |
||||
|
|
||||
|
ReferenceImplementations.Transpose8x8(temp, d); |
||||
|
|
||||
|
for (j = 0; j < 64; j++) |
||||
|
{ |
||||
|
d[j] *= 0.125f; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Original:
|
||||
|
/// <see>
|
||||
|
/// <cref>https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L15</cref>
|
||||
|
/// </see>
|
||||
|
/// </summary>
|
||||
|
/// <param name="s">Source</param>
|
||||
|
/// <param name="d">Destination</param>
|
||||
|
public static void fDCT2D8x4_32f(Span<float> s, Span<float> d) |
||||
|
{ |
||||
|
Vector4 c0 = _mm_load_ps(s, 0); |
||||
|
Vector4 c1 = _mm_load_ps(s, 56); |
||||
|
Vector4 t0 = (c0 + c1); |
||||
|
Vector4 t7 = (c0 - c1); |
||||
|
|
||||
|
c1 = _mm_load_ps(s, 48); |
||||
|
c0 = _mm_load_ps(s, 8); |
||||
|
Vector4 t1 = (c0 + c1); |
||||
|
Vector4 t6 = (c0 - c1); |
||||
|
|
||||
|
c1 = _mm_load_ps(s, 40); |
||||
|
c0 = _mm_load_ps(s, 16); |
||||
|
Vector4 t2 = (c0 + c1); |
||||
|
Vector4 t5 = (c0 - c1); |
||||
|
|
||||
|
c0 = _mm_load_ps(s, 24); |
||||
|
c1 = _mm_load_ps(s, 32); |
||||
|
Vector4 t3 = (c0 + c1); |
||||
|
Vector4 t4 = (c0 - c1); |
||||
|
|
||||
|
/* |
||||
|
c1 = x[0]; c2 = x[7]; t0 = c1 + c2; t7 = c1 - c2; |
||||
|
c1 = x[1]; c2 = x[6]; t1 = c1 + c2; t6 = c1 - c2; |
||||
|
c1 = x[2]; c2 = x[5]; t2 = c1 + c2; t5 = c1 - c2; |
||||
|
c1 = x[3]; c2 = x[4]; t3 = c1 + c2; t4 = c1 - c2; |
||||
|
*/ |
||||
|
|
||||
|
c0 = (t0 + t3); |
||||
|
Vector4 c3 = (t0 - t3); |
||||
|
c1 = (t1 + t2); |
||||
|
Vector4 c2 = (t1 - t2); |
||||
|
|
||||
|
/* |
||||
|
c0 = t0 + t3; c3 = t0 - t3; |
||||
|
c1 = t1 + t2; c2 = t1 - t2; |
||||
|
*/ |
||||
|
|
||||
|
_mm_store_ps(d, 0, (c0 + c1)); |
||||
|
|
||||
|
_mm_store_ps(d, 32, (c0 - c1)); |
||||
|
|
||||
|
/*y[0] = c0 + c1; |
||||
|
y[4] = c0 - c1;*/ |
||||
|
|
||||
|
Vector4 w0 = new Vector4(0.541196f); |
||||
|
Vector4 w1 = new Vector4(1.306563f); |
||||
|
|
||||
|
_mm_store_ps(d, 16, ((w0 * c2) + (w1 * c3))); |
||||
|
|
||||
|
_mm_store_ps(d, 48, ((w0 * c3) - (w1 * c2))); |
||||
|
/* |
||||
|
y[2] = c2 * r[6] + c3 * r[2]; |
||||
|
y[6] = c3 * r[6] - c2 * r[2]; |
||||
|
*/ |
||||
|
|
||||
|
w0 = new Vector4(1.175876f); |
||||
|
w1 = new Vector4(0.785695f); |
||||
|
c3 = ((w0 * t4) + (w1 * t7)); |
||||
|
c0 = ((w0 * t7) - (w1 * t4)); |
||||
|
/* |
||||
|
c3 = t4 * r[3] + t7 * r[5]; |
||||
|
c0 = t7 * r[3] - t4 * r[5]; |
||||
|
*/ |
||||
|
|
||||
|
w0 = new Vector4(1.387040f); |
||||
|
w1 = new Vector4(0.275899f); |
||||
|
c2 = ((w0 * t5) + (w1 * t6)); |
||||
|
c1 = ((w0 * t6) - (w1 * t5)); |
||||
|
/* |
||||
|
c2 = t5 * r[1] + t6 * r[7]; |
||||
|
c1 = t6 * r[1] - t5 * r[7]; |
||||
|
*/ |
||||
|
|
||||
|
_mm_store_ps(d, 24, (c0 - c2)); |
||||
|
|
||||
|
_mm_store_ps(d, 40, (c3 - c1)); |
||||
|
//y[5] = c3 - c1; y[3] = c0 - c2;
|
||||
|
|
||||
|
Vector4 invsqrt2 = new Vector4(0.707107f); |
||||
|
c0 = ((c0 + c2) * invsqrt2); |
||||
|
c3 = ((c3 + c1) * invsqrt2); |
||||
|
//c0 = (c0 + c2) * invsqrt2;
|
||||
|
//c3 = (c3 + c1) * invsqrt2;
|
||||
|
|
||||
|
_mm_store_ps(d, 8, (c0 + c3)); |
||||
|
|
||||
|
_mm_store_ps(d, 56, (c0 - c3)); |
||||
|
//y[1] = c0 + c3; y[7] = c0 - c3;
|
||||
|
|
||||
|
/*for(i = 0;i < 8;i++) |
||||
|
{ |
||||
|
y[i] *= invsqrt2h; |
||||
|
}*/ |
||||
|
} |
||||
|
|
||||
|
public static void fDCT8x8_llm_sse(Span<float> s, Span<float> d, Span<float> temp) |
||||
|
{ |
||||
|
ReferenceImplementations.Transpose8x8(s, temp); |
||||
|
|
||||
|
fDCT2D8x4_32f(temp, d); |
||||
|
|
||||
|
fDCT2D8x4_32f(temp.Slice(4), d.Slice(4)); |
||||
|
|
||||
|
ReferenceImplementations.Transpose8x8(d, temp); |
||||
|
|
||||
|
fDCT2D8x4_32f(temp, d); |
||||
|
|
||||
|
fDCT2D8x4_32f(temp.Slice(4), d.Slice(4)); |
||||
|
|
||||
|
Vector4 c = new Vector4(0.1250f); |
||||
|
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//0
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//1
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//2
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//3
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//4
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//5
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//6
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//7
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//8
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//9
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//10
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//11
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//12
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//13
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//14
|
||||
|
_mm_store_ps(d, 0, (_mm_load_ps(d, 0) * c)); d = d.Slice(4);//15
|
||||
|
} |
||||
|
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static Vector4 _mm_load_ps(Span<float> src, int offset) |
||||
|
{ |
||||
|
src = src.Slice(offset); |
||||
|
return new Vector4(src[0], src[1], src[2], src[3]); |
||||
|
} |
||||
|
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static void _mm_store_ps(Span<float> dest, int offset, Vector4 src) |
||||
|
{ |
||||
|
dest = dest.Slice(offset); |
||||
|
dest[0] = src.X; |
||||
|
dest[1] = src.Y; |
||||
|
dest[2] = src.Z; |
||||
|
dest[3] = src.W; |
||||
|
} |
||||
|
|
||||
|
private static readonly Vector4 _1_175876 = new Vector4(1.175876f); |
||||
|
|
||||
|
private static readonly Vector4 _1_961571 = new Vector4(-1.961571f); |
||||
|
|
||||
|
private static readonly Vector4 _0_390181 = new Vector4(-0.390181f); |
||||
|
|
||||
|
private static readonly Vector4 _0_899976 = new Vector4(-0.899976f); |
||||
|
|
||||
|
private static readonly Vector4 _2_562915 = new Vector4(-2.562915f); |
||||
|
|
||||
|
private static readonly Vector4 _0_298631 = new Vector4(0.298631f); |
||||
|
|
||||
|
private static readonly Vector4 _2_053120 = new Vector4(2.053120f); |
||||
|
|
||||
|
private static readonly Vector4 _3_072711 = new Vector4(3.072711f); |
||||
|
|
||||
|
private static readonly Vector4 _1_501321 = new Vector4(1.501321f); |
||||
|
|
||||
|
private static readonly Vector4 _0_541196 = new Vector4(0.541196f); |
||||
|
|
||||
|
private static readonly Vector4 _1_847759 = new Vector4(-1.847759f); |
||||
|
|
||||
|
private static readonly Vector4 _0_765367 = new Vector4(0.765367f); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Original:
|
||||
|
/// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L261
|
||||
|
/// Does a part of the IDCT job on the given parts of the blocks
|
||||
|
/// </summary>
|
||||
|
/// <param name="y"></param>
|
||||
|
/// <param name="x"></param>
|
||||
|
internal static void iDCT2D8x4_32f(Span<float> y, Span<float> x) |
||||
|
{ |
||||
|
/* |
||||
|
float a0,a1,a2,a3,b0,b1,b2,b3; float z0,z1,z2,z3,z4; float r[8]; int i; |
||||
|
for(i = 0;i < 8;i++){ r[i] = (float)(cos((double)i / 16.0 * M_PI) * M_SQRT2); } |
||||
|
*/ |
||||
|
/* |
||||
|
0: 1.414214 |
||||
|
1: 1.387040 |
||||
|
2: 1.306563 |
||||
|
3: |
||||
|
4: 1.000000 |
||||
|
5: 0.785695 |
||||
|
6: |
||||
|
7: 0.275899 |
||||
|
*/ |
||||
|
|
||||
|
Vector4 my1 = _mm_load_ps(y, 8); |
||||
|
Vector4 my7 = _mm_load_ps(y, 56); |
||||
|
Vector4 mz0 = my1 + my7; |
||||
|
|
||||
|
Vector4 my3 = _mm_load_ps(y, 24); |
||||
|
Vector4 mz2 = my3 + my7; |
||||
|
Vector4 my5 = _mm_load_ps(y, 40); |
||||
|
Vector4 mz1 = my3 + my5; |
||||
|
Vector4 mz3 = my1 + my5; |
||||
|
|
||||
|
Vector4 mz4 = ((mz0 + mz1) * _1_175876); |
||||
|
//z0 = y[1] + y[7]; z1 = y[3] + y[5]; z2 = y[3] + y[7]; z3 = y[1] + y[5];
|
||||
|
//z4 = (z0 + z1) * r[3];
|
||||
|
|
||||
|
mz2 = mz2 * _1_961571 + mz4; |
||||
|
mz3 = mz3 * _0_390181 + mz4; |
||||
|
mz0 = mz0 * _0_899976; |
||||
|
mz1 = mz1 * _2_562915; |
||||
|
|
||||
|
/* |
||||
|
-0.899976 |
||||
|
-2.562915 |
||||
|
-1.961571 |
||||
|
-0.390181 |
||||
|
z0 = z0 * (-r[3] + r[7]); |
||||
|
z1 = z1 * (-r[3] - r[1]); |
||||
|
z2 = z2 * (-r[3] - r[5]) + z4; |
||||
|
z3 = z3 * (-r[3] + r[5]) + z4;*/ |
||||
|
|
||||
|
Vector4 mb3 = my7 * _0_298631 + mz0 + mz2; |
||||
|
Vector4 mb2 = my5 * _2_053120 + mz1 + mz3; |
||||
|
Vector4 mb1 = my3 * _3_072711 + mz1 + mz2; |
||||
|
Vector4 mb0 = my1 * _1_501321 + mz0 + mz3; |
||||
|
|
||||
|
/* |
||||
|
0.298631 |
||||
|
2.053120 |
||||
|
3.072711 |
||||
|
1.501321 |
||||
|
b3 = y[7] * (-r[1] + r[3] + r[5] - r[7]) + z0 + z2; |
||||
|
b2 = y[5] * ( r[1] + r[3] - r[5] + r[7]) + z1 + z3; |
||||
|
b1 = y[3] * ( r[1] + r[3] + r[5] - r[7]) + z1 + z2; |
||||
|
b0 = y[1] * ( r[1] + r[3] - r[5] - r[7]) + z0 + z3; |
||||
|
*/ |
||||
|
|
||||
|
Vector4 my2 = _mm_load_ps(y, 16); |
||||
|
Vector4 my6 = _mm_load_ps(y, 48); |
||||
|
mz4 = (my2 + my6) * _0_541196; |
||||
|
Vector4 my0 = _mm_load_ps(y, 0); |
||||
|
Vector4 my4 = _mm_load_ps(y, 32); |
||||
|
mz0 = my0 + my4; |
||||
|
mz1 = my0 - my4; |
||||
|
|
||||
|
mz2 = mz4 + my6 * _1_847759; |
||||
|
mz3 = mz4 + my2 * _0_765367; |
||||
|
|
||||
|
my0 = mz0 + mz3; |
||||
|
my3 = mz0 - mz3; |
||||
|
my1 = mz1 + mz2; |
||||
|
my2 = mz1 - mz2; |
||||
|
/* |
||||
|
1.847759 |
||||
|
0.765367 |
||||
|
z4 = (y[2] + y[6]) * r[6]; |
||||
|
z0 = y[0] + y[4]; z1 = y[0] - y[4]; |
||||
|
z2 = z4 - y[6] * (r[2] + r[6]); |
||||
|
z3 = z4 + y[2] * (r[2] - r[6]); |
||||
|
a0 = z0 + z3; a3 = z0 - z3; |
||||
|
a1 = z1 + z2; a2 = z1 - z2; |
||||
|
*/ |
||||
|
|
||||
|
_mm_store_ps(x, 0, my0 + mb0); |
||||
|
|
||||
|
_mm_store_ps(x, 56, my0 - mb0); |
||||
|
|
||||
|
_mm_store_ps(x, 8, my1 + mb1); |
||||
|
|
||||
|
_mm_store_ps(x, 48, my1 - mb1); |
||||
|
|
||||
|
_mm_store_ps(x, 16, my2 + mb2); |
||||
|
|
||||
|
_mm_store_ps(x, 40, my2 - mb2); |
||||
|
|
||||
|
_mm_store_ps(x, 24, my3 + mb3); |
||||
|
|
||||
|
_mm_store_ps(x, 32, my3 - mb3); |
||||
|
/* |
||||
|
x[0] = a0 + b0; x[7] = a0 - b0; |
||||
|
x[1] = a1 + b1; x[6] = a1 - b1; |
||||
|
x[2] = a2 + b2; x[5] = a2 - b2; |
||||
|
x[3] = a3 + b3; x[4] = a3 - b3; |
||||
|
for(i = 0;i < 8;i++){ x[i] *= 0.353554f; } |
||||
|
*/ |
||||
|
} |
||||
|
|
||||
|
internal static void fDCT1Dllm_32f(Span<float> x, Span<float> y) |
||||
|
{ |
||||
|
float t0, t1, t2, t3, t4, t5, t6, t7; |
||||
|
float c0, c1, c2, c3; |
||||
|
float[] r = new float[8]; |
||||
|
|
||||
|
//for(i = 0;i < 8;i++){ r[i] = (float)(cos((double)i / 16.0 * M_PI) * M_SQRT2); }
|
||||
|
r[0] = 1.414214f; |
||||
|
r[1] = 1.387040f; |
||||
|
r[2] = 1.306563f; |
||||
|
r[3] = 1.175876f; |
||||
|
r[4] = 1.000000f; |
||||
|
r[5] = 0.785695f; |
||||
|
r[6] = 0.541196f; |
||||
|
r[7] = 0.275899f; |
||||
|
|
||||
|
const float invsqrt2 = 0.707107f; //(float)(1.0f / M_SQRT2);
|
||||
|
//const float invsqrt2h = 0.353554f; //invsqrt2*0.5f;
|
||||
|
|
||||
|
c1 = x[0]; |
||||
|
c2 = x[7]; |
||||
|
t0 = c1 + c2; |
||||
|
t7 = c1 - c2; |
||||
|
c1 = x[1]; |
||||
|
c2 = x[6]; |
||||
|
t1 = c1 + c2; |
||||
|
t6 = c1 - c2; |
||||
|
c1 = x[2]; |
||||
|
c2 = x[5]; |
||||
|
t2 = c1 + c2; |
||||
|
t5 = c1 - c2; |
||||
|
c1 = x[3]; |
||||
|
c2 = x[4]; |
||||
|
t3 = c1 + c2; |
||||
|
t4 = c1 - c2; |
||||
|
|
||||
|
c0 = t0 + t3; |
||||
|
c3 = t0 - t3; |
||||
|
c1 = t1 + t2; |
||||
|
c2 = t1 - t2; |
||||
|
|
||||
|
y[0] = c0 + c1; |
||||
|
y[4] = c0 - c1; |
||||
|
y[2] = c2 * r[6] + c3 * r[2]; |
||||
|
y[6] = c3 * r[6] - c2 * r[2]; |
||||
|
|
||||
|
c3 = t4 * r[3] + t7 * r[5]; |
||||
|
c0 = t7 * r[3] - t4 * r[5]; |
||||
|
c2 = t5 * r[1] + t6 * r[7]; |
||||
|
c1 = t6 * r[1] - t5 * r[7]; |
||||
|
|
||||
|
y[5] = c3 - c1; |
||||
|
y[3] = c0 - c2; |
||||
|
c0 = (c0 + c2) * invsqrt2; |
||||
|
c3 = (c3 + c1) * invsqrt2; |
||||
|
y[1] = c0 + c3; |
||||
|
y[7] = c0 - c3; |
||||
|
} |
||||
|
|
||||
|
internal static void fDCT2D_llm( |
||||
|
Span<float> s, |
||||
|
Span<float> d, |
||||
|
Span<float> temp, |
||||
|
bool downscaleBy8 = false, |
||||
|
bool offsetSourceByNeg128 = false) |
||||
|
{ |
||||
|
Span<float> sWorker = offsetSourceByNeg128 ? s.AddScalarToAllValues(-128f) : s; |
||||
|
|
||||
|
for (int j = 0; j < 8; j++) |
||||
|
{ |
||||
|
fDCT1Dllm_32f(sWorker.Slice(j * 8), temp.Slice(j * 8)); |
||||
|
} |
||||
|
|
||||
|
ReferenceImplementations.Transpose8x8(temp, d); |
||||
|
|
||||
|
for (int j = 0; j < 8; j++) |
||||
|
{ |
||||
|
fDCT1Dllm_32f(d.Slice(j * 8), temp.Slice(j * 8)); |
||||
|
} |
||||
|
|
||||
|
ReferenceImplementations.Transpose8x8(temp, d); |
||||
|
|
||||
|
if (downscaleBy8) |
||||
|
{ |
||||
|
for (int j = 0; j < 64; j++) |
||||
|
{ |
||||
|
d[j] *= 0.125f; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,314 @@ |
|||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
|
{ |
||||
|
using System; |
||||
|
|
||||
|
internal static partial class ReferenceImplementations |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The "original" libjpeg/golang based DCT implementation is used as reference implementation for tests.
|
||||
|
/// </summary>
|
||||
|
public static class IntegerDCT |
||||
|
{ |
||||
|
private const int fix_0_298631336 = 2446; |
||||
|
private const int fix_0_390180644 = 3196; |
||||
|
private const int fix_0_541196100 = 4433; |
||||
|
private const int fix_0_765366865 = 6270; |
||||
|
private const int fix_0_899976223 = 7373; |
||||
|
private const int fix_1_175875602 = 9633; |
||||
|
private const int fix_1_501321110 = 12299; |
||||
|
private const int fix_1_847759065 = 15137; |
||||
|
private const int fix_1_961570560 = 16069; |
||||
|
private const int fix_2_053119869 = 16819; |
||||
|
private const int fix_2_562915447 = 20995; |
||||
|
private const int fix_3_072711026 = 25172; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The number of bits
|
||||
|
/// </summary>
|
||||
|
private const int Bits = 13; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The number of bits to shift by on the first pass.
|
||||
|
/// </summary>
|
||||
|
private const int Pass1Bits = 2; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The value to shift by
|
||||
|
/// </summary>
|
||||
|
private const int CenterJSample = 128; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Performs a forward DCT on an 8x8 block of coefficients, including a level shift.
|
||||
|
/// Leave results scaled up by an overall factor of 8.
|
||||
|
/// </summary>
|
||||
|
/// <param name="block">The block of coefficients.</param>
|
||||
|
public static void TransformFDCTInplace(Span<int> block) |
||||
|
{ |
||||
|
// Pass 1: process rows.
|
||||
|
for (int y = 0; y < 8; y++) |
||||
|
{ |
||||
|
int y8 = y * 8; |
||||
|
|
||||
|
int x0 = block[y8]; |
||||
|
int x1 = block[y8 + 1]; |
||||
|
int x2 = block[y8 + 2]; |
||||
|
int x3 = block[y8 + 3]; |
||||
|
int x4 = block[y8 + 4]; |
||||
|
int x5 = block[y8 + 5]; |
||||
|
int x6 = block[y8 + 6]; |
||||
|
int x7 = block[y8 + 7]; |
||||
|
|
||||
|
int tmp0 = x0 + x7; |
||||
|
int tmp1 = x1 + x6; |
||||
|
int tmp2 = x2 + x5; |
||||
|
int tmp3 = x3 + x4; |
||||
|
|
||||
|
int tmp10 = tmp0 + tmp3; |
||||
|
int tmp12 = tmp0 - tmp3; |
||||
|
int tmp11 = tmp1 + tmp2; |
||||
|
int tmp13 = tmp1 - tmp2; |
||||
|
|
||||
|
tmp0 = x0 - x7; |
||||
|
tmp1 = x1 - x6; |
||||
|
tmp2 = x2 - x5; |
||||
|
tmp3 = x3 - x4; |
||||
|
|
||||
|
block[y8] = (tmp10 + tmp11 - (8 * CenterJSample)) << Pass1Bits; |
||||
|
block[y8 + 4] = (tmp10 - tmp11) << Pass1Bits; |
||||
|
int z1 = (tmp12 + tmp13) * fix_0_541196100; |
||||
|
z1 += 1 << (Bits - Pass1Bits - 1); |
||||
|
block[y8 + 2] = (z1 + (tmp12 * fix_0_765366865)) >> (Bits - Pass1Bits); |
||||
|
block[y8 + 6] = (z1 - (tmp13 * fix_1_847759065)) >> (Bits - Pass1Bits); |
||||
|
|
||||
|
tmp10 = tmp0 + tmp3; |
||||
|
tmp11 = tmp1 + tmp2; |
||||
|
tmp12 = tmp0 + tmp2; |
||||
|
tmp13 = tmp1 + tmp3; |
||||
|
z1 = (tmp12 + tmp13) * fix_1_175875602; |
||||
|
z1 += 1 << (Bits - Pass1Bits - 1); |
||||
|
tmp0 = tmp0 * fix_1_501321110; |
||||
|
tmp1 = tmp1 * fix_3_072711026; |
||||
|
tmp2 = tmp2 * fix_2_053119869; |
||||
|
tmp3 = tmp3 * fix_0_298631336; |
||||
|
tmp10 = tmp10 * -fix_0_899976223; |
||||
|
tmp11 = tmp11 * -fix_2_562915447; |
||||
|
tmp12 = tmp12 * -fix_0_390180644; |
||||
|
tmp13 = tmp13 * -fix_1_961570560; |
||||
|
|
||||
|
tmp12 += z1; |
||||
|
tmp13 += z1; |
||||
|
block[y8 + 1] = (tmp0 + tmp10 + tmp12) >> (Bits - Pass1Bits); |
||||
|
block[y8 + 3] = (tmp1 + tmp11 + tmp13) >> (Bits - Pass1Bits); |
||||
|
block[y8 + 5] = (tmp2 + tmp11 + tmp12) >> (Bits - Pass1Bits); |
||||
|
block[y8 + 7] = (tmp3 + tmp10 + tmp13) >> (Bits - Pass1Bits); |
||||
|
} |
||||
|
|
||||
|
// Pass 2: process columns.
|
||||
|
// We remove pass1Bits scaling, but leave results scaled up by an overall factor of 8.
|
||||
|
for (int x = 0; x < 8; x++) |
||||
|
{ |
||||
|
int tmp0 = block[x] + block[56 + x]; |
||||
|
int tmp1 = block[8 + x] + block[48 + x]; |
||||
|
int tmp2 = block[16 + x] + block[40 + x]; |
||||
|
int tmp3 = block[24 + x] + block[32 + x]; |
||||
|
|
||||
|
int tmp10 = tmp0 + tmp3 + (1 << (Pass1Bits - 1)); |
||||
|
int tmp12 = tmp0 - tmp3; |
||||
|
int tmp11 = tmp1 + tmp2; |
||||
|
int tmp13 = tmp1 - tmp2; |
||||
|
|
||||
|
tmp0 = block[x] - block[56 + x]; |
||||
|
tmp1 = block[8 + x] - block[48 + x]; |
||||
|
tmp2 = block[16 + x] - block[40 + x]; |
||||
|
tmp3 = block[24 + x] - block[32 + x]; |
||||
|
|
||||
|
block[x] = (tmp10 + tmp11) >> Pass1Bits; |
||||
|
block[32 + x] = (tmp10 - tmp11) >> Pass1Bits; |
||||
|
|
||||
|
int z1 = (tmp12 + tmp13) * fix_0_541196100; |
||||
|
z1 += 1 << (Bits + Pass1Bits - 1); |
||||
|
block[16 + x] = (z1 + (tmp12 * fix_0_765366865)) >> (Bits + Pass1Bits); |
||||
|
block[48 + x] = (z1 - (tmp13 * fix_1_847759065)) >> (Bits + Pass1Bits); |
||||
|
|
||||
|
tmp10 = tmp0 + tmp3; |
||||
|
tmp11 = tmp1 + tmp2; |
||||
|
tmp12 = tmp0 + tmp2; |
||||
|
tmp13 = tmp1 + tmp3; |
||||
|
z1 = (tmp12 + tmp13) * fix_1_175875602; |
||||
|
z1 += 1 << (Bits + Pass1Bits - 1); |
||||
|
tmp0 = tmp0 * fix_1_501321110; |
||||
|
tmp1 = tmp1 * fix_3_072711026; |
||||
|
tmp2 = tmp2 * fix_2_053119869; |
||||
|
tmp3 = tmp3 * fix_0_298631336; |
||||
|
tmp10 = tmp10 * -fix_0_899976223; |
||||
|
tmp11 = tmp11 * -fix_2_562915447; |
||||
|
tmp12 = tmp12 * -fix_0_390180644; |
||||
|
tmp13 = tmp13 * -fix_1_961570560; |
||||
|
|
||||
|
tmp12 += z1; |
||||
|
tmp13 += z1; |
||||
|
block[8 + x] = (tmp0 + tmp10 + tmp12) >> (Bits + Pass1Bits); |
||||
|
block[24 + x] = (tmp1 + tmp11 + tmp13) >> (Bits + Pass1Bits); |
||||
|
block[40 + x] = (tmp2 + tmp11 + tmp12) >> (Bits + Pass1Bits); |
||||
|
block[56 + x] = (tmp3 + tmp10 + tmp13) >> (Bits + Pass1Bits); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
private const int w1 = 2841; // 2048*sqrt(2)*cos(1*pi/16)
|
||||
|
private const int w2 = 2676; // 2048*sqrt(2)*cos(2*pi/16)
|
||||
|
private const int w3 = 2408; // 2048*sqrt(2)*cos(3*pi/16)
|
||||
|
private const int w5 = 1609; // 2048*sqrt(2)*cos(5*pi/16)
|
||||
|
private const int w6 = 1108; // 2048*sqrt(2)*cos(6*pi/16)
|
||||
|
private const int w7 = 565; // 2048*sqrt(2)*cos(7*pi/16)
|
||||
|
|
||||
|
private const int w1pw7 = w1 + w7; |
||||
|
private const int w1mw7 = w1 - w7; |
||||
|
private const int w2pw6 = w2 + w6; |
||||
|
private const int w2mw6 = w2 - w6; |
||||
|
private const int w3pw5 = w3 + w5; |
||||
|
private const int w3mw5 = w3 - w5; |
||||
|
|
||||
|
private const int r2 = 181; // 256/sqrt(2)
|
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Performs a 2-D Inverse Discrete Cosine Transformation.
|
||||
|
/// <para>
|
||||
|
/// The input coefficients should already have been multiplied by the
|
||||
|
/// appropriate quantization table. We use fixed-point computation, with the
|
||||
|
/// number of bits for the fractional component varying over the intermediate
|
||||
|
/// stages.
|
||||
|
/// </para>
|
||||
|
/// For more on the actual algorithm, see Z. Wang, "Fast algorithms for the
|
||||
|
/// discrete W transform and for the discrete Fourier transform", IEEE Trans. on
|
||||
|
/// ASSP, Vol. ASSP- 32, pp. 803-816, Aug. 1984.
|
||||
|
/// </summary>
|
||||
|
/// <param name="src">The source block of coefficients</param>
|
||||
|
public static void TransformIDCTInplace(Span<int> src) |
||||
|
{ |
||||
|
// Horizontal 1-D IDCT.
|
||||
|
for (int y = 0; y < 8; y++) |
||||
|
{ |
||||
|
int y8 = y * 8; |
||||
|
|
||||
|
// If all the AC components are zero, then the IDCT is trivial.
|
||||
|
if (src[y8 + 1] == 0 && src[y8 + 2] == 0 && src[y8 + 3] == 0 && |
||||
|
src[y8 + 4] == 0 && src[y8 + 5] == 0 && src[y8 + 6] == 0 && src[y8 + 7] == 0) |
||||
|
{ |
||||
|
int dc = src[y8 + 0] << 3; |
||||
|
src[y8 + 0] = dc; |
||||
|
src[y8 + 1] = dc; |
||||
|
src[y8 + 2] = dc; |
||||
|
src[y8 + 3] = dc; |
||||
|
src[y8 + 4] = dc; |
||||
|
src[y8 + 5] = dc; |
||||
|
src[y8 + 6] = dc; |
||||
|
src[y8 + 7] = dc; |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
// Prescale.
|
||||
|
int x0 = (src[y8 + 0] << 11) + 128; |
||||
|
int x1 = src[y8 + 4] << 11; |
||||
|
int x2 = src[y8 + 6]; |
||||
|
int x3 = src[y8 + 2]; |
||||
|
int x4 = src[y8 + 1]; |
||||
|
int x5 = src[y8 + 7]; |
||||
|
int x6 = src[y8 + 5]; |
||||
|
int x7 = src[y8 + 3]; |
||||
|
|
||||
|
// Stage 1.
|
||||
|
int x8 = w7 * (x4 + x5); |
||||
|
x4 = x8 + (w1mw7 * x4); |
||||
|
x5 = x8 - (w1pw7 * x5); |
||||
|
x8 = w3 * (x6 + x7); |
||||
|
x6 = x8 - (w3mw5 * x6); |
||||
|
x7 = x8 - (w3pw5 * x7); |
||||
|
|
||||
|
// Stage 2.
|
||||
|
x8 = x0 + x1; |
||||
|
x0 -= x1; |
||||
|
x1 = w6 * (x3 + x2); |
||||
|
x2 = x1 - (w2pw6 * x2); |
||||
|
x3 = x1 + (w2mw6 * x3); |
||||
|
x1 = x4 + x6; |
||||
|
x4 -= x6; |
||||
|
x6 = x5 + x7; |
||||
|
x5 -= x7; |
||||
|
|
||||
|
// Stage 3.
|
||||
|
x7 = x8 + x3; |
||||
|
x8 -= x3; |
||||
|
x3 = x0 + x2; |
||||
|
x0 -= x2; |
||||
|
x2 = ((r2 * (x4 + x5)) + 128) >> 8; |
||||
|
x4 = ((r2 * (x4 - x5)) + 128) >> 8; |
||||
|
|
||||
|
// Stage 4.
|
||||
|
src[y8 + 0] = (x7 + x1) >> 8; |
||||
|
src[y8 + 1] = (x3 + x2) >> 8; |
||||
|
src[y8 + 2] = (x0 + x4) >> 8; |
||||
|
src[y8 + 3] = (x8 + x6) >> 8; |
||||
|
src[y8 + 4] = (x8 - x6) >> 8; |
||||
|
src[y8 + 5] = (x0 - x4) >> 8; |
||||
|
src[y8 + 6] = (x3 - x2) >> 8; |
||||
|
src[y8 + 7] = (x7 - x1) >> 8; |
||||
|
} |
||||
|
|
||||
|
// Vertical 1-D IDCT.
|
||||
|
for (int x = 0; x < 8; x++) |
||||
|
{ |
||||
|
// Similar to the horizontal 1-D IDCT case, if all the AC components are zero, then the IDCT is trivial.
|
||||
|
// However, after performing the horizontal 1-D IDCT, there are typically non-zero AC components, so
|
||||
|
// we do not bother to check for the all-zero case.
|
||||
|
|
||||
|
// Prescale.
|
||||
|
int y0 = (src[x] << 8) + 8192; |
||||
|
int y1 = src[32 + x] << 8; |
||||
|
int y2 = src[48 + x]; |
||||
|
int y3 = src[16 + x]; |
||||
|
int y4 = src[8 + x]; |
||||
|
int y5 = src[56 + x]; |
||||
|
int y6 = src[40 + x]; |
||||
|
int y7 = src[24 + x]; |
||||
|
|
||||
|
// Stage 1.
|
||||
|
int y8 = (w7 * (y4 + y5)) + 4; |
||||
|
y4 = (y8 + (w1mw7 * y4)) >> 3; |
||||
|
y5 = (y8 - (w1pw7 * y5)) >> 3; |
||||
|
y8 = (w3 * (y6 + y7)) + 4; |
||||
|
y6 = (y8 - (w3mw5 * y6)) >> 3; |
||||
|
y7 = (y8 - (w3pw5 * y7)) >> 3; |
||||
|
|
||||
|
// Stage 2.
|
||||
|
y8 = y0 + y1; |
||||
|
y0 -= y1; |
||||
|
y1 = (w6 * (y3 + y2)) + 4; |
||||
|
y2 = (y1 - (w2pw6 * y2)) >> 3; |
||||
|
y3 = (y1 + (w2mw6 * y3)) >> 3; |
||||
|
y1 = y4 + y6; |
||||
|
y4 -= y6; |
||||
|
y6 = y5 + y7; |
||||
|
y5 -= y7; |
||||
|
|
||||
|
// Stage 3.
|
||||
|
y7 = y8 + y3; |
||||
|
y8 -= y3; |
||||
|
y3 = y0 + y2; |
||||
|
y0 -= y2; |
||||
|
y2 = ((r2 * (y4 + y5)) + 128) >> 8; |
||||
|
y4 = ((r2 * (y4 - y5)) + 128) >> 8; |
||||
|
|
||||
|
// Stage 4.
|
||||
|
src[x] = (y7 + y1) >> 14; |
||||
|
src[8 + x] = (y3 + y2) >> 14; |
||||
|
src[16 + x] = (y0 + y4) >> 14; |
||||
|
src[24 + x] = (y8 + y6) >> 14; |
||||
|
src[32 + x] = (y8 - y6) >> 14; |
||||
|
src[40 + x] = (y0 - y4) >> 14; |
||||
|
src[48 + x] = (y3 - y2) >> 14; |
||||
|
src[56 + x] = (y7 - y1) >> 14; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,135 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
|
||||
|
|
||||
|
// ReSharper disable InconsistentNaming
|
||||
|
|
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
|
{ |
||||
|
using System; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Jpeg.Common; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// This class contains simplified (unefficient) reference implementations to produce verification data for unit tests
|
||||
|
/// Floating point DCT code Ported from https://github.com/norishigefukushima/dct_simd
|
||||
|
/// </summary>
|
||||
|
internal static partial class ReferenceImplementations |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Transpose 8x8 block stored linearly in a <see cref="Span{T}"/> (inplace)
|
||||
|
/// </summary>
|
||||
|
/// <param name="data"></param>
|
||||
|
internal static void Transpose8x8(Span<float> data) |
||||
|
{ |
||||
|
for (int i = 1; i < 8; i++) |
||||
|
{ |
||||
|
int i8 = i * 8; |
||||
|
for (int j = 0; j < i; j++) |
||||
|
{ |
||||
|
float tmp = data[i8 + j]; |
||||
|
data[i8 + j] = data[j * 8 + i]; |
||||
|
data[j * 8 + i] = tmp; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Transpose 8x8 block stored linearly in a <see cref="Span{T}"/>
|
||||
|
/// </summary>
|
||||
|
internal static void Transpose8x8(Span<float> src, Span<float> dest) |
||||
|
{ |
||||
|
for (int i = 0; i < 8; i++) |
||||
|
{ |
||||
|
int i8 = i * 8; |
||||
|
for (int j = 0; j < 8; j++) |
||||
|
{ |
||||
|
dest[j * 8 + i] = src[i8 + j]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Copies color values from block to the destination image buffer.
|
||||
|
/// </summary>
|
||||
|
/// <param name="block"></param>
|
||||
|
/// <param name="buffer"></param>
|
||||
|
/// <param name="stride"></param>
|
||||
|
internal static unsafe void CopyColorsTo(ref Block8x8F block, Span<byte> buffer, int stride) |
||||
|
{ |
||||
|
fixed (Block8x8F* p = &block) |
||||
|
{ |
||||
|
float* b = (float*)p; |
||||
|
|
||||
|
for (int y = 0; y < 8; y++) |
||||
|
{ |
||||
|
int y8 = y * 8; |
||||
|
int yStride = y * stride; |
||||
|
|
||||
|
for (int x = 0; x < 8; x++) |
||||
|
{ |
||||
|
float c = b[y8 + x]; |
||||
|
|
||||
|
if (c < -128) |
||||
|
{ |
||||
|
c = 0; |
||||
|
} |
||||
|
else if (c > 127) |
||||
|
{ |
||||
|
c = 255; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
c += 128; |
||||
|
} |
||||
|
|
||||
|
buffer[yStride + x] = (byte)c; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Reference implementation to test <see cref="Block8x8F.UnzigDivRound"/>.
|
||||
|
/// Rounding is done used an integer-based algorithm defined in <see cref="RationalRound(int,int)"/>.
|
||||
|
/// </summary>
|
||||
|
/// <param name="src">The input block</param>
|
||||
|
/// <param name="dest">The destination block of integers</param>
|
||||
|
/// <param name="qt">The quantization table</param>
|
||||
|
/// <param name="unzigPtr">Pointer to <see cref="UnzigData.Data"/> </param>
|
||||
|
public static unsafe void UnZigDivRoundRational(Block8x8F* src, int* dest, Block8x8F* qt, int* unzigPtr) |
||||
|
{ |
||||
|
float* s = (float*)src; |
||||
|
float* q = (float*)qt; |
||||
|
|
||||
|
for (int zig = 0; zig < Block8x8F.Size; zig++) |
||||
|
{ |
||||
|
int a = (int)s[unzigPtr[zig]]; |
||||
|
int b = (int)q[zig]; |
||||
|
|
||||
|
int val = RationalRound(a, b); |
||||
|
dest[zig] = val; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Rounds a rational number defined as dividend/divisor into an integer
|
||||
|
/// </summary>
|
||||
|
/// <param name="dividend">The dividend</param>
|
||||
|
/// <param name="divisor">The divisior</param>
|
||||
|
/// <returns></returns>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
private static int RationalRound(int dividend, int divisor) |
||||
|
{ |
||||
|
if (dividend >= 0) |
||||
|
{ |
||||
|
return (dividend + (divisor >> 1)) / divisor; |
||||
|
} |
||||
|
|
||||
|
return -((-dividend + (divisor >> 1)) / divisor); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,4 +1,4 @@ |
|||||
namespace SixLabors.ImageSharp.Tests |
namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils |
||||
{ |
{ |
||||
using System.Collections.Generic; |
using System.Collections.Generic; |
||||
using System.Linq; |
using System.Linq; |
||||
Loading…
Reference in new issue