diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs index 4aa72bf83..acaa69e3a 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bits.cs @@ -38,7 +38,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder [MethodImpl(MethodImplOptions.AggressiveInlining)] public void EnsureNBits(int n, ref InputProcessor inputProcessor) { - OldDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(n, ref inputProcessor); + OrigDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(n, ref inputProcessor); errorCode.EnsureNoError(); } @@ -46,17 +46,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// Reads bytes from the byte buffer to ensure that bits.UnreadBits is at /// least n. For best performance (avoiding function calls inside hot loops), /// the caller is the one responsible for first checking that bits.UnreadBits < n. - /// This method does not throw. Returns instead. + /// This method does not throw. Returns instead. /// /// The number of bits to ensure. /// The /// Error code - public OldDecoderErrorCode EnsureNBitsUnsafe(int n, ref InputProcessor inputProcessor) + public OrigDecoderErrorCode EnsureNBitsUnsafe(int n, ref InputProcessor inputProcessor) { while (true) { - OldDecoderErrorCode errorCode = this.EnsureBitsStepImpl(ref inputProcessor); - if (errorCode != OldDecoderErrorCode.NoError || this.UnreadBits >= n) + OrigDecoderErrorCode errorCode = this.EnsureBitsStepImpl(ref inputProcessor); + if (errorCode != OrigDecoderErrorCode.NoError || this.UnreadBits >= n) { return errorCode; } @@ -67,8 +67,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// Unrolled version of for n==8 /// /// The - /// A - public OldDecoderErrorCode Ensure8BitsUnsafe(ref InputProcessor inputProcessor) + /// A + public OrigDecoderErrorCode Ensure8BitsUnsafe(ref InputProcessor inputProcessor) { return this.EnsureBitsStepImpl(ref inputProcessor); } @@ -77,8 +77,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// Unrolled version of for n==1 /// /// The - /// A - public OldDecoderErrorCode Ensure1BitUnsafe(ref InputProcessor inputProcessor) + /// A + public OrigDecoderErrorCode Ensure1BitUnsafe(ref InputProcessor inputProcessor) { return this.EnsureBitsStepImpl(ref inputProcessor); } @@ -93,7 +93,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder public int ReceiveExtend(int t, ref InputProcessor inputProcessor) { int x; - OldDecoderErrorCode errorCode = this.ReceiveExtendUnsafe(t, ref inputProcessor, out x); + OrigDecoderErrorCode errorCode = this.ReceiveExtendUnsafe(t, ref inputProcessor, out x); errorCode.EnsureNoError(); return x; } @@ -104,13 +104,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// Byte /// The /// Read bits value - /// The - public OldDecoderErrorCode ReceiveExtendUnsafe(int t, ref InputProcessor inputProcessor, out int x) + /// The + public OrigDecoderErrorCode ReceiveExtendUnsafe(int t, ref InputProcessor inputProcessor, out int x) { if (this.UnreadBits < t) { - OldDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(t, ref inputProcessor); - if (errorCode != OldDecoderErrorCode.NoError) + OrigDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(t, ref inputProcessor); + if (errorCode != OrigDecoderErrorCode.NoError) { x = int.MaxValue; return errorCode; @@ -127,15 +127,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder x += ((-1) << t) + 1; } - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } - private OldDecoderErrorCode EnsureBitsStepImpl(ref InputProcessor inputProcessor) + private OrigDecoderErrorCode EnsureBitsStepImpl(ref InputProcessor inputProcessor) { int c; - OldDecoderErrorCode errorCode = inputProcessor.Bytes.ReadByteStuffedByteUnsafe(inputProcessor.InputStream, out c); + OrigDecoderErrorCode errorCode = inputProcessor.Bytes.ReadByteStuffedByteUnsafe(inputProcessor.InputStream, out c); - if (errorCode != OldDecoderErrorCode.NoError) + if (errorCode != OrigDecoderErrorCode.NoError) { return errorCode; } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs index a64f10fe5..b8c64fbe4 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs @@ -85,8 +85,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Input stream /// The result byte as - /// The - public OldDecoderErrorCode ReadByteStuffedByteUnsafe(Stream inputStream, out int x) + /// The + public OrigDecoderErrorCode ReadByteStuffedByteUnsafe(Stream inputStream, out int x) { // Take the fast path if bytes.buf contains at least two bytes. if (this.I + 2 <= this.J) @@ -94,50 +94,50 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder x = this.BufferAsInt[this.I]; this.I++; this.UnreadableBytes = 1; - if (x != OldJpegConstants.Markers.XFFInt) + if (x != OrigJpegConstants.Markers.XFFInt) { - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } if (this.BufferAsInt[this.I] != 0x00) { - return OldDecoderErrorCode.MissingFF00; + return OrigDecoderErrorCode.MissingFF00; } this.I++; this.UnreadableBytes = 2; - x = OldJpegConstants.Markers.XFF; - return OldDecoderErrorCode.NoError; + x = OrigJpegConstants.Markers.XFF; + return OrigDecoderErrorCode.NoError; } this.UnreadableBytes = 0; - OldDecoderErrorCode errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); + OrigDecoderErrorCode errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); this.UnreadableBytes = 1; - if (errorCode != OldDecoderErrorCode.NoError) + if (errorCode != OrigDecoderErrorCode.NoError) { return errorCode; } - if (x != OldJpegConstants.Markers.XFF) + if (x != OrigJpegConstants.Markers.XFF) { - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); this.UnreadableBytes = 2; - if (errorCode != OldDecoderErrorCode.NoError) + if (errorCode != OrigDecoderErrorCode.NoError) { return errorCode; } if (x != 0x00) { - return OldDecoderErrorCode.MissingFF00; + return OrigDecoderErrorCode.MissingFF00; } - x = OldJpegConstants.Markers.XFF; - return OldDecoderErrorCode.NoError; + x = OrigJpegConstants.Markers.XFF; + return OrigDecoderErrorCode.NoError; } /// @@ -149,25 +149,25 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder public byte ReadByte(Stream inputStream) { byte result; - OldDecoderErrorCode errorCode = this.ReadByteUnsafe(inputStream, out result); + OrigDecoderErrorCode errorCode = this.ReadByteUnsafe(inputStream, out result); errorCode.EnsureNoError(); return result; } /// /// Extracts the next byte, whether buffered or not buffered into the result out parameter. It does not care about byte stuffing. - /// This method does not throw on format error, it returns a instead. + /// This method does not throw on format error, it returns a instead. /// /// Input stream /// The result as out parameter - /// The - public OldDecoderErrorCode ReadByteUnsafe(Stream inputStream, out byte result) + /// The + public OrigDecoderErrorCode ReadByteUnsafe(Stream inputStream, out byte result) { - OldDecoderErrorCode errorCode = OldDecoderErrorCode.NoError; + OrigDecoderErrorCode errorCode = OrigDecoderErrorCode.NoError; while (this.I == this.J) { errorCode = this.FillUnsafe(inputStream); - if (errorCode != OldDecoderErrorCode.NoError) + if (errorCode != OrigDecoderErrorCode.NoError) { result = 0; return errorCode; @@ -185,15 +185,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// The input stream /// The result - /// A + /// A [MethodImpl(MethodImplOptions.AggressiveInlining)] - public OldDecoderErrorCode ReadByteAsIntUnsafe(Stream inputStream, out int result) + public OrigDecoderErrorCode ReadByteAsIntUnsafe(Stream inputStream, out int result) { - OldDecoderErrorCode errorCode = OldDecoderErrorCode.NoError; + OrigDecoderErrorCode errorCode = OrigDecoderErrorCode.NoError; while (this.I == this.J) { errorCode = this.FillUnsafe(inputStream); - if (errorCode != OldDecoderErrorCode.NoError) + if (errorCode != OrigDecoderErrorCode.NoError) { result = 0; return errorCode; @@ -215,18 +215,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Fill(Stream inputStream) { - OldDecoderErrorCode errorCode = this.FillUnsafe(inputStream); + OrigDecoderErrorCode errorCode = this.FillUnsafe(inputStream); errorCode.EnsureNoError(); } /// /// Fills up the bytes buffer from the underlying stream. /// It should only be called when there are no unread bytes in bytes. - /// This method does not throw , returns a instead! + /// This method does not throw , returns a instead! /// /// Input stream - /// The - public OldDecoderErrorCode FillUnsafe(Stream inputStream) + /// The + public OrigDecoderErrorCode FillUnsafe(Stream inputStream) { if (this.I != this.J) { @@ -248,7 +248,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder int n = inputStream.Read(this.Buffer, this.J, this.Buffer.Length - this.J); if (n == 0) { - return OldDecoderErrorCode.UnexpectedEndOfStream; + return OrigDecoderErrorCode.UnexpectedEndOfStream; } this.J += n; @@ -258,7 +258,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder this.BufferAsInt[i] = this.Buffer[i]; } - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } } } \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs index 29d3c9703..d5a9340d7 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/DecoderThrowHelper.cs @@ -12,19 +12,19 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder internal static class DecoderThrowHelper { /// - /// Throws an exception that belongs to the given + /// Throws an exception that belongs to the given /// - /// The + /// The [MethodImpl(MethodImplOptions.NoInlining)] - public static void ThrowExceptionForErrorCode(this OldDecoderErrorCode errorCode) + public static void ThrowExceptionForErrorCode(this OrigDecoderErrorCode errorCode) { switch (errorCode) { - case OldDecoderErrorCode.NoError: + case OrigDecoderErrorCode.NoError: throw new ArgumentException("ThrowExceptionForErrorCode() called with NoError!", nameof(errorCode)); - case OldDecoderErrorCode.MissingFF00: + case OrigDecoderErrorCode.MissingFF00: throw new MissingFF00Exception(); - case OldDecoderErrorCode.UnexpectedEndOfStream: + case OrigDecoderErrorCode.UnexpectedEndOfStream: throw new EOFException(); default: throw new ArgumentOutOfRangeException(nameof(errorCode), errorCode, null); @@ -32,26 +32,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } /// - /// Throws an exception if the given defines an error. + /// Throws an exception if the given defines an error. /// - /// The + /// The [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void EnsureNoError(this OldDecoderErrorCode errorCode) + public static void EnsureNoError(this OrigDecoderErrorCode errorCode) { - if (errorCode != OldDecoderErrorCode.NoError) + if (errorCode != OrigDecoderErrorCode.NoError) { ThrowExceptionForErrorCode(errorCode); } } /// - /// Throws an exception if the given is . + /// Throws an exception if the given is . /// - /// The + /// The [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void EnsureNoEOF(this OldDecoderErrorCode errorCode) + public static void EnsureNoEOF(this OrigDecoderErrorCode errorCode) { - if (errorCode == OldDecoderErrorCode.UnexpectedEndOfStream) + if (errorCode == OrigDecoderErrorCode.UnexpectedEndOfStream) { errorCode.ThrowExceptionForErrorCode(); } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs index 8f39aa542..6426afd49 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/InputProcessor.cs @@ -8,7 +8,7 @@ using System.Runtime.CompilerServices; namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder { /// - /// Encapsulates stream reading and processing data and operations for . + /// Encapsulates stream reading and processing data and operations for . /// It's a value type for imporved data locality, and reduced number of CALLVIRT-s /// internal struct InputProcessor : IDisposable @@ -27,7 +27,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// Initializes a new instance of the struct. /// /// The input - /// Temporal buffer, same as + /// Temporal buffer, same as public InputProcessor(Stream inputStream, byte[] temp) { this.Bits = default(Bits); @@ -43,7 +43,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder public Stream InputStream { get; } /// - /// Gets the temporal buffer, same instance as + /// Gets the temporal buffer, same instance as /// public byte[] Temp { get; } @@ -56,11 +56,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// If errorCode indicates unexpected EOF, sets to true and returns false. /// Calls and returns true otherwise. /// - /// The + /// The /// indicating whether everything is OK - public bool CheckEOFEnsureNoError(OldDecoderErrorCode errorCode) + public bool CheckEOFEnsureNoError(OrigDecoderErrorCode errorCode) { - if (errorCode == OldDecoderErrorCode.UnexpectedEndOfStream) + if (errorCode == OrigDecoderErrorCode.UnexpectedEndOfStream) { this.UnexpectedEndOfStreamReached = true; return false; @@ -74,11 +74,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// If errorCode indicates unexpected EOF, sets to true and returns false. /// Returns true otherwise. /// - /// The + /// The /// indicating whether everything is OK - public bool CheckEOF(OldDecoderErrorCode errorCode) + public bool CheckEOF(OrigDecoderErrorCode errorCode) { - if (errorCode == OldDecoderErrorCode.UnexpectedEndOfStream) + if (errorCode == OrigDecoderErrorCode.UnexpectedEndOfStream) { this.UnexpectedEndOfStreamReached = true; return false; @@ -110,13 +110,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// TODO: This method (and also the usages) could be optimized by batching! /// /// The decoded bit as a - /// The - public OldDecoderErrorCode DecodeBitUnsafe(out bool result) + /// The + public OrigDecoderErrorCode DecodeBitUnsafe(out bool result) { if (this.Bits.UnreadBits == 0) { - OldDecoderErrorCode errorCode = this.Bits.Ensure1BitUnsafe(ref this); - if (errorCode != OldDecoderErrorCode.NoError) + OrigDecoderErrorCode errorCode = this.Bits.Ensure1BitUnsafe(ref this); + if (errorCode != OrigDecoderErrorCode.NoError) { result = false; return errorCode; @@ -126,18 +126,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder result = (this.Bits.Accumulator & this.Bits.Mask) != 0; this.Bits.UnreadBits--; this.Bits.Mask >>= 1; - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } /// /// Reads exactly length bytes into data. It does not care about byte stuffing. - /// Does not throw on errors, returns instead! + /// Does not throw on errors, returns instead! /// /// The data to write to. /// The offset in the source buffer /// The number of bytes to read - /// The - public OldDecoderErrorCode ReadFullUnsafe(byte[] data, int offset, int length) + /// The + public OrigDecoderErrorCode ReadFullUnsafe(byte[] data, int offset, int length) { // Unread the overshot bytes, if any. if (this.Bytes.UnreadableBytes != 0) @@ -150,7 +150,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder this.Bytes.UnreadableBytes = 0; } - OldDecoderErrorCode errorCode = OldDecoderErrorCode.NoError; + OrigDecoderErrorCode errorCode = OrigDecoderErrorCode.NoError; while (length > 0) { if (this.Bytes.J - this.Bytes.I >= length) @@ -178,8 +178,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// The number of bits to decode. /// The result - /// The - public OldDecoderErrorCode DecodeBitsUnsafe(int count, out int result) + /// The + public OrigDecoderErrorCode DecodeBitsUnsafe(int count, out int result) { if (this.Bits.UnreadBits < count) { @@ -190,7 +190,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder result = result & ((1 << count) - 1); this.Bits.UnreadBits -= count; this.Bits.Mask >>= count; - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } /// @@ -198,8 +198,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// The huffman value /// The decoded - /// The - public OldDecoderErrorCode DecodeHuffmanUnsafe(ref OldHuffmanTree huffmanTree, out int result) + /// The + public OrigDecoderErrorCode DecodeHuffmanUnsafe(ref OrigHuffmanTree huffmanTree, out int result) { result = 0; @@ -210,11 +210,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder if (this.Bits.UnreadBits < 8) { - OldDecoderErrorCode errorCode = this.Bits.Ensure8BitsUnsafe(ref this); + OrigDecoderErrorCode errorCode = this.Bits.Ensure8BitsUnsafe(ref this); - if (errorCode == OldDecoderErrorCode.NoError) + if (errorCode == OrigDecoderErrorCode.NoError) { - int lutIndex = (this.Bits.Accumulator >> (this.Bits.UnreadBits - OldHuffmanTree.LutSizeLog2)) & 0xFF; + int lutIndex = (this.Bits.Accumulator >> (this.Bits.UnreadBits - OrigHuffmanTree.LutSizeLog2)) & 0xFF; int v = huffmanTree.Lut[lutIndex]; if (v != 0) @@ -234,7 +234,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } int code = 0; - for (int i = 0; i < OldHuffmanTree.MaxCodeLength; i++) + for (int i = 0; i < OrigHuffmanTree.MaxCodeLength; i++) { if (this.Bits.UnreadBits == 0) { @@ -252,7 +252,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder if (code <= huffmanTree.MaxCodes[i]) { result = huffmanTree.GetValue(code, i); - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } code <<= 1; @@ -262,7 +262,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder DecoderThrowHelper.ThrowImageFormatException.BadHuffmanCode(); // DUMMY RETURN! C# doesn't know we have thrown an exception! - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } /// @@ -272,17 +272,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Skip(int count) { - OldDecoderErrorCode errorCode = this.SkipUnsafe(count); + OrigDecoderErrorCode errorCode = this.SkipUnsafe(count); errorCode.EnsureNoError(); } /// /// Skips the next n bytes. - /// Does not throw, returns instead! + /// Does not throw, returns instead! /// /// The number of bytes to ignore. - /// The - public OldDecoderErrorCode SkipUnsafe(int count) + /// The + public OrigDecoderErrorCode SkipUnsafe(int count) { // Unread the overshot bytes, if any. if (this.Bytes.UnreadableBytes != 0) @@ -310,14 +310,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder break; } - OldDecoderErrorCode errorCode = this.Bytes.FillUnsafe(this.InputStream); - if (errorCode != OldDecoderErrorCode.NoError) + OrigDecoderErrorCode errorCode = this.Bytes.FillUnsafe(this.InputStream); + if (errorCode != OrigDecoderErrorCode.NoError) { return errorCode; } } - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } /// @@ -329,7 +329,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder [MethodImpl(MethodImplOptions.AggressiveInlining)] public void ReadFull(byte[] data, int offset, int length) { - OldDecoderErrorCode errorCode = this.ReadFullUnsafe(data, offset, length); + OrigDecoderErrorCode errorCode = this.ReadFullUnsafe(data, offset, length); errorCode.EnsureNoError(); } @@ -357,8 +357,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Byte /// Read bits value - /// The - public OldDecoderErrorCode ReceiveExtendUnsafe(int t, out int x) + /// The + public OrigDecoderErrorCode ReceiveExtendUnsafe(int t, out int x) { return this.Bits.ReceiveExtendUnsafe(t, ref this, out x); } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegBlockProcessor.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegBlockProcessor.cs index d65680901..2520735b1 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegBlockProcessor.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegBlockProcessor.cs @@ -42,12 +42,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } /// - /// Dequantize, perform the inverse DCT and store the blocks to the into the corresponding instances. + /// Dequantize, perform the inverse DCT and store the blocks to the into the corresponding instances. /// - /// The instance - public void ProcessAllBlocks(OldJpegDecoderCore decoder) + /// The instance + public void ProcessAllBlocks(OrigJpegDecoderCore decoder) { - OldComponent component = decoder.Components[this.componentIndex]; + OrigComponent component = decoder.Components[this.componentIndex]; for (int by = 0; by < component.HeightInBlocks; by++) { @@ -59,13 +59,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } /// - /// Dequantize, perform the inverse DCT and store decodedBlock.Block to the into the corresponding instance. + /// Dequantize, perform the inverse DCT and store decodedBlock.Block to the into the corresponding instance. /// - /// The - /// The - /// The x index of the block in - /// The y index of the block in - private void ProcessBlockColors(OldJpegDecoderCore decoder, OldComponent component, int bx, int by) + /// The + /// The + /// The x index of the block in + /// The y index of the block in + private void ProcessBlockColors(OrigJpegDecoderCore decoder, OrigComponent component, int bx, int by) { ref Block8x8 sourceBlock = ref component.GetBlockReference(bx, by); @@ -79,8 +79,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder FastFloatingPointDCT.TransformIDCT(ref *b, ref *this.pointers.Temp1, ref *this.pointers.Temp2); - OldJpegPixelArea destChannel = decoder.GetDestinationChannel(this.componentIndex); - OldJpegPixelArea destArea = destChannel.GetOffsetedSubAreaForBlock(bx, by); + OrigJpegPixelArea destChannel = decoder.GetDestinationChannel(this.componentIndex); + OrigJpegPixelArea destArea = destChannel.GetOffsetedSubAreaForBlock(bx, by); destArea.LoadColorsFrom(this.pointers.Temp1, this.pointers.Temp2); } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponent.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponent.cs index bd3667e23..3fea164f0 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponent.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponent.cs @@ -1,19 +1,18 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using System; +using SixLabors.ImageSharp.Formats.Jpeg.Common; +using SixLabors.ImageSharp.Memory; + namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder { - using System; - - using SixLabors.ImageSharp.Formats.Jpeg.Common; - using SixLabors.ImageSharp.Memory; - /// /// Represents a single color component /// - internal class OldComponent : IDisposable, IJpegComponent + internal class OrigComponent : IDisposable, IJpegComponent { - public OldComponent(byte identifier, int index) + public OrigComponent(byte identifier, int index) { this.Identifier = identifier; this.Index = index; @@ -25,7 +24,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder public byte Identifier { get; } /// - /// Gets the component's position in + /// Gets the component's position in /// public int Index { get; } @@ -47,8 +46,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Gets the storing the "raw" frequency-domain decoded blocks. /// We need to apply IDCT, dequantiazition and unzigging to transform them into color-space blocks. - /// This is done by . - /// When us true, we are touching these blocks multiple times - each time we process a Scan. + /// This is done by . + /// When us true, we are touching these blocks multiple times - each time we process a Scan. /// public Buffer2D SpectralBlocks { get; private set; } @@ -70,8 +69,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Initializes /// - /// The instance - public void InitializeBlocks(OldJpegDecoderCore decoder) + /// The instance + public void InitializeBlocks(OrigJpegDecoderCore decoder) { this.WidthInBlocks = decoder.MCUCountX * this.HorizontalFactor; this.HeightInBlocks = decoder.MCUCountY * this.VerticalFactor; @@ -81,8 +80,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Initializes all component data except . /// - /// The instance - public void InitializeData(OldJpegDecoderCore decoder) + /// The instance + public void InitializeData(OrigJpegDecoderCore decoder) { // Section B.2.2 states that "the value of C_i shall be different from // the values of C_1 through C_(i-1)". @@ -97,7 +96,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } this.Selector = decoder.Temp[8 + (3 * i)]; - if (this.Selector > OldJpegDecoderCore.MaxTq) + if (this.Selector > OrigJpegDecoderCore.MaxTq) { throw new ImageFormatException("Bad Tq value"); } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponentScan.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponentScan.cs index 5114ebd04..0d9804404 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponentScan.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldComponentScan.cs @@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// Represents a component scan /// [StructLayout(LayoutKind.Sequential)] - internal struct OldComponentScan + internal struct OrigComponentScan { /// /// Gets or sets the component index. diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldDecoderErrorCode.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldDecoderErrorCode.cs index f4419fb62..02a8ea55e 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldDecoderErrorCode.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldDecoderErrorCode.cs @@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Represents "recoverable" decoder errors. /// - internal enum OldDecoderErrorCode + internal enum OrigDecoderErrorCode { /// /// NoError diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldHuffmanTree.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldHuffmanTree.cs index 21210c95d..4c97d5741 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldHuffmanTree.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldHuffmanTree.cs @@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Represents a Huffman tree /// - internal struct OldHuffmanTree : IDisposable + internal struct OrigHuffmanTree : IDisposable { /// /// The index of the AC table row @@ -98,12 +98,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder private static readonly ArrayPool CodesPool16 = ArrayPool.Create(MaxCodeLength, 50); /// - /// Creates and initializes an array of instances of size + /// Creates and initializes an array of instances of size /// - /// An array of instances representing the Huffman tables - public static OldHuffmanTree[] CreateHuffmanTrees() + /// An array of instances representing the Huffman tables + public static OrigHuffmanTree[] CreateHuffmanTrees() { - OldHuffmanTree[] result = new OldHuffmanTree[NumberOfTrees]; + OrigHuffmanTree[] result = new OrigHuffmanTree[NumberOfTrees]; for (int i = 0; i < MaxTc + 1; i++) { for (int j = 0; j < MaxTh + 1; j++) diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegPixelArea.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegPixelArea.cs index 5e3506582..0fd2b5a61 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegPixelArea.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegPixelArea.cs @@ -1,27 +1,25 @@ // Copyright (c) Six Labors and contributors. // Licensed under the Apache License, Version 2.0. +using System; using System.Runtime.CompilerServices; - using SixLabors.ImageSharp.Memory; using Block8x8F = SixLabors.ImageSharp.Formats.Jpeg.Common.Block8x8F; namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder { - using System; - /// /// Represents an area of a Jpeg subimage (channel) /// - internal struct OldJpegPixelArea + internal struct OrigJpegPixelArea { /// - /// Initializes a new instance of the struct from existing data. + /// Initializes a new instance of the struct from existing data. /// /// The pixel buffer /// The stride /// The offset - public OldJpegPixelArea(Buffer2D pixels, int stride, int offset) + public OrigJpegPixelArea(Buffer2D pixels, int stride, int offset) { this.Stride = stride; this.Pixels = pixels; @@ -29,11 +27,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } /// - /// Initializes a new instance of the struct from existing buffer. + /// Initializes a new instance of the struct from existing buffer. /// will be set to of and will be set to 0. /// /// The pixel buffer - public OldJpegPixelArea(Buffer2D pixels) + public OrigJpegPixelArea(Buffer2D pixels) : this(pixels, pixels.Width, 0) { } @@ -84,10 +82,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// The block X index /// The block Y index /// The subarea offseted by block indices - public OldJpegPixelArea GetOffsetedSubAreaForBlock(int bx, int by) + public OrigJpegPixelArea GetOffsetedSubAreaForBlock(int bx, int by) { int offset = this.Offset + (8 * ((by * this.Stride) + bx)); - return new OldJpegPixelArea(this.Pixels, this.Stride, offset); + return new OrigJpegPixelArea(this.Pixels, this.Stride, offset); } /// diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.ComputationData.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.ComputationData.cs index 3aab69643..6252d8209 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.ComputationData.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.ComputationData.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Conains the definition of /// - internal unsafe partial struct OldJpegScanDecoder + internal unsafe partial struct OrigJpegScanDecoder { /// /// Holds the "large" data blocks needed for computations. @@ -29,14 +29,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder public UnzigData Unzig; /// - /// The buffer storing the -s for each component + /// The buffer storing the -s for each component /// - public fixed byte ScanData[3 * OldJpegDecoderCore.MaxComponents]; + public fixed byte ScanData[3 * OrigJpegDecoderCore.MaxComponents]; /// /// The DC values for each component /// - public fixed int Dc[OldJpegDecoderCore.MaxComponents]; + public fixed int Dc[OrigJpegDecoderCore.MaxComponents]; /// /// Creates and initializes a new instance diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.DataPointers.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.DataPointers.cs index 478c6470c..cfa8030cd 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.DataPointers.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.DataPointers.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Conains the definition of /// - internal unsafe partial struct OldJpegScanDecoder + internal unsafe partial struct OrigJpegScanDecoder { /// /// Contains pointers to the memory regions of so they can be easily passed around to pointer based utility methods of @@ -30,7 +30,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// Pointer to as Scan* /// - public OldComponentScan* ComponentScan; + public OrigComponentScan* ComponentScan; /// /// Pointer to @@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder { this.Block = &basePtr->Block; this.Unzig = basePtr->Unzig.Data; - this.ComponentScan = (OldComponentScan*)basePtr->ScanData; + this.ComponentScan = (OrigComponentScan*)basePtr->ScanData; this.Dc = basePtr->Dc; } } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.cs index f9798fb7d..976fcb909 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.cs @@ -30,7 +30,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// For baseline JPEGs, these parameters are hard-coded to 0/63/0/0. /// [StructLayout(LayoutKind.Sequential)] - internal unsafe partial struct OldJpegScanDecoder + internal unsafe partial struct OrigJpegScanDecoder { // The JpegScanDecoder members should be ordered in a way that results in optimal memory layout. #pragma warning disable SA1202 // ElementsMustBeOrderedByAccess @@ -96,12 +96,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder private int eobRun; /// - /// Initializes a default-constructed instance for reading data from -s stream. + /// Initializes a default-constructed instance for reading data from -s stream. /// - /// Pointer to on the stack - /// The instance + /// Pointer to on the stack + /// The instance /// The remaining bytes in the segment block. - public static void InitStreamReading(OldJpegScanDecoder* p, OldJpegDecoderCore decoder, int remaining) + public static void InitStreamReading(OrigJpegScanDecoder* p, OrigJpegDecoderCore decoder, int remaining) { p->data = ComputationData.Create(); p->pointers = new DataPointers(&p->data); @@ -109,8 +109,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } /// - /// Read Huffman data from Jpeg scans in , - /// and decode it as into . + /// Read Huffman data from Jpeg scans in , + /// and decode it as into . /// /// The blocks are traversed one MCU at a time. For 4:2:0 chroma /// subsampling, there are four Y 8x8 blocks in every 16x16 MCU. @@ -135,12 +135,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// 0 1 2 /// 3 4 5 /// - /// The instance - public void DecodeBlocks(OldJpegDecoderCore decoder) + /// The instance + public void DecodeBlocks(OrigJpegDecoderCore decoder) { int blockCount = 0; int mcu = 0; - byte expectedRst = OldJpegConstants.Markers.RST0; + byte expectedRst = OrigJpegConstants.Markers.RST0; for (int my = 0; my < decoder.MCUCountY; my++) { @@ -172,7 +172,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } // Find the block at (bx,by) in the component's buffer: - OldComponent component = decoder.Components[this.ComponentIndex]; + OrigComponent component = decoder.Components[this.ComponentIndex]; ref Block8x8 blockRefOnHeap = ref component.GetBlockReference(this.bx, this.by); // Copy block to stack @@ -199,7 +199,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder // but this one assumes well-formed input, and hence the restart marker follows immediately. if (!decoder.InputProcessor.UnexpectedEndOfStreamReached) { - OldDecoderErrorCode errorCode = decoder.InputProcessor.ReadFullUnsafe(decoder.Temp, 0, 2); + OrigDecoderErrorCode errorCode = decoder.InputProcessor.ReadFullUnsafe(decoder.Temp, 0, 2); if (decoder.InputProcessor.CheckEOFEnsureNoError(errorCode)) { if (decoder.Temp[0] != 0xff || decoder.Temp[1] != expectedRst) @@ -208,9 +208,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } expectedRst++; - if (expectedRst == OldJpegConstants.Markers.RST7 + 1) + if (expectedRst == OrigJpegConstants.Markers.RST7 + 1) { - expectedRst = OldJpegConstants.Markers.RST0; + expectedRst = OrigJpegConstants.Markers.RST0; } } } @@ -232,15 +232,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder private void ResetDc() { - Unsafe.InitBlock(this.pointers.Dc, default(byte), sizeof(int) * OldJpegDecoderCore.MaxComponents); + Unsafe.InitBlock(this.pointers.Dc, default(byte), sizeof(int) * OrigJpegDecoderCore.MaxComponents); } /// /// The implementation part of as an instance method. /// - /// The + /// The /// The remaining bytes - private void InitStreamReadingImpl(OldJpegDecoderCore decoder, int remaining) + private void InitStreamReadingImpl(OrigJpegDecoderCore decoder, int remaining) { if (decoder.ComponentCount == 0) { @@ -307,10 +307,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// /// The decoder /// The index of the scan - private void DecodeBlock(OldJpegDecoderCore decoder, int scanIndex) + private void DecodeBlock(OrigJpegDecoderCore decoder, int scanIndex) { Block8x8* b = this.pointers.Block; - int huffmannIdx = (OldHuffmanTree.AcTableIndex * OldHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].AcTableSelector; + int huffmannIdx = (OrigHuffmanTree.AcTableIndex * OrigHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].AcTableSelector; if (this.ah != 0) { this.Refine(ref decoder.InputProcessor, ref decoder.HuffmanTrees[huffmannIdx], 1 << this.al); @@ -318,14 +318,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder else { int zig = this.zigStart; - OldDecoderErrorCode errorCode; + OrigDecoderErrorCode errorCode; if (zig == 0) { zig++; // Decode the DC coefficient, as specified in section F.2.2.1. int value; - int huffmanIndex = (OldHuffmanTree.DcTableIndex * OldHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].DcTableSelector; + int huffmanIndex = (OrigHuffmanTree.DcTableIndex * OrigHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].DcTableSelector; errorCode = decoder.InputProcessor.DecodeHuffmanUnsafe( ref decoder.HuffmanTrees[huffmanIndex], out value); @@ -415,30 +415,30 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } } - private OldDecoderErrorCode DecodeEobRun(int count, ref InputProcessor decoder) + private OrigDecoderErrorCode DecodeEobRun(int count, ref InputProcessor decoder) { int bitsResult; - OldDecoderErrorCode errorCode = decoder.DecodeBitsUnsafe(count, out bitsResult); - if (errorCode != OldDecoderErrorCode.NoError) + OrigDecoderErrorCode errorCode = decoder.DecodeBitsUnsafe(count, out bitsResult); + if (errorCode != OrigDecoderErrorCode.NoError) { return errorCode; } this.eobRun |= bitsResult; - return OldDecoderErrorCode.NoError; + return OrigDecoderErrorCode.NoError; } /// - /// Gets the block index used to retieve blocks from in + /// Gets the block index used to retieve blocks from in /// - /// The instance + /// The instance /// The index - private int GetBlockIndex(OldJpegDecoderCore decoder) + private int GetBlockIndex(OrigJpegDecoderCore decoder) { return ((this.by * decoder.MCUCountX) * this.hi) + this.bx; } - private void InitComponentScan(OldJpegDecoderCore decoder, int i, ref OldComponentScan currentComponentScan, ref int totalHv) + private void InitComponentScan(OrigJpegDecoderCore decoder, int i, ref OrigComponentScan currentComponentScan, ref int totalHv) { // Component selector. int cs = decoder.Temp[1 + (2 * i)]; @@ -463,11 +463,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } private void ProcessComponentImpl( - OldJpegDecoderCore decoder, + OrigJpegDecoderCore decoder, int i, - ref OldComponentScan currentComponentScan, + ref OrigComponentScan currentComponentScan, ref int totalHv, - OldComponent currentComponent) + OrigComponent currentComponent) { // Section B.2.3 states that "the value of Cs_j shall be different from // the values of Cs_1 through Cs_(j-1)". Since we have previously @@ -485,13 +485,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder totalHv += currentComponent.HorizontalFactor * currentComponent.VerticalFactor; currentComponentScan.DcTableSelector = (byte)(decoder.Temp[2 + (2 * i)] >> 4); - if (currentComponentScan.DcTableSelector > OldHuffmanTree.MaxTh) + if (currentComponentScan.DcTableSelector > OrigHuffmanTree.MaxTh) { throw new ImageFormatException("Bad DC table selector value"); } currentComponentScan.AcTableSelector = (byte)(decoder.Temp[2 + (2 * i)] & 0x0f); - if (currentComponentScan.AcTableSelector > OldHuffmanTree.MaxTh) + if (currentComponentScan.AcTableSelector > OrigHuffmanTree.MaxTh) { throw new ImageFormatException("Bad AC table selector value"); } @@ -503,7 +503,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder /// The instance /// The Huffman tree /// The low transform offset - private void Refine(ref InputProcessor bp, ref OldHuffmanTree h, int delta) + private void Refine(ref InputProcessor bp, ref OrigHuffmanTree h, int delta) { Block8x8* b = this.pointers.Block; @@ -516,7 +516,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } bool bit; - OldDecoderErrorCode errorCode = bp.DecodeBitUnsafe(out bit); + OrigDecoderErrorCode errorCode = bp.DecodeBitUnsafe(out bit); if (!bp.CheckEOFEnsureNoError(errorCode)) { return; @@ -546,7 +546,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder int z = 0; int val; - OldDecoderErrorCode errorCode = bp.DecodeHuffmanUnsafe(ref h, out val); + OrigDecoderErrorCode errorCode = bp.DecodeHuffmanUnsafe(ref h, out val); if (!bp.CheckEOF(errorCode)) { return; @@ -655,7 +655,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder } bool bit; - OldDecoderErrorCode errorCode = bp.DecodeBitUnsafe(out bit); + OrigDecoderErrorCode errorCode = bp.DecodeBitUnsafe(out bit); if (!bp.CheckEOFEnsureNoError(errorCode)) { return int.MinValue; diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/YCbCrImage.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/YCbCrImage.cs index 2fb5f3fa8..582606cc7 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/YCbCrImage.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/YCbCrImage.cs @@ -15,17 +15,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder // Complex value type field + mutable + available to other classes = the field MUST NOT be private :P #pragma warning disable SA1401 // FieldsMustBePrivate /// - /// Gets the luminance components channel as . + /// Gets the luminance components channel as . /// public Buffer2D YChannel; /// - /// Gets the blue chroma components channel as . + /// Gets the blue chroma components channel as . /// public Buffer2D CbChannel; /// - /// Gets an offseted to the Cr channel + /// Gets an offseted to the Cr channel /// public Buffer2D CrChannel; #pragma warning restore SA1401 diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/JpegEncoderCore.cs index f4cbcb4e9..984fb828c 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/JpegEncoderCore.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/JpegEncoderCore.cs @@ -58,7 +58,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// private static readonly byte[] SosHeaderYCbCr = { - OldJpegConstants.Markers.XFF, OldJpegConstants.Markers.SOS, + OrigJpegConstants.Markers.XFF, OrigJpegConstants.Markers.SOS, // Marker 0x00, 0x0c, @@ -197,7 +197,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort Guard.NotNull(image, nameof(image)); Guard.NotNull(stream, nameof(stream)); - ushort max = OldJpegConstants.MaxLength; + ushort max = OrigJpegConstants.MaxLength; if (image.Width >= max || image.Height >= max) { throw new ImageFormatException($"Image is too large to encode at {image.Width}x{image.Height}."); @@ -246,8 +246,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } // Write the End Of Image marker. - this.buffer[0] = OldJpegConstants.Markers.XFF; - this.buffer[1] = OldJpegConstants.Markers.EOI; + this.buffer[0] = OrigJpegConstants.Markers.XFF; + this.buffer[1] = OrigJpegConstants.Markers.EOI; stream.Write(this.buffer, 0, 2); stream.Flush(); } @@ -508,12 +508,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort private void WriteApplicationHeader(short horizontalResolution, short verticalResolution) { // Write the start of image marker. Markers are always prefixed with with 0xff. - this.buffer[0] = OldJpegConstants.Markers.XFF; - this.buffer[1] = OldJpegConstants.Markers.SOI; + this.buffer[0] = OrigJpegConstants.Markers.XFF; + this.buffer[1] = OrigJpegConstants.Markers.SOI; // Write the JFIF headers - this.buffer[2] = OldJpegConstants.Markers.XFF; - this.buffer[3] = OldJpegConstants.Markers.APP0; // Application Marker + this.buffer[2] = OrigJpegConstants.Markers.XFF; + this.buffer[3] = OrigJpegConstants.Markers.APP0; // Application Marker this.buffer[4] = 0x00; this.buffer[5] = 0x10; this.buffer[6] = 0x4a; // J @@ -627,7 +627,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort markerlen += 1 + 16 + s.Values.Length; } - this.WriteMarkerHeader(OldJpegConstants.Markers.DHT, markerlen); + this.WriteMarkerHeader(OrigJpegConstants.Markers.DHT, markerlen); for (int i = 0; i < specs.Length; i++) { HuffmanSpec spec = specs[i]; @@ -661,7 +661,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort { // Marker + quantization table lengths int markerlen = 2 + (QuantizationTableCount * (1 + Block8x8F.Size)); - this.WriteMarkerHeader(OldJpegConstants.Markers.DQT, markerlen); + this.WriteMarkerHeader(OrigJpegConstants.Markers.DQT, markerlen); // Loop through and collect the tables as one array. // This allows us to reduce the number of writes to the stream. @@ -699,8 +699,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort int length = data.Length + 2; - this.buffer[0] = OldJpegConstants.Markers.XFF; - this.buffer[1] = OldJpegConstants.Markers.APP1; // Application Marker + this.buffer[0] = OrigJpegConstants.Markers.XFF; + this.buffer[1] = OrigJpegConstants.Markers.APP1; // Application Marker this.buffer[2] = (byte)((length >> 8) & 0xFF); this.buffer[3] = (byte)(length & 0xFF); @@ -758,8 +758,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort dataLength -= length; - this.buffer[0] = OldJpegConstants.Markers.XFF; - this.buffer[1] = OldJpegConstants.Markers.APP2; // Application Marker + this.buffer[0] = OrigJpegConstants.Markers.XFF; + this.buffer[1] = OrigJpegConstants.Markers.APP2; // Application Marker int markerLength = length + 16; this.buffer[2] = (byte)((markerLength >> 8) & 0xFF); this.buffer[3] = (byte)(markerLength & 0xFF); @@ -831,7 +831,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort // Length (high byte, low byte), 8 + components * 3. int markerlen = 8 + (3 * componentCount); - this.WriteMarkerHeader(OldJpegConstants.Markers.SOF0, markerlen); + this.WriteMarkerHeader(OrigJpegConstants.Markers.SOF0, markerlen); this.buffer[0] = 8; // Data Precision. 8 for now, 12 and 16 bit jpegs not supported this.buffer[1] = (byte)(height >> 8); this.buffer[2] = (byte)(height & 0xff); // (2 bytes, Hi-Lo), must be > 0 if DNL not supported @@ -974,7 +974,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort private void WriteMarkerHeader(byte marker, int length) { // Markers are always prefixed with with 0xff. - this.buffer[0] = OldJpegConstants.Markers.XFF; + this.buffer[0] = OrigJpegConstants.Markers.XFF; this.buffer[1] = marker; this.buffer[2] = (byte)(length >> 8); this.buffer[3] = (byte)(length & 0xff); diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegConstants.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegConstants.cs index c2326cc4f..f38c72820 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegConstants.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegConstants.cs @@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// /// Defines jpeg constants defined in the specification. /// - internal static class OldJpegConstants + internal static class OrigJpegConstants { /// /// The maximum allowable length in each dimension of a jpeg image. diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoder.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoder.cs index 62898d399..13be70e30 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoder.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoder.cs @@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// /// Image decoder for generating an image out of a jpg stream. /// - internal sealed class OldJpegDecoder : IImageDecoder, IJpegDecoderOptions + internal sealed class OrigJpegDecoder : IImageDecoder, IJpegDecoderOptions { /// /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded. @@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort { Guard.NotNull(stream, nameof(stream)); - using (var decoder = new OldJpegDecoderCore(configuration, this)) + using (var decoder = new OrigJpegDecoderCore(configuration, this)) { return decoder.Decode(stream); } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoderCore.cs index ec19a4fe9..7c533dd20 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoderCore.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoderCore.cs @@ -20,7 +20,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// /// Performs the jpeg decoding operation. /// - internal sealed unsafe class OldJpegDecoderCore : IDisposable + internal sealed unsafe class OrigJpegDecoderCore : IDisposable { /// /// The maximum number of color components @@ -36,7 +36,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort #pragma warning disable SA1401 // FieldsMustBePrivate /// - /// Encapsulates stream reading and processing data and operations for . + /// Encapsulates stream reading and processing data and operations for . /// It's a value type for imporved data locality, and reduced number of CALLVIRT-s /// public InputProcessor InputProcessor; @@ -65,12 +65,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// /// The black image to decode to. /// - private OldJpegPixelArea blackImage; + private OrigJpegPixelArea blackImage; /// /// A grayscale image to decode to. /// - private OldJpegPixelArea grayImage; + private OrigJpegPixelArea grayImage; /// /// The horizontal resolution. Calculated if the image has a JFIF header. @@ -98,15 +98,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort private YCbCrImage ycbcrImage; /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The configuration. /// The options. - public OldJpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) + public OrigJpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) { this.IgnoreMetadata = options.IgnoreMetadata; this.configuration = configuration ?? Configuration.Default; - this.HuffmanTrees = OldHuffmanTree.CreateHuffmanTrees(); + this.HuffmanTrees = OrigHuffmanTree.CreateHuffmanTrees(); this.QuantizationTables = new Block8x8F[MaxTq + 1]; this.Temp = new byte[2 * Block8x8F.Size]; } @@ -114,12 +114,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// /// Gets the component array /// - public OldComponent[] Components { get; private set; } + public OrigComponent[] Components { get; private set; } /// /// Gets the huffman trees /// - public OldHuffmanTree[] HuffmanTrees { get; } + public OrigHuffmanTree[] HuffmanTrees { get; } /// /// Gets the quantization tables, in zigzag order. @@ -214,7 +214,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort if (this.Components != null) { - foreach (OldComponent component in this.Components) + foreach (OrigComponent component in this.Components) { component.Dispose(); } @@ -227,11 +227,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } /// - /// Gets the representing the channel at a given component index + /// Gets the representing the channel at a given component index /// /// The component index - /// The of the channel - public OldJpegPixelArea GetDestinationChannel(int compIndex) + /// The of the channel + public OrigJpegPixelArea GetDestinationChannel(int compIndex) { if (this.ComponentCount == 1) { @@ -242,11 +242,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort switch (compIndex) { case 0: - return new OldJpegPixelArea(this.ycbcrImage.YChannel); + return new OrigJpegPixelArea(this.ycbcrImage.YChannel); case 1: - return new OldJpegPixelArea(this.ycbcrImage.CbChannel); + return new OrigJpegPixelArea(this.ycbcrImage.CbChannel); case 2: - return new OldJpegPixelArea(this.ycbcrImage.CrChannel); + return new OrigJpegPixelArea(this.ycbcrImage.CrChannel); case 3: return this.blackImage; default: @@ -256,7 +256,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } /// - /// Read metadata from stream and read the blocks in the scans into . + /// Read metadata from stream and read the blocks in the scans into . /// /// The stream /// Whether to decode metadata only. @@ -268,7 +268,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort // Check for the Start Of Image marker. this.InputProcessor.ReadFull(this.Temp, 0, 2); - if (this.Temp[0] != OldJpegConstants.Markers.XFF || this.Temp[1] != OldJpegConstants.Markers.SOI) + if (this.Temp[0] != OrigJpegConstants.Markers.XFF || this.Temp[1] != OrigJpegConstants.Markers.SOI) { throw new ImageFormatException("Missing SOI marker."); } @@ -318,12 +318,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } // End Of Image. - if (marker == OldJpegConstants.Markers.EOI) + if (marker == OrigJpegConstants.Markers.EOI) { break; } - if (marker >= OldJpegConstants.Markers.RST0 && marker <= OldJpegConstants.Markers.RST7) + if (marker >= OrigJpegConstants.Markers.RST0 && marker <= OrigJpegConstants.Markers.RST7) { // Figures B.2 and B.16 of the specification suggest that restart markers should // only occur between Entropy Coded Segments and not after the final ECS. @@ -345,10 +345,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort switch (marker) { - case OldJpegConstants.Markers.SOF0: - case OldJpegConstants.Markers.SOF1: - case OldJpegConstants.Markers.SOF2: - this.IsProgressive = marker == OldJpegConstants.Markers.SOF2; + case OrigJpegConstants.Markers.SOF0: + case OrigJpegConstants.Markers.SOF1: + case OrigJpegConstants.Markers.SOF2: + this.IsProgressive = marker == OrigJpegConstants.Markers.SOF2; this.ProcessStartOfFrameMarker(remaining); if (metadataOnly && this.isJfif) { @@ -356,7 +356,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } break; - case OldJpegConstants.Markers.DHT: + case OrigJpegConstants.Markers.DHT: if (metadataOnly) { this.InputProcessor.Skip(remaining); @@ -367,7 +367,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } break; - case OldJpegConstants.Markers.DQT: + case OrigJpegConstants.Markers.DQT: if (metadataOnly) { this.InputProcessor.Skip(remaining); @@ -378,7 +378,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } break; - case OldJpegConstants.Markers.SOS: + case OrigJpegConstants.Markers.SOS: if (metadataOnly) { return; @@ -394,7 +394,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } break; - case OldJpegConstants.Markers.DRI: + case OrigJpegConstants.Markers.DRI: if (metadataOnly) { this.InputProcessor.Skip(remaining); @@ -405,25 +405,25 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } break; - case OldJpegConstants.Markers.APP0: + case OrigJpegConstants.Markers.APP0: this.ProcessApplicationHeader(remaining); break; - case OldJpegConstants.Markers.APP1: + case OrigJpegConstants.Markers.APP1: this.ProcessApp1Marker(remaining); break; - case OldJpegConstants.Markers.APP2: + case OrigJpegConstants.Markers.APP2: this.ProcessApp2Marker(remaining); break; - case OldJpegConstants.Markers.APP14: + case OrigJpegConstants.Markers.APP14: this.ProcessApp14Marker(remaining); break; default: - if ((marker >= OldJpegConstants.Markers.APP0 && marker <= OldJpegConstants.Markers.APP15) - || marker == OldJpegConstants.Markers.COM) + if ((marker >= OrigJpegConstants.Markers.APP0 && marker <= OrigJpegConstants.Markers.APP15) + || marker == OrigJpegConstants.Markers.COM) { this.InputProcessor.Skip(remaining); } - else if (marker < OldJpegConstants.Markers.SOF0) + else if (marker < OrigJpegConstants.Markers.SOF0) { // See Table B.1 "Marker code assignments". throw new ImageFormatException("Unknown marker"); @@ -448,17 +448,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort /// private void ProcessStartOfScan(int remaining) { - OldJpegScanDecoder scan = default(OldJpegScanDecoder); - OldJpegScanDecoder.InitStreamReading(&scan, this, remaining); + OrigJpegScanDecoder scan = default(OrigJpegScanDecoder); + OrigJpegScanDecoder.InitStreamReading(&scan, this, remaining); this.InputProcessor.Bits = default(Bits); this.MakeImage(); scan.DecodeBlocks(this); } /// - /// Process the blocks in into Jpeg image channels ( and ) + /// Process the blocks in into Jpeg image channels ( and ) /// are in a "raw" frequency-domain form. We need to apply IDCT, dequantization and unzigging to transform them into color-space blocks. - /// We can copy these blocks into -s afterwards. + /// We can copy these blocks into -s afterwards. /// /// The pixel type private void ProcessBlocksIntoJpegImageChannels() @@ -476,7 +476,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort } /// - /// Convert the pixel data in and/or into pixels of + /// Convert the pixel data in and/or into pixels of /// /// The pixel type /// The decoded image. @@ -503,11 +503,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort // See http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe // See https://docs.oracle.com/javase/8/docs/api/javax/imageio/metadata/doc-files/jpeg_metadata.html // TODO: YCbCrA? - if (this.adobeTransform == OldJpegConstants.Adobe.ColorTransformYcck) + if (this.adobeTransform == OrigJpegConstants.Adobe.ColorTransformYcck) { this.ConvertFromYcck(image); } - else if (this.adobeTransform == OldJpegConstants.Adobe.ColorTransformUnknown) + else if (this.adobeTransform == OrigJpegConstants.Adobe.ColorTransformUnknown) { // Assume CMYK this.ConvertFromCmyk(image); @@ -759,7 +759,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort return false; } - if (this.adobeTransformValid && this.adobeTransform == OldJpegConstants.Adobe.ColorTransformUnknown) + if (this.adobeTransformValid && this.adobeTransform == OrigJpegConstants.Adobe.ColorTransformUnknown) { // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe // says that 0 means Unknown (and in practice RGB) and 1 means YCbCr. @@ -783,7 +783,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort if (this.ComponentCount == 1) { Buffer2D buffer = Buffer2D.CreateClean(8 * this.MCUCountX, 8 * this.MCUCountY); - this.grayImage = new OldJpegPixelArea(buffer); + this.grayImage = new OrigJpegPixelArea(buffer); } else { @@ -823,7 +823,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort int v3 = this.Components[3].VerticalFactor; var buffer = Buffer2D.CreateClean(8 * h3 * this.MCUCountX, 8 * v3 * this.MCUCountY); - this.blackImage = new OldJpegPixelArea(buffer); + this.blackImage = new OrigJpegPixelArea(buffer); } } } @@ -1056,18 +1056,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort this.InputProcessor.ReadFull(this.Temp, 0, 17); int tc = this.Temp[0] >> 4; - if (tc > OldHuffmanTree.MaxTc) + if (tc > OrigHuffmanTree.MaxTc) { throw new ImageFormatException("Bad Tc value"); } int th = this.Temp[0] & 0x0f; - if (th > OldHuffmanTree.MaxTh || (!this.IsProgressive && (th > 1))) + if (th > OrigHuffmanTree.MaxTh || (!this.IsProgressive && (th > 1))) { throw new ImageFormatException("Bad Th value"); } - int huffTreeIndex = (tc * OldHuffmanTree.ThRowSize) + th; + int huffTreeIndex = (tc * OrigHuffmanTree.ThRowSize) + th; this.HuffmanTrees[huffTreeIndex].ProcessDefineHuffmanTablesMarkerLoop( ref this.InputProcessor, this.Temp, @@ -1203,12 +1203,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort throw new ImageFormatException("SOF has wrong length"); } - this.Components = new OldComponent[this.ComponentCount]; + this.Components = new OrigComponent[this.ComponentCount]; for (int i = 0; i < this.ComponentCount; i++) { byte componentIdentifier = this.Temp[6 + (3 * i)]; - var component = new OldComponent(componentIdentifier, i); + var component = new OrigComponent(componentIdentifier, i); component.InitializeData(this); this.Components[i] = component; } diff --git a/src/ImageSharp/Formats/Jpeg/GolangPort/Utils/OldJpegUtils.cs b/src/ImageSharp/Formats/Jpeg/GolangPort/Utils/OldJpegUtils.cs index a6e976258..98bfecb22 100644 --- a/src/ImageSharp/Formats/Jpeg/GolangPort/Utils/OldJpegUtils.cs +++ b/src/ImageSharp/Formats/Jpeg/GolangPort/Utils/OldJpegUtils.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Utils /// /// Jpeg specific utilities and extension methods /// - internal static unsafe class OldJpegUtils + internal static unsafe class OrigJpegUtils { /// /// Copy a region of an image into dest. De "outlier" area will be stretched out with pixels on the right and bottom of the image. diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs index 38f1d7dbc..4d985992f 100644 --- a/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs +++ b/src/ImageSharp/Formats/Jpeg/JpegDecoder.cs @@ -23,7 +23,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg { Guard.NotNull(stream, nameof(stream)); - using (var decoder = new JpegDecoderCore(configuration, this)) + using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) { return decoder.Decode(stream); } diff --git a/src/ImageSharp/Formats/Jpeg/JpegFormat.cs b/src/ImageSharp/Formats/Jpeg/JpegFormat.cs index 8dd59ac20..4f368dcde 100644 --- a/src/ImageSharp/Formats/Jpeg/JpegFormat.cs +++ b/src/ImageSharp/Formats/Jpeg/JpegFormat.cs @@ -18,9 +18,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg public string DefaultMimeType => "image/jpeg"; /// - public IEnumerable MimeTypes => OldJpegConstants.MimeTypes; + public IEnumerable MimeTypes => OrigJpegConstants.MimeTypes; /// - public IEnumerable FileExtensions => OldJpegConstants.FileExtensions; + public IEnumerable FileExtensions => OrigJpegConstants.FileExtensions; } } \ No newline at end of file diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Component.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Component.cs index 97c140120..3c35e311f 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Component.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Component.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Represents a component block /// - internal class Component : IDisposable + internal class PdfJsComponent : IDisposable { #pragma warning disable SA1401 /// diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ComponentBlocks.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ComponentBlocks.cs index ffcd32109..86a0c6b31 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ComponentBlocks.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ComponentBlocks.cs @@ -8,12 +8,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Contains all the decoded component blocks /// - internal sealed class ComponentBlocks : IDisposable + internal sealed class PdfJsComponentBlocks : IDisposable { /// /// Gets or sets the component blocks /// - public Component[] Components { get; set; } + public PdfJsComponent[] Components { get; set; } /// public void Dispose() diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FileMarker.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FileMarker.cs index d0182b63a..d6ff1e9ed 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FileMarker.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FileMarker.cs @@ -6,14 +6,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Represents a jpeg file marker /// - internal struct FileMarker + internal struct PdfJsFileMarker { /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The marker /// The position within the stream - public FileMarker(ushort marker, long position) + public PdfJsFileMarker(ushort marker, long position) { this.Marker = marker; this.Position = position; @@ -21,12 +21,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The marker /// The position within the stream /// Whether the current marker is invalid - public FileMarker(ushort marker, long position, bool invalid) + public PdfJsFileMarker(ushort marker, long position, bool invalid) { this.Marker = marker; this.Position = position; diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Frame.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Frame.cs index 2398b8c01..8ce981a09 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Frame.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Frame.cs @@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Represent a single jpeg frame /// - internal sealed class Frame : IDisposable + internal sealed class PdfJsFrame : IDisposable { /// /// Gets or sets a value indicating whether the frame uses the extended specification @@ -48,7 +48,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Gets or sets the frame component collection /// - public FrameComponent[] Components { get; set; } + public PdfJsFrameComponent[] Components { get; set; } /// /// Gets or sets the maximum horizontal sampling factor @@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components for (int i = 0; i < this.ComponentCount; i++) { - FrameComponent component = this.Components[i]; + PdfJsFrameComponent component = this.Components[i]; component.Init(); } } diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FrameComponent.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FrameComponent.cs index 8f050b6c6..3ff37febc 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FrameComponent.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FrameComponent.cs @@ -12,11 +12,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Represents a single frame component /// - internal class FrameComponent : IDisposable, IJpegComponent + internal class PdfJsFrameComponent : IDisposable, IJpegComponent { #pragma warning disable SA1401 // Fields should be private - public FrameComponent(Frame frame, byte id, int horizontalFactor, int verticalFactor, byte quantizationIdentifier) + public PdfJsFrameComponent(PdfJsFrame frame, byte id, int horizontalFactor, int verticalFactor, byte quantizationIdentifier) { this.Frame = frame; this.Id = id; @@ -79,7 +79,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components internal int BlocksPerColumnForMcu { get; private set; } - public Frame Frame { get; } + public PdfJsFrame Frame { get; } /// public void Dispose() diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTable.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTable.cs index 1c8a8fc42..9dc831567 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTable.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTable.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Represents a Huffman Table /// - internal struct HuffmanTable : IDisposable + internal struct PdfJsHuffmanTable : IDisposable { private Buffer lookahead; private Buffer valOffset; @@ -18,11 +18,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components private Buffer huffval; /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The code lengths /// The huffman values - public HuffmanTable(byte[] lengths, byte[] values) + public PdfJsHuffmanTable(byte[] lengths, byte[] values) { this.lookahead = Buffer.CreateClean(256); this.valOffset = Buffer.CreateClean(18); diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTables.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTables.cs index 46487c025..5d59809cc 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTables.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTables.cs @@ -10,16 +10,16 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Defines a pair of huffman tables /// - internal sealed class HuffmanTables : IDisposable + internal sealed class PdfJsHuffmanTables : IDisposable { - private readonly HuffmanTable[] tables = new HuffmanTable[4]; + private readonly PdfJsHuffmanTable[] tables = new PdfJsHuffmanTable[4]; /// /// Gets or sets the table at the given index. /// /// The index /// The - public ref HuffmanTable this[int index] + public ref PdfJsHuffmanTable this[int index] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/IDCT.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/IDCT.cs index 6ea257492..49bdc2423 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/IDCT.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/IDCT.cs @@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Performs the inverse Descrete Cosine Transform on each frame component. /// - internal static class IDCT + internal static class PdfJsIDCT { /// /// Precomputed values scaled up by 14 bits @@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components private static readonly byte[] Limit = new byte[5 * (MaxJSample + 1)]; - static IDCT() + static PdfJsIDCT() { // Main part of range limit table: limit[x] = x int i; @@ -88,7 +88,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// The block buffer offset /// The computational buffer for holding temp values /// The quantization table - public static void QuantizeAndInverse(FrameComponent component, int blockBufferOffset, ref Span computationBuffer, ref Span quantizationTable) + public static void QuantizeAndInverse(PdfJsFrameComponent component, int blockBufferOffset, ref Span computationBuffer, ref Span quantizationTable) { Span blockData = component.BlockData.Slice(blockBufferOffset); int v0, v1, v2, v3, v4, v5, v6, v7; @@ -307,7 +307,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// The block buffer offset /// The computational buffer for holding temp values /// The multiplier table - public static void QuantizeAndInverseFast(FrameComponent component, int blockBufferOffset, ref Span computationBuffer, ref Span multiplierTable) + public static void QuantizeAndInverseFast(PdfJsFrameComponent component, int blockBufferOffset, ref Span computationBuffer, ref Span multiplierTable) { Span blockData = component.BlockData.Slice(blockBufferOffset); int p0, p1, p2, p3, p4, p5, p6, p7; diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JFif.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JFif.cs index 57f023c2b..52ba81bbc 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JFif.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JFif.cs @@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// Provides information about the JFIF marker segment /// TODO: Thumbnail? /// - internal struct JFif : IEquatable + internal struct PdfJsJFif : IEquatable { /// /// The major version @@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components public short YDensity; /// - public bool Equals(JFif other) + public bool Equals(PdfJsJFif other) { return this.MajorVersion == other.MajorVersion && this.MinorVersion == other.MinorVersion @@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components return false; } - return obj is JFif && this.Equals((JFif)obj); + return obj is PdfJsJFif && this.Equals((PdfJsJFif)obj); } /// diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JpegPixelArea.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JpegPixelArea.cs index f04b7dadd..034986c2c 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JpegPixelArea.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JpegPixelArea.cs @@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Represents a section of the jpeg component data laid out in pixel order. /// - internal struct JpegPixelArea : IDisposable + internal struct PdfJsJpegPixelArea : IDisposable { private readonly int imageWidth; @@ -23,12 +23,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components private int rowStride; /// - /// Initializes a new instance of the struct. + /// Initializes a new instance of the struct. /// /// The image width /// The image height /// The number of components - public JpegPixelArea(int imageWidth, int imageHeight, int numberOfComponents) + public PdfJsJpegPixelArea(int imageWidth, int imageHeight, int numberOfComponents) { this.imageWidth = imageWidth; this.imageHeight = imageHeight; @@ -61,7 +61,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// The jpeg component blocks /// The pixel area width /// The pixel area height - public void LinearizeBlockData(ComponentBlocks components, int width, int height) + public void LinearizeBlockData(PdfJsComponentBlocks components, int width, int height) { this.Width = width; this.Height = height; @@ -78,7 +78,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components Span xScaleBlockOffsetSpan = xScaleBlockOffset; for (int i = 0; i < numberOfComponents; i++) { - ref Component component = ref components.Components[i]; + ref PdfJsComponent component = ref components.Components[i]; Vector2 componentScale = component.Scale * scale; int offset = i; Span output = component.Output; diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Adobe.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsAdobe.cs similarity index 91% rename from src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Adobe.cs rename to src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsAdobe.cs index fdc6ed2ca..9fba4ae9b 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Adobe.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsAdobe.cs @@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Provides information about the Adobe marker segment /// - internal struct Adobe : IEquatable + internal struct PdfJsAdobe : IEquatable { /// /// The DCT Encode Version @@ -36,7 +36,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components public byte ColorTransform; /// - public bool Equals(Adobe other) + public bool Equals(PdfJsAdobe other) { return this.DCTEncodeVersion == other.DCTEncodeVersion && this.APP14Flags0 == other.APP14Flags0 @@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components return false; } - return obj is Adobe && this.Equals((Adobe)obj); + return obj is PdfJsAdobe && this.Equals((PdfJsAdobe)obj); } /// diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/QuantizationTables.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/QuantizationTables.cs index 35dd0111a..1000ce82c 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/QuantizationTables.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/QuantizationTables.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Contains the quantization tables. /// - internal sealed class QuantizationTables : IDisposable + internal sealed class PdfJsQuantizationTables : IDisposable { /// /// Gets the ZigZag scan table diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs index 42da5964f..a2cc7cb79 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs @@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// /// Provides the means to decode a spectral scan /// - internal struct ScanDecoder + internal struct PdfJsScanDecoder { private byte[] markerBuffer; @@ -59,11 +59,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// The successive approximation bit high end /// The successive approximation bit low end public void DecodeScan( - Frame frame, + PdfJsFrame frame, Stream stream, - HuffmanTables dcHuffmanTables, - HuffmanTables acHuffmanTables, - FrameComponent[] components, + PdfJsHuffmanTables dcHuffmanTables, + PdfJsHuffmanTables acHuffmanTables, + PdfJsFrameComponent[] components, int componentIndex, int componentsLength, ushort resetInterval, @@ -94,14 +94,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components mcuExpected = mcusPerLine * frame.McusPerColumn; } - FileMarker fileMarker; + PdfJsFileMarker fileMarker; while (mcu < mcuExpected) { // Reset interval stuff int mcuToRead = resetInterval != 0 ? Math.Min(mcuExpected - mcu, resetInterval) : mcuExpected; for (int i = 0; i < components.Length; i++) { - FrameComponent c = components[i]; + PdfJsFrameComponent c = components[i]; c.Pred = 0; } @@ -141,7 +141,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components this.bitsCount = 0; this.accumulator = 0; this.bitsUnRead = 0; - fileMarker = JpegDecoderCore.FindNextFileMarker(this.markerBuffer, stream); + fileMarker = PdfJsJpegDecoderCore.FindNextFileMarker(this.markerBuffer, stream); // Some bad images seem to pad Scan blocks with e.g. zero bytes, skip past // those to attempt to find a valid marker (fixes issue4090.pdf) in original code. @@ -155,7 +155,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components ushort marker = fileMarker.Marker; // RSTn - We've alread read the bytes and altered the position so no need to skip - if (marker >= JpegConstants.Markers.RST0 && marker <= JpegConstants.Markers.RST7) + if (marker >= PdfJsJpegConstants.Markers.RST0 && marker <= PdfJsJpegConstants.Markers.RST7) { continue; } @@ -169,7 +169,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } } - fileMarker = JpegDecoderCore.FindNextFileMarker(this.markerBuffer, stream); + fileMarker = PdfJsJpegDecoderCore.FindNextFileMarker(this.markerBuffer, stream); // Some images include more Scan blocks than expected, skip past those and // attempt to find the next valid marker (fixes issue8182.pdf) in original code. @@ -189,9 +189,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components [MethodImpl(MethodImplOptions.AggressiveInlining)] private void DecodeScanBaseline( - HuffmanTables dcHuffmanTables, - HuffmanTables acHuffmanTables, - FrameComponent[] components, + PdfJsHuffmanTables dcHuffmanTables, + PdfJsHuffmanTables acHuffmanTables, + PdfJsFrameComponent[] components, int componentsLength, int mcusPerLine, int mcuToRead, @@ -200,9 +200,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { if (componentsLength == 1) { - FrameComponent component = components[this.compIndex]; - ref HuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; - ref HuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; + PdfJsFrameComponent component = components[this.compIndex]; + ref PdfJsHuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; + ref PdfJsHuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; for (int n = 0; n < mcuToRead; n++) { @@ -221,9 +221,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { for (int i = 0; i < componentsLength; i++) { - FrameComponent component = components[i]; - ref HuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; - ref HuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; + PdfJsFrameComponent component = components[i]; + ref PdfJsHuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; + ref PdfJsHuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; int h = component.HorizontalFactor; int v = component.VerticalFactor; @@ -248,8 +248,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components [MethodImpl(MethodImplOptions.AggressiveInlining)] private void DecodeScanDCFirst( - HuffmanTables dcHuffmanTables, - FrameComponent[] components, + PdfJsHuffmanTables dcHuffmanTables, + PdfJsFrameComponent[] components, int componentsLength, int mcusPerLine, int mcuToRead, @@ -258,8 +258,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { if (componentsLength == 1) { - FrameComponent component = components[this.compIndex]; - ref HuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; + PdfJsFrameComponent component = components[this.compIndex]; + ref PdfJsHuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; for (int n = 0; n < mcuToRead; n++) { @@ -278,8 +278,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { for (int i = 0; i < componentsLength; i++) { - FrameComponent component = components[i]; - ref HuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; + PdfJsFrameComponent component = components[i]; + ref PdfJsHuffmanTable dcHuffmanTable = ref dcHuffmanTables[component.DCHuffmanTableId]; int h = component.HorizontalFactor; int v = component.VerticalFactor; @@ -304,7 +304,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components [MethodImpl(MethodImplOptions.AggressiveInlining)] private void DecodeScanDCSuccessive( - FrameComponent[] components, + PdfJsFrameComponent[] components, int componentsLength, int mcusPerLine, int mcuToRead, @@ -313,7 +313,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { if (componentsLength == 1) { - FrameComponent component = components[this.compIndex]; + PdfJsFrameComponent component = components[this.compIndex]; for (int n = 0; n < mcuToRead; n++) { if (this.endOfStreamReached || this.unexpectedMarkerReached) @@ -331,7 +331,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { for (int i = 0; i < componentsLength; i++) { - FrameComponent component = components[i]; + PdfJsFrameComponent component = components[i]; int h = component.HorizontalFactor; int v = component.VerticalFactor; for (int j = 0; j < v; j++) @@ -355,8 +355,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components [MethodImpl(MethodImplOptions.AggressiveInlining)] private void DecodeScanACFirst( - HuffmanTables acHuffmanTables, - FrameComponent[] components, + PdfJsHuffmanTables acHuffmanTables, + PdfJsFrameComponent[] components, int componentsLength, int mcusPerLine, int mcuToRead, @@ -365,8 +365,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { if (componentsLength == 1) { - FrameComponent component = components[this.compIndex]; - ref HuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; + PdfJsFrameComponent component = components[this.compIndex]; + ref PdfJsHuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; for (int n = 0; n < mcuToRead; n++) { @@ -385,8 +385,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { for (int i = 0; i < componentsLength; i++) { - FrameComponent component = components[i]; - ref HuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; + PdfJsFrameComponent component = components[i]; + ref PdfJsHuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; int h = component.HorizontalFactor; int v = component.VerticalFactor; @@ -411,8 +411,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components [MethodImpl(MethodImplOptions.AggressiveInlining)] private void DecodeScanACSuccessive( - HuffmanTables acHuffmanTables, - FrameComponent[] components, + PdfJsHuffmanTables acHuffmanTables, + PdfJsFrameComponent[] components, int componentsLength, int mcusPerLine, int mcuToRead, @@ -421,8 +421,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { if (componentsLength == 1) { - FrameComponent component = components[this.compIndex]; - ref HuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; + PdfJsFrameComponent component = components[this.compIndex]; + ref PdfJsHuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; for (int n = 0; n < mcuToRead; n++) { @@ -441,8 +441,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components { for (int i = 0; i < componentsLength; i++) { - FrameComponent component = components[i]; - ref HuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; + PdfJsFrameComponent component = components[i]; + ref PdfJsHuffmanTable acHuffmanTable = ref acHuffmanTables[component.ACHuffmanTableId]; int h = component.HorizontalFactor; int v = component.VerticalFactor; @@ -466,7 +466,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeBlockBaseline(ref HuffmanTable dcHuffmanTable, ref HuffmanTable acHuffmanTable, FrameComponent component, int mcu, Stream stream) + private void DecodeBlockBaseline(ref PdfJsHuffmanTable dcHuffmanTable, ref PdfJsHuffmanTable acHuffmanTable, PdfJsFrameComponent component, int mcu, Stream stream) { int blockRow = mcu / component.WidthInBlocks; int blockCol = mcu % component.WidthInBlocks; @@ -475,7 +475,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeMcuBaseline(ref HuffmanTable dcHuffmanTable, ref HuffmanTable acHuffmanTable, FrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) + private void DecodeMcuBaseline(ref PdfJsHuffmanTable dcHuffmanTable, ref PdfJsHuffmanTable acHuffmanTable, PdfJsFrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) { int mcuRow = mcu / mcusPerLine; int mcuCol = mcu % mcusPerLine; @@ -486,7 +486,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeBlockDCFirst(ref HuffmanTable dcHuffmanTable, FrameComponent component, int mcu, Stream stream) + private void DecodeBlockDCFirst(ref PdfJsHuffmanTable dcHuffmanTable, PdfJsFrameComponent component, int mcu, Stream stream) { int blockRow = mcu / component.WidthInBlocks; int blockCol = mcu % component.WidthInBlocks; @@ -495,7 +495,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeMcuDCFirst(ref HuffmanTable dcHuffmanTable, FrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) + private void DecodeMcuDCFirst(ref PdfJsHuffmanTable dcHuffmanTable, PdfJsFrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) { int mcuRow = mcu / mcusPerLine; int mcuCol = mcu % mcusPerLine; @@ -506,7 +506,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeBlockDCSuccessive(FrameComponent component, int mcu, Stream stream) + private void DecodeBlockDCSuccessive(PdfJsFrameComponent component, int mcu, Stream stream) { int blockRow = mcu / component.WidthInBlocks; int blockCol = mcu % component.WidthInBlocks; @@ -515,7 +515,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeMcuDCSuccessive(FrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) + private void DecodeMcuDCSuccessive(PdfJsFrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) { int mcuRow = mcu / mcusPerLine; int mcuCol = mcu % mcusPerLine; @@ -526,7 +526,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeBlockACFirst(ref HuffmanTable acHuffmanTable, FrameComponent component, int mcu, Stream stream) + private void DecodeBlockACFirst(ref PdfJsHuffmanTable acHuffmanTable, PdfJsFrameComponent component, int mcu, Stream stream) { int blockRow = mcu / component.WidthInBlocks; int blockCol = mcu % component.WidthInBlocks; @@ -535,7 +535,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeMcuACFirst(ref HuffmanTable acHuffmanTable, FrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) + private void DecodeMcuACFirst(ref PdfJsHuffmanTable acHuffmanTable, PdfJsFrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) { int mcuRow = mcu / mcusPerLine; int mcuCol = mcu % mcusPerLine; @@ -546,7 +546,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeBlockACSuccessive(ref HuffmanTable acHuffmanTable, FrameComponent component, int mcu, Stream stream) + private void DecodeBlockACSuccessive(ref PdfJsHuffmanTable acHuffmanTable, PdfJsFrameComponent component, int mcu, Stream stream) { int blockRow = mcu / component.WidthInBlocks; int blockCol = mcu % component.WidthInBlocks; @@ -555,7 +555,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeMcuACSuccessive(ref HuffmanTable acHuffmanTable, FrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) + private void DecodeMcuACSuccessive(ref PdfJsHuffmanTable acHuffmanTable, PdfJsFrameComponent component, int mcusPerLine, int mcu, int row, int col, Stream stream) { int mcuRow = mcu / mcusPerLine; int mcuCol = mcu % mcusPerLine; @@ -583,7 +583,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components this.endOfStreamReached = true; } - if (this.bitsData == JpegConstants.Markers.Prefix) + if (this.bitsData == PdfJsJpegConstants.Markers.Prefix) { int nextByte = stream.ReadByte(); if (nextByte != 0) @@ -606,7 +606,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private short DecodeHuffman(ref HuffmanTable tree, Stream stream) + private short DecodeHuffman(ref PdfJsHuffmanTable tree, Stream stream) { short code = -1; @@ -705,7 +705,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeBaseline(FrameComponent component, int offset, ref HuffmanTable dcHuffmanTable, ref HuffmanTable acHuffmanTable, Stream stream) + private void DecodeBaseline(PdfJsFrameComponent component, int offset, ref PdfJsHuffmanTable dcHuffmanTable, ref PdfJsHuffmanTable acHuffmanTable, Stream stream) { int t = this.DecodeHuffman(ref dcHuffmanTable, stream); if (this.endOfStreamReached || this.unexpectedMarkerReached) @@ -746,7 +746,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components break; } - byte z = QuantizationTables.DctZigZag[k]; + byte z = PdfJsQuantizationTables.DctZigZag[k]; short re = (short)this.ReceiveAndExtend(s, stream); component.BlockData[offset + z] = re; k++; @@ -754,7 +754,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeDCFirst(FrameComponent component, int offset, ref HuffmanTable dcHuffmanTable, Stream stream) + private void DecodeDCFirst(PdfJsFrameComponent component, int offset, ref PdfJsHuffmanTable dcHuffmanTable, Stream stream) { int t = this.DecodeHuffman(ref dcHuffmanTable, stream); if (this.endOfStreamReached || this.unexpectedMarkerReached) @@ -767,7 +767,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeDCSuccessive(FrameComponent component, int offset, Stream stream) + private void DecodeDCSuccessive(PdfJsFrameComponent component, int offset, Stream stream) { int bit = this.ReadBit(stream); if (this.endOfStreamReached || this.unexpectedMarkerReached) @@ -779,7 +779,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeACFirst(FrameComponent component, int offset, ref HuffmanTable acHuffmanTable, Stream stream) + private void DecodeACFirst(PdfJsFrameComponent component, int offset, ref PdfJsHuffmanTable acHuffmanTable, Stream stream) { if (this.eobrun > 0) { @@ -814,14 +814,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components } k += r; - byte z = QuantizationTables.DctZigZag[k]; + byte z = PdfJsQuantizationTables.DctZigZag[k]; componentBlockDataSpan[offset + z] = (short)(this.ReceiveAndExtend(s, stream) * (1 << this.successiveState)); k++; } } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private void DecodeACSuccessive(FrameComponent component, int offset, ref HuffmanTable acHuffmanTable, Stream stream) + private void DecodeACSuccessive(PdfJsFrameComponent component, int offset, ref PdfJsHuffmanTable acHuffmanTable, Stream stream) { int k = this.specStart; int e = this.specEnd; @@ -829,7 +829,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components Span componentBlockDataSpan = component.BlockData.Span; while (k <= e) { - byte z = QuantizationTables.DctZigZag[k]; + byte z = PdfJsQuantizationTables.DctZigZag[k]; switch (this.successiveACState) { case 0: // Initial state diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/YCbCrToRgbTables.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/YCbCrToRgbTables.cs index e4f99275b..ddc577270 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/YCbCrToRgbTables.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/YCbCrToRgbTables.cs @@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components /// Provides 8-bit lookup tables for converting from YCbCr to Rgb colorspace. /// Methods to build the tables are based on libjpeg implementation. /// - internal struct YCbCrToRgbTables + internal struct PdfJsYCbCrToRgbTables { /// /// The red red-chrominance table diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegConstants.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegConstants.cs index c23cb9e9b..08b42891d 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegConstants.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegConstants.cs @@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// Contains jpeg constant values /// - internal static class JpegConstants + internal static class PdfJsJpegConstants { /// /// Contains marker specific constants diff --git a/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegDecoderCore.cs index a9962a7b8..d22c5040c 100644 --- a/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegDecoderCore.cs +++ b/src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegDecoderCore.cs @@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// Performs the jpeg decoding operation. /// Ported from with additional fixes to handle common encoding errors /// - internal sealed class JpegDecoderCore : IDisposable + internal sealed class PdfJsJpegDecoderCore : IDisposable { #pragma warning disable SA1401 // Fields should be private /// @@ -32,15 +32,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort private readonly byte[] markerBuffer = new byte[2]; - private QuantizationTables quantizationTables; + private PdfJsQuantizationTables quantizationTables; - private HuffmanTables dcHuffmanTables; + private PdfJsHuffmanTables dcHuffmanTables; - private HuffmanTables acHuffmanTables; + private PdfJsHuffmanTables acHuffmanTables; - private ComponentBlocks components; + private PdfJsComponentBlocks components; - private JpegPixelArea pixelArea; + private PdfJsJpegPixelArea pixelArea; private ushort resetInterval; @@ -52,27 +52,27 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// Contains information about the JFIF marker /// - private JFif jFif; + private PdfJsJFif jFif; /// /// Contains information about the Adobe marker /// - private Adobe adobe; + private PdfJsAdobe adobe; /// - /// Initializes static members of the class. + /// Initializes static members of the class. /// - static JpegDecoderCore() + static PdfJsJpegDecoderCore() { - YCbCrToRgbTables.Create(); + PdfJsYCbCrToRgbTables.Create(); } /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The configuration. /// The options. - public JpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) + public PdfJsJpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) { this.configuration = configuration ?? Configuration.Default; this.IgnoreMetadata = options.IgnoreMetadata; @@ -81,7 +81,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// Gets the frame /// - public Frame Frame { get; private set; } + public PdfJsFrame Frame { get; private set; } /// /// Gets the image width @@ -113,35 +113,35 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// The buffer to read file markers to /// The input stream - /// The - public static FileMarker FindNextFileMarker(byte[] marker, Stream stream) + /// The + public static PdfJsFileMarker FindNextFileMarker(byte[] marker, Stream stream) { int value = stream.Read(marker, 0, 2); if (value == 0) { - return new FileMarker(JpegConstants.Markers.EOI, (int)stream.Length - 2); + return new PdfJsFileMarker(PdfJsJpegConstants.Markers.EOI, (int)stream.Length - 2); } - if (marker[0] == JpegConstants.Markers.Prefix) + if (marker[0] == PdfJsJpegConstants.Markers.Prefix) { // According to Section B.1.1.2: // "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code 0xFF." - while (marker[1] == JpegConstants.Markers.Prefix) + while (marker[1] == PdfJsJpegConstants.Markers.Prefix) { int suffix = stream.ReadByte(); if (suffix == -1) { - return new FileMarker(JpegConstants.Markers.EOI, (int)stream.Length - 2); + return new PdfJsFileMarker(PdfJsJpegConstants.Markers.EOI, (int)stream.Length - 2); } marker[1] = (byte)value; } - return new FileMarker((ushort)((marker[0] << 8) | marker[1]), (int)(stream.Position - 2)); + return new PdfJsFileMarker((ushort)((marker[0] << 8) | marker[1]), (int)(stream.Position - 2)); } - return new FileMarker((ushort)((marker[0] << 8) | marker[1]), (int)(stream.Position - 2), true); + return new PdfJsFileMarker((ushort)((marker[0] << 8) | marker[1]), (int)(stream.Position - 2), true); } /// @@ -191,7 +191,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort } [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static int GetBlockBufferOffset(ref Component component, int row, int col) + private static int GetBlockBufferOffset(ref PdfJsComponent component, int row, int col) { return 64 * (((component.BlocksPerLine + 1) * row) + col); } @@ -205,79 +205,79 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort { // TODO: metadata only logic // Check for the Start Of Image marker. - var fileMarker = new FileMarker(this.ReadUint16(), 0); - if (fileMarker.Marker != JpegConstants.Markers.SOI) + var fileMarker = new PdfJsFileMarker(this.ReadUint16(), 0); + if (fileMarker.Marker != PdfJsJpegConstants.Markers.SOI) { throw new ImageFormatException("Missing SOI marker."); } ushort marker = this.ReadUint16(); - fileMarker = new FileMarker(marker, (int)this.InputStream.Position - 2); + fileMarker = new PdfJsFileMarker(marker, (int)this.InputStream.Position - 2); - this.quantizationTables = new QuantizationTables(); - this.dcHuffmanTables = new HuffmanTables(); - this.acHuffmanTables = new HuffmanTables(); + this.quantizationTables = new PdfJsQuantizationTables(); + this.dcHuffmanTables = new PdfJsHuffmanTables(); + this.acHuffmanTables = new PdfJsHuffmanTables(); - while (fileMarker.Marker != JpegConstants.Markers.EOI) + while (fileMarker.Marker != PdfJsJpegConstants.Markers.EOI) { // Get the marker length int remaining = this.ReadUint16() - 2; switch (fileMarker.Marker) { - case JpegConstants.Markers.APP0: + case PdfJsJpegConstants.Markers.APP0: this.ProcessApplicationHeaderMarker(remaining); break; - case JpegConstants.Markers.APP1: + case PdfJsJpegConstants.Markers.APP1: this.ProcessApp1Marker(remaining, metaData); break; - case JpegConstants.Markers.APP2: + case PdfJsJpegConstants.Markers.APP2: this.ProcessApp2Marker(remaining, metaData); break; - case JpegConstants.Markers.APP3: - case JpegConstants.Markers.APP4: - case JpegConstants.Markers.APP5: - case JpegConstants.Markers.APP6: - case JpegConstants.Markers.APP7: - case JpegConstants.Markers.APP8: - case JpegConstants.Markers.APP9: - case JpegConstants.Markers.APP10: - case JpegConstants.Markers.APP11: - case JpegConstants.Markers.APP12: - case JpegConstants.Markers.APP13: + case PdfJsJpegConstants.Markers.APP3: + case PdfJsJpegConstants.Markers.APP4: + case PdfJsJpegConstants.Markers.APP5: + case PdfJsJpegConstants.Markers.APP6: + case PdfJsJpegConstants.Markers.APP7: + case PdfJsJpegConstants.Markers.APP8: + case PdfJsJpegConstants.Markers.APP9: + case PdfJsJpegConstants.Markers.APP10: + case PdfJsJpegConstants.Markers.APP11: + case PdfJsJpegConstants.Markers.APP12: + case PdfJsJpegConstants.Markers.APP13: this.InputStream.Skip(remaining); break; - case JpegConstants.Markers.APP14: + case PdfJsJpegConstants.Markers.APP14: this.ProcessApp14Marker(remaining); break; - case JpegConstants.Markers.APP15: - case JpegConstants.Markers.COM: + case PdfJsJpegConstants.Markers.APP15: + case PdfJsJpegConstants.Markers.COM: this.InputStream.Skip(remaining); break; - case JpegConstants.Markers.DQT: + case PdfJsJpegConstants.Markers.DQT: this.ProcessDefineQuantizationTablesMarker(remaining); break; - case JpegConstants.Markers.SOF0: - case JpegConstants.Markers.SOF1: - case JpegConstants.Markers.SOF2: + case PdfJsJpegConstants.Markers.SOF0: + case PdfJsJpegConstants.Markers.SOF1: + case PdfJsJpegConstants.Markers.SOF2: this.ProcessStartOfFrameMarker(remaining, fileMarker); break; - case JpegConstants.Markers.DHT: + case PdfJsJpegConstants.Markers.DHT: this.ProcessDefineHuffmanTablesMarker(remaining); break; - case JpegConstants.Markers.DRI: + case PdfJsJpegConstants.Markers.DRI: this.ProcessDefineRestartIntervalMarker(remaining); break; - case JpegConstants.Markers.SOS: + case PdfJsJpegConstants.Markers.SOS: this.ProcessStartOfScanMarker(); break; } @@ -288,12 +288,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.ImageWidth = this.Frame.SamplesPerLine; this.ImageHeight = this.Frame.Scanlines; - this.components = new ComponentBlocks { Components = new Component[this.Frame.ComponentCount] }; + this.components = new PdfJsComponentBlocks { Components = new PdfJsComponent[this.Frame.ComponentCount] }; for (int i = 0; i < this.components.Components.Length; i++) { - FrameComponent frameComponent = this.Frame.Components[i]; - var component = new Component + PdfJsFrameComponent frameComponent = this.Frame.Components[i]; + var component = new PdfJsComponent { Scale = new System.Numerics.Vector2( frameComponent.HorizontalFactor / (float)this.Frame.MaxHorizontalFactor, @@ -313,8 +313,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort { for (int i = 0; i < this.components.Components.Length; i++) { - FrameComponent frameComponent = this.Frame.Components[i]; - Component component = this.components.Components[i]; + PdfJsFrameComponent frameComponent = this.Frame.Components[i]; + PdfJsComponent component = this.components.Components[i]; this.QuantizeAndInverseComponentData(component, frameComponent); } @@ -333,7 +333,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort throw new ImageFormatException($"Unsupported color mode. Max components 4; found {this.NumberOfComponents}"); } - this.pixelArea = new JpegPixelArea(image.Width, image.Height, this.NumberOfComponents); + this.pixelArea = new PdfJsJpegPixelArea(image.Width, image.Height, this.NumberOfComponents); this.pixelArea.LinearizeBlockData(this.components, image.Width, image.Height); if (this.NumberOfComponents == 1) @@ -344,11 +344,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort if (this.NumberOfComponents == 3) { - if (this.adobe.Equals(default(Adobe)) || this.adobe.ColorTransform == JpegConstants.Markers.Adobe.ColorTransformYCbCr) + if (this.adobe.Equals(default(PdfJsAdobe)) || this.adobe.ColorTransform == PdfJsJpegConstants.Markers.Adobe.ColorTransformYCbCr) { this.FillYCbCrImage(image); } - else if (this.adobe.ColorTransform == JpegConstants.Markers.Adobe.ColorTransformUnknown) + else if (this.adobe.ColorTransform == PdfJsJpegConstants.Markers.Adobe.ColorTransformUnknown) { this.FillRgbImage(image); } @@ -356,7 +356,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort if (this.NumberOfComponents == 4) { - if (this.adobe.ColorTransform == JpegConstants.Markers.Adobe.ColorTransformYcck) + if (this.adobe.ColorTransform == PdfJsJpegConstants.Markers.Adobe.ColorTransformYcck) { this.FillYcckImage(image); } @@ -411,15 +411,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.InputStream.Read(this.temp, 0, 13); remaining -= 13; - bool isJfif = this.temp[0] == JpegConstants.Markers.JFif.J && - this.temp[1] == JpegConstants.Markers.JFif.F && - this.temp[2] == JpegConstants.Markers.JFif.I && - this.temp[3] == JpegConstants.Markers.JFif.F && - this.temp[4] == JpegConstants.Markers.JFif.Null; + bool isJfif = this.temp[0] == PdfJsJpegConstants.Markers.JFif.J && + this.temp[1] == PdfJsJpegConstants.Markers.JFif.F && + this.temp[2] == PdfJsJpegConstants.Markers.JFif.I && + this.temp[3] == PdfJsJpegConstants.Markers.JFif.F && + this.temp[4] == PdfJsJpegConstants.Markers.JFif.Null; if (isJfif) { - this.jFif = new JFif + this.jFif = new PdfJsJFif { MajorVersion = this.temp[5], MinorVersion = this.temp[6], @@ -453,12 +453,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort byte[] profile = new byte[remaining]; this.InputStream.Read(profile, 0, remaining); - if (profile[0] == JpegConstants.Markers.Exif.E && - profile[1] == JpegConstants.Markers.Exif.X && - profile[2] == JpegConstants.Markers.Exif.I && - profile[3] == JpegConstants.Markers.Exif.F && - profile[4] == JpegConstants.Markers.Exif.Null && - profile[5] == JpegConstants.Markers.Exif.Null) + if (profile[0] == PdfJsJpegConstants.Markers.Exif.E && + profile[1] == PdfJsJpegConstants.Markers.Exif.X && + profile[2] == PdfJsJpegConstants.Markers.Exif.I && + profile[3] == PdfJsJpegConstants.Markers.Exif.F && + profile[4] == PdfJsJpegConstants.Markers.Exif.Null && + profile[5] == PdfJsJpegConstants.Markers.Exif.Null) { this.isExif = true; metadata.ExifProfile = new ExifProfile(profile); @@ -484,18 +484,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.InputStream.Read(identifier, 0, Icclength); remaining -= Icclength; // We have read it by this point - if (identifier[0] == JpegConstants.Markers.ICC.I && - identifier[1] == JpegConstants.Markers.ICC.C && - identifier[2] == JpegConstants.Markers.ICC.C && - identifier[3] == JpegConstants.Markers.ICC.UnderScore && - identifier[4] == JpegConstants.Markers.ICC.P && - identifier[5] == JpegConstants.Markers.ICC.R && - identifier[6] == JpegConstants.Markers.ICC.O && - identifier[7] == JpegConstants.Markers.ICC.F && - identifier[8] == JpegConstants.Markers.ICC.I && - identifier[9] == JpegConstants.Markers.ICC.L && - identifier[10] == JpegConstants.Markers.ICC.E && - identifier[11] == JpegConstants.Markers.ICC.Null) + if (identifier[0] == PdfJsJpegConstants.Markers.ICC.I && + identifier[1] == PdfJsJpegConstants.Markers.ICC.C && + identifier[2] == PdfJsJpegConstants.Markers.ICC.C && + identifier[3] == PdfJsJpegConstants.Markers.ICC.UnderScore && + identifier[4] == PdfJsJpegConstants.Markers.ICC.P && + identifier[5] == PdfJsJpegConstants.Markers.ICC.R && + identifier[6] == PdfJsJpegConstants.Markers.ICC.O && + identifier[7] == PdfJsJpegConstants.Markers.ICC.F && + identifier[8] == PdfJsJpegConstants.Markers.ICC.I && + identifier[9] == PdfJsJpegConstants.Markers.ICC.L && + identifier[10] == PdfJsJpegConstants.Markers.ICC.E && + identifier[11] == PdfJsJpegConstants.Markers.ICC.Null) { byte[] profile = new byte[remaining]; this.InputStream.Read(profile, 0, remaining); @@ -533,15 +533,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.InputStream.Read(this.temp, 0, 12); remaining -= 12; - bool isAdobe = this.temp[0] == JpegConstants.Markers.Adobe.A && - this.temp[1] == JpegConstants.Markers.Adobe.D && - this.temp[2] == JpegConstants.Markers.Adobe.O && - this.temp[3] == JpegConstants.Markers.Adobe.B && - this.temp[4] == JpegConstants.Markers.Adobe.E; + bool isAdobe = this.temp[0] == PdfJsJpegConstants.Markers.Adobe.A && + this.temp[1] == PdfJsJpegConstants.Markers.Adobe.D && + this.temp[2] == PdfJsJpegConstants.Markers.Adobe.O && + this.temp[3] == PdfJsJpegConstants.Markers.Adobe.B && + this.temp[4] == PdfJsJpegConstants.Markers.Adobe.E; if (isAdobe) { - this.adobe = new Adobe + this.adobe = new PdfJsAdobe { DCTEncodeVersion = (short)((this.temp[5] << 8) | this.temp[6]), APP14Flags0 = (short)((this.temp[7] << 8) | this.temp[8]), @@ -588,7 +588,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort Span tableSpan = this.quantizationTables.Tables.GetRowSpan(quantizationTableSpec & 15); for (int j = 0; j < 64; j++) { - tableSpan[QuantizationTables.DctZigZag[j]] = this.temp[j]; + tableSpan[PdfJsQuantizationTables.DctZigZag[j]] = this.temp[j]; } } @@ -608,7 +608,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort Span tableSpan = this.quantizationTables.Tables.GetRowSpan(quantizationTableSpec & 15); for (int j = 0; j < 64; j++) { - tableSpan[QuantizationTables.DctZigZag[j]] = (short)((this.temp[2 * j] << 8) | this.temp[(2 * j) + 1]); + tableSpan[PdfJsQuantizationTables.DctZigZag[j]] = (short)((this.temp[2 * j] << 8) | this.temp[(2 * j) + 1]); } } @@ -634,7 +634,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// The remaining bytes in the segment block. /// The current frame marker. - private void ProcessStartOfFrameMarker(int remaining, FileMarker frameMarker) + private void ProcessStartOfFrameMarker(int remaining, PdfJsFileMarker frameMarker) { if (this.Frame != null) { @@ -643,10 +643,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort this.InputStream.Read(this.temp, 0, remaining); - this.Frame = new Frame + this.Frame = new PdfJsFrame { - Extended = frameMarker.Marker == JpegConstants.Markers.SOF1, - Progressive = frameMarker.Marker == JpegConstants.Markers.SOF2, + Extended = frameMarker.Marker == PdfJsJpegConstants.Markers.SOF1, + Progressive = frameMarker.Marker == PdfJsJpegConstants.Markers.SOF2, Precision = this.temp[0], Scanlines = (short)((this.temp[1] << 8) | this.temp[2]), SamplesPerLine = (short)((this.temp[3] << 8) | this.temp[4]), @@ -659,7 +659,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort // No need to pool this. They max out at 4 this.Frame.ComponentIds = new byte[this.Frame.ComponentCount]; - this.Frame.Components = new FrameComponent[this.Frame.ComponentCount]; + this.Frame.Components = new PdfJsFrameComponent[this.Frame.ComponentCount]; for (int i = 0; i < this.Frame.Components.Length; i++) { @@ -676,7 +676,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort maxV = v; } - var component = new FrameComponent(this.Frame, this.temp[index], h, v, this.temp[index + 2]); + var component = new PdfJsFrameComponent(this.Frame, this.temp[index], h, v, this.temp[index + 2]); this.Frame.Components[i] = component; this.Frame.ComponentIds[i] = component.Id; @@ -775,7 +775,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort throw new ImageFormatException("Unknown component selector"); } - ref FrameComponent component = ref this.Frame.Components[componentIndex]; + ref PdfJsFrameComponent component = ref this.Frame.Components[componentIndex]; int tableSpec = this.InputStream.ReadByte(); component.DCHuffmanTableId = tableSpec >> 4; component.ACHuffmanTableId = tableSpec & 15; @@ -786,7 +786,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort int spectralStart = this.temp[0]; int spectralEnd = this.temp[1]; int successiveApproximation = this.temp[2]; - var scanDecoder = default(ScanDecoder); + var scanDecoder = default(PdfJsScanDecoder); scanDecoder.DecodeScan( this.Frame, @@ -808,7 +808,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// /// The component /// The frame component - private void QuantizeAndInverseComponentData(Component component, FrameComponent frameComponent) + private void QuantizeAndInverseComponentData(PdfJsComponent component, PdfJsFrameComponent frameComponent) { int blocksPerLine = component.BlocksPerLine; int blocksPerColumn = component.BlocksPerColumn; @@ -834,7 +834,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort for (int blockCol = 0; blockCol < blocksPerLine; blockCol++) { int offset = GetBlockBufferOffset(ref component, blockRow, blockCol); - IDCT.QuantizeAndInverse(frameComponent, offset, ref computationBufferSpan, ref quantizationTable); + PdfJsIDCT.QuantizeAndInverse(frameComponent, offset, ref computationBufferSpan, ref quantizationTable); } } } @@ -849,9 +849,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort /// The table index /// The codelengths /// The values - private void BuildHuffmanTable(HuffmanTables tables, int index, byte[] codeLengths, byte[] values) + private void BuildHuffmanTable(PdfJsHuffmanTables tables, int index, byte[] codeLengths, byte[] values) { - tables[index] = new HuffmanTable(codeLengths, values); + tables[index] = new PdfJsHuffmanTable(codeLengths, values); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -887,7 +887,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort ref byte cb = ref areaRowSpan[o + 1]; ref byte cr = ref areaRowSpan[o + 2]; ref TPixel pixel = ref imageRowSpan[x]; - YCbCrToRgbTables.PackYCbCr(ref pixel, yy, cb, cr); + PdfJsYCbCrToRgbTables.PackYCbCr(ref pixel, yy, cb, cr); } } } @@ -908,7 +908,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort ref byte k = ref areaRowSpan[o + 3]; ref TPixel pixel = ref imageRowSpan[x]; - YCbCrToRgbTables.PackYccK(ref pixel, yy, cb, cr, k); + PdfJsYCbCrToRgbTables.PackYccK(ref pixel, yy, cb, cr, k); } } } diff --git a/tests/ImageSharp.Benchmarks/Image/DecodeJpegMultiple.cs b/tests/ImageSharp.Benchmarks/Image/DecodeJpegMultiple.cs index 102861a45..ce2762eb1 100644 --- a/tests/ImageSharp.Benchmarks/Image/DecodeJpegMultiple.cs +++ b/tests/ImageSharp.Benchmarks/Image/DecodeJpegMultiple.cs @@ -65,7 +65,7 @@ namespace SixLabors.ImageSharp.Benchmarks.Image { Guard.NotNull(stream, "stream"); - using (var decoder = new OldJpegDecoderCore(configuration, this)) + using (var decoder = new OrigJpegDecoderCore(configuration, this)) { return decoder.Decode(stream); } diff --git a/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs index 40a3895ad..ca9b62639 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/DCTTests.cs @@ -26,7 +26,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] sourceArray = JpegUtilityTestFixture.Create8x8FloatData(); float[] expectedDestArray = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.iDCT2D8x4_32f(sourceArray, expectedDestArray); + ReferenceImplementations.LLM_FloatingPoint_DCT.iDCT2D8x4_32f(sourceArray, expectedDestArray); Block8x8F source = new Block8x8F(); source.LoadFrom(sourceArray); @@ -51,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] sourceArray = JpegUtilityTestFixture.Create8x8FloatData(); float[] expectedDestArray = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.iDCT2D8x4_32f(sourceArray.AsSpan().Slice(4), expectedDestArray.AsSpan().Slice(4)); + ReferenceImplementations.LLM_FloatingPoint_DCT.iDCT2D8x4_32f(sourceArray.AsSpan().Slice(4), expectedDestArray.AsSpan().Slice(4)); Block8x8F source = new Block8x8F(); source.LoadFrom(sourceArray); @@ -80,7 +80,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] expectedDestArray = new float[64]; float[] tempArray = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.iDCT2D_llm(sourceArray, expectedDestArray, tempArray); + ReferenceImplementations.LLM_FloatingPoint_DCT.iDCT2D_llm(sourceArray, expectedDestArray, tempArray); // ReferenceImplementations.iDCT8x8_llm_sse(sourceArray, expectedDestArray, tempArray); Block8x8F source = new Block8x8F(); @@ -115,7 +115,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] expectedDest = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.fDCT2D8x4_32f(src, expectedDest); + ReferenceImplementations.LLM_FloatingPoint_DCT.fDCT2D8x4_32f(src, expectedDest); FastFloatingPointDCT.FDCT8x4_LeftPart(ref srcBlock, ref destBlock); float[] actualDest = new float[64]; @@ -137,7 +137,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] expectedDest = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.fDCT2D8x4_32f(src.Slice(4), expectedDest.AsSpan().Slice(4)); + ReferenceImplementations.LLM_FloatingPoint_DCT.fDCT2D8x4_32f(src.Slice(4), expectedDest.AsSpan().Slice(4)); FastFloatingPointDCT.FDCT8x4_RightPart(ref srcBlock, ref destBlock); float[] actualDest = new float[64]; @@ -161,7 +161,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] temp1 = new float[64]; Block8x8F temp2 = new Block8x8F(); - ReferenceImplementations.FastFloatingPointDCT.fDCT2D_llm(src, expectedDest, temp1, downscaleBy8: true); + ReferenceImplementations.LLM_FloatingPoint_DCT.fDCT2D_llm(src, expectedDest, temp1, downscaleBy8: true); FastFloatingPointDCT.TransformFDCT(ref srcBlock, ref destBlock, ref temp2, false); float[] actualDest = new float[64]; diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs index 9bbb2558b..435e846cc 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs @@ -55,7 +55,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg private ITestOutputHelper Output { get; } - private static IImageDecoder OldJpegDecoder => new OldJpegDecoder(); + private static IImageDecoder OldJpegDecoder => new OrigJpegDecoder(); private static IImageDecoder PdfJsJpegDecoder => new JpegDecoder(); @@ -65,7 +65,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg byte[] bytes = TestFile.Create(TestImages.Jpeg.Progressive.Progress).Bytes; using (var ms = new MemoryStream(bytes)) { - var decoder = new OldJpegDecoderCore(Configuration.Default, new JpegDecoder()); + var decoder = new OrigJpegDecoderCore(Configuration.Default, new JpegDecoder()); decoder.ParseStream(ms); VerifyJpeg.Components3(decoder.Components, 43, 61, 22, 31, 22, 31); @@ -78,7 +78,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg byte[] bytes = TestFile.Create(TestImages.Jpeg.Progressive.Progress).Bytes; using (var ms = new MemoryStream(bytes)) { - var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); + var decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); decoder.ParseStream(ms); VerifyJpeg.Components3(decoder.Frame.Components, 43, 61, 22, 31, 22, 31); diff --git a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs index 034d5efd7..19b81668c 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs @@ -22,23 +22,23 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(42, 0)] [InlineData(1, 0)] [InlineData(2, 0)] - public void ForwardThenInverse(int seed, int startAt) + public void LLM_ForwardThenInverse(int seed, int startAt) { int[] data = JpegUtilityTestFixture.Create8x8RandomIntData(-1000, 1000, seed); float[] src = data.ConvertAllToFloat(); float[] dest = new float[64]; float[] temp = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.fDCT2D_llm(src, dest, temp, true); - ReferenceImplementations.FastFloatingPointDCT.iDCT2D_llm(dest, src, temp); + ReferenceImplementations.LLM_FloatingPoint_DCT.fDCT2D_llm(src, dest, temp, true); + ReferenceImplementations.LLM_FloatingPoint_DCT.iDCT2D_llm(dest, src, temp); this.CompareBlocks(data.ConvertAllToFloat(), src, 2f); } // [Fact] - public void CalcConstants() + public void LLM_CalcConstants() { - ReferenceImplementations.FastFloatingPointDCT.PrintConstants(this.Output); + ReferenceImplementations.LLM_FloatingPoint_DCT.PrintConstants(this.Output); } [Theory] @@ -48,7 +48,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(42, 200)] [InlineData(1, 200)] [InlineData(2, 200)] - public void IDCT_IsEquivalentTo_AccurateImplementation(int seed, int range) + public void LLM_IDCT_IsEquivalentTo_AccurateImplementation(int seed, int range) { int[] intData = JpegUtilityTestFixture.Create8x8RandomIntData(-range, range, seed); float[] floatSrc = intData.ConvertAllToFloat(); @@ -58,7 +58,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg float[] dest = new float[64]; float[] temp = new float[64]; - ReferenceImplementations.FastFloatingPointDCT.iDCT2D_llm(floatSrc, dest, temp); + ReferenceImplementations.LLM_FloatingPoint_DCT.iDCT2D_llm(floatSrc, dest, temp); this.CompareBlocks(intData.ConvertAllToFloat(), dest, 1f); } @@ -67,7 +67,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg [InlineData(42)] [InlineData(1)] [InlineData(2)] - public void FDCT_IsEquivalentTo_AccurateImplementation(int seed) + public void LLM_FDCT_IsEquivalentTo_AccurateImplementation(int seed) { float[] floatData = JpegUtilityTestFixture.Create8x8RandomFloatData(-1000, 1000); @@ -75,13 +75,32 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg source.LoadFrom(floatData); Block8x8F expected = ReferenceImplementations.AccurateDCT.TransformFDCT(ref source); - Block8x8F actual = ReferenceImplementations.FastFloatingPointDCT.TransformFDCT_UpscaleBy8(ref source); + Block8x8F actual = ReferenceImplementations.LLM_FloatingPoint_DCT.TransformFDCT_UpscaleBy8(ref source); actual /= 8; this.CompareBlocks(expected, actual, 1f); } + [Theory] + [InlineData(42, 1000)] + [InlineData(1, 1000)] + [InlineData(2, 1000)] + [InlineData(42, 200)] + [InlineData(1, 200)] + [InlineData(2, 200)] + public void GT_IDCT_IsEquivalentTo_AccurateImplementation(int seed, int range) + { + int[] intData = JpegUtilityTestFixture.Create8x8RandomIntData(-range, range, seed); + float[] floatSrc = intData.ConvertAllToFloat(); + + ReferenceImplementations.AccurateDCT.TransformIDCTInplace(intData); + float[] dest = new float[64]; + + ReferenceImplementations.GT_FloatingPoint_DCT.iDCT8x8GT(floatSrc, dest); + + this.CompareBlocks(intData.ConvertAllToFloat(), dest, 1f); + } } } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs index ad6182d22..67465c16a 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs @@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg public void PdfJsDecoder_ParseStream_SaveSpectralResult(TestImageProvider provider) where TPixel : struct, IPixel { - JpegDecoderCore decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); + PdfJsJpegDecoderCore decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; @@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg public void OriginalDecoder_ParseStream_SaveSpectralResult(TestImageProvider provider) where TPixel : struct, IPixel { - OldJpegDecoderCore decoder = new OldJpegDecoderCore(Configuration.Default, new JpegDecoder()); + OrigJpegDecoderCore decoder = new OrigJpegDecoderCore(Configuration.Default, new JpegDecoder()); byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; @@ -125,7 +125,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg public void VerifySpectralCorrectness_PdfJs(TestImageProvider provider) where TPixel : struct, IPixel { - JpegDecoderCore decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder()); + PdfJsJpegDecoderCore decoder = new PdfJsJpegDecoderCore(Configuration.Default, new JpegDecoder()); byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; @@ -143,7 +143,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg public void VerifySpectralResults_OriginalDecoder(TestImageProvider provider) where TPixel : struct, IPixel { - OldJpegDecoderCore decoder = new OldJpegDecoderCore(Configuration.Default, new JpegDecoder()); + OrigJpegDecoderCore decoder = new OrigJpegDecoderCore(Configuration.Default, new JpegDecoder()); byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes; diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs index 5798491ff..37fe4820c 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs @@ -43,7 +43,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils this.Blocks[x, y] = new Block8x8(data); } - public static ComponentData Load(FrameComponent c, int index) + public static ComponentData Load(PdfJsFrameComponent c, int index) { var result = new ComponentData( c.BlocksPerColumnForMcu, @@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils return result; } - public static ComponentData Load(OldComponent c) + public static ComponentData Load(OrigComponent c) { var result = new ComponentData( c.HeightInBlocks, diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs index 39465a69d..327d3f338 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs @@ -24,17 +24,17 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils this.Components = components; } - public static SpectralData LoadFromImageSharpDecoder(JpegDecoderCore decoder) + public static SpectralData LoadFromImageSharpDecoder(PdfJsJpegDecoderCore decoder) { - FrameComponent[] srcComponents = decoder.Frame.Components; + PdfJsFrameComponent[] srcComponents = decoder.Frame.Components; LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray(); return new SpectralData(destComponents); } - public static SpectralData LoadFromImageSharpDecoder(OldJpegDecoderCore decoder) + public static SpectralData LoadFromImageSharpDecoder(OrigJpegDecoderCore decoder) { - OldComponent[] srcComponents = decoder.Components; + OrigComponent[] srcComponents = decoder.Components; LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray(); return new SpectralData(destComponents); diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.GT_FloatingPoint_DCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.GT_FloatingPoint_DCT.cs new file mode 100644 index 000000000..2e2f12fbc --- /dev/null +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.GT_FloatingPoint_DCT.cs @@ -0,0 +1,69 @@ +// ReSharper disable InconsistentNaming + +namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils +{ + using System; + + internal static partial class ReferenceImplementations + { + /// + /// Non-optimized method ported from: + /// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L446 + /// + /// *** Paper *** + /// Plonka, Gerlind, and Manfred Tasche. "Fast and numerically stable algorithms for discrete cosine transforms." Linear algebra and its applications 394 (2005) : 309 - 345. + /// + internal static class GT_FloatingPoint_DCT + { + public static void idct81d_GT(Span src, Span dst) + { + for (int i = 0; i < 8; i++) + { + float mx00 = 1.4142135623731f * src[0]; + float mx01 = 1.38703984532215f * src[1] + 0.275899379282943f * src[7]; + float mx02 = 1.30656296487638f * src[2] + 0.541196100146197f * src[6]; + float mx03 = 1.17587560241936f * src[3] + 0.785694958387102f * src[5]; + float mx04 = 1.4142135623731f * src[4]; + float mx05 = -0.785694958387102f * src[3] + 1.17587560241936f * src[5]; + float mx06 = 0.541196100146197f * src[2] - 1.30656296487638f * src[6]; + float mx07 = -0.275899379282943f * src[1] + 1.38703984532215f * src[7]; + float mx09 = mx00 + mx04; + float mx0a = mx01 + mx03; + float mx0b = 1.4142135623731f * mx02; + float mx0c = mx00 - mx04; + float mx0d = mx01 - mx03; + float mx0e = 0.353553390593274f * (mx09 - mx0b); + float mx0f = 0.353553390593274f * (mx0c + mx0d); + float mx10 = 0.353553390593274f * (mx0c - mx0d); + float mx11 = 1.4142135623731f * mx06; + float mx12 = mx05 + mx07; + float mx13 = mx05 - mx07; + float mx14 = 0.353553390593274f * (mx11 + mx12); + float mx15 = 0.353553390593274f * (mx11 - mx12); + float mx16 = 0.5f * mx13; + dst[0] = 0.25f * (mx09 + mx0b) + 0.353553390593274f * mx0a; + dst[1] = 0.707106781186547f * (mx0f + mx15); + dst[2] = 0.707106781186547f * (mx0f - mx15); + dst[3] = 0.707106781186547f * (mx0e + mx16); + dst[4] = 0.707106781186547f * (mx0e - mx16); + dst[5] = 0.707106781186547f * (mx10 - mx14); + dst[6] = 0.707106781186547f * (mx10 + mx14); + dst[7] = 0.25f * (mx09 + mx0b) - 0.353553390593274f * mx0a; + dst = dst.Slice(8); + src = src.Slice(8); + } + } + + public static void iDCT8x8GT(Span s, Span d) + { + idct81d_GT(s, d); + + Transpose8x8(d); + + idct81d_GT(d, d); + + Transpose8x8(d); + } + } + } +} \ No newline at end of file diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.FastFloatingPointDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs similarity index 97% rename from tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.FastFloatingPointDCT.cs rename to tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs index ddfb75517..eeb9aacb4 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.FastFloatingPointDCT.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.LLM_FloatingPoint_DCT.cs @@ -13,14 +13,20 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils internal static partial class ReferenceImplementations { /// - /// Contains a non-optimized port of: + /// Contains port of non-optimized methods in: /// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp /// + /// *** Paper *** + /// paper LLM89 + /// C. Loeffler, A. Ligtenberg, and G. S. Moschytz, + /// "Practical fast 1-D DCT algorithms with 11 multiplications," + /// Proc. Int'l. Conf. on Acoustics, Speech, and Signal Processing (ICASSP89), pp. 988-991, 1989. + /// /// The main purpose of this code is testing and documentation, it is intented to be similar to it's original counterpart. /// DO NOT clean it! /// DO NOT StyleCop it! /// - internal static class FastFloatingPointDCT + internal static class LLM_FloatingPoint_DCT { public static Block8x8F TransformIDCT(ref Block8x8F source) { @@ -137,14 +143,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils iDCT1Dllm_32f(s.Slice(j * 8), temp.Slice(j * 8)); } - ReferenceImplementations.Transpose8x8(temp, d); + Transpose8x8(temp, d); for (j = 0; j < 8; j++) { iDCT1Dllm_32f(d.Slice(j * 8), temp.Slice(j * 8)); } - ReferenceImplementations.Transpose8x8(temp, d); + Transpose8x8(temp, d); for (j = 0; j < 64; j++) { diff --git a/tests/ImageSharp.Tests/Formats/Jpg/YCbCrImageTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/YCbCrImageTests.cs index 79e00711a..d1a5376c2 100644 --- a/tests/ImageSharp.Tests/Formats/Jpg/YCbCrImageTests.cs +++ b/tests/ImageSharp.Tests/Formats/Jpg/YCbCrImageTests.cs @@ -63,7 +63,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg Assert.Equal(img.CrChannel.Width, 400 / expectedCStrideDiv); } - private void PrintChannel(string name, OldJpegPixelArea channel) + private void PrintChannel(string name, OrigJpegPixelArea channel) { this.Output.WriteLine($"{name}: Stride={channel.Stride}"); }