mirror of https://github.com/SixLabors/ImageSharp
Browse Source
# Conflicts: # src/ImageSharp/Processing/Processors/Normalization/HistogramEqualizationProcessor.cspull/673/head
popow
8 years ago
197 changed files with 2071 additions and 6107 deletions
@ -0,0 +1,22 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Threading.Tasks; |
|||
|
|||
namespace SixLabors.ImageSharp |
|||
{ |
|||
/// <summary>
|
|||
/// Contains extension methods for <see cref="Configuration"/>
|
|||
/// </summary>
|
|||
internal static class ConfigurationExtensions |
|||
{ |
|||
/// <summary>
|
|||
/// Creates a <see cref="ParallelOptions"/> object based on <paramref name="configuration"/>,
|
|||
/// having <see cref="ParallelOptions.MaxDegreeOfParallelism"/> set to <see cref="Configuration.MaxDegreeOfParallelism"/>
|
|||
/// </summary>
|
|||
public static ParallelOptions GetParallelOptions(this Configuration configuration) |
|||
{ |
|||
return new ParallelOptions() { MaxDegreeOfParallelism = configuration.MaxDegreeOfParallelism }; |
|||
} |
|||
} |
|||
} |
|||
@ -1,24 +1,23 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort.Components |
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Defines a 2 pairs of huffman tables
|
|||
/// Defines a 2 pairs of huffman tables.
|
|||
/// </summary>
|
|||
internal sealed class PdfJsHuffmanTables |
|||
internal sealed class HuffmanTables |
|||
{ |
|||
private readonly PdfJsHuffmanTable[] tables = new PdfJsHuffmanTable[4]; |
|||
private readonly HuffmanTable[] tables = new HuffmanTable[4]; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the table at the given index.
|
|||
/// </summary>
|
|||
/// <param name="index">The index</param>
|
|||
/// <returns>The <see cref="PdfJsHuffmanTable"/></returns>
|
|||
public ref PdfJsHuffmanTable this[int index] |
|||
/// <returns>The <see cref="HuffmanTable"/></returns>
|
|||
public ref HuffmanTable this[int index] |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
get => ref this.tables[index]; |
|||
@ -1,155 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Holds the unprocessed bits that have been taken from the byte-stream.
|
|||
/// The n least significant bits of a form the unread bits, to be read in MSB to
|
|||
/// LSB order.
|
|||
/// </summary>
|
|||
internal struct Bits |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets the accumulator.
|
|||
/// </summary>
|
|||
public int Accumulator; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the mask.
|
|||
/// <![CDATA[mask==1<<(unreadbits-1) when unreadbits>0, with mask==0 when unreadbits==0.]]>
|
|||
/// </summary>
|
|||
public int Mask; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of unread bits in the accumulator.
|
|||
/// </summary>
|
|||
public int UnreadBits; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="n">The number of bits to ensure.</param>
|
|||
/// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void EnsureNBits(int n, ref InputProcessor inputProcessor) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(n, ref inputProcessor); |
|||
errorCode.EnsureNoError(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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="GolangDecoderErrorCode"/> 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 GolangDecoderErrorCode EnsureNBitsUnsafe(int n, ref InputProcessor inputProcessor) |
|||
{ |
|||
while (true) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = this.EnsureBitsStepImpl(ref inputProcessor); |
|||
if (errorCode != GolangDecoderErrorCode.NoError || this.UnreadBits >= n) |
|||
{ |
|||
return errorCode; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Unrolled version of <see cref="EnsureNBitsUnsafe"/> for n==8
|
|||
/// </summary>
|
|||
/// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
|
|||
/// <returns>A <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode Ensure8BitsUnsafe(ref InputProcessor inputProcessor) |
|||
{ |
|||
return this.EnsureBitsStepImpl(ref inputProcessor); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Unrolled version of <see cref="EnsureNBitsUnsafe"/> for n==1
|
|||
/// </summary>
|
|||
/// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
|
|||
/// <returns>A <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode Ensure1BitUnsafe(ref InputProcessor inputProcessor) |
|||
{ |
|||
return this.EnsureBitsStepImpl(ref inputProcessor); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Receive extend
|
|||
/// </summary>
|
|||
/// <param name="t">Byte</param>
|
|||
/// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
|
|||
/// <returns>Read bits value</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public int ReceiveExtend(int t, ref InputProcessor inputProcessor) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = this.ReceiveExtendUnsafe(t, ref inputProcessor, out int x); |
|||
errorCode.EnsureNoError(); |
|||
return x; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Receive extend
|
|||
/// </summary>
|
|||
/// <param name="t">Byte</param>
|
|||
/// <param name="inputProcessor">The <see cref="InputProcessor"/></param>
|
|||
/// <param name="x">Read bits value</param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode ReceiveExtendUnsafe(int t, ref InputProcessor inputProcessor, out int x) |
|||
{ |
|||
if (this.UnreadBits < t) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = this.EnsureNBitsUnsafe(t, ref inputProcessor); |
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
x = int.MaxValue; |
|||
return errorCode; |
|||
} |
|||
} |
|||
|
|||
this.UnreadBits -= t; |
|||
this.Mask >>= t; |
|||
int s = 1 << t; |
|||
x = (this.Accumulator >> this.UnreadBits) & (s - 1); |
|||
|
|||
if (x < (s >> 1)) |
|||
{ |
|||
x += ((-1) << t) + 1; |
|||
} |
|||
|
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
private GolangDecoderErrorCode EnsureBitsStepImpl(ref InputProcessor inputProcessor) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = inputProcessor.Bytes.ReadByteStuffedByteUnsafe(inputProcessor.InputStream, out int c); |
|||
|
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
return errorCode; |
|||
} |
|||
|
|||
this.Accumulator = (this.Accumulator << 8) | c; |
|||
this.UnreadBits += 8; |
|||
if (this.Mask == 0) |
|||
{ |
|||
this.Mask = 1 << 7; |
|||
} |
|||
else |
|||
{ |
|||
this.Mask <<= 8; |
|||
} |
|||
|
|||
return errorCode; |
|||
} |
|||
} |
|||
} |
|||
@ -1,255 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Bytes is a byte buffer, similar to a stream, except that it
|
|||
/// has to be able to unread more than 1 byte, due to byte stuffing.
|
|||
/// Byte stuffing is specified in section F.1.2.3.
|
|||
/// TODO: Optimize buffer management inside this class!
|
|||
/// </summary>
|
|||
internal struct Bytes : IDisposable |
|||
{ |
|||
/// <summary>
|
|||
/// Specifies the buffer size for <see cref="Buffer"/> and <see cref="BufferAsInt"/>
|
|||
/// </summary>
|
|||
public const int BufferSize = 4096; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the buffer.
|
|||
/// buffer[i:j] are the buffered bytes read from the underlying
|
|||
/// stream that haven't yet been passed further on.
|
|||
/// </summary>
|
|||
public byte[] Buffer; |
|||
|
|||
/// <summary>
|
|||
/// Values of <see cref="Buffer"/> converted to <see cref="int"/>-s
|
|||
/// </summary>
|
|||
public int[] BufferAsInt; |
|||
|
|||
/// <summary>
|
|||
/// Start of bytes read
|
|||
/// </summary>
|
|||
public int I; |
|||
|
|||
/// <summary>
|
|||
/// End of bytes read
|
|||
/// </summary>
|
|||
public int J; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the unreadable bytes. The number of bytes to back up i after
|
|||
/// overshooting. It can be 0, 1 or 2.
|
|||
/// </summary>
|
|||
public int UnreadableBytes; |
|||
|
|||
/// <summary>
|
|||
/// Creates a new instance of the <see cref="Bytes"/>, and initializes it's buffer.
|
|||
/// </summary>
|
|||
/// <returns>The bytes created</returns>
|
|||
public static Bytes Create() |
|||
{ |
|||
// DO NOT bother with buffers and array pooling here!
|
|||
// It only makes things worse!
|
|||
return new Bytes |
|||
{ |
|||
Buffer = new byte[BufferSize], |
|||
BufferAsInt = new int[BufferSize] |
|||
}; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Disposes of the underlying buffer
|
|||
/// </summary>
|
|||
public void Dispose() |
|||
{ |
|||
this.Buffer = null; |
|||
this.BufferAsInt = null; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// ReadByteStuffedByte is like ReadByte but is for byte-stuffed Huffman data.
|
|||
/// </summary>
|
|||
/// <param name="inputStream">Input stream</param>
|
|||
/// <param name="x">The result byte as <see cref="int"/></param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode ReadByteStuffedByteUnsafe(Stream inputStream, out int x) |
|||
{ |
|||
// Take the fast path if bytes.buf contains at least two bytes.
|
|||
if (this.I + 2 <= this.J) |
|||
{ |
|||
x = this.BufferAsInt[this.I]; |
|||
this.I++; |
|||
this.UnreadableBytes = 1; |
|||
if (x != JpegConstants.Markers.XFFInt) |
|||
{ |
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
if (this.BufferAsInt[this.I] != 0x00) |
|||
{ |
|||
return GolangDecoderErrorCode.MissingFF00; |
|||
} |
|||
|
|||
this.I++; |
|||
this.UnreadableBytes = 2; |
|||
x = JpegConstants.Markers.XFF; |
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
this.UnreadableBytes = 0; |
|||
|
|||
GolangDecoderErrorCode errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); |
|||
this.UnreadableBytes = 1; |
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
return errorCode; |
|||
} |
|||
|
|||
if (x != JpegConstants.Markers.XFF) |
|||
{ |
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
errorCode = this.ReadByteAsIntUnsafe(inputStream, out x); |
|||
this.UnreadableBytes = 2; |
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
return errorCode; |
|||
} |
|||
|
|||
if (x != 0x00) |
|||
{ |
|||
return GolangDecoderErrorCode.MissingFF00; |
|||
} |
|||
|
|||
x = JpegConstants.Markers.XFF; |
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the next byte, whether buffered or not buffered. It does not care about byte stuffing.
|
|||
/// </summary>
|
|||
/// <param name="inputStream">Input stream</param>
|
|||
/// <returns>The <see cref="byte"/></returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public byte ReadByte(Stream inputStream) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = this.ReadByteUnsafe(inputStream, out byte 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="GolangDecoderErrorCode"/> instead.
|
|||
/// </summary>
|
|||
/// <param name="inputStream">Input stream</param>
|
|||
/// <param name="result">The result <see cref="byte"/> as out parameter</param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode ReadByteUnsafe(Stream inputStream, out byte result) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = GolangDecoderErrorCode.NoError; |
|||
while (this.I == this.J) |
|||
{ |
|||
errorCode = this.FillUnsafe(inputStream); |
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
result = 0; |
|||
return errorCode; |
|||
} |
|||
} |
|||
|
|||
result = this.Buffer[this.I]; |
|||
this.I++; |
|||
this.UnreadableBytes = 0; |
|||
return errorCode; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Same as <see cref="ReadByteUnsafe"/> but the result is an <see cref="int"/>
|
|||
/// </summary>
|
|||
/// <param name="inputStream">The input stream</param>
|
|||
/// <param name="result">The result <see cref="int"/></param>
|
|||
/// <returns>A <see cref="GolangDecoderErrorCode"/></returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public GolangDecoderErrorCode ReadByteAsIntUnsafe(Stream inputStream, out int result) |
|||
{ |
|||
GolangDecoderErrorCode errorCode = GolangDecoderErrorCode.NoError; |
|||
while (this.I == this.J) |
|||
{ |
|||
errorCode = this.FillUnsafe(inputStream); |
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
result = 0; |
|||
return errorCode; |
|||
} |
|||
} |
|||
|
|||
result = this.BufferAsInt[this.I]; |
|||
this.I++; |
|||
this.UnreadableBytes = 0; |
|||
return errorCode; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Fills up the bytes buffer from the underlying stream.
|
|||
/// It should only be called when there are no unread bytes in bytes.
|
|||
/// </summary>
|
|||
/// <exception cref="EOFException">Thrown when reached end of stream unexpectedly.</exception>
|
|||
/// <param name="inputStream">Input stream</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void Fill(Stream inputStream) |
|||
{ |
|||
GolangDecoderErrorCode 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="GolangDecoderErrorCode"/> instead!
|
|||
/// </summary>
|
|||
/// <param name="inputStream">Input stream</param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode FillUnsafe(Stream inputStream) |
|||
{ |
|||
if (this.I != this.J) |
|||
{ |
|||
// Unrecoverable error in the input, throwing!
|
|||
DecoderThrowHelper.ThrowImageFormatException.FillCalledWhenUnreadBytesExist(); |
|||
} |
|||
|
|||
// Move the last 2 bytes to the start of the buffer, in case we need
|
|||
// to call UnreadByteStuffedByte.
|
|||
if (this.J > 2) |
|||
{ |
|||
this.Buffer[0] = this.Buffer[this.J - 2]; |
|||
this.Buffer[1] = this.Buffer[this.J - 1]; |
|||
this.I = 2; |
|||
this.J = 2; |
|||
} |
|||
|
|||
// Fill in the rest of the buffer.
|
|||
int n = inputStream.Read(this.Buffer, this.J, this.Buffer.Length - this.J); |
|||
if (n == 0) |
|||
{ |
|||
return GolangDecoderErrorCode.UnexpectedEndOfStream; |
|||
} |
|||
|
|||
this.J += n; |
|||
|
|||
for (int i = 0; i < this.Buffer.Length; i++) |
|||
{ |
|||
this.BufferAsInt[i] = this.Buffer[i]; |
|||
} |
|||
|
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
} |
|||
} |
|||
@ -1,96 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Encapsulates exception thrower methods for the Jpeg Encoder
|
|||
/// </summary>
|
|||
internal static class DecoderThrowHelper |
|||
{ |
|||
/// <summary>
|
|||
/// Throws an exception that belongs to the given <see cref="GolangDecoderErrorCode"/>
|
|||
/// </summary>
|
|||
/// <param name="errorCode">The <see cref="GolangDecoderErrorCode"/></param>
|
|||
[MethodImpl(MethodImplOptions.NoInlining)] |
|||
public static void ThrowExceptionForErrorCode(this GolangDecoderErrorCode errorCode) |
|||
{ |
|||
// REMARK: If this method throws for an image that is expected to be decodable,
|
|||
// consider using the ***Unsafe variant of the parsing method that asks for ThrowExceptionForErrorCode()
|
|||
// then verify the error code + implement fallback logic manually!
|
|||
switch (errorCode) |
|||
{ |
|||
case GolangDecoderErrorCode.NoError: |
|||
throw new ArgumentException("ThrowExceptionForErrorCode() called with NoError!", nameof(errorCode)); |
|||
case GolangDecoderErrorCode.MissingFF00: |
|||
throw new MissingFF00Exception(); |
|||
case GolangDecoderErrorCode.UnexpectedEndOfStream: |
|||
throw new EOFException(); |
|||
default: |
|||
throw new ArgumentOutOfRangeException(nameof(errorCode), errorCode, null); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Throws an exception if the given <see cref="GolangDecoderErrorCode"/> defines an error.
|
|||
/// </summary>
|
|||
/// <param name="errorCode">The <see cref="GolangDecoderErrorCode"/></param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void EnsureNoError(this GolangDecoderErrorCode errorCode) |
|||
{ |
|||
if (errorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
ThrowExceptionForErrorCode(errorCode); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Throws an exception if the given <see cref="GolangDecoderErrorCode"/> is <see cref="GolangDecoderErrorCode.UnexpectedEndOfStream"/>.
|
|||
/// </summary>
|
|||
/// <param name="errorCode">The <see cref="GolangDecoderErrorCode"/></param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void EnsureNoEOF(this GolangDecoderErrorCode errorCode) |
|||
{ |
|||
if (errorCode == GolangDecoderErrorCode.UnexpectedEndOfStream) |
|||
{ |
|||
errorCode.ThrowExceptionForErrorCode(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Encapsulates methods throwing different flavours of <see cref="ImageFormatException"/>-s.
|
|||
/// </summary>
|
|||
public static class ThrowImageFormatException |
|||
{ |
|||
/// <summary>
|
|||
/// Throws "Fill called when unread bytes exist".
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.NoInlining)] |
|||
public static void FillCalledWhenUnreadBytesExist() |
|||
{ |
|||
throw new ImageFormatException("Fill called when unread bytes exist!"); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Throws "Bad Huffman code".
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.NoInlining)] |
|||
public static void BadHuffmanCode() |
|||
{ |
|||
throw new ImageFormatException("Bad Huffman code!"); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Throws "Uninitialized Huffman table".
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.NoInlining)] |
|||
public static void UninitializedHuffmanTable() |
|||
{ |
|||
throw new ImageFormatException("Uninitialized Huffman table"); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,23 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// The EOF (End of File exception).
|
|||
/// Thrown when the decoder encounters an EOF marker without a proceeding EOI (End Of Image) marker
|
|||
/// TODO: Rename to UnexpectedEndOfStreamException
|
|||
/// </summary>
|
|||
internal class EOFException : Exception |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="EOFException"/> class.
|
|||
/// </summary>
|
|||
public EOFException() |
|||
: base("Reached end of stream before proceeding EOI marker!") |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -1,253 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components; |
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; |
|||
using SixLabors.Memory; |
|||
using SixLabors.Primitives; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <inheritdoc cref="IJpegComponent" />
|
|||
/// <summary>
|
|||
/// Represents a single color component
|
|||
/// </summary>
|
|||
internal class GolangComponent : IDisposable, IJpegComponent |
|||
{ |
|||
public GolangComponent(byte identifier, int index) |
|||
{ |
|||
this.Identifier = identifier; |
|||
this.Index = index; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the identifier
|
|||
/// </summary>
|
|||
public byte Identifier { get; } |
|||
|
|||
/// <inheritdoc />
|
|||
public int Index { get; } |
|||
|
|||
public Size SizeInBlocks { get; private set; } |
|||
|
|||
public Size SamplingFactors { get; private set; } |
|||
|
|||
public Size SubSamplingDivisors { get; private set; } |
|||
|
|||
public int HorizontalSamplingFactor => this.SamplingFactors.Width; |
|||
|
|||
public int VerticalSamplingFactor => this.SamplingFactors.Height; |
|||
|
|||
/// <inheritdoc />
|
|||
public int QuantizationTableIndex { get; private set; } |
|||
|
|||
/// <inheritdoc />
|
|||
/// <summary>
|
|||
/// Gets the <see cref="T:SixLabors.ImageSharp.Memory.Buffer`1" /> 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="M:SixLabors.ImageSharp.Formats.Jpeg.GolangPort.OrigJpegDecoderCore.ProcessBlocksIntoJpegImageChannels" />.
|
|||
/// When <see cref="P:SixLabors.ImageSharp.Formats.Jpeg.GolangPort.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; } |
|||
|
|||
/// <summary>
|
|||
/// Initializes <see cref="SpectralBlocks"/>
|
|||
/// </summary>
|
|||
/// <param name="memoryAllocator">The <see cref="MemoryAllocator"/> to use for buffer allocations.</param>
|
|||
/// <param name="decoder">The <see cref="GolangJpegDecoderCore"/> instance</param>
|
|||
public void InitializeDerivedData(MemoryAllocator memoryAllocator, GolangJpegDecoderCore decoder) |
|||
{ |
|||
// For 4-component images (either CMYK or YCbCrK), we only support two
|
|||
// hv vectors: [0x11 0x11 0x11 0x11] and [0x22 0x11 0x11 0x22].
|
|||
// Theoretically, 4-component JPEG images could mix and match hv values
|
|||
// but in practice, those two combinations are the only ones in use,
|
|||
// and it simplifies the applyBlack code below if we can assume that:
|
|||
// - for CMYK, the C and K channels have full samples, and if the M
|
|||
// and Y channels subsample, they subsample both horizontally and
|
|||
// vertically.
|
|||
// - for YCbCrK, the Y and K channels have full samples.
|
|||
this.SizeInBlocks = decoder.ImageSizeInMCU.MultiplyBy(this.SamplingFactors); |
|||
|
|||
if (this.Index == 0 || this.Index == 3) |
|||
{ |
|||
this.SubSamplingDivisors = new Size(1, 1); |
|||
} |
|||
else |
|||
{ |
|||
GolangComponent c0 = decoder.Components[0]; |
|||
this.SubSamplingDivisors = c0.SamplingFactors.DivideBy(this.SamplingFactors); |
|||
} |
|||
|
|||
this.SpectralBlocks = memoryAllocator.Allocate2D<Block8x8>(this.SizeInBlocks.Width, this.SizeInBlocks.Height, true); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes all component data except <see cref="SpectralBlocks"/>.
|
|||
/// </summary>
|
|||
/// <param name="decoder">The <see cref="GolangJpegDecoderCore"/> instance</param>
|
|||
public void InitializeCoreData(GolangJpegDecoderCore 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)".
|
|||
int i = this.Index; |
|||
|
|||
for (int j = 0; j < this.Index; j++) |
|||
{ |
|||
if (this.Identifier == decoder.Components[j].Identifier) |
|||
{ |
|||
throw new ImageFormatException("Repeated component identifier"); |
|||
} |
|||
} |
|||
|
|||
this.QuantizationTableIndex = decoder.Temp[8 + (3 * i)]; |
|||
if (this.QuantizationTableIndex > GolangJpegDecoderCore.MaxTq) |
|||
{ |
|||
throw new ImageFormatException("Bad Tq value"); |
|||
} |
|||
|
|||
byte hv = decoder.Temp[7 + (3 * i)]; |
|||
int h = hv >> 4; |
|||
int v = hv & 0x0f; |
|||
if (h < 1 || h > 4 || v < 1 || v > 4) |
|||
{ |
|||
throw new ImageFormatException("Unsupported Luma/chroma subsampling ratio"); |
|||
} |
|||
|
|||
if (h == 3 || v == 3) |
|||
{ |
|||
throw new ImageFormatException("Lnsupported subsampling ratio"); |
|||
} |
|||
|
|||
switch (decoder.ComponentCount) |
|||
{ |
|||
case 1: |
|||
|
|||
// If a JPEG image has only one component, section A.2 says "this data
|
|||
// is non-interleaved by definition" and section A.2.2 says "[in this
|
|||
// case...] the order of data units within a scan shall be left-to-right
|
|||
// and top-to-bottom... regardless of the values of H_1 and V_1". Section
|
|||
// 4.8.2 also says "[for non-interleaved data], the MCU is defined to be
|
|||
// one data unit". Similarly, section A.1.1 explains that it is the ratio
|
|||
// of H_i to max_j(H_j) that matters, and similarly for V. For grayscale
|
|||
// images, H_1 is the maximum H_j for all components j, so that ratio is
|
|||
// always 1. The component's (h, v) is effectively always (1, 1): even if
|
|||
// the nominal (h, v) is (2, 1), a 20x5 image is encoded in three 8x8
|
|||
// MCUs, not two 16x8 MCUs.
|
|||
h = 1; |
|||
v = 1; |
|||
break; |
|||
|
|||
case 3: |
|||
|
|||
// For YCbCr images, we only support 4:4:4, 4:4:0, 4:2:2, 4:2:0,
|
|||
// 4:1:1 or 4:1:0 chroma subsampling ratios. This implies that the
|
|||
// (h, v) values for the Y component are either (1, 1), (1, 2),
|
|||
// (2, 1), (2, 2), (4, 1) or (4, 2), and the Y component's values
|
|||
// must be a multiple of the Cb and Cr component's values. We also
|
|||
// assume that the two chroma components have the same subsampling
|
|||
// ratio.
|
|||
switch (i) |
|||
{ |
|||
case 0: |
|||
{ |
|||
// Y.
|
|||
// We have already verified, above, that h and v are both
|
|||
// either 1, 2 or 4, so invalid (h, v) combinations are those
|
|||
// with v == 4.
|
|||
if (v == 4) |
|||
{ |
|||
throw new ImageFormatException("Unsupported subsampling ratio"); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
case 1: |
|||
{ |
|||
// Cb.
|
|||
Size s0 = decoder.Components[0].SamplingFactors; |
|||
|
|||
if (s0.Width % h != 0 || s0.Height % v != 0) |
|||
{ |
|||
throw new ImageFormatException("Unsupported subsampling ratio"); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
case 2: |
|||
{ |
|||
// Cr.
|
|||
Size s1 = decoder.Components[1].SamplingFactors; |
|||
|
|||
if (s1.Width != h || s1.Height != v) |
|||
{ |
|||
throw new ImageFormatException("Unsupported subsampling ratio"); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
break; |
|||
|
|||
case 4: |
|||
|
|||
// For 4-component images (either CMYK or YCbCrK), we only support two
|
|||
// hv vectors: [0x11 0x11 0x11 0x11] and [0x22 0x11 0x11 0x22].
|
|||
// Theoretically, 4-component JPEG images could mix and match hv values
|
|||
// but in practice, those two combinations are the only ones in use,
|
|||
// and it simplifies the applyBlack code below if we can assume that:
|
|||
// - for CMYK, the C and K channels have full samples, and if the M
|
|||
// and Y channels subsample, they subsample both horizontally and
|
|||
// vertically.
|
|||
// - for YCbCrK, the Y and K channels have full samples.
|
|||
switch (i) |
|||
{ |
|||
case 0: |
|||
if (hv != 0x11 && hv != 0x22) |
|||
{ |
|||
throw new ImageFormatException("Unsupported subsampling ratio"); |
|||
} |
|||
|
|||
break; |
|||
case 1: |
|||
case 2: |
|||
if (hv != 0x11) |
|||
{ |
|||
throw new ImageFormatException("Unsupported subsampling ratio"); |
|||
} |
|||
|
|||
break; |
|||
case 3: |
|||
Size s0 = decoder.Components[0].SamplingFactors; |
|||
|
|||
if (s0.Width != h || s0.Height != v) |
|||
{ |
|||
throw new ImageFormatException("Unsupported subsampling ratio"); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
this.SamplingFactors = new Size(h, v); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ref Block8x8 GetBlockReference(int column, int row) |
|||
{ |
|||
return ref this.SpectralBlocks[column, row]; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
this.SpectralBlocks?.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
@ -1,29 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a component scan
|
|||
/// </summary>
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
internal struct GolangComponentScan |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets the component index.
|
|||
/// </summary>
|
|||
public byte ComponentIndex; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the DC table selector
|
|||
/// </summary>
|
|||
public byte DcTableSelector; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the AC table selector
|
|||
/// </summary>
|
|||
public byte AcTableSelector; |
|||
} |
|||
} |
|||
@ -1,27 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Represents "recoverable" decoder errors.
|
|||
/// </summary>
|
|||
internal enum GolangDecoderErrorCode |
|||
{ |
|||
/// <summary>
|
|||
/// NoError
|
|||
/// </summary>
|
|||
NoError, |
|||
|
|||
/// <summary>
|
|||
/// MissingFF00
|
|||
/// </summary>
|
|||
// ReSharper disable once InconsistentNaming
|
|||
MissingFF00, |
|||
|
|||
/// <summary>
|
|||
/// End of stream reached unexpectedly
|
|||
/// </summary>
|
|||
UnexpectedEndOfStream |
|||
} |
|||
} |
|||
@ -1,260 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a Huffman tree
|
|||
/// </summary>
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
internal unsafe struct GolangHuffmanTree |
|||
{ |
|||
/// <summary>
|
|||
/// The index of the AC table row
|
|||
/// </summary>
|
|||
public const int AcTableIndex = 1; |
|||
|
|||
/// <summary>
|
|||
/// The index of the DC table row
|
|||
/// </summary>
|
|||
public const int DcTableIndex = 0; |
|||
|
|||
/// <summary>
|
|||
/// The maximum (inclusive) number of codes in a Huffman tree.
|
|||
/// </summary>
|
|||
public const int MaxNCodes = 256; |
|||
|
|||
/// <summary>
|
|||
/// The maximum (inclusive) number of bits in a Huffman code.
|
|||
/// </summary>
|
|||
public const int MaxCodeLength = 16; |
|||
|
|||
/// <summary>
|
|||
/// The maximum number of Huffman table classes
|
|||
/// </summary>
|
|||
public const int MaxTc = 1; |
|||
|
|||
/// <summary>
|
|||
/// The maximum number of Huffman table identifiers
|
|||
/// </summary>
|
|||
public const int MaxTh = 3; |
|||
|
|||
/// <summary>
|
|||
/// Row size of the Huffman table
|
|||
/// </summary>
|
|||
public const int ThRowSize = MaxTh + 1; |
|||
|
|||
/// <summary>
|
|||
/// Number of Hufman Trees in the Huffman table
|
|||
/// </summary>
|
|||
public const int NumberOfTrees = (MaxTc + 1) * (MaxTh + 1); |
|||
|
|||
/// <summary>
|
|||
/// The log-2 size of the Huffman decoder's look-up table.
|
|||
/// </summary>
|
|||
public const int LutSizeLog2 = 8; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of codes in the tree.
|
|||
/// </summary>
|
|||
public int Length; |
|||
|
|||
/// <summary>
|
|||
/// Gets the look-up table for the next LutSize bits in the bit-stream.
|
|||
/// The high 8 bits of the uint16 are the encoded value. The low 8 bits
|
|||
/// are 1 plus the code length, or 0 if the value is too large to fit in
|
|||
/// lutSize bits.
|
|||
/// </summary>
|
|||
public FixedInt32Buffer256 Lut; |
|||
|
|||
/// <summary>
|
|||
/// Gets the the decoded values, sorted by their encoding.
|
|||
/// </summary>
|
|||
public FixedInt32Buffer256 Values; |
|||
|
|||
/// <summary>
|
|||
/// Gets the array of minimum codes.
|
|||
/// MinCodes[i] is the minimum code of length i, or -1 if there are no codes of that length.
|
|||
/// </summary>
|
|||
public FixedInt32Buffer16 MinCodes; |
|||
|
|||
/// <summary>
|
|||
/// Gets the array of maximum codes.
|
|||
/// MaxCodes[i] is the maximum code of length i, or -1 if there are no codes of that length.
|
|||
/// </summary>
|
|||
public FixedInt32Buffer16 MaxCodes; |
|||
|
|||
/// <summary>
|
|||
/// Gets the array of indices. Indices[i] is the index into Values of MinCodes[i].
|
|||
/// </summary>
|
|||
public FixedInt32Buffer16 Indices; |
|||
|
|||
/// <summary>
|
|||
/// Creates and initializes an array of <see cref="GolangHuffmanTree" /> instances of size <see cref="NumberOfTrees" />
|
|||
/// </summary>
|
|||
/// <returns>An array of <see cref="GolangHuffmanTree" /> instances representing the Huffman tables</returns>
|
|||
public static GolangHuffmanTree[] CreateHuffmanTrees() |
|||
{ |
|||
return new GolangHuffmanTree[NumberOfTrees]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Internal part of the DHT processor, whatever does it mean
|
|||
/// </summary>
|
|||
/// <param name="inputProcessor">The decoder instance</param>
|
|||
/// <param name="defineHuffmanTablesData">The temporary buffer that holds the data that has been read from the Jpeg stream</param>
|
|||
/// <param name="remaining">Remaining bits</param>
|
|||
public void ProcessDefineHuffmanTablesMarkerLoop( |
|||
ref InputProcessor inputProcessor, |
|||
byte[] defineHuffmanTablesData, |
|||
ref int remaining) |
|||
{ |
|||
// Read nCodes and huffman.Valuess (and derive h.Length).
|
|||
// nCodes[i] is the number of codes with code length i.
|
|||
// h.Length is the total number of codes.
|
|||
this.Length = 0; |
|||
|
|||
int[] ncodes = new int[MaxCodeLength]; |
|||
for (int i = 0; i < ncodes.Length; i++) |
|||
{ |
|||
ncodes[i] = defineHuffmanTablesData[i + 1]; |
|||
this.Length += ncodes[i]; |
|||
} |
|||
|
|||
if (this.Length == 0) |
|||
{ |
|||
throw new ImageFormatException("Huffman table has zero length"); |
|||
} |
|||
|
|||
if (this.Length > MaxNCodes) |
|||
{ |
|||
throw new ImageFormatException("Huffman table has excessive length"); |
|||
} |
|||
|
|||
remaining -= this.Length + 17; |
|||
if (remaining < 0) |
|||
{ |
|||
throw new ImageFormatException("DHT has wrong length"); |
|||
} |
|||
|
|||
byte[] values = new byte[MaxNCodes]; |
|||
inputProcessor.ReadFull(values, 0, this.Length); |
|||
|
|||
fixed (int* valuesPtr = this.Values.Data) |
|||
fixed (int* lutPtr = this.Lut.Data) |
|||
{ |
|||
for (int i = 0; i < values.Length; i++) |
|||
{ |
|||
valuesPtr[i] = values[i]; |
|||
} |
|||
|
|||
// Derive the look-up table.
|
|||
for (int i = 0; i < MaxNCodes; i++) |
|||
{ |
|||
lutPtr[i] = 0; |
|||
} |
|||
|
|||
int x = 0, code = 0; |
|||
|
|||
for (int i = 0; i < LutSizeLog2; i++) |
|||
{ |
|||
code <<= 1; |
|||
|
|||
for (int j = 0; j < ncodes[i]; j++) |
|||
{ |
|||
// The codeLength is 1+i, so shift code by 8-(1+i) to
|
|||
// calculate the high bits for every 8-bit sequence
|
|||
// whose codeLength's high bits matches code.
|
|||
// The high 8 bits of lutValue are the encoded value.
|
|||
// The low 8 bits are 1 plus the codeLength.
|
|||
int base2 = code << (7 - i); |
|||
int lutValue = (valuesPtr[x] << 8) | (2 + i); |
|||
|
|||
for (int k = 0; k < 1 << (7 - i); k++) |
|||
{ |
|||
lutPtr[base2 | k] = lutValue; |
|||
} |
|||
|
|||
code++; |
|||
x++; |
|||
} |
|||
} |
|||
} |
|||
|
|||
fixed (int* minCodesPtr = this.MinCodes.Data) |
|||
fixed (int* maxCodesPtr = this.MaxCodes.Data) |
|||
fixed (int* indicesPtr = this.Indices.Data) |
|||
{ |
|||
// Derive minCodes, maxCodes, and indices.
|
|||
int c = 0, index = 0; |
|||
for (int i = 0; i < ncodes.Length; i++) |
|||
{ |
|||
int nc = ncodes[i]; |
|||
if (nc == 0) |
|||
{ |
|||
minCodesPtr[i] = -1; |
|||
maxCodesPtr[i] = -1; |
|||
indicesPtr[i] = -1; |
|||
} |
|||
else |
|||
{ |
|||
minCodesPtr[i] = c; |
|||
maxCodesPtr[i] = c + nc - 1; |
|||
indicesPtr[i] = index; |
|||
c += nc; |
|||
index += nc; |
|||
} |
|||
|
|||
c <<= 1; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the value for the given code and index.
|
|||
/// </summary>
|
|||
/// <param name="code">The code</param>
|
|||
/// <param name="codeLength">The code length</param>
|
|||
/// <returns>The value</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public int GetValue(int code, int codeLength) |
|||
{ |
|||
return this.Values[this.Indices[codeLength] + code - this.MinCodes[codeLength]]; |
|||
} |
|||
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
internal struct FixedInt32Buffer256 |
|||
{ |
|||
public fixed int Data[256]; |
|||
|
|||
public int this[int idx] |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
get |
|||
{ |
|||
ref int self = ref Unsafe.As<FixedInt32Buffer256, int>(ref this); |
|||
return Unsafe.Add(ref self, idx); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
internal struct FixedInt32Buffer16 |
|||
{ |
|||
public fixed int Data[16]; |
|||
|
|||
public int this[int idx] |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
get |
|||
{ |
|||
ref int self = ref Unsafe.As<FixedInt32Buffer16, int>(ref this); |
|||
return Unsafe.Add(ref self, idx); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,53 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Runtime.InteropServices; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <content>
|
|||
/// Conains the definition of <see cref="ComputationData"/>
|
|||
/// </content>
|
|||
internal unsafe partial struct GolangJpegScanDecoder |
|||
{ |
|||
/// <summary>
|
|||
/// Holds the "large" data blocks needed for computations.
|
|||
/// </summary>
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
public struct ComputationData |
|||
{ |
|||
/// <summary>
|
|||
/// The main input/working block
|
|||
/// </summary>
|
|||
public Block8x8 Block; |
|||
|
|||
/// <summary>
|
|||
/// The jpeg unzig data
|
|||
/// </summary>
|
|||
public ZigZag Unzig; |
|||
|
|||
/// <summary>
|
|||
/// The buffer storing the <see cref="GolangComponentScan"/>-s for each component
|
|||
/// </summary>
|
|||
public fixed byte ScanData[3 * GolangJpegDecoderCore.MaxComponents]; |
|||
|
|||
/// <summary>
|
|||
/// The DC values for each component
|
|||
/// </summary>
|
|||
public fixed int Dc[GolangJpegDecoderCore.MaxComponents]; |
|||
|
|||
/// <summary>
|
|||
/// Creates and initializes a new <see cref="ComputationData"/> instance
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="ComputationData"/></returns>
|
|||
public static ComputationData Create() |
|||
{ |
|||
ComputationData data = default; |
|||
data.Unzig = ZigZag.CreateUnzigTable(); |
|||
return data; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,51 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <content>
|
|||
/// Conains the definition of <see cref="DataPointers"/>
|
|||
/// </content>
|
|||
internal unsafe partial struct GolangJpegScanDecoder |
|||
{ |
|||
/// <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"/>
|
|||
/// </summary>
|
|||
public struct DataPointers |
|||
{ |
|||
/// <summary>
|
|||
/// Pointer to <see cref="ComputationData.Block"/>
|
|||
/// </summary>
|
|||
public Block8x8* Block; |
|||
|
|||
/// <summary>
|
|||
/// Pointer to <see cref="ComputationData.Unzig"/> as byte*
|
|||
/// </summary>
|
|||
public byte* Unzig; |
|||
|
|||
/// <summary>
|
|||
/// Pointer to <see cref="ComputationData.ScanData"/> as Scan*
|
|||
/// </summary>
|
|||
public GolangComponentScan* ComponentScan; |
|||
|
|||
/// <summary>
|
|||
/// Pointer to <see cref="ComputationData.Dc"/>
|
|||
/// </summary>
|
|||
public int* Dc; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DataPointers" /> struct.
|
|||
/// </summary>
|
|||
/// <param name="basePtr">The pointer pointing to <see cref="ComputationData"/></param>
|
|||
public DataPointers(ComputationData* basePtr) |
|||
{ |
|||
this.Block = &basePtr->Block; |
|||
this.Unzig = basePtr->Unzig.Data; |
|||
this.ComponentScan = (GolangComponentScan*)basePtr->ScanData; |
|||
this.Dc = basePtr->Dc; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,705 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components; |
|||
|
|||
// ReSharper disable InconsistentNaming
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Encapsulates the impementation of Jpeg SOS Huffman decoding. See JpegScanDecoder.md!
|
|||
///
|
|||
/// <see cref="zigStart"/> and <see cref="zigEnd"/> are the spectral selection bounds.
|
|||
/// <see cref="ah"/> and <see cref="al"/> are the successive approximation high and low values.
|
|||
/// The spec calls these values Ss, Se, Ah and Al.
|
|||
/// For progressive JPEGs, these are the two more-or-less independent
|
|||
/// aspects of progression. Spectral selection progression is when not
|
|||
/// all of a block's 64 DCT coefficients are transmitted in one pass.
|
|||
/// For example, three passes could transmit coefficient 0 (the DC
|
|||
/// component), coefficients 1-5, and coefficients 6-63, in zig-zag
|
|||
/// order. Successive approximation is when not all of the bits of a
|
|||
/// band of coefficients are transmitted in one pass. For example,
|
|||
/// three passes could transmit the 6 most significant bits, followed
|
|||
/// by the second-least significant bit, followed by the least
|
|||
/// significant bit.
|
|||
/// For baseline JPEGs, these parameters are hard-coded to 0/63/0/0.
|
|||
/// </summary>
|
|||
[StructLayout(LayoutKind.Sequential)] |
|||
internal unsafe partial struct GolangJpegScanDecoder |
|||
{ |
|||
// The JpegScanDecoder members should be ordered in a way that results in optimal memory layout.
|
|||
#pragma warning disable SA1202 // ElementsMustBeOrderedByAccess
|
|||
|
|||
/// <summary>
|
|||
/// The <see cref="ComputationData"/> buffer
|
|||
/// </summary>
|
|||
private ComputationData data; |
|||
|
|||
/// <summary>
|
|||
/// Pointers to elements of <see cref="data"/>
|
|||
/// </summary>
|
|||
private DataPointers pointers; |
|||
|
|||
/// <summary>
|
|||
/// The current component index
|
|||
/// </summary>
|
|||
public int ComponentIndex; |
|||
|
|||
/// <summary>
|
|||
/// X coordinate of the current block, in units of 8x8. (The third block in the first row has (bx, by) = (2, 0))
|
|||
/// </summary>
|
|||
private int bx; |
|||
|
|||
/// <summary>
|
|||
/// Y coordinate of the current block, in units of 8x8. (The third block in the first row has (bx, by) = (2, 0))
|
|||
/// </summary>
|
|||
private int by; |
|||
|
|||
/// <summary>
|
|||
/// Start index of the zig-zag selection bound
|
|||
/// </summary>
|
|||
private int zigStart; |
|||
|
|||
/// <summary>
|
|||
/// End index of the zig-zag selection bound
|
|||
/// </summary>
|
|||
private int zigEnd; |
|||
|
|||
/// <summary>
|
|||
/// Successive approximation high value
|
|||
/// </summary>
|
|||
private int ah; |
|||
|
|||
/// <summary>
|
|||
/// Successive approximation low value
|
|||
/// </summary>
|
|||
private int al; |
|||
|
|||
/// <summary>
|
|||
/// The number of component scans
|
|||
/// </summary>
|
|||
private int componentScanCount; |
|||
|
|||
/// <summary>
|
|||
/// Horizontal sampling factor at the current component index
|
|||
/// </summary>
|
|||
private int hi; |
|||
|
|||
/// <summary>
|
|||
/// End-of-Band run, specified in section G.1.2.2.
|
|||
/// </summary>
|
|||
private int eobRun; |
|||
|
|||
/// <summary>
|
|||
/// The block counter
|
|||
/// </summary>
|
|||
private int blockCounter; |
|||
|
|||
/// <summary>
|
|||
/// The MCU counter
|
|||
/// </summary>
|
|||
private int mcuCounter; |
|||
|
|||
/// <summary>
|
|||
/// The expected RST marker value
|
|||
/// </summary>
|
|||
private byte expectedRst; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a default-constructed <see cref="GolangJpegScanDecoder"/> instance for reading data from <see cref="GolangJpegDecoderCore"/>-s stream.
|
|||
/// </summary>
|
|||
/// <param name="p">Pointer to <see cref="GolangJpegScanDecoder"/> on the stack</param>
|
|||
/// <param name="decoder">The <see cref="GolangJpegDecoderCore"/> instance</param>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
public static void InitStreamReading(GolangJpegScanDecoder* p, GolangJpegDecoderCore decoder, int remaining) |
|||
{ |
|||
p->data = ComputationData.Create(); |
|||
p->pointers = new DataPointers(&p->data); |
|||
p->InitStreamReadingImpl(decoder, remaining); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read Huffman data from Jpeg scans in <see cref="GolangJpegDecoderCore.InputStream"/>,
|
|||
/// and decode it as <see cref="Block8x8"/> into <see cref="GolangComponent.SpectralBlocks"/>.
|
|||
///
|
|||
/// 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.
|
|||
/// For a baseline 32x16 pixel image, the Y blocks visiting order is:
|
|||
/// 0 1 4 5
|
|||
/// 2 3 6 7
|
|||
/// For progressive images, the interleaved scans (those with component count > 1)
|
|||
/// are traversed as above, but non-interleaved scans are traversed left
|
|||
/// to right, top to bottom:
|
|||
/// 0 1 2 3
|
|||
/// 4 5 6 7
|
|||
/// Only DC scans (zigStart == 0) can be interleave AC scans must have
|
|||
/// only one component.
|
|||
/// To further complicate matters, for non-interleaved scans, there is no
|
|||
/// data for any blocks that are inside the image at the MCU level but
|
|||
/// outside the image at the pixel level. For example, a 24x16 pixel 4:2:0
|
|||
/// progressive image consists of two 16x16 MCUs. The interleaved scans
|
|||
/// will process 8 Y blocks:
|
|||
/// 0 1 4 5
|
|||
/// 2 3 6 7
|
|||
/// The non-interleaved scans will process only 6 Y blocks:
|
|||
/// 0 1 2
|
|||
/// 3 4 5
|
|||
/// </summary>
|
|||
/// <param name="decoder">The <see cref="GolangJpegDecoderCore"/> instance</param>
|
|||
public void DecodeBlocks(GolangJpegDecoderCore decoder) |
|||
{ |
|||
decoder.InputProcessor.ResetErrorState(); |
|||
|
|||
this.blockCounter = 0; |
|||
this.mcuCounter = 0; |
|||
this.expectedRst = JpegConstants.Markers.RST0; |
|||
|
|||
for (int my = 0; my < decoder.MCUCountY; my++) |
|||
{ |
|||
for (int mx = 0; mx < decoder.MCUCountX; mx++) |
|||
{ |
|||
this.DecodeBlocksAtMcuIndex(decoder, mx, my); |
|||
|
|||
this.mcuCounter++; |
|||
|
|||
// Handling restart intervals
|
|||
// Useful info: https://stackoverflow.com/a/8751802
|
|||
if (decoder.IsAtRestartInterval(this.mcuCounter)) |
|||
{ |
|||
this.ProcessRSTMarker(decoder); |
|||
this.Reset(decoder); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void DecodeBlocksAtMcuIndex(GolangJpegDecoderCore decoder, int mx, int my) |
|||
{ |
|||
for (int scanIndex = 0; scanIndex < this.componentScanCount; scanIndex++) |
|||
{ |
|||
this.ComponentIndex = this.pointers.ComponentScan[scanIndex].ComponentIndex; |
|||
GolangComponent component = decoder.Components[this.ComponentIndex]; |
|||
|
|||
this.hi = component.HorizontalSamplingFactor; |
|||
int vi = component.VerticalSamplingFactor; |
|||
|
|||
for (int j = 0; j < this.hi * vi; j++) |
|||
{ |
|||
if (this.componentScanCount != 1) |
|||
{ |
|||
this.bx = (this.hi * mx) + (j % this.hi); |
|||
this.by = (vi * my) + (j / this.hi); |
|||
} |
|||
else |
|||
{ |
|||
int q = decoder.MCUCountX * this.hi; |
|||
this.bx = this.blockCounter % q; |
|||
this.by = this.blockCounter / q; |
|||
this.blockCounter++; |
|||
if (this.bx * 8 >= decoder.ImageWidth || this.by * 8 >= decoder.ImageHeight) |
|||
{ |
|||
continue; |
|||
} |
|||
} |
|||
|
|||
// Find the block at (bx,by) in the component's buffer:
|
|||
ref Block8x8 blockRefOnHeap = ref component.GetBlockReference(this.bx, this.by); |
|||
|
|||
// Copy block to stack
|
|||
this.data.Block = blockRefOnHeap; |
|||
|
|||
if (!decoder.InputProcessor.ReachedEOF) |
|||
{ |
|||
this.DecodeBlock(decoder, scanIndex); |
|||
} |
|||
|
|||
// Store the result block:
|
|||
blockRefOnHeap = this.data.Block; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void ProcessRSTMarker(GolangJpegDecoderCore decoder) |
|||
{ |
|||
// Attempt to look for RST[0-7] markers to resynchronize from corrupt input.
|
|||
if (!decoder.InputProcessor.ReachedEOF) |
|||
{ |
|||
decoder.InputProcessor.ReadFullUnsafe(decoder.Temp, 0, 2); |
|||
if (decoder.InputProcessor.CheckEOFEnsureNoError()) |
|||
{ |
|||
if (decoder.Temp[0] != 0xFF || decoder.Temp[1] != this.expectedRst) |
|||
{ |
|||
bool invalidRst = true; |
|||
|
|||
// Most jpeg's containing well-formed input will have a RST[0-7] marker following immediately
|
|||
// but some, see Issue #481, contain padding bytes "0xFF" before the RST[0-7] marker.
|
|||
// If we identify that case we attempt to read until we have bypassed the padded bytes.
|
|||
// We then check again for our RST marker and throw if invalid.
|
|||
// No other methods are attempted to resynchronize from corrupt input.
|
|||
if (decoder.Temp[0] == 0xFF && decoder.Temp[1] == 0xFF) |
|||
{ |
|||
while (decoder.Temp[0] == 0xFF && decoder.InputProcessor.CheckEOFEnsureNoError()) |
|||
{ |
|||
decoder.InputProcessor.ReadFullUnsafe(decoder.Temp, 0, 1); |
|||
if (!decoder.InputProcessor.CheckEOFEnsureNoError()) |
|||
{ |
|||
break; |
|||
} |
|||
} |
|||
|
|||
// Have we found a valid restart marker?
|
|||
invalidRst = decoder.Temp[0] != this.expectedRst; |
|||
} |
|||
|
|||
if (invalidRst) |
|||
{ |
|||
throw new ImageFormatException("Bad RST marker"); |
|||
} |
|||
} |
|||
|
|||
this.expectedRst++; |
|||
if (this.expectedRst == JpegConstants.Markers.RST7 + 1) |
|||
{ |
|||
this.expectedRst = JpegConstants.Markers.RST0; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void Reset(GolangJpegDecoderCore decoder) |
|||
{ |
|||
decoder.InputProcessor.ResetHuffmanDecoder(); |
|||
|
|||
this.ResetDcValues(); |
|||
|
|||
// Reset the progressive decoder state, as per section G.1.2.2.
|
|||
this.eobRun = 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reset the DC components, as per section F.2.1.3.1.
|
|||
/// </summary>
|
|||
private void ResetDcValues() |
|||
{ |
|||
Unsafe.InitBlock(this.pointers.Dc, default, sizeof(int) * GolangJpegDecoderCore.MaxComponents); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The implementation part of <see cref="InitStreamReading"/> as an instance method.
|
|||
/// </summary>
|
|||
/// <param name="decoder">The <see cref="GolangJpegDecoderCore"/></param>
|
|||
/// <param name="remaining">The remaining bytes</param>
|
|||
private void InitStreamReadingImpl(GolangJpegDecoderCore decoder, int remaining) |
|||
{ |
|||
if (decoder.ComponentCount == 0) |
|||
{ |
|||
throw new ImageFormatException("Missing SOF marker"); |
|||
} |
|||
|
|||
if (remaining < 6 || 4 + (2 * decoder.ComponentCount) < remaining || remaining % 2 != 0) |
|||
{ |
|||
throw new ImageFormatException("SOS has wrong length"); |
|||
} |
|||
|
|||
decoder.InputProcessor.ReadFull(decoder.Temp, 0, remaining); |
|||
this.componentScanCount = decoder.Temp[0]; |
|||
|
|||
int scanComponentCountX2 = 2 * this.componentScanCount; |
|||
if (remaining != 4 + scanComponentCountX2) |
|||
{ |
|||
throw new ImageFormatException("SOS length inconsistent with number of components"); |
|||
} |
|||
|
|||
int totalHv = 0; |
|||
|
|||
for (int i = 0; i < this.componentScanCount; i++) |
|||
{ |
|||
this.InitComponentScan(decoder, i, ref this.pointers.ComponentScan[i], ref totalHv); |
|||
} |
|||
|
|||
// Section B.2.3 states that if there is more than one component then the
|
|||
// total H*V values in a scan must be <= 10.
|
|||
if (decoder.ComponentCount > 1 && totalHv > 10) |
|||
{ |
|||
throw new ImageFormatException("Total sampling factors too large."); |
|||
} |
|||
|
|||
this.zigEnd = Block8x8F.Size - 1; |
|||
|
|||
if (decoder.IsProgressive) |
|||
{ |
|||
this.zigStart = decoder.Temp[1 + scanComponentCountX2]; |
|||
this.zigEnd = decoder.Temp[2 + scanComponentCountX2]; |
|||
this.ah = decoder.Temp[3 + scanComponentCountX2] >> 4; |
|||
this.al = decoder.Temp[3 + scanComponentCountX2] & 0x0f; |
|||
|
|||
if ((this.zigStart == 0 && this.zigEnd != 0) || this.zigStart > this.zigEnd |
|||
|| this.zigEnd >= Block8x8F.Size) |
|||
{ |
|||
throw new ImageFormatException("Bad spectral selection bounds"); |
|||
} |
|||
|
|||
if (this.zigStart != 0 && this.componentScanCount != 1) |
|||
{ |
|||
throw new ImageFormatException("Progressive AC coefficients for more than one component"); |
|||
} |
|||
|
|||
if (this.ah != 0 && this.ah != this.al + 1) |
|||
{ |
|||
throw new ImageFormatException("Bad successive approximation values"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read the current the current block at (<see cref="bx"/>, <see cref="by"/>) from the decoders stream
|
|||
/// </summary>
|
|||
/// <param name="decoder">The decoder</param>
|
|||
/// <param name="scanIndex">The index of the scan</param>
|
|||
private void DecodeBlock(GolangJpegDecoderCore decoder, int scanIndex) |
|||
{ |
|||
Block8x8* b = this.pointers.Block; |
|||
int huffmannIdx = (GolangHuffmanTree.AcTableIndex * GolangHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].AcTableSelector; |
|||
if (this.ah != 0) |
|||
{ |
|||
this.Refine(ref decoder.InputProcessor, ref decoder.HuffmanTrees[huffmannIdx], 1 << this.al); |
|||
} |
|||
else |
|||
{ |
|||
int zig = this.zigStart; |
|||
|
|||
if (zig == 0) |
|||
{ |
|||
zig++; |
|||
|
|||
// Decode the DC coefficient, as specified in section F.2.2.1.
|
|||
int huffmanIndex = (GolangHuffmanTree.DcTableIndex * GolangHuffmanTree.ThRowSize) + this.pointers.ComponentScan[scanIndex].DcTableSelector; |
|||
decoder.InputProcessor.DecodeHuffmanUnsafe( |
|||
ref decoder.HuffmanTrees[huffmanIndex], |
|||
out int value); |
|||
if (!decoder.InputProcessor.CheckEOF()) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (value > 16) |
|||
{ |
|||
throw new ImageFormatException("Excessive DC component"); |
|||
} |
|||
|
|||
decoder.InputProcessor.ReceiveExtendUnsafe(value, out int deltaDC); |
|||
if (!decoder.InputProcessor.CheckEOFEnsureNoError()) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
this.pointers.Dc[this.ComponentIndex] += deltaDC; |
|||
|
|||
// b[0] = dc[compIndex] << al;
|
|||
value = this.pointers.Dc[this.ComponentIndex] << this.al; |
|||
Block8x8.SetScalarAt(b, 0, (short)value); |
|||
} |
|||
|
|||
if (zig <= this.zigEnd && this.eobRun > 0) |
|||
{ |
|||
this.eobRun--; |
|||
} |
|||
else |
|||
{ |
|||
// Decode the AC coefficients, as specified in section F.2.2.2.
|
|||
for (; zig <= this.zigEnd; zig++) |
|||
{ |
|||
decoder.InputProcessor.DecodeHuffmanUnsafe(ref decoder.HuffmanTrees[huffmannIdx], out int value); |
|||
if (decoder.InputProcessor.HasError) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
int val0 = value >> 4; |
|||
int val1 = value & 0x0f; |
|||
if (val1 != 0) |
|||
{ |
|||
zig += val0; |
|||
if (zig > this.zigEnd) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
decoder.InputProcessor.ReceiveExtendUnsafe(val1, out int ac); |
|||
if (decoder.InputProcessor.HasError) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
// b[Unzig[zig]] = ac << al;
|
|||
value = ac << this.al; |
|||
Block8x8.SetScalarAt(b, this.pointers.Unzig[zig], (short)value); |
|||
} |
|||
else |
|||
{ |
|||
if (val0 != 0x0f) |
|||
{ |
|||
this.eobRun = (ushort)(1 << val0); |
|||
if (val0 != 0) |
|||
{ |
|||
this.DecodeEobRun(val0, ref decoder.InputProcessor); |
|||
if (!decoder.InputProcessor.CheckEOFEnsureNoError()) |
|||
{ |
|||
return; |
|||
} |
|||
} |
|||
|
|||
this.eobRun--; |
|||
break; |
|||
} |
|||
|
|||
zig += 0x0f; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void DecodeEobRun(int count, ref InputProcessor processor) |
|||
{ |
|||
processor.DecodeBitsUnsafe(count, out int bitsResult); |
|||
if (processor.LastErrorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
this.eobRun |= bitsResult; |
|||
} |
|||
|
|||
private void InitComponentScan(GolangJpegDecoderCore decoder, int i, ref GolangComponentScan currentComponentScan, ref int totalHv) |
|||
{ |
|||
// Component selector.
|
|||
int cs = decoder.Temp[1 + (2 * i)]; |
|||
int compIndex = -1; |
|||
for (int j = 0; j < decoder.ComponentCount; j++) |
|||
{ |
|||
// Component compv = ;
|
|||
if (cs == decoder.Components[j].Identifier) |
|||
{ |
|||
compIndex = j; |
|||
} |
|||
} |
|||
|
|||
if (compIndex < 0) |
|||
{ |
|||
throw new ImageFormatException("Unknown component selector"); |
|||
} |
|||
|
|||
currentComponentScan.ComponentIndex = (byte)compIndex; |
|||
|
|||
this.ProcessComponentImpl(decoder, i, ref currentComponentScan, ref totalHv, decoder.Components[compIndex]); |
|||
} |
|||
|
|||
private void ProcessComponentImpl( |
|||
GolangJpegDecoderCore decoder, |
|||
int i, |
|||
ref GolangComponentScan currentComponentScan, |
|||
ref int totalHv, |
|||
GolangComponent 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
|
|||
// verified that a frame's component identifiers (C_i values in section
|
|||
// B.2.2) are unique, it suffices to check that the implicit indexes
|
|||
// into comp are unique.
|
|||
for (int j = 0; j < i; j++) |
|||
{ |
|||
if (currentComponentScan.ComponentIndex == this.pointers.ComponentScan[j].ComponentIndex) |
|||
{ |
|||
throw new ImageFormatException("Repeated component selector"); |
|||
} |
|||
} |
|||
|
|||
totalHv += currentComponent.HorizontalSamplingFactor * currentComponent.VerticalSamplingFactor; |
|||
|
|||
currentComponentScan.DcTableSelector = (byte)(decoder.Temp[2 + (2 * i)] >> 4); |
|||
if (currentComponentScan.DcTableSelector > GolangHuffmanTree.MaxTh) |
|||
{ |
|||
throw new ImageFormatException("Bad DC table selector value"); |
|||
} |
|||
|
|||
currentComponentScan.AcTableSelector = (byte)(decoder.Temp[2 + (2 * i)] & 0x0f); |
|||
if (currentComponentScan.AcTableSelector > GolangHuffmanTree.MaxTh) |
|||
{ |
|||
throw new ImageFormatException("Bad AC table selector value"); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes a successive approximation refinement block, as specified in section G.1.2.
|
|||
/// </summary>
|
|||
/// <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 GolangHuffmanTree h, int delta) |
|||
{ |
|||
Block8x8* b = this.pointers.Block; |
|||
|
|||
// Refining a DC component is trivial.
|
|||
if (this.zigStart == 0) |
|||
{ |
|||
if (this.zigEnd != 0) |
|||
{ |
|||
throw new ImageFormatException("Invalid state for zig DC component"); |
|||
} |
|||
|
|||
bp.DecodeBitUnsafe(out bool bit); |
|||
if (!bp.CheckEOFEnsureNoError()) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (bit) |
|||
{ |
|||
int stuff = Block8x8.GetScalarAt(b, 0); |
|||
|
|||
// int stuff = (int)b[0];
|
|||
stuff |= delta; |
|||
|
|||
// b[0] = stuff;
|
|||
Block8x8.SetScalarAt(b, 0, (short)stuff); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
// Refining AC components is more complicated; see sections G.1.2.2 and G.1.2.3.
|
|||
int zig = this.zigStart; |
|||
if (this.eobRun == 0) |
|||
{ |
|||
for (; zig <= this.zigEnd; zig++) |
|||
{ |
|||
bool done = false; |
|||
int z = 0; |
|||
|
|||
bp.DecodeHuffmanUnsafe(ref h, out int val); |
|||
if (!bp.CheckEOF()) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
int val0 = val >> 4; |
|||
int val1 = val & 0x0f; |
|||
|
|||
switch (val1) |
|||
{ |
|||
case 0: |
|||
if (val0 != 0x0f) |
|||
{ |
|||
this.eobRun = 1 << val0; |
|||
if (val0 != 0) |
|||
{ |
|||
this.DecodeEobRun(val0, ref bp); |
|||
if (!bp.CheckEOFEnsureNoError()) |
|||
{ |
|||
return; |
|||
} |
|||
} |
|||
|
|||
done = true; |
|||
} |
|||
|
|||
break; |
|||
case 1: |
|||
z = delta; |
|||
|
|||
bp.DecodeBitUnsafe(out bool bit); |
|||
if (!bp.CheckEOFEnsureNoError()) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (!bit) |
|||
{ |
|||
z = -z; |
|||
} |
|||
|
|||
break; |
|||
default: |
|||
throw new ImageFormatException("Unexpected Huffman code"); |
|||
} |
|||
|
|||
if (done) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
zig = this.RefineNonZeroes(ref bp, zig, val0, delta); |
|||
|
|||
if (bp.ReachedEOF || bp.HasError) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (z != 0 && zig <= this.zigEnd) |
|||
{ |
|||
// b[Unzig[zig]] = z;
|
|||
Block8x8.SetScalarAt(b, this.pointers.Unzig[zig], (short)z); |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (this.eobRun > 0) |
|||
{ |
|||
this.eobRun--; |
|||
this.RefineNonZeroes(ref bp, zig, -1, delta); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Refines non-zero entries of b in zig-zag order.
|
|||
/// If <paramref name="nz" /> >= 0, the first <paramref name="nz" /> zero entries are skipped over.
|
|||
/// </summary>
|
|||
/// <param name="bp">The <see cref="InputProcessor"/></param>
|
|||
/// <param name="zig">The zig-zag start index</param>
|
|||
/// <param name="nz">The non-zero entry</param>
|
|||
/// <param name="delta">The low transform offset</param>
|
|||
/// <returns>The <see cref="int" /></returns>
|
|||
private int RefineNonZeroes(ref InputProcessor bp, int zig, int nz, int delta) |
|||
{ |
|||
Block8x8* b = this.pointers.Block; |
|||
for (; zig <= this.zigEnd; zig++) |
|||
{ |
|||
int u = this.pointers.Unzig[zig]; |
|||
int bu = Block8x8.GetScalarAt(b, u); |
|||
|
|||
// TODO: Are the equality comparsions OK with floating point values? Isn't an epsilon value necessary?
|
|||
if (bu == 0) |
|||
{ |
|||
if (nz == 0) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
nz--; |
|||
continue; |
|||
} |
|||
|
|||
bp.DecodeBitUnsafe(out bool bit); |
|||
if (bp.HasError) |
|||
{ |
|||
return int.MinValue; |
|||
} |
|||
|
|||
if (!bit) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
int val = bu >= 0 ? bu + delta : bu - delta; |
|||
|
|||
Block8x8.SetScalarAt(b, u, (short)val); |
|||
} |
|||
|
|||
return zig; |
|||
} |
|||
} |
|||
} |
|||
@ -1,392 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// Encapsulates stream reading and processing data and operations for <see cref="GolangJpegDecoderCore"/>.
|
|||
/// It's a value type for imporved data locality, and reduced number of CALLVIRT-s
|
|||
/// </summary>
|
|||
internal struct InputProcessor : IDisposable |
|||
{ |
|||
/// <summary>
|
|||
/// Holds the unprocessed bits that have been taken from the byte-stream.
|
|||
/// </summary>
|
|||
public Bits Bits; |
|||
|
|||
/// <summary>
|
|||
/// The byte buffer
|
|||
/// </summary>
|
|||
public Bytes Bytes; |
|||
|
|||
/// <summary>
|
|||
/// 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="GolangJpegDecoderCore.Temp"/></param>
|
|||
public InputProcessor(Stream inputStream, byte[] temp) |
|||
{ |
|||
this.Bits = default; |
|||
this.Bytes = Bytes.Create(); |
|||
this.InputStream = inputStream; |
|||
this.Temp = temp; |
|||
this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the input stream
|
|||
/// </summary>
|
|||
public Stream InputStream { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the temporary buffer, same instance as <see cref="GolangJpegDecoderCore.Temp"/>
|
|||
/// </summary>
|
|||
public byte[] Temp { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether an unexpected EOF reached in <see cref="InputStream"/>.
|
|||
/// </summary>
|
|||
public bool ReachedEOF => this.LastErrorCode == GolangDecoderErrorCode.UnexpectedEndOfStream; |
|||
|
|||
public bool HasError => this.LastErrorCode != GolangDecoderErrorCode.NoError; |
|||
|
|||
public GolangDecoderErrorCode LastErrorCode { get; private set; } |
|||
|
|||
public void ResetErrorState() => this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
|
|||
/// <summary>
|
|||
/// If errorCode indicates unexpected EOF, sets <see cref="ReachedEOF"/> to true and returns false.
|
|||
/// Calls <see cref="DecoderThrowHelper.EnsureNoError"/> and returns true otherwise.
|
|||
/// </summary>
|
|||
/// <returns>A <see cref="bool"/> indicating whether EOF reached</returns>
|
|||
public bool CheckEOFEnsureNoError() |
|||
{ |
|||
if (this.LastErrorCode == GolangDecoderErrorCode.UnexpectedEndOfStream) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
this.LastErrorCode.EnsureNoError(); |
|||
return true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// If errorCode indicates unexpected EOF, sets <see cref="ReachedEOF"/> to true and returns false.
|
|||
/// Returns true otherwise.
|
|||
/// </summary>
|
|||
/// <returns>A <see cref="bool"/> indicating whether EOF reached</returns>
|
|||
public bool CheckEOF() |
|||
{ |
|||
if (this.LastErrorCode == GolangDecoderErrorCode.UnexpectedEndOfStream) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
public void Dispose() |
|||
{ |
|||
this.Bytes.Dispose(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the next byte, whether buffered or not buffered. It does not care about byte stuffing.
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="byte" /></returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public byte ReadByte() |
|||
{ |
|||
return this.Bytes.ReadByte(this.InputStream); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public GolangDecoderErrorCode ReadByteUnsafe(out byte result) |
|||
{ |
|||
this.LastErrorCode = this.Bytes.ReadByteUnsafe(this.InputStream, out result); |
|||
return this.LastErrorCode; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes a single bit
|
|||
/// 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="GolangDecoderErrorCode" /></returns>
|
|||
public GolangDecoderErrorCode DecodeBitUnsafe(out bool result) |
|||
{ |
|||
if (this.Bits.UnreadBits == 0) |
|||
{ |
|||
this.LastErrorCode = this.Bits.Ensure1BitUnsafe(ref this); |
|||
if (this.LastErrorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
result = false; |
|||
return this.LastErrorCode; |
|||
} |
|||
} |
|||
|
|||
result = (this.Bits.Accumulator & this.Bits.Mask) != 0; |
|||
this.Bits.UnreadBits--; |
|||
this.Bits.Mask >>= 1; |
|||
return this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads exactly length bytes into data. It does not care about byte stuffing.
|
|||
/// Does not throw on errors, returns <see cref="GolangJpegDecoderCore"/> 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="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode ReadFullUnsafe(byte[] data, int offset, int length) |
|||
{ |
|||
// Unread the overshot bytes, if any.
|
|||
if (this.Bytes.UnreadableBytes != 0) |
|||
{ |
|||
if (this.Bits.UnreadBits >= 8) |
|||
{ |
|||
this.UnreadByteStuffedByte(); |
|||
} |
|||
|
|||
this.Bytes.UnreadableBytes = 0; |
|||
} |
|||
|
|||
this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
while (length > 0 && this.LastErrorCode == GolangDecoderErrorCode.NoError) |
|||
{ |
|||
if (this.Bytes.J - this.Bytes.I >= length) |
|||
{ |
|||
Array.Copy(this.Bytes.Buffer, this.Bytes.I, data, offset, length); |
|||
this.Bytes.I += length; |
|||
length -= length; |
|||
} |
|||
else |
|||
{ |
|||
Array.Copy(this.Bytes.Buffer, this.Bytes.I, data, offset, this.Bytes.J - this.Bytes.I); |
|||
offset += this.Bytes.J - this.Bytes.I; |
|||
length -= this.Bytes.J - this.Bytes.I; |
|||
this.Bytes.I += this.Bytes.J - this.Bytes.I; |
|||
|
|||
this.LastErrorCode = this.Bytes.FillUnsafe(this.InputStream); |
|||
} |
|||
} |
|||
|
|||
return this.LastErrorCode; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the given number of bits
|
|||
/// </summary>
|
|||
/// <param name="count">The number of bits to decode.</param>
|
|||
/// <param name="result">The <see cref="uint" /> result</param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode DecodeBitsUnsafe(int count, out int result) |
|||
{ |
|||
if (this.Bits.UnreadBits < count) |
|||
{ |
|||
this.LastErrorCode = this.Bits.EnsureNBitsUnsafe(count, ref this); |
|||
if (this.LastErrorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
result = 0; |
|||
return this.LastErrorCode; |
|||
} |
|||
} |
|||
|
|||
result = this.Bits.Accumulator >> (this.Bits.UnreadBits - count); |
|||
result = result & ((1 << count) - 1); |
|||
this.Bits.UnreadBits -= count; |
|||
this.Bits.Mask >>= count; |
|||
return this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Extracts the next Huffman-coded value from the bit-stream into result, decoded according to the given value.
|
|||
/// </summary>
|
|||
/// <param name="huffmanTree">The huffman value</param>
|
|||
/// <param name="result">The decoded <see cref="byte" /></param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode DecodeHuffmanUnsafe(ref GolangHuffmanTree huffmanTree, out int result) |
|||
{ |
|||
result = 0; |
|||
|
|||
if (huffmanTree.Length == 0) |
|||
{ |
|||
DecoderThrowHelper.ThrowImageFormatException.UninitializedHuffmanTable(); |
|||
} |
|||
|
|||
if (this.Bits.UnreadBits < 8) |
|||
{ |
|||
this.LastErrorCode = this.Bits.Ensure8BitsUnsafe(ref this); |
|||
|
|||
if (this.LastErrorCode == GolangDecoderErrorCode.NoError) |
|||
{ |
|||
int lutIndex = (this.Bits.Accumulator >> (this.Bits.UnreadBits - GolangHuffmanTree.LutSizeLog2)) & 0xFF; |
|||
int v = huffmanTree.Lut[lutIndex]; |
|||
|
|||
if (v != 0) |
|||
{ |
|||
int n = (v & 0xFF) - 1; |
|||
this.Bits.UnreadBits -= n; |
|||
this.Bits.Mask >>= n; |
|||
result = v >> 8; |
|||
return this.LastErrorCode; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
this.UnreadByteStuffedByte(); |
|||
return this.LastErrorCode; |
|||
} |
|||
} |
|||
|
|||
int code = 0; |
|||
for (int i = 0; i < GolangHuffmanTree.MaxCodeLength; i++) |
|||
{ |
|||
if (this.Bits.UnreadBits == 0) |
|||
{ |
|||
this.LastErrorCode = this.Bits.EnsureNBitsUnsafe(1, ref this); |
|||
|
|||
if (this.HasError) |
|||
{ |
|||
return this.LastErrorCode; |
|||
} |
|||
} |
|||
|
|||
if ((this.Bits.Accumulator & this.Bits.Mask) != 0) |
|||
{ |
|||
code |= 1; |
|||
} |
|||
|
|||
this.Bits.UnreadBits--; |
|||
this.Bits.Mask >>= 1; |
|||
|
|||
if (code <= huffmanTree.MaxCodes[i]) |
|||
{ |
|||
result = huffmanTree.GetValue(code, i); |
|||
return this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
code <<= 1; |
|||
} |
|||
|
|||
// Unrecoverable error, throwing:
|
|||
DecoderThrowHelper.ThrowImageFormatException.BadHuffmanCode(); |
|||
|
|||
// DUMMY RETURN! C# doesn't know we have thrown an exception!
|
|||
return GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Skips the next n bytes.
|
|||
/// </summary>
|
|||
/// <param name="count">The number of bytes to ignore.</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void Skip(int count) |
|||
{ |
|||
this.LastErrorCode = this.SkipUnsafe(count); |
|||
this.LastErrorCode.EnsureNoError(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Skips the next n bytes.
|
|||
/// Does not throw, returns <see cref="GolangDecoderErrorCode"/> instead!
|
|||
/// </summary>
|
|||
/// <param name="count">The number of bytes to ignore.</param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode SkipUnsafe(int count) |
|||
{ |
|||
// Unread the overshot bytes, if any.
|
|||
if (this.Bytes.UnreadableBytes != 0) |
|||
{ |
|||
if (this.Bits.UnreadBits >= 8) |
|||
{ |
|||
this.UnreadByteStuffedByte(); |
|||
} |
|||
|
|||
this.Bytes.UnreadableBytes = 0; |
|||
} |
|||
|
|||
while (true) |
|||
{ |
|||
int m = this.Bytes.J - this.Bytes.I; |
|||
if (m > count) |
|||
{ |
|||
m = count; |
|||
} |
|||
|
|||
this.Bytes.I += m; |
|||
count -= m; |
|||
if (count == 0) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
this.LastErrorCode = this.Bytes.FillUnsafe(this.InputStream); |
|||
if (this.LastErrorCode != GolangDecoderErrorCode.NoError) |
|||
{ |
|||
return this.LastErrorCode; |
|||
} |
|||
} |
|||
|
|||
return this.LastErrorCode = GolangDecoderErrorCode.NoError; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads exactly length bytes into data. It does not care about byte stuffing.
|
|||
/// </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>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void ReadFull(byte[] data, int offset, int length) |
|||
{ |
|||
this.LastErrorCode = this.ReadFullUnsafe(data, offset, length); |
|||
this.LastErrorCode.EnsureNoError(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Undoes the most recent ReadByteStuffedByte call,
|
|||
/// giving a byte of data back from bits to bytes. The Huffman look-up table
|
|||
/// requires at least 8 bits for look-up, which means that Huffman decoding can
|
|||
/// sometimes overshoot and read one or two too many bytes. Two-byte overshoot
|
|||
/// can happen when expecting to read a 0xff 0x00 byte-stuffed byte.
|
|||
/// </summary>
|
|||
public void UnreadByteStuffedByte() |
|||
{ |
|||
this.Bytes.I -= this.Bytes.UnreadableBytes; |
|||
this.Bytes.UnreadableBytes = 0; |
|||
if (this.Bits.UnreadBits >= 8) |
|||
{ |
|||
this.Bits.Accumulator >>= 8; |
|||
this.Bits.UnreadBits -= 8; |
|||
this.Bits.Mask >>= 8; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Receive extend
|
|||
/// </summary>
|
|||
/// <param name="t">Byte</param>
|
|||
/// <param name="x">Read bits value</param>
|
|||
/// <returns>The <see cref="GolangDecoderErrorCode"/></returns>
|
|||
public GolangDecoderErrorCode ReceiveExtendUnsafe(int t, out int x) |
|||
{ |
|||
this.LastErrorCode = this.Bits.ReceiveExtendUnsafe(t, ref this, out x); |
|||
return this.LastErrorCode; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reset the Huffman decoder.
|
|||
/// </summary>
|
|||
public void ResetHuffmanDecoder() |
|||
{ |
|||
this.Bits = default; |
|||
} |
|||
} |
|||
} |
|||
@ -1,25 +0,0 @@ |
|||
## JpegScanDecoder |
|||
Encapsulates the impementation of the Jpeg top-to bottom scan decoder triggered by the `SOS` marker. |
|||
The implementation is optimized to hold most of the necessary data in a single value type, which is intended to be used as an on-stack object. |
|||
|
|||
#### Benefits: |
|||
- Maximized locality of reference by keeping most of the operation data on the stack |
|||
- Achieving this without long parameter lists, most of the values describing the state of the decoder algorithm |
|||
are members of the `JpegScanDecoder` struct |
|||
- Most of the logic related to Scan decoding is refactored & simplified now to live in the methods of `JpegScanDecoder` |
|||
- The first step is done towards separating the stream reading from block processing. They can be refactored later to be executed in two disctinct loops. |
|||
- The input processing loop can be `async` |
|||
- The block processing loop can be parallelized |
|||
|
|||
#### Data layout |
|||
|
|||
|JpegScanDecoder | |
|||
|-------------------| |
|||
|Variables | |
|||
|DataPointers | |
|||
|ComputationData | |
|||
|
|||
- **ComputationData** holds the "large" data blocks needed for computations (Mostly `Block8x8F`-s) |
|||
- **DataPointers** contains pointers to the memory regions of `ComponentData` so they can be easily passed around to pointer based utility methods of `Block8x8F` |
|||
|
|||
|
|||
@ -1,15 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder |
|||
{ |
|||
/// <summary>
|
|||
/// The missing ff00 exception.
|
|||
/// </summary>
|
|||
// ReSharper disable once InconsistentNaming
|
|||
internal class MissingFF00Exception : Exception |
|||
{ |
|||
} |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.IO; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort |
|||
{ |
|||
/// <summary>
|
|||
/// Image decoder for generating an image out of a jpg stream.
|
|||
/// </summary>
|
|||
internal sealed class GolangJpegDecoder : IImageDecoder, IJpegDecoderOptions, IImageInfoDetector |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
|
|||
/// </summary>
|
|||
public bool IgnoreMetadata { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream) |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
using (var decoder = new GolangJpegDecoderCore(configuration, this)) |
|||
{ |
|||
return decoder.Decode<TPixel>(stream); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public IImageInfo Identify(Configuration configuration, Stream stream) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
using (var decoder = new GolangJpegDecoderCore(configuration, this)) |
|||
{ |
|||
return decoder.Identify(stream); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,824 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components; |
|||
using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder; |
|||
using SixLabors.ImageSharp.Formats.Jpeg.GolangPort.Components.Decoder; |
|||
using SixLabors.ImageSharp.MetaData; |
|||
using SixLabors.ImageSharp.MetaData.Profiles.Exif; |
|||
using SixLabors.ImageSharp.MetaData.Profiles.Icc; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using SixLabors.ImageSharp.Primitives; |
|||
using SixLabors.Primitives; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.GolangPort |
|||
{ |
|||
/// <inheritdoc />
|
|||
/// <summary>
|
|||
/// Performs the jpeg decoding operation.
|
|||
/// </summary>
|
|||
internal sealed unsafe class GolangJpegDecoderCore : IRawJpegData |
|||
{ |
|||
/// <summary>
|
|||
/// The maximum number of color components
|
|||
/// </summary>
|
|||
public const int MaxComponents = 4; |
|||
|
|||
/// <summary>
|
|||
/// The maximum number of quantization tables
|
|||
/// </summary>
|
|||
public const int MaxTq = 3; |
|||
|
|||
/// <summary>
|
|||
/// The only supported precision
|
|||
/// </summary>
|
|||
public const int SupportedPrecision = 8; |
|||
|
|||
// Complex value type field + mutable + available to other classes = the field MUST NOT be private :P
|
|||
#pragma warning disable SA1401 // FieldsMustBePrivate
|
|||
|
|||
/// <summary>
|
|||
/// Encapsulates stream reading and processing data and operations for <see cref="GolangJpegDecoderCore"/>.
|
|||
/// It's a value type for improved data locality, and reduced number of CALLVIRT-s
|
|||
/// </summary>
|
|||
public InputProcessor InputProcessor; |
|||
#pragma warning restore SA401
|
|||
|
|||
/// <summary>
|
|||
/// The global configuration
|
|||
/// </summary>
|
|||
private readonly Configuration configuration; |
|||
|
|||
/// <summary>
|
|||
/// Whether the image has a JFIF header
|
|||
/// It's faster to check this than to use the equality operator on the struct
|
|||
/// </summary>
|
|||
private bool isJFif; |
|||
|
|||
/// <summary>
|
|||
/// Contains information about the JFIF marker
|
|||
/// </summary>
|
|||
private JFifMarker jFif; |
|||
|
|||
/// <summary>
|
|||
/// Whether the image has a EXIF header
|
|||
/// </summary>
|
|||
private bool isExif; |
|||
|
|||
/// <summary>
|
|||
/// Whether the image has an Adobe marker.
|
|||
/// It's faster to check this than to use the equality operator on the struct
|
|||
/// </summary>
|
|||
private bool isAdobe; |
|||
|
|||
/// <summary>
|
|||
/// Contains information about the Adobe marker
|
|||
/// </summary>
|
|||
private AdobeMarker adobe; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="GolangJpegDecoderCore" /> class.
|
|||
/// </summary>
|
|||
/// <param name="configuration">The configuration.</param>
|
|||
/// <param name="options">The options.</param>
|
|||
public GolangJpegDecoderCore(Configuration configuration, IJpegDecoderOptions options) |
|||
{ |
|||
this.IgnoreMetadata = options.IgnoreMetadata; |
|||
this.configuration = configuration ?? Configuration.Default; |
|||
this.Temp = new byte[2 * Block8x8F.Size]; |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
public JpegColorSpace ColorSpace { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the component array
|
|||
/// </summary>
|
|||
public GolangComponent[] Components { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the huffman trees
|
|||
/// </summary>
|
|||
public GolangHuffmanTree[] HuffmanTrees { get; private set; } |
|||
|
|||
/// <inheritdoc />
|
|||
public Block8x8F[] QuantizationTables { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the temporary buffer used to store bytes read from the stream.
|
|||
/// TODO: Should be stack allocated, fixed sized buffer!
|
|||
/// </summary>
|
|||
public byte[] Temp { get; } |
|||
|
|||
/// <inheritdoc />
|
|||
public Size ImageSizeInPixels { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of MCU blocks in the image as <see cref="Size"/>.
|
|||
/// </summary>
|
|||
public Size ImageSizeInMCU { get; private set; } |
|||
|
|||
/// <inheritdoc />
|
|||
public int ComponentCount { get; private set; } |
|||
|
|||
IEnumerable<IJpegComponent> IRawJpegData.Components => this.Components; |
|||
|
|||
/// <summary>
|
|||
/// Gets the color depth, in number of bits per pixel.
|
|||
/// </summary>
|
|||
public int BitsPerPixel => this.ComponentCount * SupportedPrecision; |
|||
|
|||
/// <summary>
|
|||
/// Gets the image height
|
|||
/// </summary>
|
|||
public int ImageHeight => this.ImageSizeInPixels.Height; |
|||
|
|||
/// <summary>
|
|||
/// Gets the image width
|
|||
/// </summary>
|
|||
public int ImageWidth => this.ImageSizeInPixels.Width; |
|||
|
|||
/// <summary>
|
|||
/// Gets the input stream.
|
|||
/// </summary>
|
|||
public Stream InputStream { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the image is interlaced (progressive)
|
|||
/// </summary>
|
|||
public bool IsProgressive { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the restart interval
|
|||
/// </summary>
|
|||
public int RestartInterval { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of MCU-s (Minimum Coded Units) in the image along the X axis
|
|||
/// </summary>
|
|||
public int MCUCountX => this.ImageSizeInMCU.Width; |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of MCU-s (Minimum Coded Units) in the image along the Y axis
|
|||
/// </summary>
|
|||
public int MCUCountY => this.ImageSizeInMCU.Height; |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of MCU-s (Minimum Coded Units) in the image.
|
|||
/// </summary>
|
|||
public int TotalMCUCount => this.MCUCountX * this.MCUCountY; |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
|
|||
/// </summary>
|
|||
public bool IgnoreMetadata { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the <see cref="ImageMetaData"/> decoded by this decoder instance.
|
|||
/// </summary>
|
|||
public ImageMetaData MetaData { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Decodes the image from the specified <see cref="Stream"/> and sets
|
|||
/// the data to image.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="stream">The stream, where the image should be.</param>
|
|||
/// <returns>The decoded image.</returns>
|
|||
public Image<TPixel> Decode<TPixel>(Stream stream) |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
this.ParseStream(stream); |
|||
return this.PostProcessIntoImage<TPixel>(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the raw image information from the specified stream.
|
|||
/// </summary>
|
|||
/// <param name="stream">The <see cref="Stream"/> containing image data.</param>
|
|||
public IImageInfo Identify(Stream stream) |
|||
{ |
|||
this.ParseStream(stream, true); |
|||
return new ImageInfo(new PixelTypeInfo(this.BitsPerPixel), this.ImageWidth, this.ImageHeight, this.MetaData); |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
public void Dispose() |
|||
{ |
|||
if (this.Components != null) |
|||
{ |
|||
foreach (GolangComponent component in this.Components) |
|||
{ |
|||
component?.Dispose(); |
|||
} |
|||
} |
|||
|
|||
this.InputProcessor.Dispose(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read metadata from stream and read the blocks in the scans into <see cref="GolangComponent.SpectralBlocks"/>.
|
|||
/// </summary>
|
|||
/// <param name="stream">The stream</param>
|
|||
/// <param name="metadataOnly">Whether to decode metadata only.</param>
|
|||
public void ParseStream(Stream stream, bool metadataOnly = false) |
|||
{ |
|||
this.MetaData = new ImageMetaData(); |
|||
this.InputStream = stream; |
|||
this.InputProcessor = new InputProcessor(stream, this.Temp); |
|||
|
|||
if (!metadataOnly) |
|||
{ |
|||
this.HuffmanTrees = GolangHuffmanTree.CreateHuffmanTrees(); |
|||
this.QuantizationTables = new Block8x8F[MaxTq + 1]; |
|||
} |
|||
|
|||
// Check for the Start Of Image marker.
|
|||
this.InputProcessor.ReadFull(this.Temp, 0, 2); |
|||
|
|||
if (this.Temp[0] != JpegConstants.Markers.XFF || this.Temp[1] != JpegConstants.Markers.SOI) |
|||
{ |
|||
throw new ImageFormatException("Missing SOI marker."); |
|||
} |
|||
|
|||
// Process the remaining segments until the End Of Image marker.
|
|||
bool processBytes = true; |
|||
|
|||
// we can't currently short circute progressive images so don't try.
|
|||
while (processBytes) |
|||
{ |
|||
this.InputProcessor.ReadFull(this.Temp, 0, 2); |
|||
|
|||
if (this.InputProcessor.ReachedEOF) |
|||
{ |
|||
// We've reached the end of the stream.
|
|||
processBytes = false; |
|||
} |
|||
|
|||
while (this.Temp[0] != 0xff) |
|||
{ |
|||
// Strictly speaking, this is a format error. However, libjpeg is
|
|||
// liberal in what it accepts. As of version 9, next_marker in
|
|||
// jdmarker.c treats this as a warning (JWRN_EXTRANEOUS_DATA) and
|
|||
// continues to decode the stream. Even before next_marker sees
|
|||
// extraneous data, jpeg_fill_bit_buffer in jdhuff.c reads as many
|
|||
// bytes as it can, possibly past the end of a scan's data. It
|
|||
// effectively puts back any markers that it overscanned (e.g. an
|
|||
// "\xff\xd9" EOI marker), but it does not put back non-marker data,
|
|||
// and thus it can silently ignore a small number of extraneous
|
|||
// non-marker bytes before next_marker has a chance to see them (and
|
|||
// print a warning).
|
|||
// We are therefore also liberal in what we accept. Extraneous data
|
|||
// is silently ignore
|
|||
// This is similar to, but not exactly the same as, the restart
|
|||
// mechanism within a scan (the RST[0-7] markers).
|
|||
// Note that extraneous 0xff bytes in e.g. SOS data are escaped as
|
|||
// "\xff\x00", and so are detected a little further down below.
|
|||
this.Temp[0] = this.Temp[1]; |
|||
this.Temp[1] = this.InputProcessor.ReadByte(); |
|||
} |
|||
|
|||
byte marker = this.Temp[1]; |
|||
if (marker == 0) |
|||
{ |
|||
// Treat "\xff\x00" as extraneous data.
|
|||
continue; |
|||
} |
|||
|
|||
while (marker == 0xff) |
|||
{ |
|||
// Section B.1.1.2 says, "Any marker may optionally be preceded by any
|
|||
// number of fill bytes, which are bytes assigned code X'FF'".
|
|||
this.InputProcessor.ReadByteUnsafe(out marker); |
|||
|
|||
if (this.InputProcessor.ReachedEOF) |
|||
{ |
|||
// We've reached the end of the stream.
|
|||
processBytes = false; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
// End Of Image.
|
|||
if (marker == JpegConstants.Markers.EOI) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (marker >= JpegConstants.Markers.RST0 && marker <= JpegConstants.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.
|
|||
// However, some encoders may generate incorrect JPEGs with a final restart
|
|||
// marker. That restart marker will be seen here instead of inside the ProcessSOS
|
|||
// method, and is ignored as a harmless error. Restart markers have no extra data,
|
|||
// so we check for this before we read the 16-bit length of the segment.
|
|||
continue; |
|||
} |
|||
|
|||
// Read the 16-bit length of the segment. The value includes the 2 bytes for the
|
|||
// length itself, so we subtract 2 to get the number of remaining bytes.
|
|||
this.InputProcessor.ReadFullUnsafe(this.Temp, 0, 2); |
|||
int remaining = (this.Temp[0] << 8) + this.Temp[1] - 2; |
|||
if (remaining < 0) |
|||
{ |
|||
throw new ImageFormatException("Short segment length."); |
|||
} |
|||
|
|||
switch (marker) |
|||
{ |
|||
case JpegConstants.Markers.SOF0: |
|||
case JpegConstants.Markers.SOF1: |
|||
case JpegConstants.Markers.SOF2: |
|||
this.IsProgressive = marker == JpegConstants.Markers.SOF2; |
|||
this.ProcessStartOfFrameMarker(remaining, metadataOnly); |
|||
|
|||
break; |
|||
case JpegConstants.Markers.DHT: |
|||
|
|||
if (metadataOnly) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
else |
|||
{ |
|||
this.ProcessDefineHuffmanTablesMarker(remaining); |
|||
} |
|||
|
|||
break; |
|||
case JpegConstants.Markers.DQT: |
|||
if (metadataOnly) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
else |
|||
{ |
|||
this.ProcessDefineQuantizationTablesMarker(remaining); |
|||
} |
|||
|
|||
break; |
|||
case JpegConstants.Markers.SOS: |
|||
if (!metadataOnly) |
|||
{ |
|||
this.ProcessStartOfScanMarker(remaining); |
|||
if (this.InputProcessor.ReachedEOF) |
|||
{ |
|||
// If unexpected EOF reached. We can stop processing bytes as we now have the image data.
|
|||
processBytes = false; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// It's highly unlikely that APPn related data will be found after the SOS marker
|
|||
// We should have gathered everything we need by now.
|
|||
processBytes = false; |
|||
} |
|||
|
|||
break; |
|||
|
|||
case JpegConstants.Markers.DRI: |
|||
if (metadataOnly) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
else |
|||
{ |
|||
this.ProcessDefineRestartIntervalMarker(remaining); |
|||
} |
|||
|
|||
break; |
|||
case JpegConstants.Markers.APP0: |
|||
this.ProcessApplicationHeaderMarker(remaining); |
|||
break; |
|||
case JpegConstants.Markers.APP1: |
|||
this.ProcessApp1Marker(remaining); |
|||
break; |
|||
case JpegConstants.Markers.APP2: |
|||
this.ProcessApp2Marker(remaining); |
|||
break; |
|||
case JpegConstants.Markers.APP14: |
|||
this.ProcessApp14Marker(remaining); |
|||
break; |
|||
default: |
|||
if ((marker >= JpegConstants.Markers.APP0 && marker <= JpegConstants.Markers.APP15) |
|||
|| marker == JpegConstants.Markers.COM) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
this.InitDerivedMetaDataProperties(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true if 'mcuCounter' is at restart interval
|
|||
/// </summary>
|
|||
public bool IsAtRestartInterval(int mcuCounter) |
|||
{ |
|||
return this.RestartInterval > 0 && mcuCounter % this.RestartInterval == 0 |
|||
&& mcuCounter < this.TotalMCUCount; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Assigns derived metadata properties to <see cref="MetaData"/>, eg. horizontal and vertical resolution if it has a JFIF header.
|
|||
/// </summary>
|
|||
private void InitDerivedMetaDataProperties() |
|||
{ |
|||
if (this.isJFif) |
|||
{ |
|||
this.MetaData.HorizontalResolution = this.jFif.XDensity; |
|||
this.MetaData.VerticalResolution = this.jFif.YDensity; |
|||
} |
|||
else if (this.isExif) |
|||
{ |
|||
double horizontalValue = this.MetaData.ExifProfile.TryGetValue(ExifTag.XResolution, out ExifValue horizonalTag) |
|||
? ((Rational)horizonalTag.Value).ToDouble() |
|||
: 0; |
|||
|
|||
double verticalValue = this.MetaData.ExifProfile.TryGetValue(ExifTag.YResolution, out ExifValue verticalTag) |
|||
? ((Rational)verticalTag.Value).ToDouble() |
|||
: 0; |
|||
|
|||
if (horizontalValue > 0 && verticalValue > 0) |
|||
{ |
|||
this.MetaData.HorizontalResolution = horizontalValue; |
|||
this.MetaData.VerticalResolution = verticalValue; |
|||
} |
|||
} |
|||
|
|||
if (this.MetaData.IccProfile?.CheckIsValid() == false) |
|||
{ |
|||
this.MetaData.IccProfile = null; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the application header containing the JFIF identifier plus extra data.
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
private void ProcessApplicationHeaderMarker(int remaining) |
|||
{ |
|||
if (remaining < 5) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
return; |
|||
} |
|||
|
|||
const int MarkerLength = JFifMarker.Length; |
|||
this.InputProcessor.ReadFull(this.Temp, 0, MarkerLength); |
|||
remaining -= MarkerLength; |
|||
|
|||
this.isJFif = JFifMarker.TryParse(this.Temp, out this.jFif); |
|||
|
|||
if (remaining > 0) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the App1 marker retrieving any stored metadata
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
private void ProcessApp1Marker(int remaining) |
|||
{ |
|||
if (remaining < 6 || this.IgnoreMetadata) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
return; |
|||
} |
|||
|
|||
byte[] profile = new byte[remaining]; |
|||
this.InputProcessor.ReadFull(profile, 0, remaining); |
|||
|
|||
if (ProfileResolver.IsProfile(profile, ProfileResolver.ExifMarker)) |
|||
{ |
|||
this.isExif = true; |
|||
this.MetaData.ExifProfile = new ExifProfile(profile); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the App2 marker retrieving any stored ICC profile information
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
private void ProcessApp2Marker(int remaining) |
|||
{ |
|||
// Length is 14 though we only need to check 12.
|
|||
const int Icclength = 14; |
|||
if (remaining < Icclength || this.IgnoreMetadata) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
return; |
|||
} |
|||
|
|||
byte[] identifier = new byte[Icclength]; |
|||
this.InputProcessor.ReadFull(identifier, 0, Icclength); |
|||
remaining -= Icclength; // We have read it by this point
|
|||
|
|||
if (ProfileResolver.IsProfile(identifier, ProfileResolver.IccMarker)) |
|||
{ |
|||
byte[] profile = new byte[remaining]; |
|||
this.InputProcessor.ReadFull(profile, 0, remaining); |
|||
|
|||
if (this.MetaData.IccProfile == null) |
|||
{ |
|||
this.MetaData.IccProfile = new IccProfile(profile); |
|||
} |
|||
else |
|||
{ |
|||
this.MetaData.IccProfile.Extend(profile); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// Not an ICC profile we can handle. Skip the remaining bytes so we can carry on and ignore this.
|
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the application header containing the Adobe identifier
|
|||
/// which stores image encoding information for DCT filters.
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
private void ProcessApp14Marker(int remaining) |
|||
{ |
|||
const int MarkerLength = AdobeMarker.Length; |
|||
if (remaining < MarkerLength) |
|||
{ |
|||
// Skip the application header length
|
|||
this.InputProcessor.Skip(remaining); |
|||
return; |
|||
} |
|||
|
|||
this.InputProcessor.ReadFull(this.Temp, 0, MarkerLength); |
|||
remaining -= MarkerLength; |
|||
|
|||
this.isAdobe = AdobeMarker.TryParse(this.Temp, out this.adobe); |
|||
|
|||
if (remaining > 0) |
|||
{ |
|||
this.InputProcessor.Skip(remaining); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the Define Quantization Marker and tables. Specified in section B.2.4.1.
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// Thrown if the tables do not match the header
|
|||
/// </exception>
|
|||
private void ProcessDefineQuantizationTablesMarker(int remaining) |
|||
{ |
|||
while (remaining > 0) |
|||
{ |
|||
bool done = false; |
|||
|
|||
remaining--; |
|||
byte x = this.InputProcessor.ReadByte(); |
|||
int tq = x & 0x0F; |
|||
if (tq > MaxTq) |
|||
{ |
|||
throw new ImageFormatException("Bad Tq value"); |
|||
} |
|||
|
|||
switch (x >> 4) |
|||
{ |
|||
case 0: |
|||
if (remaining < Block8x8F.Size) |
|||
{ |
|||
done = true; |
|||
break; |
|||
} |
|||
|
|||
remaining -= Block8x8F.Size; |
|||
this.InputProcessor.ReadFull(this.Temp, 0, Block8x8F.Size); |
|||
|
|||
for (int i = 0; i < Block8x8F.Size; i++) |
|||
{ |
|||
this.QuantizationTables[tq][i] = this.Temp[i]; |
|||
} |
|||
|
|||
break; |
|||
case 1: |
|||
if (remaining < 2 * Block8x8F.Size) |
|||
{ |
|||
done = true; |
|||
break; |
|||
} |
|||
|
|||
remaining -= 2 * Block8x8F.Size; |
|||
this.InputProcessor.ReadFull(this.Temp, 0, 2 * Block8x8F.Size); |
|||
|
|||
for (int i = 0; i < Block8x8F.Size; i++) |
|||
{ |
|||
this.QuantizationTables[tq][i] = (this.Temp[2 * i] << 8) | this.Temp[(2 * i) + 1]; |
|||
} |
|||
|
|||
break; |
|||
default: |
|||
throw new ImageFormatException("Bad Pq value"); |
|||
} |
|||
|
|||
if (done) |
|||
{ |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (remaining != 0) |
|||
{ |
|||
throw new ImageFormatException("DQT has wrong length"); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the Start of Frame marker. Specified in section B.2.2.
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
/// <param name="metadataOnly">Whether to decode metadata only.</param>
|
|||
private void ProcessStartOfFrameMarker(int remaining, bool metadataOnly) |
|||
{ |
|||
if (this.ComponentCount != 0) |
|||
{ |
|||
throw new ImageFormatException("Multiple SOF markers"); |
|||
} |
|||
|
|||
switch (remaining) |
|||
{ |
|||
case 6 + (3 * 1): // grayscale image.
|
|||
this.ComponentCount = 1; |
|||
break; |
|||
case 6 + (3 * 3): // YCbCr or RGB image.
|
|||
this.ComponentCount = 3; |
|||
break; |
|||
case 6 + (3 * 4): // YCbCrK or CMYK image.
|
|||
this.ComponentCount = 4; |
|||
break; |
|||
default: |
|||
throw new ImageFormatException("Incorrect number of components"); |
|||
} |
|||
|
|||
this.InputProcessor.ReadFull(this.Temp, 0, remaining); |
|||
|
|||
// We only support 8-bit precision.
|
|||
if (this.Temp[0] != SupportedPrecision) |
|||
{ |
|||
throw new ImageFormatException("Only 8-Bit precision supported."); |
|||
} |
|||
|
|||
int height = (this.Temp[1] << 8) + this.Temp[2]; |
|||
int width = (this.Temp[3] << 8) + this.Temp[4]; |
|||
|
|||
this.ImageSizeInPixels = new Size(width, height); |
|||
|
|||
if (this.Temp[5] != this.ComponentCount) |
|||
{ |
|||
throw new ImageFormatException("SOF has wrong length"); |
|||
} |
|||
|
|||
if (!metadataOnly) |
|||
{ |
|||
this.Components = new GolangComponent[this.ComponentCount]; |
|||
|
|||
for (int i = 0; i < this.ComponentCount; i++) |
|||
{ |
|||
byte componentIdentifier = this.Temp[6 + (3 * i)]; |
|||
var component = new GolangComponent(componentIdentifier, i); |
|||
component.InitializeCoreData(this); |
|||
this.Components[i] = component; |
|||
} |
|||
|
|||
int h0 = this.Components[0].HorizontalSamplingFactor; |
|||
int v0 = this.Components[0].VerticalSamplingFactor; |
|||
|
|||
this.ImageSizeInMCU = this.ImageSizeInPixels.DivideRoundUp(8 * h0, 8 * v0); |
|||
|
|||
this.ColorSpace = this.DeduceJpegColorSpace(); |
|||
|
|||
foreach (GolangComponent component in this.Components) |
|||
{ |
|||
component.InitializeDerivedData(this.configuration.MemoryAllocator, this); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes a Define Huffman Table marker, and initializes a huffman
|
|||
/// struct from its contents. Specified in section B.2.4.2.
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
private void ProcessDefineHuffmanTablesMarker(int remaining) |
|||
{ |
|||
while (remaining > 0) |
|||
{ |
|||
if (remaining < 17) |
|||
{ |
|||
throw new ImageFormatException($"DHT has wrong length. {remaining}"); |
|||
} |
|||
|
|||
this.InputProcessor.ReadFull(this.Temp, 0, 17); |
|||
|
|||
int tc = this.Temp[0] >> 4; |
|||
if (tc > GolangHuffmanTree.MaxTc) |
|||
{ |
|||
throw new ImageFormatException("Bad Tc value"); |
|||
} |
|||
|
|||
int th = this.Temp[0] & 0x0f; |
|||
if (th > GolangHuffmanTree.MaxTh) |
|||
{ |
|||
throw new ImageFormatException("Bad Th value"); |
|||
} |
|||
|
|||
int huffTreeIndex = (tc * GolangHuffmanTree.ThRowSize) + th; |
|||
this.HuffmanTrees[huffTreeIndex].ProcessDefineHuffmanTablesMarkerLoop( |
|||
ref this.InputProcessor, |
|||
this.Temp, |
|||
ref remaining); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the DRI (Define Restart Interval Marker) Which specifies the interval between RSTn markers, in
|
|||
/// macroblocks
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
private void ProcessDefineRestartIntervalMarker(int remaining) |
|||
{ |
|||
if (remaining != 2) |
|||
{ |
|||
throw new ImageFormatException("DRI has wrong length"); |
|||
} |
|||
|
|||
this.InputProcessor.ReadFull(this.Temp, 0, remaining); |
|||
this.RestartInterval = (this.Temp[0] << 8) + this.Temp[1]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Processes the SOS (Start of scan marker).
|
|||
/// </summary>
|
|||
/// <param name="remaining">The remaining bytes in the segment block.</param>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// Missing SOF Marker
|
|||
/// SOS has wrong length
|
|||
/// </exception>
|
|||
private void ProcessStartOfScanMarker(int remaining) |
|||
{ |
|||
GolangJpegScanDecoder scan = default; |
|||
GolangJpegScanDecoder.InitStreamReading(&scan, this, remaining); |
|||
this.InputProcessor.Bits = default; |
|||
scan.DecodeBlocks(this); |
|||
} |
|||
|
|||
private JpegColorSpace DeduceJpegColorSpace() |
|||
{ |
|||
switch (this.ComponentCount) |
|||
{ |
|||
case 1: |
|||
return JpegColorSpace.Grayscale; |
|||
case 3: |
|||
if (!this.isAdobe || this.adobe.ColorTransform == JpegConstants.Adobe.ColorTransformYCbCr) |
|||
{ |
|||
return JpegColorSpace.YCbCr; |
|||
} |
|||
|
|||
if (this.adobe.ColorTransform == JpegConstants.Adobe.ColorTransformUnknown) |
|||
{ |
|||
return JpegColorSpace.RGB; |
|||
} |
|||
|
|||
break; |
|||
case 4: |
|||
if (this.adobe.ColorTransform == JpegConstants.Adobe.ColorTransformYcck) |
|||
{ |
|||
return JpegColorSpace.Ycck; |
|||
} |
|||
|
|||
return JpegColorSpace.Cmyk; |
|||
} |
|||
|
|||
throw new ImageFormatException($"Unsupported color mode. Max components 4; found {this.ComponentCount}." |
|||
+ "JpegDecoder only supports YCbCr, RGB, YccK, CMYK and grayscale color spaces."); |
|||
} |
|||
|
|||
private Image<TPixel> PostProcessIntoImage<TPixel>() |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
using (var postProcessor = new JpegImagePostProcessor(this.configuration.MemoryAllocator, this)) |
|||
{ |
|||
var image = new Image<TPixel>(this.configuration, this.ImageWidth, this.ImageHeight, this.MetaData); |
|||
postProcessor.PostProcess(image.Frames.RootFrame); |
|||
return image; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.IO; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.PdfJsPort |
|||
{ |
|||
/// <summary>
|
|||
/// Image decoder for generating an image out of a jpg stream.
|
|||
/// </summary>
|
|||
internal sealed class PdfJsJpegDecoder : IImageDecoder, IJpegDecoderOptions, IImageInfoDetector |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
|
|||
/// </summary>
|
|||
public bool IgnoreMetadata { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream) |
|||
where TPixel : struct, IPixel<TPixel> |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) |
|||
{ |
|||
return decoder.Decode<TPixel>(stream); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public IImageInfo Identify(Configuration configuration, Stream stream) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
using (var decoder = new PdfJsJpegDecoderCore(configuration, this)) |
|||
{ |
|||
return decoder.Identify(stream); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,3 +1,8 @@ |
|||
Encoder/Decoder adapted and extended from: |
|||
Encoder adapted and extended from: |
|||
https://golang.org/src/image/jpeg/ |
|||
|
|||
https://golang.org/src/image/jpeg/ |
|||
Decoder orchestration code is based on: |
|||
https://github.com/mozilla/pdf.js |
|||
|
|||
Huffmann decoder is based on: |
|||
https://github.com/rds1983/StbSharp |
|||
@ -1,83 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Contains <see cref="Buffer{T}"/> and <see cref="ManagedByteBuffer"/>
|
|||
/// </summary>
|
|||
public partial class ArrayPoolMemoryAllocator |
|||
{ |
|||
/// <summary>
|
|||
/// The buffer implementation of <see cref="ArrayPoolMemoryAllocator"/>.
|
|||
/// In this implementation <see cref="IBuffer{T}.Memory"/> is owned.
|
|||
/// </summary>
|
|||
private class Buffer<T> : ManagedBufferBase<T> |
|||
where T : struct |
|||
{ |
|||
/// <summary>
|
|||
/// The length of the buffer
|
|||
/// </summary>
|
|||
private readonly int length; |
|||
|
|||
/// <summary>
|
|||
/// A weak reference to the source pool.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// By using a weak reference here, we are making sure that array pools and their retained arrays are always GC-ed
|
|||
/// after a call to <see cref="ArrayPoolMemoryAllocator.ReleaseRetainedResources"/>, regardless of having buffer instances still being in use.
|
|||
/// </remarks>
|
|||
private WeakReference<ArrayPool<byte>> sourcePoolReference; |
|||
|
|||
public Buffer(byte[] data, int length, ArrayPool<byte> sourcePool) |
|||
{ |
|||
this.Data = data; |
|||
this.length = length; |
|||
this.sourcePoolReference = new WeakReference<ArrayPool<byte>>(sourcePool); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the buffer as a byte array.
|
|||
/// </summary>
|
|||
protected byte[] Data { get; private set; } |
|||
|
|||
/// <inheritdoc />
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
if (!disposing || this.Data == null || this.sourcePoolReference == null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (this.sourcePoolReference.TryGetTarget(out ArrayPool<byte> pool)) |
|||
{ |
|||
pool.Return(this.Data); |
|||
} |
|||
|
|||
this.sourcePoolReference = null; |
|||
this.Data = null; |
|||
} |
|||
|
|||
public override Span<T> GetSpan() => MemoryMarshal.Cast<byte, T>(this.Data.AsSpan()).Slice(0, this.length); |
|||
|
|||
protected override object GetPinnableObject() => this.Data; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The <see cref="IManagedByteBuffer"/> implementation of <see cref="ArrayPoolMemoryAllocator"/>.
|
|||
/// </summary>
|
|||
private class ManagedByteBuffer : Buffer<byte>, IManagedByteBuffer |
|||
{ |
|||
public ManagedByteBuffer(byte[] data, int length, ArrayPool<byte> sourcePool) |
|||
: base(data, length, sourcePool) |
|||
{ |
|||
} |
|||
|
|||
public byte[] Array => this.Data; |
|||
} |
|||
} |
|||
} |
|||
@ -1,71 +0,0 @@ |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Contains common factory methods and configuration constants.
|
|||
/// </summary>
|
|||
public partial class ArrayPoolMemoryAllocator |
|||
{ |
|||
/// <summary>
|
|||
/// The default value for: maximum size of pooled arrays in bytes.
|
|||
/// Currently set to 24MB, which is equivalent to 8 megapixels of raw <see cref="Rgba32"/> data.
|
|||
/// </summary>
|
|||
internal const int DefaultMaxPooledBufferSizeInBytes = 24 * 1024 * 1024; |
|||
|
|||
/// <summary>
|
|||
/// The value for: The threshold to pool arrays in <see cref="largeArrayPool"/> which has less buckets for memory safety.
|
|||
/// </summary>
|
|||
private const int DefaultBufferSelectorThresholdInBytes = 8 * 1024 * 1024; |
|||
|
|||
/// <summary>
|
|||
/// The default bucket count for <see cref="largeArrayPool"/>.
|
|||
/// </summary>
|
|||
private const int DefaultLargePoolBucketCount = 6; |
|||
|
|||
/// <summary>
|
|||
/// The default bucket count for <see cref="normalArrayPool"/>.
|
|||
/// </summary>
|
|||
private const int DefaultNormalPoolBucketCount = 16; |
|||
|
|||
/// <summary>
|
|||
/// This is the default. Should be good for most use cases.
|
|||
/// </summary>
|
|||
/// <returns>The memory manager</returns>
|
|||
public static ArrayPoolMemoryAllocator CreateDefault() |
|||
{ |
|||
return new ArrayPoolMemoryAllocator( |
|||
DefaultMaxPooledBufferSizeInBytes, |
|||
DefaultBufferSelectorThresholdInBytes, |
|||
DefaultLargePoolBucketCount, |
|||
DefaultNormalPoolBucketCount); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// For environments with limited memory capabilities. Only small images are pooled, which can result in reduced througput.
|
|||
/// </summary>
|
|||
/// <returns>The memory manager</returns>
|
|||
public static ArrayPoolMemoryAllocator CreateWithModeratePooling() |
|||
{ |
|||
return new ArrayPoolMemoryAllocator(1024 * 1024, 32 * 1024, 16, 24); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Only pool small buffers like image rows.
|
|||
/// </summary>
|
|||
/// <returns>The memory manager</returns>
|
|||
public static ArrayPoolMemoryAllocator CreateWithMinimalPooling() |
|||
{ |
|||
return new ArrayPoolMemoryAllocator(64 * 1024, 32 * 1024, 8, 24); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// RAM is not an issue for me, gimme maximum througput!
|
|||
/// </summary>
|
|||
/// <returns>The memory manager</returns>
|
|||
public static ArrayPoolMemoryAllocator CreateWithAggressivePooling() |
|||
{ |
|||
return new ArrayPoolMemoryAllocator(128 * 1024 * 1024, 32 * 1024 * 1024, 16, 32); |
|||
} |
|||
} |
|||
} |
|||
@ -1,140 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Buffers; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Implements <see cref="MemoryAllocator"/> by allocating memory from <see cref="ArrayPool{T}"/>.
|
|||
/// </summary>
|
|||
public sealed partial class ArrayPoolMemoryAllocator : MemoryAllocator |
|||
{ |
|||
/// <summary>
|
|||
/// The <see cref="ArrayPool{T}"/> for small-to-medium buffers which is not kept clean.
|
|||
/// </summary>
|
|||
private ArrayPool<byte> normalArrayPool; |
|||
|
|||
/// <summary>
|
|||
/// The <see cref="ArrayPool{T}"/> for huge buffers, which is not kept clean.
|
|||
/// </summary>
|
|||
private ArrayPool<byte> largeArrayPool; |
|||
|
|||
private readonly int maxArraysPerBucketNormalPool; |
|||
|
|||
private readonly int maxArraysPerBucketLargePool; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ArrayPoolMemoryAllocator"/> class.
|
|||
/// </summary>
|
|||
public ArrayPoolMemoryAllocator() |
|||
: this(DefaultMaxPooledBufferSizeInBytes, DefaultBufferSelectorThresholdInBytes) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ArrayPoolMemoryAllocator"/> class.
|
|||
/// </summary>
|
|||
/// <param name="maxPoolSizeInBytes">The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated.</param>
|
|||
public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes) |
|||
: this(maxPoolSizeInBytes, GetLargeBufferThresholdInBytes(maxPoolSizeInBytes)) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ArrayPoolMemoryAllocator"/> class.
|
|||
/// </summary>
|
|||
/// <param name="maxPoolSizeInBytes">The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated.</param>
|
|||
/// <param name="poolSelectorThresholdInBytes">Arrays over this threshold will be pooled in <see cref="largeArrayPool"/> which has less buckets for memory safety.</param>
|
|||
public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes, int poolSelectorThresholdInBytes) |
|||
: this(maxPoolSizeInBytes, poolSelectorThresholdInBytes, DefaultLargePoolBucketCount, DefaultNormalPoolBucketCount) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ArrayPoolMemoryAllocator"/> class.
|
|||
/// </summary>
|
|||
/// <param name="maxPoolSizeInBytes">The maximum size of pooled arrays. Arrays over the thershold are gonna be always allocated.</param>
|
|||
/// <param name="poolSelectorThresholdInBytes">The threshold to pool arrays in <see cref="largeArrayPool"/> which has less buckets for memory safety.</param>
|
|||
/// <param name="maxArraysPerBucketLargePool">Max arrays per bucket for the large array pool</param>
|
|||
/// <param name="maxArraysPerBucketNormalPool">Max arrays per bucket for the normal array pool</param>
|
|||
public ArrayPoolMemoryAllocator(int maxPoolSizeInBytes, int poolSelectorThresholdInBytes, int maxArraysPerBucketLargePool, int maxArraysPerBucketNormalPool) |
|||
{ |
|||
ImageSharp.Guard.MustBeGreaterThan(maxPoolSizeInBytes, 0, nameof(maxPoolSizeInBytes)); |
|||
Guard.MustBeLessThanOrEqualTo(poolSelectorThresholdInBytes, maxPoolSizeInBytes, nameof(poolSelectorThresholdInBytes)); |
|||
|
|||
this.MaxPoolSizeInBytes = maxPoolSizeInBytes; |
|||
this.PoolSelectorThresholdInBytes = poolSelectorThresholdInBytes; |
|||
this.maxArraysPerBucketLargePool = maxArraysPerBucketLargePool; |
|||
this.maxArraysPerBucketNormalPool = maxArraysPerBucketNormalPool; |
|||
|
|||
this.InitArrayPools(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the maximum size of pooled arrays in bytes.
|
|||
/// </summary>
|
|||
public int MaxPoolSizeInBytes { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the threshold to pool arrays in <see cref="largeArrayPool"/> which has less buckets for memory safety.
|
|||
/// </summary>
|
|||
public int PoolSelectorThresholdInBytes { get; } |
|||
|
|||
/// <inheritdoc />
|
|||
public override void ReleaseRetainedResources() |
|||
{ |
|||
this.InitArrayPools(); |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
internal override IBuffer<T> Allocate<T>(int length, bool clear) |
|||
{ |
|||
int itemSizeBytes = Unsafe.SizeOf<T>(); |
|||
int bufferSizeInBytes = length * itemSizeBytes; |
|||
|
|||
ArrayPool<byte> pool = this.GetArrayPool(bufferSizeInBytes); |
|||
byte[] byteArray = pool.Rent(bufferSizeInBytes); |
|||
|
|||
var buffer = new Buffer<T>(byteArray, length, pool); |
|||
if (clear) |
|||
{ |
|||
buffer.Clear(); |
|||
} |
|||
|
|||
return buffer; |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
internal override IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear) |
|||
{ |
|||
ArrayPool<byte> pool = this.GetArrayPool(length); |
|||
byte[] byteArray = pool.Rent(length); |
|||
|
|||
var buffer = new ManagedByteBuffer(byteArray, length, pool); |
|||
if (clear) |
|||
{ |
|||
buffer.Clear(); |
|||
} |
|||
|
|||
return buffer; |
|||
} |
|||
|
|||
private static int GetLargeBufferThresholdInBytes(int maxPoolSizeInBytes) |
|||
{ |
|||
return maxPoolSizeInBytes / 4; |
|||
} |
|||
|
|||
private ArrayPool<byte> GetArrayPool(int bufferSizeInBytes) |
|||
{ |
|||
return bufferSizeInBytes <= this.PoolSelectorThresholdInBytes ? this.normalArrayPool : this.largeArrayPool; |
|||
} |
|||
|
|||
private void InitArrayPools() |
|||
{ |
|||
this.largeArrayPool = ArrayPool<byte>.Create(this.MaxPoolSizeInBytes, this.maxArraysPerBucketLargePool); |
|||
this.normalArrayPool = ArrayPool<byte>.Create(this.PoolSelectorThresholdInBytes, this.maxArraysPerBucketNormalPool); |
|||
} |
|||
} |
|||
} |
|||
@ -1,59 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Wraps an array as an <see cref="IBuffer{T}"/> instance. In this implementation <see cref="IBuffer{T}.Memory"/> is owned.
|
|||
/// </summary>
|
|||
internal class BasicArrayBuffer<T> : ManagedBufferBase<T> |
|||
where T : struct |
|||
{ |
|||
public BasicArrayBuffer(T[] array, int length) |
|||
{ |
|||
ImageSharp.DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length)); |
|||
this.Array = array; |
|||
this.Length = length; |
|||
} |
|||
|
|||
public BasicArrayBuffer(T[] array) |
|||
: this(array, array.Length) |
|||
{ |
|||
} |
|||
|
|||
public T[] Array { get; } |
|||
|
|||
public int Length { get; } |
|||
|
|||
/// <summary>
|
|||
/// Returns a reference to specified element of the buffer.
|
|||
/// </summary>
|
|||
/// <param name="index">The index</param>
|
|||
/// <returns>The reference to the specified element</returns>
|
|||
public ref T this[int index] |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
get |
|||
{ |
|||
DebugGuard.MustBeLessThan(index, this.Length, nameof(index)); |
|||
|
|||
Span<T> span = this.GetSpan(); |
|||
return ref span[index]; |
|||
} |
|||
} |
|||
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
|
|||
public override Span<T> GetSpan() => this.Array.AsSpan(0, this.Length); |
|||
|
|||
protected override object GetPinnableObject() |
|||
{ |
|||
return this.Array; |
|||
} |
|||
} |
|||
} |
|||
@ -1,13 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
internal sealed class BasicByteBuffer : BasicArrayBuffer<byte>, IManagedByteBuffer |
|||
{ |
|||
internal BasicByteBuffer(byte[] array) |
|||
: base(array) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -1,34 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// A buffer implementation that consumes an existing <see cref="Memory{T}"/> instance.
|
|||
/// The ownership of the memory remains external.
|
|||
/// </summary>
|
|||
/// <typeparam name="T">The value type</typeparam>
|
|||
internal sealed class ConsumedBuffer<T> : IBuffer<T> |
|||
where T : struct |
|||
{ |
|||
public ConsumedBuffer(Memory<T> memory) |
|||
{ |
|||
this.Memory = memory; |
|||
} |
|||
|
|||
public Memory<T> Memory { get; } |
|||
|
|||
public bool IsMemoryOwner => false; |
|||
|
|||
public Span<T> GetSpan() |
|||
{ |
|||
return this.Memory.Span; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -1,38 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a contigous memory buffer of value-type items.
|
|||
/// Depending on it's implementation, an <see cref="IBuffer{T}"/> can (1) OWN or (2) CONSUME the <see cref="Memory{T}"/> instance it wraps.
|
|||
/// For a deeper understanding of the owner/consumer model, read the following docs: <br/>
|
|||
/// https://gist.github.com/GrabYourPitchforks/4c3e1935fd4d9fa2831dbfcab35dffc6
|
|||
/// TODO: We need more SOC here! For owned buffers we should use <see cref="IMemoryOwner{T}"/>.
|
|||
/// For the consumption case we should not use buffers at all. We need to refactor Buffer2D{T} for this.
|
|||
/// </summary>
|
|||
/// <typeparam name="T">The value type</typeparam>
|
|||
internal interface IBuffer<T> : IDisposable |
|||
where T : struct |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the <see cref="Memory{T}"/> ownerd/consumed by this buffer.
|
|||
/// </summary>
|
|||
Memory<T> Memory { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether this instance is owning the <see cref="Memory"/>.
|
|||
/// </summary>
|
|||
bool IsMemoryOwner { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the span to the memory "promised" by this buffer when it's OWNED (1).
|
|||
/// Gets `this.Memory.Span` when the buffer CONSUMED (2).
|
|||
/// </summary>
|
|||
/// <returns>The <see cref="Span{T}"/></returns>
|
|||
Span<T> GetSpan(); |
|||
} |
|||
} |
|||
@ -1,16 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a byte buffer backed by a managed array. Useful for interop with classic .NET API-s.
|
|||
/// </summary>
|
|||
internal interface IManagedByteBuffer : IBuffer<byte> |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the managed array backing this buffer instance.
|
|||
/// </summary>
|
|||
byte[] Array { get; } |
|||
} |
|||
} |
|||
@ -1,43 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Buffers; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Provides a base class for <see cref="IBuffer{T}"/> implementations by implementing pinning logic for <see cref="MemoryManager{T}"/> adaption.
|
|||
/// </summary>
|
|||
internal abstract class ManagedBufferBase<T> : MemoryManager<T>, IBuffer<T> |
|||
where T : struct |
|||
{ |
|||
private GCHandle pinHandle; |
|||
|
|||
public bool IsMemoryOwner => true; |
|||
|
|||
/// <summary>
|
|||
/// Gets the object that should be pinned.
|
|||
/// </summary>
|
|||
protected abstract object GetPinnableObject(); |
|||
|
|||
public override unsafe MemoryHandle Pin(int elementIndex = 0) |
|||
{ |
|||
if (!this.pinHandle.IsAllocated) |
|||
{ |
|||
this.pinHandle = GCHandle.Alloc(this.GetPinnableObject(), GCHandleType.Pinned); |
|||
} |
|||
|
|||
void* ptr = (void*)this.pinHandle.AddrOfPinnedObject(); |
|||
return new MemoryHandle(ptr, this.pinHandle); |
|||
} |
|||
|
|||
public override void Unpin() |
|||
{ |
|||
if (this.pinHandle.IsAllocated) |
|||
{ |
|||
this.pinHandle.Free(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,38 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Memory managers are used to allocate memory for image processing operations.
|
|||
/// </summary>
|
|||
public abstract class MemoryAllocator |
|||
{ |
|||
/// <summary>
|
|||
/// Allocates an <see cref="IBuffer{T}"/> of size <paramref name="length"/>, optionally
|
|||
/// clearing the buffer before it gets returned.
|
|||
/// </summary>
|
|||
/// <typeparam name="T">Type of the data stored in the buffer</typeparam>
|
|||
/// <param name="length">Size of the buffer to allocate</param>
|
|||
/// <param name="clear">True to clear the backing memory of the buffer</param>
|
|||
/// <returns>A buffer of values of type <typeparamref name="T"/>.</returns>
|
|||
internal abstract IBuffer<T> Allocate<T>(int length, bool clear) |
|||
where T : struct; |
|||
|
|||
/// <summary>
|
|||
/// Allocates an <see cref="IManagedByteBuffer"/>
|
|||
/// </summary>
|
|||
/// <param name="length">The requested buffer length</param>
|
|||
/// <param name="clear">A value indicating whether to clean the buffer</param>
|
|||
/// <returns>The <see cref="IManagedByteBuffer"/></returns>
|
|||
internal abstract IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear); |
|||
|
|||
/// <summary>
|
|||
/// Releases all retained resources not being in use.
|
|||
/// Eg: by resetting array pools and letting GC to free the arrays.
|
|||
/// </summary>
|
|||
public virtual void ReleaseRetainedResources() |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,103 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
|
|||
using SixLabors.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Holds a <see cref="System.Memory{T}"/> that is either OWNED or CONSUMED.
|
|||
/// When the memory is being owned, the <see cref="IMemoryOwner{T}"/> instance is also known.
|
|||
/// Implements content transfer logic in <see cref="SwapOrCopyContent"/> that depends on the ownership status.
|
|||
/// This is needed to transfer the contents of a temporary <see cref="Buffer2D{T}"/>
|
|||
/// to a persistent <see cref="SixLabors.ImageSharp.ImageFrame{T}.PixelBuffer"/> without copying the buffer.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// For a deeper understanding of the owner/consumer model, check out the following docs: <br/>
|
|||
/// https://gist.github.com/GrabYourPitchforks/4c3e1935fd4d9fa2831dbfcab35dffc6
|
|||
/// https://www.codemag.com/Article/1807051/Introducing-.NET-Core-2.1-Flagship-Types-Span-T-and-Memory-T
|
|||
/// </remarks>
|
|||
internal struct MemorySource<T> : IDisposable |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="MemorySource{T}"/> struct
|
|||
/// by wrapping an existing <see cref="IMemoryOwner{T}"/>.
|
|||
/// </summary>
|
|||
/// <param name="memoryOwner">The <see cref="IMemoryOwner{T}"/> to wrap</param>
|
|||
/// <param name="isInternalMemorySource">
|
|||
/// A value indicating whether <paramref name="memoryOwner"/> is an internal memory source managed by ImageSharp.
|
|||
/// Eg. allocated by a <see cref="MemoryAllocator"/>.
|
|||
/// </param>
|
|||
public MemorySource(IMemoryOwner<T> memoryOwner, bool isInternalMemorySource) |
|||
{ |
|||
this.MemoryOwner = memoryOwner; |
|||
this.Memory = memoryOwner.Memory; |
|||
this.HasSwappableContents = isInternalMemorySource; |
|||
} |
|||
|
|||
public MemorySource(Memory<T> memory) |
|||
{ |
|||
this.Memory = memory; |
|||
this.MemoryOwner = null; |
|||
this.HasSwappableContents = false; |
|||
} |
|||
|
|||
public IMemoryOwner<T> MemoryOwner { get; private set; } |
|||
|
|||
public Memory<T> Memory { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether we are allowed to swap the contents of this buffer
|
|||
/// with an other <see cref="MemorySource{T}"/> instance.
|
|||
/// The value is true only and only if <see cref="MemoryOwner"/> is present,
|
|||
/// and it's coming from an internal source managed by ImageSharp (<see cref="MemoryAllocator"/>).
|
|||
/// </summary>
|
|||
public bool HasSwappableContents { get; } |
|||
|
|||
public Span<T> GetSpan() => this.Memory.Span; |
|||
|
|||
public void Clear() => this.Memory.Span.Clear(); |
|||
|
|||
/// <summary>
|
|||
/// Swaps the contents of 'destination' with 'source' if the buffers are owned (1),
|
|||
/// copies the contents of 'source' to 'destination' otherwise (2). Buffers should be of same size in case 2!
|
|||
/// </summary>
|
|||
public static void SwapOrCopyContent(ref MemorySource<T> destination, ref MemorySource<T> source) |
|||
{ |
|||
if (source.HasSwappableContents && destination.HasSwappableContents) |
|||
{ |
|||
SwapContents(ref destination, ref source); |
|||
} |
|||
else |
|||
{ |
|||
if (destination.Memory.Length != source.Memory.Length) |
|||
{ |
|||
throw new InvalidOperationException("SwapOrCopyContents(): buffers should both owned or the same size!"); |
|||
} |
|||
|
|||
source.Memory.CopyTo(destination.Memory); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
public void Dispose() |
|||
{ |
|||
this.MemoryOwner?.Dispose(); |
|||
} |
|||
|
|||
private static void SwapContents(ref MemorySource<T> a, ref MemorySource<T> b) |
|||
{ |
|||
IMemoryOwner<T> tempOwner = a.MemoryOwner; |
|||
Memory<T> tempMemory = a.Memory; |
|||
|
|||
a.MemoryOwner = b.MemoryOwner; |
|||
a.Memory = b.Memory; |
|||
|
|||
b.MemoryOwner = tempOwner; |
|||
b.Memory = tempMemory; |
|||
} |
|||
} |
|||
} |
|||
@ -1,19 +0,0 @@ |
|||
namespace SixLabors.Memory |
|||
{ |
|||
/// <summary>
|
|||
/// Implements <see cref="MemoryAllocator"/> by newing up arrays by the GC on every allocation requests.
|
|||
/// </summary>
|
|||
public sealed class SimpleGcMemoryAllocator : MemoryAllocator |
|||
{ |
|||
/// <inheritdoc />
|
|||
internal override IBuffer<T> Allocate<T>(int length, bool clear) |
|||
{ |
|||
return new BasicArrayBuffer<T>(new T[length]); |
|||
} |
|||
|
|||
internal override IManagedByteBuffer AllocateManagedByteBuffer(int length, bool clear) |
|||
{ |
|||
return new BasicByteBuffer(new byte[length]); |
|||
} |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue