Postfixing: Orig*** instead of Old** + introducing PdfJs*** again

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 <see cref="OldDecoderErrorCode"/> instead.
+        /// This method does not throw. Returns <see cref="OrigDecoderErrorCode"/> instead.
         /// </summary>
         /// <param name="n">The number of bits to ensure.</param>
         /// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
         /// <returns>Error code</returns>
-        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 <see cref="EnsureNBitsUnsafe"/> for n==8
         /// </summary>
         /// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
-        /// <returns>A <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode Ensure8BitsUnsafe(ref InputProcessor inputProcessor)
+        /// <returns>A <see cref="OrigDecoderErrorCode"/></returns>
+        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 <see cref="EnsureNBitsUnsafe"/> for n==1
         /// </summary>
         /// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
-        /// <returns>A <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode Ensure1BitUnsafe(ref InputProcessor inputProcessor)
+        /// <returns>A <see cref="OrigDecoderErrorCode"/></returns>
+        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
         /// <param name="t">Byte</param>
         /// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
         /// <param name="x">Read bits value</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode ReceiveExtendUnsafe(int t, ref InputProcessor inputProcessor, out int x)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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;
             }

src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/Bytes.cs

@@ -85,8 +85,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// </summary>
         /// <param name="inputStream">Input stream</param>
         /// <param name="x">The result byte as <see cref="int"/></param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode ReadByteStuffedByteUnsafe(Stream inputStream, out int x)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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;
         }
 
         /// <summary>
@@ -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;
         }
 
         /// <summary>
         /// 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 <see cref="OldDecoderErrorCode"/> instead.
+        /// This method does not throw on format error, it returns a <see cref="OrigDecoderErrorCode"/> instead.
         /// </summary>
         /// <param name="inputStream">Input stream</param>
         /// <param name="result">The result <see cref="byte"/> as out parameter</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode ReadByteUnsafe(Stream inputStream, out byte result)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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
         /// </summary>
         /// <param name="inputStream">The input stream</param>
         /// <param name="result">The result <see cref="int"/></param>
-        /// <returns>A <see cref="OldDecoderErrorCode"/></returns>
+        /// <returns>A <see cref="OrigDecoderErrorCode"/></returns>
         [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();
         }
 
         /// <summary>
         /// 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 <see cref="EOFException"/>, returns a <see cref="OldDecoderErrorCode"/> instead!
+        /// This method does not throw <see cref="EOFException"/>, returns a <see cref="OrigDecoderErrorCode"/> instead!
         /// </summary>
         /// <param name="inputStream">Input stream</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode FillUnsafe(Stream inputStream)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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;
         }
     }
 }

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
     {
         /// <summary>
-        /// Throws an exception that belongs to the given <see cref="OldDecoderErrorCode"/>
+        /// Throws an exception that belongs to the given <see cref="OrigDecoderErrorCode"/>
         /// </summary>
-        /// <param name="errorCode">The <see cref="OldDecoderErrorCode"/></param>
+        /// <param name="errorCode">The <see cref="OrigDecoderErrorCode"/></param>
         [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
         }
 
         /// <summary>
-        /// Throws an exception if the given <see cref="OldDecoderErrorCode"/> defines an error.
+        /// Throws an exception if the given <see cref="OrigDecoderErrorCode"/> defines an error.
         /// </summary>
-        /// <param name="errorCode">The <see cref="OldDecoderErrorCode"/></param>
+        /// <param name="errorCode">The <see cref="OrigDecoderErrorCode"/></param>
         [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);
             }
         }
 
         /// <summary>
-        /// Throws an exception if the given <see cref="OldDecoderErrorCode"/> is <see cref="OldDecoderErrorCode.UnexpectedEndOfStream"/>.
+        /// Throws an exception if the given <see cref="OrigDecoderErrorCode"/> is <see cref="OrigDecoderErrorCode.UnexpectedEndOfStream"/>.
         /// </summary>
-        /// <param name="errorCode">The <see cref="OldDecoderErrorCode"/></param>
+        /// <param name="errorCode">The <see cref="OrigDecoderErrorCode"/></param>
         [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();
             }

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
 {
     /// <summary>
-    /// Encapsulates stream reading and processing data and operations for <see cref="OldJpegDecoderCore"/>.
+    /// Encapsulates stream reading and processing data and operations for <see cref="OrigJpegDecoderCore"/>.
     /// It's a value type for imporved data locality, and reduced number of CALLVIRT-s
     /// </summary>
     internal struct InputProcessor : IDisposable
@@ -27,7 +27,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// Initializes a new instance of the <see cref="InputProcessor"/> struct.
         /// </summary>
         /// <param name="inputStream">The input <see cref="Stream"/></param>
-        /// <param name="temp">Temporal buffer, same as <see cref="OldJpegDecoderCore.Temp"/></param>
+        /// <param name="temp">Temporal buffer, same as <see cref="OrigJpegDecoderCore.Temp"/></param>
         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; }
 
         /// <summary>
-        /// Gets the temporal buffer, same instance as <see cref="OldJpegDecoderCore.Temp"/>
+        /// Gets the temporal buffer, same instance as <see cref="OrigJpegDecoderCore.Temp"/>
         /// </summary>
         public byte[] Temp { get; }
 
@@ -56,11 +56,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// If errorCode indicates unexpected EOF, sets <see cref="UnexpectedEndOfStreamReached"/> to true and returns false.
         /// Calls <see cref="DecoderThrowHelper.EnsureNoError"/> and returns true otherwise.
         /// </summary>
-        /// <param name="errorCode">The <see cref="OldDecoderErrorCode"/></param>
+        /// <param name="errorCode">The <see cref="OrigDecoderErrorCode"/></param>
         /// <returns><see cref="bool"/> indicating whether everything is OK</returns>
-        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 <see cref="UnexpectedEndOfStreamReached"/> to true and returns false.
         /// Returns true otherwise.
         /// </summary>
-        /// <param name="errorCode">The <see cref="OldDecoderErrorCode"/></param>
+        /// <param name="errorCode">The <see cref="OrigDecoderErrorCode"/></param>
         /// <returns><see cref="bool"/> indicating whether everything is OK</returns>
-        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!
         /// </summary>
         /// <param name="result">The decoded bit as a <see cref="bool"/></param>
-        /// <returns>The <see cref="OldDecoderErrorCode" /></returns>
-        public OldDecoderErrorCode DecodeBitUnsafe(out bool result)
+        /// <returns>The <see cref="OrigDecoderErrorCode" /></returns>
+        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;
         }
 
         /// <summary>
         /// Reads exactly length bytes into data. It does not care about byte stuffing.
-        /// Does not throw on errors, returns <see cref="OldJpegDecoderCore"/> instead!
+        /// Does not throw on errors, returns <see cref="OrigJpegDecoderCore"/> instead!
         /// </summary>
         /// <param name="data">The data to write to.</param>
         /// <param name="offset">The offset in the source buffer</param>
         /// <param name="length">The number of bytes to read</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode ReadFullUnsafe(byte[] data, int offset, int length)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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
         /// </summary>
         /// <param name="count">The number of bits to decode.</param>
         /// <param name="result">The <see cref="uint" /> result</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode DecodeBitsUnsafe(int count, out int result)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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;
         }
 
         /// <summary>
@@ -198,8 +198,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// </summary>
         /// <param name="huffmanTree">The huffman value</param>
         /// <param name="result">The decoded <see cref="byte" /></param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode DecodeHuffmanUnsafe(ref OldHuffmanTree huffmanTree, out int result)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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;
         }
 
         /// <summary>
@@ -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();
         }
 
         /// <summary>
         /// Skips the next n bytes.
-        /// Does not throw, returns <see cref="OldDecoderErrorCode"/> instead!
+        /// Does not throw, returns <see cref="OrigDecoderErrorCode"/> instead!
         /// </summary>
         /// <param name="count">The number of bytes to ignore.</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode SkipUnsafe(int count)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        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;
         }
 
         /// <summary>
@@ -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
         /// </summary>
         /// <param name="t">Byte</param>
         /// <param name="x">Read bits value</param>
-        /// <returns>The <see cref="OldDecoderErrorCode"/></returns>
-        public OldDecoderErrorCode ReceiveExtendUnsafe(int t, out int x)
+        /// <returns>The <see cref="OrigDecoderErrorCode"/></returns>
+        public OrigDecoderErrorCode ReceiveExtendUnsafe(int t, out int x)
         {
             return this.Bits.ReceiveExtendUnsafe(t, ref this, out x);
         }

src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/JpegBlockProcessor.cs

@@ -42,12 +42,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         }
 
         /// <summary>
-        /// Dequantize, perform the inverse DCT and store the blocks to the into the corresponding <see cref="OldJpegPixelArea"/> instances.
+        /// Dequantize, perform the inverse DCT and store the blocks to the into the corresponding <see cref="OrigJpegPixelArea"/> instances.
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/> instance</param>
-        public void ProcessAllBlocks(OldJpegDecoderCore decoder)
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/> instance</param>
+        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
         }
 
         /// <summary>
-        /// Dequantize, perform the inverse DCT and store decodedBlock.Block to the into the corresponding <see cref="OldJpegPixelArea"/> instance.
+        /// Dequantize, perform the inverse DCT and store decodedBlock.Block to the into the corresponding <see cref="OrigJpegPixelArea"/> instance.
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/></param>
-        /// <param name="component">The <see cref="OldComponent"/></param>
-        /// <param name="bx">The x index of the block in <see cref="OldComponent.SpectralBlocks"/></param>
-        /// <param name="by">The y index of the block in <see cref="OldComponent.SpectralBlocks"/></param>
-        private void ProcessBlockColors(OldJpegDecoderCore decoder, OldComponent component, int bx, int by)
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/></param>
+        /// <param name="component">The <see cref="OrigComponent"/></param>
+        /// <param name="bx">The x index of the block in <see cref="OrigComponent.SpectralBlocks"/></param>
+        /// <param name="by">The y index of the block in <see cref="OrigComponent.SpectralBlocks"/></param>
+        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);
         }
 

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;
-
     /// <summary>
     /// Represents a single color component
     /// </summary>
-    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; }
 
         /// <summary>
-        /// Gets the component's position in <see cref="OldJpegDecoderCore.Components"/>
+        /// Gets the component's position in <see cref="OrigJpegDecoderCore.Components"/>
         /// </summary>
         public int Index { get; }
 
@@ -47,8 +46,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// <summary>
         /// Gets the <see cref="Buffer{T}"/> 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 <see cref="OldJpegDecoderCore.ProcessBlocksIntoJpegImageChannels{TPixel}"/>.
-        /// When <see cref="OldJpegDecoderCore.IsProgressive"/> us true, we are touching these blocks multiple times - each time we process a Scan.
+        /// This is done by <see cref="OrigJpegDecoderCore.ProcessBlocksIntoJpegImageChannels{TPixel}"/>.
+        /// When <see cref="OrigJpegDecoderCore.IsProgressive"/> us true, we are touching these blocks multiple times - each time we process a Scan.
         /// </summary>
         public Buffer2D<Block8x8> SpectralBlocks { get; private set; }
 
@@ -70,8 +69,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// <summary>
         /// Initializes <see cref="SpectralBlocks"/>
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/> instance</param>
-        public void InitializeBlocks(OldJpegDecoderCore decoder)
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/> instance</param>
+        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
         /// <summary>
         /// Initializes all component data except <see cref="SpectralBlocks"/>.
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/> instance</param>
-        public void InitializeData(OldJpegDecoderCore decoder)
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/> instance</param>
+        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");
             }

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
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
-    internal struct OldComponentScan
+    internal struct OrigComponentScan
     {
         /// <summary>
         /// Gets or sets the component index.

src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldDecoderErrorCode.cs

@@ -6,7 +6,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
     /// <summary>
     /// Represents "recoverable" decoder errors.
     /// </summary>
-    internal enum OldDecoderErrorCode
+    internal enum OrigDecoderErrorCode
     {
         /// <summary>
         /// NoError

src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldHuffmanTree.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
     /// <summary>
     /// Represents a Huffman tree
     /// </summary>
-    internal struct OldHuffmanTree : IDisposable
+    internal struct OrigHuffmanTree : IDisposable
     {
         /// <summary>
         /// The index of the AC table row
@@ -98,12 +98,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         private static readonly ArrayPool<int> CodesPool16 = ArrayPool<int>.Create(MaxCodeLength, 50);
 
         /// <summary>
-        /// Creates and initializes an array of <see cref="OldHuffmanTree" /> instances of size <see cref="NumberOfTrees" />
+        /// Creates and initializes an array of <see cref="OrigHuffmanTree" /> instances of size <see cref="NumberOfTrees" />
         /// </summary>
-        /// <returns>An array of <see cref="OldHuffmanTree" /> instances representing the Huffman tables</returns>
-        public static OldHuffmanTree[] CreateHuffmanTrees()
+        /// <returns>An array of <see cref="OrigHuffmanTree" /> instances representing the Huffman tables</returns>
+        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++)

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;
-
     /// <summary>
     /// Represents an area of a Jpeg subimage (channel)
     /// </summary>
-    internal struct OldJpegPixelArea
+    internal struct OrigJpegPixelArea
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="OldJpegPixelArea" /> struct from existing data.
+        /// Initializes a new instance of the <see cref="OrigJpegPixelArea" /> struct from existing data.
         /// </summary>
         /// <param name="pixels">The pixel buffer</param>
         /// <param name="stride">The stride</param>
         /// <param name="offset">The offset</param>
-        public OldJpegPixelArea(Buffer2D<byte> pixels, int stride, int offset)
+        public OrigJpegPixelArea(Buffer2D<byte> pixels, int stride, int offset)
         {
             this.Stride = stride;
             this.Pixels = pixels;
@@ -29,11 +27,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="OldJpegPixelArea" /> struct from existing buffer.
+        /// Initializes a new instance of the <see cref="OrigJpegPixelArea" /> struct from existing buffer.
         /// <see cref="Stride"/> will be set to <see cref="Buffer2D{T}.Width"/> of <paramref name="pixels"/> and <see cref="Offset"/> will be set to 0.
         /// </summary>
         /// <param name="pixels">The pixel buffer</param>
-        public OldJpegPixelArea(Buffer2D<byte> pixels)
+        public OrigJpegPixelArea(Buffer2D<byte> pixels)
             : this(pixels, pixels.Width, 0)
         {
         }
@@ -84,10 +82,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
         /// <param name="bx">The block X index</param>
         /// <param name="by">The block Y index</param>
         /// <returns>The subarea offseted by block indices</returns>
-        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);
         }
 
         /// <summary>

src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.ComputationData.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
     /// <content>
     /// Conains the definition of <see cref="ComputationData"/>
     /// </content>
-    internal unsafe partial struct OldJpegScanDecoder
+    internal unsafe partial struct OrigJpegScanDecoder
     {
         /// <summary>
         /// Holds the "large" data blocks needed for computations.
@@ -29,14 +29,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
             public UnzigData Unzig;
 
             /// <summary>
-            /// The buffer storing the <see cref="OldComponentScan"/>-s for each component
+            /// The buffer storing the <see cref="OrigComponentScan"/>-s for each component
             /// </summary>
-            public fixed byte ScanData[3 * OldJpegDecoderCore.MaxComponents];
+            public fixed byte ScanData[3 * OrigJpegDecoderCore.MaxComponents];
 
             /// <summary>
             /// The DC values for each component
             /// </summary>
-            public fixed int Dc[OldJpegDecoderCore.MaxComponents];
+            public fixed int Dc[OrigJpegDecoderCore.MaxComponents];
 
             /// <summary>
             /// Creates and initializes a new <see cref="ComputationData"/> instance

src/ImageSharp/Formats/Jpeg/GolangPort/Components/Decoder/OldJpegScanDecoder.DataPointers.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
     /// <content>
     /// Conains the definition of <see cref="DataPointers"/>
     /// </content>
-    internal unsafe partial struct OldJpegScanDecoder
+    internal unsafe partial struct OrigJpegScanDecoder
     {
         /// <summary>
         /// Contains pointers to the memory regions of <see cref="ComputationData"/> so they can be easily passed around to pointer based utility methods of <see cref="Block8x8F"/>
@@ -30,7 +30,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder
             /// <summary>
             /// Pointer to <see cref="ComputationData.ScanData"/> as Scan*
             /// </summary>
-            public OldComponentScan* ComponentScan;
+            public OrigComponentScan* ComponentScan;
 
             /// <summary>
             /// Pointer to <see cref="ComputationData.Dc"/>
@@ -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;
             }
         }

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.
     /// </summary>
     [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;
 
         /// <summary>
-        /// Initializes a default-constructed <see cref="OldJpegScanDecoder"/> instance for reading data from <see cref="OldJpegDecoderCore"/>-s stream.
+        /// Initializes a default-constructed <see cref="OrigJpegScanDecoder"/> instance for reading data from <see cref="OrigJpegDecoderCore"/>-s stream.
         /// </summary>
-        /// <param name="p">Pointer to <see cref="OldJpegScanDecoder"/> on the stack</param>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/> instance</param>
+        /// <param name="p">Pointer to <see cref="OrigJpegScanDecoder"/> on the stack</param>
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/> instance</param>
         /// <param name="remaining">The remaining bytes in the segment block.</param>
-        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
         }
 
         /// <summary>
-        /// Read Huffman data from Jpeg scans in <see cref="OldJpegDecoderCore.InputStream"/>,
-        /// and decode it as <see cref="Block8x8F"/> into <see cref="OldJpegDecoderCore.DecodedBlocks"/>.
+        /// Read Huffman data from Jpeg scans in <see cref="OrigJpegDecoderCore.InputStream"/>,
+        /// and decode it as <see cref="Block8x8F"/> into <see cref="OrigJpegDecoderCore.DecodedBlocks"/>.
         ///
         /// 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
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/> instance</param>
-        public void DecodeBlocks(OldJpegDecoderCore decoder)
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/> instance</param>
+        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);
         }
 
         /// <summary>
         /// The implementation part of <see cref="InitStreamReading"/> as an instance method.
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/></param>
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/></param>
         /// <param name="remaining">The remaining bytes</param>
-        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
         /// </summary>
         /// <param name="decoder">The decoder</param>
         /// <param name="scanIndex">The index of the scan</param>
-        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;
         }
 
         /// <summary>
-        /// Gets the block index used to retieve blocks from in <see cref="OldJpegDecoderCore.DecodedBlocks"/>
+        /// Gets the block index used to retieve blocks from in <see cref="OrigJpegDecoderCore.DecodedBlocks"/>
         /// </summary>
-        /// <param name="decoder">The <see cref="OldJpegDecoderCore"/> instance</param>
+        /// <param name="decoder">The <see cref="OrigJpegDecoderCore"/> instance</param>
         /// <returns>The index</returns>
-        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
         /// <param name="bp">The <see cref="InputProcessor"/> instance</param>
         /// <param name="h">The Huffman tree</param>
         /// <param name="delta">The low transform offset</param>
-        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;

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
         /// <summary>
-        /// Gets the luminance components channel as <see cref="OldJpegPixelArea" />.
+        /// Gets the luminance components channel as <see cref="OrigJpegPixelArea" />.
         /// </summary>
         public Buffer2D<byte> YChannel;
 
         /// <summary>
-        /// Gets the blue chroma components channel as <see cref="OldJpegPixelArea" />.
+        /// Gets the blue chroma components channel as <see cref="OrigJpegPixelArea" />.
         /// </summary>
         public Buffer2D<byte> CbChannel;
 
         /// <summary>
-        /// Gets an offseted <see cref="OldJpegPixelArea" /> to the Cr channel
+        /// Gets an offseted <see cref="OrigJpegPixelArea" /> to the Cr channel
         /// </summary>
         public Buffer2D<byte> CrChannel;
 #pragma warning restore SA1401

src/ImageSharp/Formats/Jpeg/GolangPort/JpegEncoderCore.cs

@@ -58,7 +58,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
         /// </summary>
         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);

src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegConstants.cs

@@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
     /// <summary>
     /// Defines jpeg constants defined in the specification.
     /// </summary>
-    internal static class OldJpegConstants
+    internal static class OrigJpegConstants
     {
         /// <summary>
         /// The maximum allowable length in each dimension of a jpeg image.

src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoder.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
     /// <summary>
     /// Image decoder for generating an image out of a jpg stream.
     /// </summary>
-    internal sealed class OldJpegDecoder : IImageDecoder, IJpegDecoderOptions
+    internal sealed class OrigJpegDecoder : IImageDecoder, IJpegDecoderOptions
     {
         /// <summary>
         /// 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<TPixel>(stream);
             }

src/ImageSharp/Formats/Jpeg/GolangPort/OldJpegDecoderCore.cs

@@ -20,7 +20,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
     /// <summary>
     /// Performs the jpeg decoding operation.
     /// </summary>
-    internal sealed unsafe class OldJpegDecoderCore : IDisposable
+    internal sealed unsafe class OrigJpegDecoderCore : IDisposable
     {
         /// <summary>
         /// The maximum number of color components
@@ -36,7 +36,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
 #pragma warning disable SA1401 // FieldsMustBePrivate
 
         /// <summary>
-        /// Encapsulates stream reading and processing data and operations for <see cref="OldJpegDecoderCore"/>.
+        /// Encapsulates stream reading and processing data and operations for <see cref="OrigJpegDecoderCore"/>.
         /// It's a value type for imporved data locality, and reduced number of CALLVIRT-s
         /// </summary>
         public InputProcessor InputProcessor;
@@ -65,12 +65,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
         /// <summary>
         /// The black image to decode to.
         /// </summary>
-        private OldJpegPixelArea blackImage;
+        private OrigJpegPixelArea blackImage;
 
         /// <summary>
         /// A grayscale image to decode to.
         /// </summary>
-        private OldJpegPixelArea grayImage;
+        private OrigJpegPixelArea grayImage;
 
         /// <summary>
         /// The horizontal resolution. Calculated if the image has a JFIF header.
@@ -98,15 +98,15 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
         private YCbCrImage ycbcrImage;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="OldJpegDecoderCore" /> class.
+        /// Initializes a new instance of the <see cref="OrigJpegDecoderCore" /> class.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
         /// <param name="options">The options.</param>
-        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
         /// <summary>
         /// Gets the component array
         /// </summary>
-        public OldComponent[] Components { get; private set; }
+        public OrigComponent[] Components { get; private set; }
 
         /// <summary>
         /// Gets the huffman trees
         /// </summary>
-        public OldHuffmanTree[] HuffmanTrees { get; }
+        public OrigHuffmanTree[] HuffmanTrees { get; }
 
         /// <summary>
         /// 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
         }
 
         /// <summary>
-        /// Gets the <see cref="OldJpegPixelArea"/> representing the channel at a given component index
+        /// Gets the <see cref="OrigJpegPixelArea"/> representing the channel at a given component index
         /// </summary>
         /// <param name="compIndex">The component index</param>
-        /// <returns>The <see cref="OldJpegPixelArea"/> of the channel</returns>
-        public OldJpegPixelArea GetDestinationChannel(int compIndex)
+        /// <returns>The <see cref="OrigJpegPixelArea"/> of the channel</returns>
+        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
         }
 
         /// <summary>
-        /// Read metadata from stream and read the blocks in the scans into <see cref="OldComponent.SpectralBlocks"/>.
+        /// Read metadata from stream and read the blocks in the scans into <see cref="OrigComponent.SpectralBlocks"/>.
         /// </summary>
         /// <param name="stream">The stream</param>
         /// <param name="metadataOnly">Whether to decode metadata only.</param>
@@ -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
         /// </exception>
         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);
         }
 
         /// <summary>
-        /// Process the blocks in <see cref="DecodedBlocks"/> into Jpeg image channels (<see cref="YCbCrImage"/> and <see cref="OldJpegPixelArea"/>)
+        /// Process the blocks in <see cref="DecodedBlocks"/> into Jpeg image channels (<see cref="YCbCrImage"/> and <see cref="OrigJpegPixelArea"/>)
         /// <see cref="DecodedBlocks"/> 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 <see cref="OldJpegPixelArea"/>-s afterwards.
+        /// We can copy these blocks into <see cref="OrigJpegPixelArea"/>-s afterwards.
         /// </summary>
         /// <typeparam name="TPixel">The pixel type</typeparam>
         private void ProcessBlocksIntoJpegImageChannels<TPixel>()
@@ -476,7 +476,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort
         }
 
         /// <summary>
-        /// Convert the pixel data in <see cref="YCbCrImage"/> and/or <see cref="OldJpegPixelArea"/> into pixels of <see cref="Image{TPixel}"/>
+        /// Convert the pixel data in <see cref="YCbCrImage"/> and/or <see cref="OrigJpegPixelArea"/> into pixels of <see cref="Image{TPixel}"/>
         /// </summary>
         /// <typeparam name="TPixel">The pixel type</typeparam>
         /// <returns>The decoded image.</returns>
@@ -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<byte> buffer = Buffer2D<byte>.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<byte>.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;
             }

src/ImageSharp/Formats/Jpeg/GolangPort/Utils/OldJpegUtils.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Utils
     /// <summary>
     ///     Jpeg specific utilities and extension methods
     /// </summary>
-    internal static unsafe class OldJpegUtils
+    internal static unsafe class OrigJpegUtils
     {
         /// <summary>
         /// 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.

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<TPixel>(stream);
             }

src/ImageSharp/Formats/Jpeg/JpegFormat.cs

@@ -18,9 +18,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public string DefaultMimeType => "image/jpeg";
 
         /// <inheritdoc/>
-        public IEnumerable<string> MimeTypes => OldJpegConstants.MimeTypes;
+        public IEnumerable<string> MimeTypes => OrigJpegConstants.MimeTypes;
 
         /// <inheritdoc/>
-        public IEnumerable<string> FileExtensions => OldJpegConstants.FileExtensions;
+        public IEnumerable<string> FileExtensions => OrigJpegConstants.FileExtensions;
     }
 }

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Component.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Represents a component block
     /// </summary>
-    internal class Component : IDisposable
+    internal class PdfJsComponent : IDisposable
     {
 #pragma warning disable SA1401
         /// <summary>

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ComponentBlocks.cs

@@ -8,12 +8,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Contains all the decoded component blocks
     /// </summary>
-    internal sealed class ComponentBlocks : IDisposable
+    internal sealed class PdfJsComponentBlocks : IDisposable
     {
         /// <summary>
         /// Gets or sets the component blocks
         /// </summary>
-        public Component[] Components { get; set; }
+        public PdfJsComponent[] Components { get; set; }
 
         /// <inheritdoc/>
         public void Dispose()

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FileMarker.cs

@@ -6,14 +6,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Represents a jpeg file marker
     /// </summary>
-    internal struct FileMarker
+    internal struct PdfJsFileMarker
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="FileMarker"/> struct.
+        /// Initializes a new instance of the <see cref="PdfJsFileMarker"/> struct.
         /// </summary>
         /// <param name="marker">The marker</param>
         /// <param name="position">The position within the stream</param>
-        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
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="FileMarker"/> struct.
+        /// Initializes a new instance of the <see cref="PdfJsFileMarker"/> struct.
         /// </summary>
         /// <param name="marker">The marker</param>
         /// <param name="position">The position within the stream</param>
         /// <param name="invalid">Whether the current marker is invalid</param>
-        public FileMarker(ushort marker, long position, bool invalid)
+        public PdfJsFileMarker(ushort marker, long position, bool invalid)
         {
             this.Marker = marker;
             this.Position = position;

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Frame.cs

@@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Represent a single jpeg frame
     /// </summary>
-    internal sealed class Frame : IDisposable
+    internal sealed class PdfJsFrame : IDisposable
     {
         /// <summary>
         /// Gets or sets a value indicating whether the frame uses the extended specification
@@ -48,7 +48,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
         /// <summary>
         /// Gets or sets the frame component collection
         /// </summary>
-        public FrameComponent[] Components { get; set; }
+        public PdfJsFrameComponent[] Components { get; set; }
 
         /// <summary>
         /// 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();
             }
         }

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/FrameComponent.cs

@@ -12,11 +12,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Represents a single frame component
     /// </summary>
-    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; }
 
         /// <inheritdoc/>
         public void Dispose()

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTable.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Represents a Huffman Table
     /// </summary>
-    internal struct HuffmanTable : IDisposable
+    internal struct PdfJsHuffmanTable : IDisposable
     {
         private Buffer<short> lookahead;
         private Buffer<short> valOffset;
@@ -18,11 +18,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
         private Buffer<byte> huffval;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="HuffmanTable"/> struct.
+        /// Initializes a new instance of the <see cref="PdfJsHuffmanTable"/> struct.
         /// </summary>
         /// <param name="lengths">The code lengths</param>
         /// <param name="values">The huffman values</param>
-        public HuffmanTable(byte[] lengths, byte[] values)
+        public PdfJsHuffmanTable(byte[] lengths, byte[] values)
         {
             this.lookahead = Buffer<short>.CreateClean(256);
             this.valOffset = Buffer<short>.CreateClean(18);

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/HuffmanTables.cs

@@ -10,16 +10,16 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Defines a pair of huffman tables
     /// </summary>
-    internal sealed class HuffmanTables : IDisposable
+    internal sealed class PdfJsHuffmanTables : IDisposable
     {
-        private readonly HuffmanTable[] tables = new HuffmanTable[4];
+        private readonly PdfJsHuffmanTable[] tables = new PdfJsHuffmanTable[4];
 
         /// <summary>
         /// Gets or sets the table at the given index.
         /// </summary>
         /// <param name="index">The index</param>
         /// <returns>The <see cref="List{HuffmanBranch}"/></returns>
-        public ref HuffmanTable this[int index]
+        public ref PdfJsHuffmanTable this[int index]
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/IDCT.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Performs the inverse Descrete Cosine Transform on each frame component.
     /// </summary>
-    internal static class IDCT
+    internal static class PdfJsIDCT
     {
         /// <summary>
         /// 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
         /// <param name="blockBufferOffset">The block buffer offset</param>
         /// <param name="computationBuffer">The computational buffer for holding temp values</param>
         /// <param name="quantizationTable">The quantization table</param>
-        public static void QuantizeAndInverse(FrameComponent component, int blockBufferOffset, ref Span<short> computationBuffer, ref Span<short> quantizationTable)
+        public static void QuantizeAndInverse(PdfJsFrameComponent component, int blockBufferOffset, ref Span<short> computationBuffer, ref Span<short> quantizationTable)
         {
             Span<short> 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
         /// <param name="blockBufferOffset">The block buffer offset</param>
         /// <param name="computationBuffer">The computational buffer for holding temp values</param>
         /// <param name="multiplierTable">The multiplier table</param>
-        public static void QuantizeAndInverseFast(FrameComponent component, int blockBufferOffset, ref Span<short> computationBuffer, ref Span<short> multiplierTable)
+        public static void QuantizeAndInverseFast(PdfJsFrameComponent component, int blockBufferOffset, ref Span<short> computationBuffer, ref Span<short> multiplierTable)
         {
             Span<short> blockData = component.BlockData.Slice(blockBufferOffset);
             int p0, p1, p2, p3, p4, p5, p6, p7;

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?
     /// </summary>
-    internal struct JFif : IEquatable<JFif>
+    internal struct PdfJsJFif : IEquatable<PdfJsJFif>
     {
         /// <summary>
         /// The major version
@@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
         public short YDensity;
 
         /// <inheritdoc/>
-        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);
         }
 
         /// <inheritdoc/>

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/JpegPixelArea.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Represents a section of the jpeg component data laid out in pixel order.
     /// </summary>
-    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;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="JpegPixelArea"/> struct.
+        /// Initializes a new instance of the <see cref="PdfJsJpegPixelArea"/> struct.
         /// </summary>
         /// <param name="imageWidth">The image width</param>
         /// <param name="imageHeight">The image height</param>
         /// <param name="numberOfComponents">The number of components</param>
-        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
         /// <param name="components">The jpeg component blocks</param>
         /// <param name="width">The pixel area width</param>
         /// <param name="height">The pixel area height</param>
-        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<int> 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<short> output = component.Output;

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/Adobe.cs → src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/PdfJsAdobe.cs

@@ -9,7 +9,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Provides information about the Adobe marker segment
     /// </summary>
-    internal struct Adobe : IEquatable<Adobe>
+    internal struct PdfJsAdobe : IEquatable<PdfJsAdobe>
     {
         /// <summary>
         /// The DCT Encode Version
@@ -36,7 +36,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
         public byte ColorTransform;
 
         /// <inheritdoc/>
-        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);
         }
 
         /// <inheritdoc/>

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/QuantizationTables.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Contains the quantization tables.
     /// </summary>
-    internal sealed class QuantizationTables : IDisposable
+    internal sealed class PdfJsQuantizationTables : IDisposable
     {
         /// <summary>
         /// Gets the ZigZag scan table

src/ImageSharp/Formats/Jpeg/PdfJsPort/Components/ScanDecoder.cs

@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
     /// <summary>
     /// Provides the means to decode a spectral scan
     /// </summary>
-    internal struct ScanDecoder
+    internal struct PdfJsScanDecoder
     {
         private byte[] markerBuffer;
 
@@ -59,11 +59,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components
         /// <param name="successivePrev">The successive approximation bit high end</param>
         /// <param name="successive">The successive approximation bit low end</param>
         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<short> componentBlockDataSpan = component.BlockData.Span;
             while (k <= e)
             {
-                byte z = QuantizationTables.DctZigZag[k];
+                byte z = PdfJsQuantizationTables.DctZigZag[k];
                 switch (this.successiveACState)
                 {
                     case 0: // Initial state

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.
     /// </summary>
-    internal struct YCbCrToRgbTables
+    internal struct PdfJsYCbCrToRgbTables
     {
         /// <summary>
         /// The red red-chrominance table

src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegConstants.cs

@@ -7,7 +7,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort
     /// <summary>
     /// Contains jpeg constant values
     /// </summary>
-    internal static class JpegConstants
+    internal static class PdfJsJpegConstants
     {
         /// <summary>
         /// Contains marker specific constants

src/ImageSharp/Formats/Jpeg/PdfJsPort/JpegDecoderCore.cs

@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort
     /// Performs the jpeg decoding operation.
     /// Ported from <see href="https://github.com/mozilla/pdf.js/blob/master/src/core/jpg.js"/> with additional fixes to handle common encoding errors
     /// </summary>
-    internal sealed class JpegDecoderCore : IDisposable
+    internal sealed class PdfJsJpegDecoderCore : IDisposable
     {
 #pragma warning disable SA1401 // Fields should be private
         /// <summary>
@@ -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
         /// <summary>
         /// Contains information about the JFIF marker
         /// </summary>
-        private JFif jFif;
+        private PdfJsJFif jFif;
 
         /// <summary>
         /// Contains information about the Adobe marker
         /// </summary>
-        private Adobe adobe;
+        private PdfJsAdobe adobe;
 
         /// <summary>
-        /// Initializes static members of the <see cref="JpegDecoderCore"/> class.
+        /// Initializes static members of the <see cref="PdfJsJpegDecoderCore"/> class.
         /// </summary>
-        static JpegDecoderCore()
+        static PdfJsJpegDecoderCore()
         {
-            YCbCrToRgbTables.Create();
+            PdfJsYCbCrToRgbTables.Create();
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="JpegDecoderCore" /> class.
+        /// Initializes a new instance of the <see cref="PdfJsJpegDecoderCore" /> class.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
         /// <param name="options">The options.</param>
-        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
         /// <summary>
         /// Gets the frame
         /// </summary>
-        public Frame Frame { get; private set; }
+        public PdfJsFrame Frame { get; private set; }
 
         /// <summary>
         /// Gets the image width
@@ -113,35 +113,35 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort
         /// </summary>
         /// <param name="marker">The buffer to read file markers to</param>
         /// <param name="stream">The input stream</param>
-        /// <returns>The <see cref="FileMarker"/></returns>
-        public static FileMarker FindNextFileMarker(byte[] marker, Stream stream)
+        /// <returns>The <see cref="PdfJsFileMarker"/></returns>
+        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);
         }
 
         /// <summary>
@@ -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<short> 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<short> 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
         /// </summary>
         /// <param name="remaining">The remaining bytes in the segment block.</param>
         /// <param name="frameMarker">The current frame marker.</param>
-        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
         /// </summary>
         /// <param name="component">The component</param>
         /// <param name="frameComponent">The frame component</param>
-        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
         /// <param name="index">The table index</param>
         /// <param name="codeLengths">The codelengths</param>
         /// <param name="values">The values</param>
-        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);
                 }
             }
         }

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<TPixel>(stream);
                 }

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];

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);

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);
+            }
         }
     }
 }

tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs

@@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         public void PdfJsDecoder_ParseStream_SaveSpectralResult<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
-            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<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
-            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<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
-            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<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
-            OldJpegDecoderCore decoder = new OldJpegDecoderCore(Configuration.Default, new JpegDecoder());
+            OrigJpegDecoderCore decoder = new OrigJpegDecoderCore(Configuration.Default, new JpegDecoder());
 
             byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
 

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,

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);

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
+    {
+        /// <summary>
+        /// 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.
+        /// </summary>
+        internal static class GT_FloatingPoint_DCT
+        {
+            public static void idct81d_GT(Span<float> src, Span<float> 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<float> s, Span<float> d)
+            {
+                idct81d_GT(s, d);
+
+                Transpose8x8(d);
+
+                idct81d_GT(d, d);
+
+                Transpose8x8(d);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Formats/Jpg/Utils/ReferenceImplementations.FastFloatingPointDCT.cs → 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
     {
         /// <summary>
-        /// 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!
         /// </summary>
-        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++)
                 {

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}");
         }