mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
5 years ago
committed by
GitHub
GitHub
619 changed files with 18663 additions and 3709 deletions
@ -1 +1 @@ |
|||
Subproject commit 48e73f455f15eafefbe3175efc7433e5f277e506 |
|||
Subproject commit 9b94ebc4be9b7a8d7620c257e6ee485455973332 |
|||
@ -0,0 +1,23 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp |
|||
{ |
|||
/// <summary>
|
|||
/// The byte order of the data stream.
|
|||
/// </summary>
|
|||
public enum ByteOrder |
|||
{ |
|||
/// <summary>
|
|||
/// The big-endian byte order (Motorola).
|
|||
/// Most-significant byte comes first, and ends with the least-significant byte.
|
|||
/// </summary>
|
|||
BigEndian, |
|||
|
|||
/// <summary>
|
|||
/// The little-endian byte order (Intel).
|
|||
/// Least-significant byte comes first and ends with the most-significant byte.
|
|||
/// </summary>
|
|||
LittleEndian |
|||
} |
|||
} |
|||
@ -1,7 +1,7 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Png.Zlib |
|||
namespace SixLabors.ImageSharp.Compression.Zlib |
|||
{ |
|||
/// <content>
|
|||
/// Contains precalulated tables for scalar calculations.
|
|||
@ -0,0 +1,81 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Compression.Zlib |
|||
{ |
|||
/// <summary>
|
|||
/// Provides enumeration of available deflate compression levels.
|
|||
/// </summary>
|
|||
public enum DeflateCompressionLevel |
|||
{ |
|||
/// <summary>
|
|||
/// Level 0. Equivalent to <see cref="NoCompression"/>.
|
|||
/// </summary>
|
|||
Level0 = 0, |
|||
|
|||
/// <summary>
|
|||
/// No compression. Equivalent to <see cref="Level0"/>.
|
|||
/// </summary>
|
|||
NoCompression = Level0, |
|||
|
|||
/// <summary>
|
|||
/// Level 1. Equivalent to <see cref="BestSpeed"/>.
|
|||
/// </summary>
|
|||
Level1 = 1, |
|||
|
|||
/// <summary>
|
|||
/// Best speed compression level.
|
|||
/// </summary>
|
|||
BestSpeed = Level1, |
|||
|
|||
/// <summary>
|
|||
/// Level 2.
|
|||
/// </summary>
|
|||
Level2 = 2, |
|||
|
|||
/// <summary>
|
|||
/// Level 3.
|
|||
/// </summary>
|
|||
Level3 = 3, |
|||
|
|||
/// <summary>
|
|||
/// Level 4.
|
|||
/// </summary>
|
|||
Level4 = 4, |
|||
|
|||
/// <summary>
|
|||
/// Level 5.
|
|||
/// </summary>
|
|||
Level5 = 5, |
|||
|
|||
/// <summary>
|
|||
/// Level 6. Equivalent to <see cref="DefaultCompression"/>.
|
|||
/// </summary>
|
|||
Level6 = 6, |
|||
|
|||
/// <summary>
|
|||
/// The default compression level. Equivalent to <see cref="Level6"/>.
|
|||
/// </summary>
|
|||
DefaultCompression = Level6, |
|||
|
|||
/// <summary>
|
|||
/// Level 7.
|
|||
/// </summary>
|
|||
Level7 = 7, |
|||
|
|||
/// <summary>
|
|||
/// Level 8.
|
|||
/// </summary>
|
|||
Level8 = 8, |
|||
|
|||
/// <summary>
|
|||
/// Level 9. Equivalent to <see cref="BestCompression"/>.
|
|||
/// </summary>
|
|||
Level9 = 9, |
|||
|
|||
/// <summary>
|
|||
/// Best compression level. Equivalent to <see cref="Level9"/>.
|
|||
/// </summary>
|
|||
BestCompression = Level9, |
|||
} |
|||
} |
|||
@ -0,0 +1,524 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.IO; |
|||
using System.Runtime.CompilerServices; |
|||
#if SUPPORTS_RUNTIME_INTRINSICS
|
|||
using System.Runtime.Intrinsics; |
|||
using System.Runtime.Intrinsics.X86; |
|||
#endif
|
|||
using System.Threading; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder |
|||
{ |
|||
internal class HuffmanScanEncoder |
|||
{ |
|||
/// <summary>
|
|||
/// Compiled huffman tree to encode given values.
|
|||
/// </summary>
|
|||
/// <remarks>Yields codewords by index consisting of [run length | bitsize].</remarks>
|
|||
private HuffmanLut[] huffmanTables; |
|||
|
|||
/// <summary>
|
|||
/// Number of bytes cached before being written to target stream via Stream.Write(byte[], offest, count).
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is subject to change, 1024 seems to be the best value in terms of performance.
|
|||
/// <see cref="Emit(int, int)"/> expects it to be at least 8 (see comments in method body).
|
|||
/// </remarks>
|
|||
private const int EmitBufferSizeInBytes = 1024; |
|||
|
|||
/// <summary>
|
|||
/// A buffer for reducing the number of stream writes when emitting Huffman tables.
|
|||
/// </summary>
|
|||
private readonly byte[] emitBuffer = new byte[EmitBufferSizeInBytes]; |
|||
|
|||
/// <summary>
|
|||
/// Number of filled bytes in <see cref="emitBuffer"/> buffer
|
|||
/// </summary>
|
|||
private int emitLen = 0; |
|||
|
|||
/// <summary>
|
|||
/// Emmited bits 'micro buffer' before being transfered to the <see cref="emitBuffer"/>.
|
|||
/// </summary>
|
|||
private int accumulatedBits; |
|||
|
|||
/// <summary>
|
|||
/// Number of jagged bits stored in <see cref="accumulatedBits"/>
|
|||
/// </summary>
|
|||
private int bitCount; |
|||
|
|||
private Block8x8F temporalBlock1; |
|||
private Block8x8F temporalBlock2; |
|||
|
|||
/// <summary>
|
|||
/// The output stream. All attempted writes after the first error become no-ops.
|
|||
/// </summary>
|
|||
private readonly Stream target; |
|||
|
|||
public HuffmanScanEncoder(Stream outputStream) |
|||
{ |
|||
this.target = outputStream; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Encodes the image with no subsampling.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
|
|||
/// <param name="luminanceQuantTable">Luminance quantization table provided by the callee</param>
|
|||
/// <param name="chrominanceQuantTable">Chrominance quantization table provided by the callee</param>
|
|||
/// <param name="cancellationToken">The token to monitor for cancellation.</param>
|
|||
public void Encode444<TPixel>(Image<TPixel> pixels, ref Block8x8F luminanceQuantTable, ref Block8x8F chrominanceQuantTable, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
this.huffmanTables = HuffmanLut.TheHuffmanLut; |
|||
|
|||
var unzig = ZigZag.CreateUnzigTable(); |
|||
|
|||
// ReSharper disable once InconsistentNaming
|
|||
int prevDCY = 0, prevDCCb = 0, prevDCCr = 0; |
|||
|
|||
ImageFrame<TPixel> frame = pixels.Frames.RootFrame; |
|||
Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer; |
|||
RowOctet<TPixel> currentRows = default; |
|||
|
|||
var pixelConverter = new YCbCrForwardConverter444<TPixel>(frame); |
|||
|
|||
for (int y = 0; y < pixels.Height; y += 8) |
|||
{ |
|||
cancellationToken.ThrowIfCancellationRequested(); |
|||
currentRows.Update(pixelBuffer, y); |
|||
|
|||
for (int x = 0; x < pixels.Width; x += 8) |
|||
{ |
|||
pixelConverter.Convert(x, y, ref currentRows); |
|||
|
|||
prevDCY = this.WriteBlock( |
|||
QuantIndex.Luminance, |
|||
prevDCY, |
|||
ref pixelConverter.Y, |
|||
ref luminanceQuantTable, |
|||
ref unzig); |
|||
|
|||
prevDCCb = this.WriteBlock( |
|||
QuantIndex.Chrominance, |
|||
prevDCCb, |
|||
ref pixelConverter.Cb, |
|||
ref chrominanceQuantTable, |
|||
ref unzig); |
|||
|
|||
prevDCCr = this.WriteBlock( |
|||
QuantIndex.Chrominance, |
|||
prevDCCr, |
|||
ref pixelConverter.Cr, |
|||
ref chrominanceQuantTable, |
|||
ref unzig); |
|||
} |
|||
} |
|||
|
|||
this.FlushInternalBuffer(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Encodes the image with subsampling. The Cb and Cr components are each subsampled
|
|||
/// at a factor of 2 both horizontally and vertically.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
|
|||
/// <param name="luminanceQuantTable">Luminance quantization table provided by the callee</param>
|
|||
/// <param name="chrominanceQuantTable">Chrominance quantization table provided by the callee</param>
|
|||
/// <param name="cancellationToken">The token to monitor for cancellation.</param>
|
|||
public void Encode420<TPixel>(Image<TPixel> pixels, ref Block8x8F luminanceQuantTable, ref Block8x8F chrominanceQuantTable, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
this.huffmanTables = HuffmanLut.TheHuffmanLut; |
|||
|
|||
var unzig = ZigZag.CreateUnzigTable(); |
|||
|
|||
// ReSharper disable once InconsistentNaming
|
|||
int prevDCY = 0, prevDCCb = 0, prevDCCr = 0; |
|||
ImageFrame<TPixel> frame = pixels.Frames.RootFrame; |
|||
Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer; |
|||
RowOctet<TPixel> currentRows = default; |
|||
|
|||
var pixelConverter = new YCbCrForwardConverter420<TPixel>(frame); |
|||
|
|||
for (int y = 0; y < pixels.Height; y += 16) |
|||
{ |
|||
cancellationToken.ThrowIfCancellationRequested(); |
|||
for (int x = 0; x < pixels.Width; x += 16) |
|||
{ |
|||
for (int i = 0; i < 2; i++) |
|||
{ |
|||
int yOff = i * 8; |
|||
currentRows.Update(pixelBuffer, y + yOff); |
|||
pixelConverter.Convert(x, y, ref currentRows, i); |
|||
|
|||
prevDCY = this.WriteBlock( |
|||
QuantIndex.Luminance, |
|||
prevDCY, |
|||
ref pixelConverter.YLeft, |
|||
ref luminanceQuantTable, |
|||
ref unzig); |
|||
|
|||
prevDCY = this.WriteBlock( |
|||
QuantIndex.Luminance, |
|||
prevDCY, |
|||
ref pixelConverter.YRight, |
|||
ref luminanceQuantTable, |
|||
ref unzig); |
|||
} |
|||
|
|||
prevDCCb = this.WriteBlock( |
|||
QuantIndex.Chrominance, |
|||
prevDCCb, |
|||
ref pixelConverter.Cb, |
|||
ref chrominanceQuantTable, |
|||
ref unzig); |
|||
|
|||
prevDCCr = this.WriteBlock( |
|||
QuantIndex.Chrominance, |
|||
prevDCCr, |
|||
ref pixelConverter.Cr, |
|||
ref chrominanceQuantTable, |
|||
ref unzig); |
|||
} |
|||
} |
|||
|
|||
this.FlushInternalBuffer(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Encodes the image with no chroma, just luminance.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="pixels">The pixel accessor providing access to the image pixels.</param>
|
|||
/// <param name="luminanceQuantTable">Luminance quantization table provided by the callee</param>
|
|||
/// <param name="cancellationToken">The token to monitor for cancellation.</param>
|
|||
public void EncodeGrayscale<TPixel>(Image<TPixel> pixels, ref Block8x8F luminanceQuantTable, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
this.huffmanTables = HuffmanLut.TheHuffmanLut; |
|||
|
|||
var unzig = ZigZag.CreateUnzigTable(); |
|||
|
|||
// ReSharper disable once InconsistentNaming
|
|||
int prevDCY = 0; |
|||
|
|||
var pixelConverter = LuminanceForwardConverter<TPixel>.Create(); |
|||
ImageFrame<TPixel> frame = pixels.Frames.RootFrame; |
|||
Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer; |
|||
RowOctet<TPixel> currentRows = default; |
|||
|
|||
for (int y = 0; y < pixels.Height; y += 8) |
|||
{ |
|||
cancellationToken.ThrowIfCancellationRequested(); |
|||
currentRows.Update(pixelBuffer, y); |
|||
|
|||
for (int x = 0; x < pixels.Width; x += 8) |
|||
{ |
|||
pixelConverter.Convert(frame, x, y, ref currentRows); |
|||
|
|||
prevDCY = this.WriteBlock( |
|||
QuantIndex.Luminance, |
|||
prevDCY, |
|||
ref pixelConverter.Y, |
|||
ref luminanceQuantTable, |
|||
ref unzig); |
|||
} |
|||
} |
|||
|
|||
this.FlushInternalBuffer(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a block of pixel data using the given quantization table,
|
|||
/// returning the post-quantized DC value of the DCT-transformed block.
|
|||
/// The block is in natural (not zig-zag) order.
|
|||
/// </summary>
|
|||
/// <param name="index">The quantization table index.</param>
|
|||
/// <param name="prevDC">The previous DC value.</param>
|
|||
/// <param name="src">Source block</param>
|
|||
/// <param name="quant">Quantization table</param>
|
|||
/// <param name="unZig">The 8x8 Unzig block.</param>
|
|||
/// <returns>The <see cref="int"/>.</returns>
|
|||
private int WriteBlock( |
|||
QuantIndex index, |
|||
int prevDC, |
|||
ref Block8x8F src, |
|||
ref Block8x8F quant, |
|||
ref ZigZag unZig) |
|||
{ |
|||
ref Block8x8F refTemp1 = ref this.temporalBlock1; |
|||
ref Block8x8F refTemp2 = ref this.temporalBlock2; |
|||
|
|||
FastFloatingPointDCT.TransformFDCT(ref src, ref refTemp1, ref refTemp2); |
|||
|
|||
Block8x8F.Quantize(ref refTemp1, ref refTemp2, ref quant, ref unZig); |
|||
|
|||
// Emit the DC delta.
|
|||
int dc = (int)refTemp2[0]; |
|||
this.EmitDirectCurrentTerm(this.huffmanTables[2 * (int)index].Values, dc - prevDC); |
|||
|
|||
// Emit the AC components.
|
|||
int[] acHuffTable = this.huffmanTables[(2 * (int)index) + 1].Values; |
|||
|
|||
int runLength = 0; |
|||
int lastValuableIndex = GetLastValuableElementIndex(ref refTemp2); |
|||
for (int zig = 1; zig <= lastValuableIndex; zig++) |
|||
{ |
|||
int ac = (int)refTemp2[zig]; |
|||
|
|||
if (ac == 0) |
|||
{ |
|||
runLength++; |
|||
} |
|||
else |
|||
{ |
|||
while (runLength > 15) |
|||
{ |
|||
this.EmitHuff(acHuffTable, 0xf0); |
|||
runLength -= 16; |
|||
} |
|||
|
|||
this.EmitHuffRLE(acHuffTable, runLength, ac); |
|||
runLength = 0; |
|||
} |
|||
} |
|||
|
|||
// if mcu block contains trailing zeros - we must write end of block (EOB) value indicating that current block is over
|
|||
// this can be done for any number of trailing zeros, even when all 63 ac values are zero
|
|||
// (Block8x8F.Size - 1) == 63 - last index of the mcu elements
|
|||
if (lastValuableIndex != Block8x8F.Size - 1) |
|||
{ |
|||
this.EmitHuff(acHuffTable, 0x00); |
|||
} |
|||
|
|||
return dc; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Emits the least significant count of bits to the stream write buffer.
|
|||
/// The precondition is bits
|
|||
/// <example>
|
|||
/// < 1<<nBits && nBits <= 16
|
|||
/// </example>
|
|||
/// .
|
|||
/// </summary>
|
|||
/// <param name="bits">The packed bits.</param>
|
|||
/// <param name="count">The number of bits</param>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
private void Emit(int bits, int count) |
|||
{ |
|||
count += this.bitCount; |
|||
bits <<= 32 - count; |
|||
bits |= this.accumulatedBits; |
|||
|
|||
// Only write if more than 8 bits.
|
|||
if (count >= 8) |
|||
{ |
|||
// Track length
|
|||
while (count >= 8) |
|||
{ |
|||
byte b = (byte)(bits >> 24); |
|||
this.emitBuffer[this.emitLen++] = b; |
|||
|
|||
// Adding stuff byte
|
|||
// This is because by JPEG standard scan data can contain JPEG markers (indicated by the 0xFF byte, followed by a non-zero byte)
|
|||
// Considering this every 0xFF byte must be followed by 0x00 padding byte to signal that this is not a marker
|
|||
if (b == byte.MaxValue) |
|||
{ |
|||
this.emitBuffer[this.emitLen++] = byte.MinValue; |
|||
} |
|||
|
|||
bits <<= 8; |
|||
count -= 8; |
|||
} |
|||
|
|||
// This can emit 4 times of:
|
|||
// 1 byte guaranteed
|
|||
// 1 extra byte.MinValue byte if previous one was byte.MaxValue
|
|||
// Thus writing (1 + 1) * 4 = 8 bytes max
|
|||
// So we must check if emit buffer has extra 8 bytes, if not - call stream.Write
|
|||
if (this.emitLen > EmitBufferSizeInBytes - 8) |
|||
{ |
|||
this.target.Write(this.emitBuffer, 0, this.emitLen); |
|||
this.emitLen = 0; |
|||
} |
|||
} |
|||
|
|||
this.accumulatedBits = bits; |
|||
this.bitCount = count; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Emits the given value with the given Huffman encoder.
|
|||
/// </summary>
|
|||
/// <param name="table">Compiled Huffman spec values.</param>
|
|||
/// <param name="value">The value to encode.</param>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
private void EmitHuff(int[] table, int value) |
|||
{ |
|||
int x = table[value]; |
|||
this.Emit(x >> 8, x & 0xff); |
|||
} |
|||
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
private void EmitDirectCurrentTerm(int[] table, int value) |
|||
{ |
|||
int a = value; |
|||
int b = value; |
|||
if (a < 0) |
|||
{ |
|||
a = -value; |
|||
b = value - 1; |
|||
} |
|||
|
|||
int bt = GetHuffmanEncodingLength((uint)a); |
|||
|
|||
this.EmitHuff(table, bt); |
|||
if (bt > 0) |
|||
{ |
|||
this.Emit(b & ((1 << bt) - 1), bt); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Emits a run of runLength copies of value encoded with the given Huffman encoder.
|
|||
/// </summary>
|
|||
/// <param name="table">Compiled Huffman spec values.</param>
|
|||
/// <param name="runLength">The number of copies to encode.</param>
|
|||
/// <param name="value">The value to encode.</param>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
private void EmitHuffRLE(int[] table, int runLength, int value) |
|||
{ |
|||
int a = value; |
|||
int b = value; |
|||
if (a < 0) |
|||
{ |
|||
a = -value; |
|||
b = value - 1; |
|||
} |
|||
|
|||
int bt = GetHuffmanEncodingLength((uint)a); |
|||
|
|||
this.EmitHuff(table, (runLength << 4) | bt); |
|||
this.Emit(b & ((1 << bt) - 1), bt); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes remaining bytes from internal buffer to the target stream.
|
|||
/// </summary>
|
|||
/// <remarks>Pads last byte with 1's if necessary</remarks>
|
|||
private void FlushInternalBuffer() |
|||
{ |
|||
// pad last byte with 1's
|
|||
int padBitsCount = 8 - (this.bitCount % 8); |
|||
if (padBitsCount != 0) |
|||
{ |
|||
this.Emit((1 << padBitsCount) - 1, padBitsCount); |
|||
this.target.Write(this.emitBuffer, 0, this.emitLen); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates how many minimum bits needed to store given value for Huffman jpeg encoding.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is an internal operation supposed to be used only in <see cref="HuffmanScanEncoder"/> class for jpeg encoding.
|
|||
/// </remarks>
|
|||
/// <param name="value">The value.</param>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
internal static int GetHuffmanEncodingLength(uint value) |
|||
{ |
|||
DebugGuard.IsTrue(value <= (1 << 16), "Huffman encoder is supposed to encode a value of 16bit size max"); |
|||
#if SUPPORTS_BITOPERATIONS
|
|||
// This should have been implemented as (BitOperations.Log2(value) + 1) as in non-intrinsic implementation
|
|||
// But internal log2 is implementated like this: (31 - (int)Lzcnt.LeadingZeroCount(value))
|
|||
|
|||
// BitOperations.Log2 implementation also checks if input value is zero for the convention 0->0
|
|||
// Lzcnt would return 32 for input value of 0 - no need to check that with branching
|
|||
// Fallback code if Lzcnt is not supported still use if-check
|
|||
// But most modern CPUs support this instruction so this should not be a problem
|
|||
return 32 - System.Numerics.BitOperations.LeadingZeroCount(value); |
|||
#else
|
|||
// Ideally:
|
|||
// if 0 - return 0 in this case
|
|||
// else - return log2(value) + 1
|
|||
//
|
|||
// Hack based on input value constaint:
|
|||
// We know that input values are guaranteed to be maximum 16 bit large for huffman encoding
|
|||
// We can safely shift input value for one bit -> log2(value << 1)
|
|||
// Because of the 16 bit value constraint it won't overflow
|
|||
// With that input value change we no longer need to add 1 before returning
|
|||
// And this eliminates need to check if input value is zero - it is a standard convention which Log2SoftwareFallback adheres to
|
|||
return Numerics.Log2(value << 1); |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns index of the last non-zero element in given mcu block.
|
|||
/// If all values of the mcu block are zero, this method might return different results depending on the runtime and hardware support.
|
|||
/// This is jpeg mcu specific code, mcu[0] stores a dc value which will be encoded outside of the loop.
|
|||
/// This method is guaranteed to return either -1 or 0 if all elements are zero.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is an internal operation supposed to be used only in <see cref="HuffmanScanEncoder"/> class for jpeg encoding.
|
|||
/// </remarks>
|
|||
/// <param name="mcu">Mcu block.</param>
|
|||
/// <returns>Index of the last non-zero element.</returns>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
internal static int GetLastValuableElementIndex(ref Block8x8F mcu) |
|||
{ |
|||
#if SUPPORTS_RUNTIME_INTRINSICS
|
|||
if (Avx2.IsSupported) |
|||
{ |
|||
const int equalityMask = unchecked((int)0b1111_1111_1111_1111_1111_1111_1111_1111); |
|||
|
|||
Vector256<int> zero8 = Vector256<int>.Zero; |
|||
|
|||
ref Vector256<float> mcuStride = ref mcu.V0; |
|||
|
|||
for (int i = 7; i >= 0; i--) |
|||
{ |
|||
int areEqual = Avx2.MoveMask(Avx2.CompareEqual(Avx.ConvertToVector256Int32(Unsafe.Add(ref mcuStride, i)), zero8).AsByte()); |
|||
|
|||
// we do not know for sure if this stride contain all non-zero elements or if it has some trailing zeros
|
|||
if (areEqual != equalityMask) |
|||
{ |
|||
// last index in the stride, we go from the end to the start of the stride
|
|||
int startIndex = i * 8; |
|||
int index = startIndex + 7; |
|||
ref float elemRef = ref Unsafe.As<Block8x8F, float>(ref mcu); |
|||
while (index >= startIndex && (int)Unsafe.Add(ref elemRef, index) == 0) |
|||
{ |
|||
index--; |
|||
} |
|||
|
|||
// this implementation will return -1 if all ac components are zero and dc are zero
|
|||
return index; |
|||
} |
|||
} |
|||
|
|||
return -1; |
|||
} |
|||
else |
|||
#endif
|
|||
{ |
|||
int index = Block8x8F.Size - 1; |
|||
ref float elemRef = ref Unsafe.As<Block8x8F, float>(ref mcu); |
|||
|
|||
while (index > 0 && (int)Unsafe.Add(ref elemRef, index) == 0) |
|||
{ |
|||
index--; |
|||
} |
|||
|
|||
// this implementation will return 0 if all ac components and dc are zero
|
|||
return index; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,121 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder |
|||
{ |
|||
/// <summary>
|
|||
/// On-stack worker struct to efficiently encapsulate the TPixel -> Rgb24 -> YCbCr conversion chain of 8x8 pixel blocks.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel type to work on</typeparam>
|
|||
internal ref struct YCbCrForwardConverter420<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <summary>
|
|||
/// Number of pixels processed per single <see cref="Convert(int, int, ref RowOctet{TPixel}, int)"/> call
|
|||
/// </summary>
|
|||
private const int PixelsPerSample = 16 * 8; |
|||
|
|||
/// <summary>
|
|||
/// Total byte size of processed pixels converted from TPixel to <see cref="Rgb24"/>
|
|||
/// </summary>
|
|||
private const int RgbSpanByteSize = PixelsPerSample * 3; |
|||
|
|||
/// <summary>
|
|||
/// <see cref="Size"/> of sampling area from given frame pixel buffer
|
|||
/// </summary>
|
|||
private static readonly Size SampleSize = new Size(16, 8); |
|||
|
|||
/// <summary>
|
|||
/// The left Y component
|
|||
/// </summary>
|
|||
public Block8x8F YLeft; |
|||
|
|||
/// <summary>
|
|||
/// The left Y component
|
|||
/// </summary>
|
|||
public Block8x8F YRight; |
|||
|
|||
/// <summary>
|
|||
/// The Cb component
|
|||
/// </summary>
|
|||
public Block8x8F Cb; |
|||
|
|||
/// <summary>
|
|||
/// The Cr component
|
|||
/// </summary>
|
|||
public Block8x8F Cr; |
|||
|
|||
/// <summary>
|
|||
/// The color conversion tables
|
|||
/// </summary>
|
|||
private RgbToYCbCrConverterLut colorTables; |
|||
|
|||
/// <summary>
|
|||
/// Temporal 16x8 block to hold TPixel data
|
|||
/// </summary>
|
|||
private Span<TPixel> pixelSpan; |
|||
|
|||
/// <summary>
|
|||
/// Temporal RGB block
|
|||
/// </summary>
|
|||
private Span<Rgb24> rgbSpan; |
|||
|
|||
/// <summary>
|
|||
/// Sampled pixel buffer size
|
|||
/// </summary>
|
|||
private Size samplingAreaSize; |
|||
|
|||
/// <summary>
|
|||
/// <see cref="Configuration"/> for internal operations
|
|||
/// </summary>
|
|||
private Configuration config; |
|||
|
|||
public YCbCrForwardConverter420(ImageFrame<TPixel> frame) |
|||
{ |
|||
// matrices would be filled during convert calls
|
|||
this.YLeft = default; |
|||
this.YRight = default; |
|||
this.Cb = default; |
|||
this.Cr = default; |
|||
|
|||
// temporal pixel buffers
|
|||
this.pixelSpan = new TPixel[PixelsPerSample].AsSpan(); |
|||
this.rgbSpan = MemoryMarshal.Cast<byte, Rgb24>(new byte[RgbSpanByteSize + RgbToYCbCrConverterVectorized.AvxCompatibilityPadding].AsSpan()); |
|||
|
|||
// frame data
|
|||
this.samplingAreaSize = new Size(frame.Width, frame.Height); |
|||
this.config = frame.GetConfiguration(); |
|||
|
|||
// conversion vector fallback data
|
|||
if (!RgbToYCbCrConverterVectorized.IsSupported) |
|||
{ |
|||
this.colorTables = RgbToYCbCrConverterLut.Create(); |
|||
} |
|||
else |
|||
{ |
|||
this.colorTables = default; |
|||
} |
|||
} |
|||
|
|||
public void Convert(int x, int y, ref RowOctet<TPixel> currentRows, int idx) |
|||
{ |
|||
YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize); |
|||
|
|||
PixelOperations<TPixel>.Instance.ToRgb24(this.config, this.pixelSpan, this.rgbSpan); |
|||
|
|||
if (RgbToYCbCrConverterVectorized.IsSupported) |
|||
{ |
|||
RgbToYCbCrConverterVectorized.Convert420(this.rgbSpan, ref this.YLeft, ref this.YRight, ref this.Cb, ref this.Cr, idx); |
|||
} |
|||
else |
|||
{ |
|||
this.colorTables.Convert420(this.rgbSpan, ref this.YLeft, ref this.YRight, ref this.Cb, ref this.Cr, idx); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,122 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder |
|||
{ |
|||
/// <summary>
|
|||
/// On-stack worker struct to efficiently encapsulate the TPixel -> Rgb24 -> YCbCr conversion chain of 8x8 pixel blocks.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel type to work on</typeparam>
|
|||
internal ref struct YCbCrForwardConverter444<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <summary>
|
|||
/// Number of pixels processed per single <see cref="Convert(int, int, ref RowOctet{TPixel})"/> call
|
|||
/// </summary>
|
|||
private const int PixelsPerSample = 8 * 8; |
|||
|
|||
/// <summary>
|
|||
/// Total byte size of processed pixels converted from TPixel to <see cref="Rgb24"/>
|
|||
/// </summary>
|
|||
private const int RgbSpanByteSize = PixelsPerSample * 3; |
|||
|
|||
/// <summary>
|
|||
/// <see cref="Size"/> of sampling area from given frame pixel buffer
|
|||
/// </summary>
|
|||
private static readonly Size SampleSize = new Size(8, 8); |
|||
|
|||
/// <summary>
|
|||
/// The Y component
|
|||
/// </summary>
|
|||
public Block8x8F Y; |
|||
|
|||
/// <summary>
|
|||
/// The Cb component
|
|||
/// </summary>
|
|||
public Block8x8F Cb; |
|||
|
|||
/// <summary>
|
|||
/// The Cr component
|
|||
/// </summary>
|
|||
public Block8x8F Cr; |
|||
|
|||
/// <summary>
|
|||
/// The color conversion tables
|
|||
/// </summary>
|
|||
private RgbToYCbCrConverterLut colorTables; |
|||
|
|||
/// <summary>
|
|||
/// Temporal 64-byte span to hold unconverted TPixel data
|
|||
/// </summary>
|
|||
private Span<TPixel> pixelSpan; |
|||
|
|||
/// <summary>
|
|||
/// Temporal 64-byte span to hold converted Rgb24 data
|
|||
/// </summary>
|
|||
private Span<Rgb24> rgbSpan; |
|||
|
|||
/// <summary>
|
|||
/// Sampled pixel buffer size
|
|||
/// </summary>
|
|||
private Size samplingAreaSize; |
|||
|
|||
/// <summary>
|
|||
/// <see cref="Configuration"/> for internal operations
|
|||
/// </summary>
|
|||
private Configuration config; |
|||
|
|||
public YCbCrForwardConverter444(ImageFrame<TPixel> frame) |
|||
{ |
|||
// matrices would be filled during convert calls
|
|||
this.Y = default; |
|||
this.Cb = default; |
|||
this.Cr = default; |
|||
|
|||
// temporal pixel buffers
|
|||
this.pixelSpan = new TPixel[PixelsPerSample].AsSpan(); |
|||
this.rgbSpan = MemoryMarshal.Cast<byte, Rgb24>(new byte[RgbSpanByteSize + RgbToYCbCrConverterVectorized.AvxCompatibilityPadding].AsSpan()); |
|||
|
|||
// frame data
|
|||
this.samplingAreaSize = new Size(frame.Width, frame.Height); |
|||
this.config = frame.GetConfiguration(); |
|||
|
|||
// conversion vector fallback data
|
|||
if (!RgbToYCbCrConverterVectorized.IsSupported) |
|||
{ |
|||
this.colorTables = RgbToYCbCrConverterLut.Create(); |
|||
} |
|||
else |
|||
{ |
|||
this.colorTables = default; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Converts a 8x8 image area inside 'pixels' at position (x,y) placing the result members of the structure (<see cref="Y"/>, <see cref="Cb"/>, <see cref="Cr"/>)
|
|||
/// </summary>
|
|||
public void Convert(int x, int y, ref RowOctet<TPixel> currentRows) |
|||
{ |
|||
YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize); |
|||
|
|||
PixelOperations<TPixel>.Instance.ToRgb24(this.config, this.pixelSpan, this.rgbSpan); |
|||
|
|||
ref Block8x8F yBlock = ref this.Y; |
|||
ref Block8x8F cbBlock = ref this.Cb; |
|||
ref Block8x8F crBlock = ref this.Cr; |
|||
|
|||
if (RgbToYCbCrConverterVectorized.IsSupported) |
|||
{ |
|||
RgbToYCbCrConverterVectorized.Convert444(this.rgbSpan, ref yBlock, ref cbBlock, ref crBlock); |
|||
} |
|||
else |
|||
{ |
|||
this.colorTables.Convert444(this.rgbSpan, ref yBlock, ref cbBlock, ref crBlock); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,4 +1,4 @@ |
|||
# Encoder/Decoder for true vision targa files |
|||
# Encoder/Decoder for true vision targa files |
|||
|
|||
Useful links for reference: |
|||
|
|||
@ -0,0 +1,51 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
internal static class BitWriterUtils |
|||
{ |
|||
public static void WriteBits(Span<byte> buffer, int pos, uint count, byte value) |
|||
{ |
|||
int bitPos = pos % 8; |
|||
int bufferPos = pos / 8; |
|||
int startIdx = bufferPos + bitPos; |
|||
int endIdx = (int)(startIdx + count); |
|||
|
|||
if (value == 1) |
|||
{ |
|||
for (int i = startIdx; i < endIdx; i++) |
|||
{ |
|||
WriteBit(buffer, bufferPos, bitPos); |
|||
|
|||
bitPos++; |
|||
if (bitPos >= 8) |
|||
{ |
|||
bitPos = 0; |
|||
bufferPos++; |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
for (int i = startIdx; i < endIdx; i++) |
|||
{ |
|||
WriteZeroBit(buffer, bufferPos, bitPos); |
|||
|
|||
bitPos++; |
|||
if (bitPos >= 8) |
|||
{ |
|||
bitPos = 0; |
|||
bufferPos++; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
public static void WriteBit(Span<byte> buffer, int bufferPos, int bitPos) => buffer[bufferPos] |= (byte)(1 << (7 - bitPos)); |
|||
|
|||
public static void WriteZeroBit(Span<byte> buffer, int bufferPos, int bitPos) => buffer[bufferPos] = (byte)(buffer[bufferPos] & ~(1 << (7 - bitPos))); |
|||
} |
|||
} |
|||
@ -0,0 +1,62 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Compression.Zlib; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
internal sealed class DeflateCompressor : TiffBaseCompressor |
|||
{ |
|||
private readonly DeflateCompressionLevel compressionLevel; |
|||
|
|||
private readonly MemoryStream memoryStream = new MemoryStream(); |
|||
|
|||
public DeflateCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor, DeflateCompressionLevel compressionLevel) |
|||
: base(output, allocator, width, bitsPerPixel, predictor) |
|||
=> this.compressionLevel = compressionLevel; |
|||
|
|||
/// <inheritdoc/>
|
|||
public override TiffCompression Method => TiffCompression.Deflate; |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Initialize(int rowsPerStrip) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void CompressStrip(Span<byte> rows, int height) |
|||
{ |
|||
this.memoryStream.Seek(0, SeekOrigin.Begin); |
|||
using (var stream = new ZlibDeflateStream(this.Allocator, this.memoryStream, this.compressionLevel)) |
|||
{ |
|||
if (this.Predictor == TiffPredictor.Horizontal) |
|||
{ |
|||
HorizontalPredictor.ApplyHorizontalPrediction(rows, this.BytesPerRow, this.BitsPerPixel); |
|||
} |
|||
|
|||
stream.Write(rows); |
|||
stream.Flush(); |
|||
} |
|||
|
|||
int size = (int)this.memoryStream.Position; |
|||
|
|||
#if !NETSTANDARD1_3
|
|||
byte[] buffer = this.memoryStream.GetBuffer(); |
|||
this.Output.Write(buffer, 0, size); |
|||
#else
|
|||
this.memoryStream.SetLength(size); |
|||
this.memoryStream.Position = 0; |
|||
this.memoryStream.CopyTo(this.Output); |
|||
#endif
|
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,40 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
internal sealed class LzwCompressor : TiffBaseCompressor |
|||
{ |
|||
private TiffLzwEncoder lzwEncoder; |
|||
|
|||
public LzwCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor) |
|||
: base(output, allocator, width, bitsPerPixel, predictor) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override TiffCompression Method => TiffCompression.Lzw; |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Initialize(int rowsPerStrip) => this.lzwEncoder = new TiffLzwEncoder(this.Allocator); |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void CompressStrip(Span<byte> rows, int height) |
|||
{ |
|||
if (this.Predictor == TiffPredictor.Horizontal) |
|||
{ |
|||
HorizontalPredictor.ApplyHorizontalPrediction(rows, this.BytesPerRow, this.BitsPerPixel); |
|||
} |
|||
|
|||
this.lzwEncoder.Encode(rows, this.Output); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) => this.lzwEncoder?.Dispose(); |
|||
} |
|||
} |
|||
@ -0,0 +1,34 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
internal sealed class NoCompressor : TiffBaseCompressor |
|||
{ |
|||
public NoCompressor(Stream output, MemoryAllocator memoryAllocator, int width, int bitsPerPixel) |
|||
: base(output, memoryAllocator, width, bitsPerPixel) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override TiffCompression Method => TiffCompression.None; |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Initialize(int rowsPerStrip) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void CompressStrip(Span<byte> rows, int height) => this.Output.Write(rows); |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,49 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
internal sealed class PackBitsCompressor : TiffBaseCompressor |
|||
{ |
|||
private IMemoryOwner<byte> pixelData; |
|||
|
|||
public PackBitsCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel) |
|||
: base(output, allocator, width, bitsPerPixel) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override TiffCompression Method => TiffCompression.PackBits; |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Initialize(int rowsPerStrip) |
|||
{ |
|||
int additionalBytes = ((this.BytesPerRow + 126) / 127) + 1; |
|||
this.pixelData = this.Allocator.Allocate<byte>(this.BytesPerRow + additionalBytes); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void CompressStrip(Span<byte> rows, int height) |
|||
{ |
|||
DebugGuard.IsTrue(rows.Length % height == 0, "Invalid height"); |
|||
DebugGuard.IsTrue(this.BytesPerRow == rows.Length / height, "The widths must match"); |
|||
|
|||
Span<byte> span = this.pixelData.GetSpan(); |
|||
for (int i = 0; i < height; i++) |
|||
{ |
|||
Span<byte> row = rows.Slice(i * this.BytesPerRow, this.BytesPerRow); |
|||
int size = PackBitsWriter.PackBits(row, span); |
|||
this.Output.Write(span.Slice(0, size)); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) => this.pixelData?.Dispose(); |
|||
} |
|||
} |
|||
@ -0,0 +1,128 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
/// <summary>
|
|||
/// Pack Bits compression for tiff images. See Tiff Spec v6, section 9.
|
|||
/// </summary>
|
|||
internal static class PackBitsWriter |
|||
{ |
|||
public static int PackBits(ReadOnlySpan<byte> rowSpan, Span<byte> compressedRowSpan) |
|||
{ |
|||
int maxRunLength = 127; |
|||
int posInRowSpan = 0; |
|||
int bytesWritten = 0; |
|||
int literalRunLength = 0; |
|||
|
|||
while (posInRowSpan < rowSpan.Length) |
|||
{ |
|||
bool useReplicateRun = IsReplicateRun(rowSpan, posInRowSpan); |
|||
if (useReplicateRun) |
|||
{ |
|||
if (literalRunLength > 0) |
|||
{ |
|||
WriteLiteralRun(rowSpan, posInRowSpan, literalRunLength, compressedRowSpan, bytesWritten); |
|||
bytesWritten += literalRunLength + 1; |
|||
} |
|||
|
|||
// Write a run with the same bytes.
|
|||
int runLength = FindRunLength(rowSpan, posInRowSpan, maxRunLength); |
|||
WriteRun(rowSpan, posInRowSpan, runLength, compressedRowSpan, bytesWritten); |
|||
|
|||
bytesWritten += 2; |
|||
literalRunLength = 0; |
|||
posInRowSpan += runLength; |
|||
continue; |
|||
} |
|||
|
|||
literalRunLength++; |
|||
posInRowSpan++; |
|||
|
|||
if (literalRunLength >= maxRunLength) |
|||
{ |
|||
WriteLiteralRun(rowSpan, posInRowSpan, literalRunLength, compressedRowSpan, bytesWritten); |
|||
bytesWritten += literalRunLength + 1; |
|||
literalRunLength = 0; |
|||
} |
|||
} |
|||
|
|||
if (literalRunLength > 0) |
|||
{ |
|||
WriteLiteralRun(rowSpan, posInRowSpan, literalRunLength, compressedRowSpan, bytesWritten); |
|||
bytesWritten += literalRunLength + 1; |
|||
} |
|||
|
|||
return bytesWritten; |
|||
} |
|||
|
|||
private static void WriteLiteralRun(ReadOnlySpan<byte> rowSpan, int end, int literalRunLength, Span<byte> compressedRowSpan, int compressedRowPos) |
|||
{ |
|||
DebugGuard.MustBeLessThanOrEqualTo(literalRunLength, 127, nameof(literalRunLength)); |
|||
|
|||
int literalRunStart = end - literalRunLength; |
|||
sbyte runLength = (sbyte)(literalRunLength - 1); |
|||
compressedRowSpan[compressedRowPos] = (byte)runLength; |
|||
rowSpan.Slice(literalRunStart, literalRunLength).CopyTo(compressedRowSpan.Slice(compressedRowPos + 1)); |
|||
} |
|||
|
|||
private static void WriteRun(ReadOnlySpan<byte> rowSpan, int start, int runLength, Span<byte> compressedRowSpan, int compressedRowPos) |
|||
{ |
|||
DebugGuard.MustBeLessThanOrEqualTo(runLength, 127, nameof(runLength)); |
|||
|
|||
sbyte headerByte = (sbyte)(-runLength + 1); |
|||
compressedRowSpan[compressedRowPos] = (byte)headerByte; |
|||
compressedRowSpan[compressedRowPos + 1] = rowSpan[start]; |
|||
} |
|||
|
|||
private static bool IsReplicateRun(ReadOnlySpan<byte> rowSpan, int startPos) |
|||
{ |
|||
// We consider run which has at least 3 same consecutive bytes a candidate for a run.
|
|||
var startByte = rowSpan[startPos]; |
|||
int count = 0; |
|||
for (int i = startPos + 1; i < rowSpan.Length; i++) |
|||
{ |
|||
if (rowSpan[i] == startByte) |
|||
{ |
|||
count++; |
|||
if (count >= 2) |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
break; |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private static int FindRunLength(ReadOnlySpan<byte> rowSpan, int startPos, int maxRunLength) |
|||
{ |
|||
var startByte = rowSpan[startPos]; |
|||
int count = 1; |
|||
for (int i = startPos + 1; i < rowSpan.Length; i++) |
|||
{ |
|||
if (rowSpan[i] == startByte) |
|||
{ |
|||
count++; |
|||
} |
|||
else |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (count == maxRunLength) |
|||
{ |
|||
break; |
|||
} |
|||
} |
|||
|
|||
return count; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,594 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
/// <summary>
|
|||
/// Bitwriter for writing compressed CCITT T4 1D data.
|
|||
/// </summary>
|
|||
internal sealed class T4BitCompressor : TiffBaseCompressor |
|||
{ |
|||
private const uint WhiteZeroRunTermCode = 0x35; |
|||
|
|||
private const uint BlackZeroRunTermCode = 0x37; |
|||
|
|||
private static readonly uint[] MakeupRunLength = |
|||
{ |
|||
64, 128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560 |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen4TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 2, 0x7 }, { 3, 0x8 }, { 4, 0xB }, { 5, 0xC }, { 6, 0xE }, { 7, 0xF } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen5TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 8, 0x13 }, { 9, 0x14 }, { 10, 0x7 }, { 11, 0x8 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen6TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 1, 0x7 }, { 12, 0x8 }, { 13, 0x3 }, { 14, 0x34 }, { 15, 0x35 }, { 16, 0x2A }, { 17, 0x2B } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen7TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 18, 0x27 }, { 19, 0xC }, { 20, 0x8 }, { 21, 0x17 }, { 22, 0x3 }, { 23, 0x4 }, { 24, 0x28 }, { 25, 0x2B }, { 26, 0x13 }, |
|||
{ 27, 0x24 }, { 28, 0x18 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen8TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0, WhiteZeroRunTermCode }, { 29, 0x2 }, { 30, 0x3 }, { 31, 0x1A }, { 32, 0x1B }, { 33, 0x12 }, { 34, 0x13 }, { 35, 0x14 }, |
|||
{ 36, 0x15 }, { 37, 0x16 }, { 38, 0x17 }, { 39, 0x28 }, { 40, 0x29 }, { 41, 0x2A }, { 42, 0x2B }, { 43, 0x2C }, { 44, 0x2D }, |
|||
{ 45, 0x4 }, { 46, 0x5 }, { 47, 0xA }, { 48, 0xB }, { 49, 0x52 }, { 50, 0x53 }, { 51, 0x54 }, { 52, 0x55 }, { 53, 0x24 }, |
|||
{ 54, 0x25 }, { 55, 0x58 }, { 56, 0x59 }, { 57, 0x5A }, { 58, 0x5B }, { 59, 0x4A }, { 60, 0x4B }, { 61, 0x32 }, { 62, 0x33 }, |
|||
{ 63, 0x34 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen2TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 2, 0x3 }, { 3, 0x2 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen3TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 1, 0x2 }, { 4, 0x3 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen4TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 5, 0x3 }, { 6, 0x2 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen5TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 7, 0x3 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen6TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 8, 0x5 }, { 9, 0x4 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen7TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 10, 0x4 }, { 11, 0x5 }, { 12, 0x7 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen8TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 13, 0x4 }, { 14, 0x7 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen9TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 15, 0x18 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen10TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0, BlackZeroRunTermCode }, { 16, 0x17 }, { 17, 0x18 }, { 18, 0x8 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen11TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 19, 0x67 }, { 20, 0x68 }, { 21, 0x6C }, { 22, 0x37 }, { 23, 0x28 }, { 24, 0x17 }, { 25, 0x18 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen12TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 26, 0xCA }, { 27, 0xCB }, { 28, 0xCC }, { 29, 0xCD }, { 30, 0x68 }, { 31, 0x69 }, { 32, 0x6A }, { 33, 0x6B }, { 34, 0xD2 }, |
|||
{ 35, 0xD3 }, { 36, 0xD4 }, { 37, 0xD5 }, { 38, 0xD6 }, { 39, 0xD7 }, { 40, 0x6C }, { 41, 0x6D }, { 42, 0xDA }, { 43, 0xDB }, |
|||
{ 44, 0x54 }, { 45, 0x55 }, { 46, 0x56 }, { 47, 0x57 }, { 48, 0x64 }, { 49, 0x65 }, { 50, 0x52 }, { 51, 0x53 }, { 52, 0x24 }, |
|||
{ 53, 0x37 }, { 54, 0x38 }, { 55, 0x27 }, { 56, 0x28 }, { 57, 0x58 }, { 58, 0x59 }, { 59, 0x2B }, { 60, 0x2C }, { 61, 0x5A }, |
|||
{ 62, 0x66 }, { 63, 0x67 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen5MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 64, 0x1B }, { 128, 0x12 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen6MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 192, 0x17 }, { 1664, 0x18 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen8MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 320, 0x36 }, { 384, 0x37 }, { 448, 0x64 }, { 512, 0x65 }, { 576, 0x68 }, { 640, 0x67 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen7MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 256, 0x37 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen9MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 704, 0xCC }, { 768, 0xCD }, { 832, 0xD2 }, { 896, 0xD3 }, { 960, 0xD4 }, { 1024, 0xD5 }, { 1088, 0xD6 }, |
|||
{ 1152, 0xD7 }, { 1216, 0xD8 }, { 1280, 0xD9 }, { 1344, 0xDA }, { 1408, 0xDB }, { 1472, 0x98 }, { 1536, 0x99 }, |
|||
{ 1600, 0x9A }, { 1728, 0x9B } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen11MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 1792, 0x8 }, { 1856, 0xC }, { 1920, 0xD } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen12MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 1984, 0x12 }, { 2048, 0x13 }, { 2112, 0x14 }, { 2176, 0x15 }, { 2240, 0x16 }, { 2304, 0x17 }, { 2368, 0x1C }, |
|||
{ 2432, 0x1D }, { 2496, 0x1E }, { 2560, 0x1F } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen10MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 64, 0xF } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen11MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 1792, 0x8 }, { 1856, 0xC }, { 1920, 0xD } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen12MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 128, 0xC8 }, { 192, 0xC9 }, { 256, 0x5B }, { 320, 0x33 }, { 384, 0x34 }, { 448, 0x35 }, |
|||
{ 1984, 0x12 }, { 2048, 0x13 }, { 2112, 0x14 }, { 2176, 0x15 }, { 2240, 0x16 }, { 2304, 0x17 }, { 2368, 0x1C }, |
|||
{ 2432, 0x1D }, { 2496, 0x1E }, { 2560, 0x1F } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen13MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 512, 0x6C }, { 576, 0x6D }, { 640, 0x4A }, { 704, 0x4B }, { 768, 0x4C }, { 832, 0x4D }, { 896, 0x72 }, |
|||
{ 960, 0x73 }, { 1024, 0x74 }, { 1088, 0x75 }, { 1152, 0x76 }, { 1216, 0x77 }, { 1280, 0x52 }, { 1344, 0x53 }, |
|||
{ 1408, 0x54 }, { 1472, 0x55 }, { 1536, 0x5A }, { 1600, 0x5B }, { 1664, 0x64 }, { 1728, 0x65 } |
|||
}; |
|||
|
|||
/// <summary>
|
|||
/// The modified huffman is basically the same as CCITT T4, but without EOL markers and padding at the end of the rows.
|
|||
/// </summary>
|
|||
private readonly bool useModifiedHuffman; |
|||
|
|||
private IMemoryOwner<byte> compressedDataBuffer; |
|||
|
|||
private int bytePosition; |
|||
|
|||
private byte bitPosition; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="T4BitCompressor" /> class.
|
|||
/// </summary>
|
|||
/// <param name="output">The output.</param>
|
|||
/// <param name="allocator">The allocator.</param>
|
|||
/// <param name="width">The width.</param>
|
|||
/// <param name="bitsPerPixel">The bits per pixel.</param>
|
|||
/// <param name="useModifiedHuffman">Indicates if the modified huffman RLE should be used.</param>
|
|||
public T4BitCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel, bool useModifiedHuffman = false) |
|||
: base(output, allocator, width, bitsPerPixel) |
|||
{ |
|||
this.bytePosition = 0; |
|||
this.bitPosition = 0; |
|||
this.useModifiedHuffman = useModifiedHuffman; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override TiffCompression Method => this.useModifiedHuffman ? TiffCompression.Ccitt1D : TiffCompression.CcittGroup3Fax; |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Initialize(int rowsPerStrip) |
|||
{ |
|||
// This is too much memory allocated, but just 1 bit per pixel will not do, if the compression rate is not good.
|
|||
int maxNeededBytes = this.Width * rowsPerStrip; |
|||
this.compressedDataBuffer = this.Allocator.Allocate<byte>(maxNeededBytes); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a image compressed with CCITT T4 to the stream.
|
|||
/// </summary>
|
|||
/// <param name="pixelsAsGray">The pixels as 8-bit gray array.</param>
|
|||
/// <param name="height">The strip height.</param>
|
|||
public override void CompressStrip(Span<byte> pixelsAsGray, int height) |
|||
{ |
|||
DebugGuard.IsTrue(pixelsAsGray.Length / height == this.Width, "Values must be equals"); |
|||
DebugGuard.IsTrue(pixelsAsGray.Length % height == 0, "Values must be equals"); |
|||
|
|||
this.compressedDataBuffer.Clear(); |
|||
Span<byte> compressedData = this.compressedDataBuffer.GetSpan(); |
|||
|
|||
this.bytePosition = 0; |
|||
this.bitPosition = 0; |
|||
|
|||
if (!this.useModifiedHuffman) |
|||
{ |
|||
// An EOL code is expected at the start of the data.
|
|||
this.WriteCode(12, 1, compressedData); |
|||
} |
|||
|
|||
for (int y = 0; y < height; y++) |
|||
{ |
|||
bool isWhiteRun = true; |
|||
bool isStartOrRow = true; |
|||
int x = 0; |
|||
|
|||
Span<byte> row = pixelsAsGray.Slice(y * this.Width, this.Width); |
|||
while (x < this.Width) |
|||
{ |
|||
uint runLength = 0; |
|||
for (int i = x; i < this.Width; i++) |
|||
{ |
|||
if (isWhiteRun && row[i] != 255) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (isWhiteRun && row[i] == 255) |
|||
{ |
|||
runLength++; |
|||
continue; |
|||
} |
|||
|
|||
if (!isWhiteRun && row[i] != 0) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (!isWhiteRun && row[i] == 0) |
|||
{ |
|||
runLength++; |
|||
} |
|||
} |
|||
|
|||
if (isStartOrRow && runLength == 0) |
|||
{ |
|||
this.WriteCode(8, WhiteZeroRunTermCode, compressedData); |
|||
|
|||
isWhiteRun = false; |
|||
isStartOrRow = false; |
|||
continue; |
|||
} |
|||
|
|||
uint code; |
|||
uint codeLength; |
|||
if (runLength <= 63) |
|||
{ |
|||
code = this.GetTermCode(runLength, out codeLength, isWhiteRun); |
|||
this.WriteCode(codeLength, code, compressedData); |
|||
x += (int)runLength; |
|||
} |
|||
else |
|||
{ |
|||
runLength = this.GetBestFittingMakeupRunLength(runLength); |
|||
code = this.GetMakeupCode(runLength, out codeLength, isWhiteRun); |
|||
this.WriteCode(codeLength, code, compressedData); |
|||
x += (int)runLength; |
|||
|
|||
// If we are at the end of the line with a makeup code, we need to write a final term code with a length of zero.
|
|||
if (x == this.Width) |
|||
{ |
|||
if (isWhiteRun) |
|||
{ |
|||
this.WriteCode(8, WhiteZeroRunTermCode, compressedData); |
|||
} |
|||
else |
|||
{ |
|||
this.WriteCode(10, BlackZeroRunTermCode, compressedData); |
|||
} |
|||
} |
|||
|
|||
continue; |
|||
} |
|||
|
|||
isStartOrRow = false; |
|||
isWhiteRun = !isWhiteRun; |
|||
} |
|||
|
|||
this.WriteEndOfLine(compressedData); |
|||
} |
|||
|
|||
// Write the compressed data to the stream.
|
|||
int bytesToWrite = this.bitPosition != 0 ? this.bytePosition + 1 : this.bytePosition; |
|||
this.Output.Write(compressedData.Slice(0, bytesToWrite)); |
|||
} |
|||
|
|||
protected override void Dispose(bool disposing) => this.compressedDataBuffer?.Dispose(); |
|||
|
|||
private void WriteEndOfLine(Span<byte> compressedData) |
|||
{ |
|||
if (this.useModifiedHuffman) |
|||
{ |
|||
// Check if padding is necessary.
|
|||
if (this.bitPosition % 8 != 0) |
|||
{ |
|||
// Skip padding bits, move to next byte.
|
|||
this.bytePosition++; |
|||
this.bitPosition = 0; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// Write EOL.
|
|||
this.WriteCode(12, 1, compressedData); |
|||
} |
|||
} |
|||
|
|||
private void WriteCode(uint codeLength, uint code, Span<byte> compressedData) |
|||
{ |
|||
while (codeLength > 0) |
|||
{ |
|||
int bitNumber = (int)codeLength; |
|||
bool bit = (code & (1 << (bitNumber - 1))) != 0; |
|||
if (bit) |
|||
{ |
|||
BitWriterUtils.WriteBit(compressedData, this.bytePosition, this.bitPosition); |
|||
} |
|||
else |
|||
{ |
|||
BitWriterUtils.WriteZeroBit(compressedData, this.bytePosition, this.bitPosition); |
|||
} |
|||
|
|||
this.bitPosition++; |
|||
if (this.bitPosition == 8) |
|||
{ |
|||
this.bytePosition++; |
|||
this.bitPosition = 0; |
|||
} |
|||
|
|||
codeLength--; |
|||
} |
|||
} |
|||
|
|||
private uint GetBestFittingMakeupRunLength(uint runLength) |
|||
{ |
|||
for (int i = 0; i < MakeupRunLength.Length - 1; i++) |
|||
{ |
|||
if (MakeupRunLength[i] <= runLength && MakeupRunLength[i + 1] > runLength) |
|||
{ |
|||
return MakeupRunLength[i]; |
|||
} |
|||
} |
|||
|
|||
return MakeupRunLength[MakeupRunLength.Length - 1]; |
|||
} |
|||
|
|||
private uint GetTermCode(uint runLength, out uint codeLength, bool isWhiteRun) |
|||
{ |
|||
if (isWhiteRun) |
|||
{ |
|||
return this.GetWhiteTermCode(runLength, out codeLength); |
|||
} |
|||
|
|||
return this.GetBlackTermCode(runLength, out codeLength); |
|||
} |
|||
|
|||
private uint GetMakeupCode(uint runLength, out uint codeLength, bool isWhiteRun) |
|||
{ |
|||
if (isWhiteRun) |
|||
{ |
|||
return this.GetWhiteMakeupCode(runLength, out codeLength); |
|||
} |
|||
|
|||
return this.GetBlackMakeupCode(runLength, out codeLength); |
|||
} |
|||
|
|||
private uint GetWhiteMakeupCode(uint runLength, out uint codeLength) |
|||
{ |
|||
codeLength = 0; |
|||
|
|||
if (WhiteLen5MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 5; |
|||
return WhiteLen5MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen6MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 6; |
|||
return WhiteLen6MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen7MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 7; |
|||
return WhiteLen7MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen8MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 8; |
|||
return WhiteLen8MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen9MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 9; |
|||
return WhiteLen9MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen11MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 11; |
|||
return WhiteLen11MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen12MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 12; |
|||
return WhiteLen12MakeupCodes[runLength]; |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private uint GetBlackMakeupCode(uint runLength, out uint codeLength) |
|||
{ |
|||
codeLength = 0; |
|||
|
|||
if (BlackLen10MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 10; |
|||
return BlackLen10MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen11MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 11; |
|||
return BlackLen11MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen12MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 12; |
|||
return BlackLen12MakeupCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen13MakeupCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 13; |
|||
return BlackLen13MakeupCodes[runLength]; |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private uint GetWhiteTermCode(uint runLength, out uint codeLength) |
|||
{ |
|||
codeLength = 0; |
|||
|
|||
if (WhiteLen4TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 4; |
|||
return WhiteLen4TermCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen5TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 5; |
|||
return WhiteLen5TermCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen6TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 6; |
|||
return WhiteLen6TermCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen7TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 7; |
|||
return WhiteLen7TermCodes[runLength]; |
|||
} |
|||
|
|||
if (WhiteLen8TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 8; |
|||
return WhiteLen8TermCodes[runLength]; |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private uint GetBlackTermCode(uint runLength, out uint codeLength) |
|||
{ |
|||
codeLength = 0; |
|||
|
|||
if (BlackLen2TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 2; |
|||
return BlackLen2TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen3TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 3; |
|||
return BlackLen3TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen4TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 4; |
|||
return BlackLen4TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen5TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 5; |
|||
return BlackLen5TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen6TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 6; |
|||
return BlackLen6TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen7TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 7; |
|||
return BlackLen7TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen8TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 8; |
|||
return BlackLen8TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen9TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 9; |
|||
return BlackLen9TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen10TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 10; |
|||
return BlackLen10TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen11TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 11; |
|||
return BlackLen11TermCodes[runLength]; |
|||
} |
|||
|
|||
if (BlackLen12TermCodes.ContainsKey(runLength)) |
|||
{ |
|||
codeLength = 12; |
|||
return BlackLen12TermCodes[runLength]; |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,270 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Gif; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors |
|||
{ |
|||
/* |
|||
This implementation is a port of a java tiff encoder by Harald Kuhr: https://github.com/haraldk/TwelveMonkeys
|
|||
|
|||
Original licence: |
|||
|
|||
BSD 3-Clause License |
|||
|
|||
* Copyright (c) 2015, Harald Kuhr |
|||
* All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions are met: |
|||
* |
|||
* * Redistributions of source code must retain the above copyright notice, this |
|||
* list of conditions and the following disclaimer. |
|||
* |
|||
* * Redistributions in binary form must reproduce the above copyright notice, |
|||
* this list of conditions and the following disclaimer in the documentation |
|||
* and/or other materials provided with the distribution. |
|||
* |
|||
** Neither the name of the copyright holder nor the names of its |
|||
* contributors may be used to endorse or promote products derived from |
|||
* this software without specific prior written permission. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
|||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
* DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
|||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
|||
* OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
*/ |
|||
|
|||
/// <summary>
|
|||
/// Encodes and compresses the image data using dynamic Lempel-Ziv compression.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>
|
|||
/// This code is based on the <see cref="LzwEncoder"/> used for GIF encoding. There is potential
|
|||
/// for a shared implementation. Differences between the GIF and TIFF implementations of the LZW
|
|||
/// encoding are: (i) The GIF implementation includes an initial 'data size' byte, whilst this is
|
|||
/// always 8 for TIFF. (ii) The GIF implementation writes a number of sub-blocks with an initial
|
|||
/// byte indicating the length of the sub-block. In TIFF the data is written as a single block
|
|||
/// with no length indicator (this can be determined from the 'StripByteCounts' entry).
|
|||
/// </para>
|
|||
/// </remarks>
|
|||
internal sealed class TiffLzwEncoder : IDisposable |
|||
{ |
|||
// Clear: Re-initialize tables.
|
|||
private static readonly int ClearCode = 256; |
|||
|
|||
// End of Information.
|
|||
private static readonly int EoiCode = 257; |
|||
|
|||
private static readonly int MinBits = 9; |
|||
private static readonly int MaxBits = 12; |
|||
|
|||
private static readonly int TableSize = 1 << MaxBits; |
|||
|
|||
// A child is made up of a parent (or prefix) code plus a suffix byte
|
|||
// and siblings are strings with a common parent(or prefix) and different suffix bytes.
|
|||
private readonly IMemoryOwner<int> children; |
|||
|
|||
private readonly IMemoryOwner<int> siblings; |
|||
|
|||
private readonly IMemoryOwner<int> suffixes; |
|||
|
|||
// Initial setup
|
|||
private int parent; |
|||
private int bitsPerCode; |
|||
private int nextValidCode; |
|||
private int maxCode; |
|||
|
|||
// Buffer for partial codes
|
|||
private int bits; |
|||
private int bitPos; |
|||
private int bufferPosition; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffLzwEncoder"/> class.
|
|||
/// </summary>
|
|||
/// <param name="memoryAllocator">The memory allocator.</param>
|
|||
public TiffLzwEncoder(MemoryAllocator memoryAllocator) |
|||
{ |
|||
this.children = memoryAllocator.Allocate<int>(TableSize); |
|||
this.siblings = memoryAllocator.Allocate<int>(TableSize); |
|||
this.suffixes = memoryAllocator.Allocate<int>(TableSize); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Encodes and compresses the indexed pixels to the stream.
|
|||
/// </summary>
|
|||
/// <param name="data">The data to compress.</param>
|
|||
/// <param name="stream">The stream to write to.</param>
|
|||
public void Encode(Span<byte> data, Stream stream) |
|||
{ |
|||
this.Reset(); |
|||
|
|||
Span<int> childrenSpan = this.children.GetSpan(); |
|||
Span<int> suffixesSpan = this.suffixes.GetSpan(); |
|||
Span<int> siblingsSpan = this.siblings.GetSpan(); |
|||
int length = data.Length; |
|||
|
|||
if (length == 0) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (this.parent == -1) |
|||
{ |
|||
// Init stream.
|
|||
this.WriteCode(stream, ClearCode); |
|||
this.parent = this.ReadNextByte(data); |
|||
} |
|||
|
|||
while (this.bufferPosition < data.Length) |
|||
{ |
|||
int value = this.ReadNextByte(data); |
|||
int child = childrenSpan[this.parent]; |
|||
|
|||
if (child > 0) |
|||
{ |
|||
if (suffixesSpan[child] == value) |
|||
{ |
|||
this.parent = child; |
|||
} |
|||
else |
|||
{ |
|||
int sibling = child; |
|||
|
|||
while (true) |
|||
{ |
|||
if (siblingsSpan[sibling] > 0) |
|||
{ |
|||
sibling = siblingsSpan[sibling]; |
|||
|
|||
if (suffixesSpan[sibling] == value) |
|||
{ |
|||
this.parent = sibling; |
|||
break; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
siblingsSpan[sibling] = (short)this.nextValidCode; |
|||
suffixesSpan[this.nextValidCode] = (short)value; |
|||
this.WriteCode(stream, this.parent); |
|||
this.parent = value; |
|||
this.nextValidCode++; |
|||
|
|||
this.IncreaseCodeSizeOrResetIfNeeded(stream); |
|||
|
|||
break; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
childrenSpan[this.parent] = (short)this.nextValidCode; |
|||
suffixesSpan[this.nextValidCode] = (short)value; |
|||
this.WriteCode(stream, this.parent); |
|||
this.parent = value; |
|||
this.nextValidCode++; |
|||
|
|||
this.IncreaseCodeSizeOrResetIfNeeded(stream); |
|||
} |
|||
} |
|||
|
|||
// Write EOI when we are done.
|
|||
this.WriteCode(stream, this.parent); |
|||
this.WriteCode(stream, EoiCode); |
|||
|
|||
// Flush partial codes by writing 0 pad.
|
|||
if (this.bitPos > 0) |
|||
{ |
|||
this.WriteCode(stream, 0); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc />
|
|||
public void Dispose() |
|||
{ |
|||
this.children.Dispose(); |
|||
this.siblings.Dispose(); |
|||
this.suffixes.Dispose(); |
|||
} |
|||
|
|||
private void Reset() |
|||
{ |
|||
this.children.Clear(); |
|||
this.siblings.Clear(); |
|||
this.suffixes.Clear(); |
|||
|
|||
this.parent = -1; |
|||
this.bitsPerCode = MinBits; |
|||
this.nextValidCode = EoiCode + 1; |
|||
this.maxCode = (1 << this.bitsPerCode) - 1; |
|||
|
|||
this.bits = 0; |
|||
this.bitPos = 0; |
|||
this.bufferPosition = 0; |
|||
} |
|||
|
|||
private byte ReadNextByte(Span<byte> data) => data[this.bufferPosition++]; |
|||
|
|||
private void IncreaseCodeSizeOrResetIfNeeded(Stream stream) |
|||
{ |
|||
if (this.nextValidCode > this.maxCode) |
|||
{ |
|||
if (this.bitsPerCode == MaxBits) |
|||
{ |
|||
// Reset stream by writing Clear code.
|
|||
this.WriteCode(stream, ClearCode); |
|||
|
|||
// Reset tables.
|
|||
this.ResetTables(); |
|||
} |
|||
else |
|||
{ |
|||
// Increase code size.
|
|||
this.bitsPerCode++; |
|||
this.maxCode = MaxValue(this.bitsPerCode); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void WriteCode(Stream stream, int code) |
|||
{ |
|||
this.bits = (this.bits << this.bitsPerCode) | (code & this.maxCode); |
|||
this.bitPos += this.bitsPerCode; |
|||
|
|||
while (this.bitPos >= 8) |
|||
{ |
|||
int b = (this.bits >> (this.bitPos - 8)) & 0xff; |
|||
stream.WriteByte((byte)b); |
|||
this.bitPos -= 8; |
|||
} |
|||
|
|||
this.bits &= BitmaskFor(this.bitPos); |
|||
} |
|||
|
|||
private void ResetTables() |
|||
{ |
|||
this.children.GetSpan().Fill(0); |
|||
this.siblings.GetSpan().Fill(0); |
|||
this.bitsPerCode = MinBits; |
|||
this.maxCode = MaxValue(this.bitsPerCode); |
|||
this.nextValidCode = EoiCode + 1; |
|||
} |
|||
|
|||
private static int MaxValue(int codeLen) => (1 << codeLen) - 1; |
|||
|
|||
private static int BitmaskFor(int bits) => MaxValue(bits); |
|||
} |
|||
} |
|||
@ -0,0 +1,63 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO.Compression; |
|||
|
|||
using SixLabors.ImageSharp.Compression.Zlib; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Compression; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Class to handle cases where TIFF image data is compressed using Deflate compression.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Note that the 'OldDeflate' compression type is identical to the 'Deflate' compression type.
|
|||
/// </remarks>
|
|||
internal class DeflateTiffCompression : TiffBaseDecompressor |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DeflateTiffCompression" /> class.
|
|||
/// </summary>
|
|||
/// <param name="memoryAllocator">The memoryAllocator to use for buffer allocations.</param>
|
|||
/// <param name="width">The image width.</param>
|
|||
/// <param name="bitsPerPixel">The bits used per pixel.</param>
|
|||
/// <param name="predictor">The tiff predictor used.</param>
|
|||
public DeflateTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel, TiffPredictor predictor) |
|||
: base(memoryAllocator, width, bitsPerPixel, predictor) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) |
|||
{ |
|||
long pos = stream.Position; |
|||
using (var deframeStream = new ZlibInflateStream( |
|||
stream, |
|||
() => |
|||
{ |
|||
int left = (int)(byteCount - (stream.Position - pos)); |
|||
return left > 0 ? left : 0; |
|||
})) |
|||
{ |
|||
deframeStream.AllocateNewBytes(byteCount, true); |
|||
DeflateStream dataStream = deframeStream.CompressedStream; |
|||
dataStream.Read(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
if (this.Predictor == TiffPredictor.Horizontal) |
|||
{ |
|||
HorizontalPredictor.Undo(buffer, this.Width, this.BitsPerPixel); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,95 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a lzw string with a code word and a code length.
|
|||
/// </summary>
|
|||
public class LzwString |
|||
{ |
|||
private static readonly LzwString Empty = new LzwString(0, 0, 0, null); |
|||
|
|||
private readonly LzwString previous; |
|||
private readonly byte value; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="LzwString"/> class.
|
|||
/// </summary>
|
|||
/// <param name="code">The code word.</param>
|
|||
public LzwString(byte code) |
|||
: this(code, code, 1, null) |
|||
{ |
|||
} |
|||
|
|||
private LzwString(byte value, byte firstChar, int length, LzwString previous) |
|||
{ |
|||
this.value = value; |
|||
this.FirstChar = firstChar; |
|||
this.Length = length; |
|||
this.previous = previous; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the code length;
|
|||
/// </summary>
|
|||
public int Length { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the first character of the codeword.
|
|||
/// </summary>
|
|||
public byte FirstChar { get; } |
|||
|
|||
/// <summary>
|
|||
/// Concatenates two code words.
|
|||
/// </summary>
|
|||
/// <param name="other">The code word to concatenate.</param>
|
|||
/// <returns>A concatenated lzw string.</returns>
|
|||
public LzwString Concatenate(byte other) |
|||
{ |
|||
if (this == Empty) |
|||
{ |
|||
return new LzwString(other); |
|||
} |
|||
|
|||
return new LzwString(other, this.FirstChar, this.Length + 1, this); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes decoded pixel to buffer at a given position.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to write to.</param>
|
|||
/// <param name="offset">The position to write to.</param>
|
|||
/// <returns>The number of bytes written.</returns>
|
|||
public int WriteTo(Span<byte> buffer, int offset) |
|||
{ |
|||
if (this.Length == 0) |
|||
{ |
|||
return 0; |
|||
} |
|||
|
|||
if (this.Length == 1) |
|||
{ |
|||
buffer[offset] = this.value; |
|||
return 1; |
|||
} |
|||
|
|||
LzwString e = this; |
|||
int endIdx = this.Length - 1; |
|||
if (endIdx >= buffer.Length) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("Error reading lzw compressed stream. Either pixel buffer to write to is to small or code length is invalid!"); |
|||
} |
|||
|
|||
for (int i = endIdx; i >= 0; i--) |
|||
{ |
|||
buffer[offset + i] = e.value; |
|||
e = e.previous; |
|||
} |
|||
|
|||
return this.Length; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,45 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Class to handle cases where TIFF image data is compressed using LZW compression.
|
|||
/// </summary>
|
|||
internal class LzwTiffCompression : TiffBaseDecompressor |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="LzwTiffCompression" /> class.
|
|||
/// </summary>
|
|||
/// <param name="memoryAllocator">The memoryAllocator to use for buffer allocations.</param>
|
|||
/// <param name="width">The image width.</param>
|
|||
/// <param name="bitsPerPixel">The bits used per pixel.</param>
|
|||
/// <param name="predictor">The tiff predictor used.</param>
|
|||
public LzwTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel, TiffPredictor predictor) |
|||
: base(memoryAllocator, width, bitsPerPixel, predictor) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) |
|||
{ |
|||
var decoder = new TiffLzwDecoder(stream); |
|||
decoder.DecodePixels(buffer); |
|||
|
|||
if (this.Predictor == TiffPredictor.Horizontal) |
|||
{ |
|||
HorizontalPredictor.Undo(buffer, this.Width, this.BitsPerPixel); |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,79 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Class to handle cases where TIFF image data is compressed using Modified Huffman Compression.
|
|||
/// </summary>
|
|||
internal class ModifiedHuffmanTiffCompression : T4TiffCompression |
|||
{ |
|||
private readonly byte whiteValue; |
|||
|
|||
private readonly byte blackValue; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="ModifiedHuffmanTiffCompression" /> class.
|
|||
/// </summary>
|
|||
/// <param name="allocator">The memory allocator.</param>
|
|||
/// <param name="width">The image width.</param>
|
|||
/// <param name="bitsPerPixel">The number of bits per pixel.</param>
|
|||
/// <param name="photometricInterpretation">The photometric interpretation.</param>
|
|||
public ModifiedHuffmanTiffCompression(MemoryAllocator allocator, int width, int bitsPerPixel, TiffPhotometricInterpretation photometricInterpretation) |
|||
: base(allocator, width, bitsPerPixel, FaxCompressionOptions.None, photometricInterpretation) |
|||
{ |
|||
bool isWhiteZero = photometricInterpretation == TiffPhotometricInterpretation.WhiteIsZero; |
|||
this.whiteValue = (byte)(isWhiteZero ? 0 : 1); |
|||
this.blackValue = (byte)(isWhiteZero ? 1 : 0); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) |
|||
{ |
|||
using var bitReader = new T4BitReader(stream, byteCount, this.Allocator, eolPadding: false, isModifiedHuffman: true); |
|||
|
|||
buffer.Clear(); |
|||
uint bitsWritten = 0; |
|||
uint pixelsWritten = 0; |
|||
while (bitReader.HasMoreData) |
|||
{ |
|||
bitReader.ReadNextRun(); |
|||
|
|||
if (bitReader.RunLength > 0) |
|||
{ |
|||
if (bitReader.IsWhiteRun) |
|||
{ |
|||
BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.whiteValue); |
|||
bitsWritten += bitReader.RunLength; |
|||
pixelsWritten += bitReader.RunLength; |
|||
} |
|||
else |
|||
{ |
|||
BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.blackValue); |
|||
bitsWritten += bitReader.RunLength; |
|||
pixelsWritten += bitReader.RunLength; |
|||
} |
|||
} |
|||
|
|||
if (pixelsWritten % this.Width == 0) |
|||
{ |
|||
bitReader.StartNewRow(); |
|||
|
|||
// Write padding bits, if necessary.
|
|||
uint pad = 8 - (bitsWritten % 8); |
|||
if (pad != 8) |
|||
{ |
|||
BitWriterUtils.WriteBits(buffer, (int)bitsWritten, pad, 0); |
|||
bitsWritten += pad; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,35 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Class to handle cases where TIFF image data is not compressed.
|
|||
/// </summary>
|
|||
internal class NoneTiffCompression : TiffBaseDecompressor |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="NoneTiffCompression" /> class.
|
|||
/// </summary>
|
|||
/// <param name="memoryAllocator">The memory allocator.</param>
|
|||
/// <param name="width">The width of the image.</param>
|
|||
/// <param name="bitsPerPixel">The bits per pixel.</param>
|
|||
public NoneTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel) |
|||
: base(memoryAllocator, width, bitsPerPixel) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) => _ = stream.Read(buffer, 0, Math.Min(buffer.Length, byteCount)); |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,96 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
|
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Class to handle cases where TIFF image data is compressed using PackBits compression.
|
|||
/// </summary>
|
|||
internal class PackBitsTiffCompression : TiffBaseDecompressor |
|||
{ |
|||
private IMemoryOwner<byte> compressedDataMemory; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="PackBitsTiffCompression" /> class.
|
|||
/// </summary>
|
|||
/// <param name="memoryAllocator">The memoryAllocator to use for buffer allocations.</param>
|
|||
/// <param name="width">The width of the image.</param>
|
|||
/// <param name="bitsPerPixel">The number of bits per pixel.</param>
|
|||
public PackBitsTiffCompression(MemoryAllocator memoryAllocator, int width, int bitsPerPixel) |
|||
: base(memoryAllocator, width, bitsPerPixel) |
|||
{ |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) |
|||
{ |
|||
if (this.compressedDataMemory == null) |
|||
{ |
|||
this.compressedDataMemory = this.Allocator.Allocate<byte>(byteCount); |
|||
} |
|||
else if (this.compressedDataMemory.Length() < byteCount) |
|||
{ |
|||
this.compressedDataMemory.Dispose(); |
|||
this.compressedDataMemory = this.Allocator.Allocate<byte>(byteCount); |
|||
} |
|||
|
|||
Span<byte> compressedData = this.compressedDataMemory.GetSpan(); |
|||
|
|||
stream.Read(compressedData, 0, byteCount); |
|||
int compressedOffset = 0; |
|||
int decompressedOffset = 0; |
|||
|
|||
while (compressedOffset < byteCount) |
|||
{ |
|||
byte headerByte = compressedData[compressedOffset]; |
|||
|
|||
if (headerByte <= 127) |
|||
{ |
|||
int literalOffset = compressedOffset + 1; |
|||
int literalLength = compressedData[compressedOffset] + 1; |
|||
|
|||
if ((literalOffset + literalLength) > compressedData.Length) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("Tiff packbits compression error: not enough data."); |
|||
} |
|||
|
|||
compressedData.Slice(literalOffset, literalLength).CopyTo(buffer.Slice(decompressedOffset)); |
|||
|
|||
compressedOffset += literalLength + 1; |
|||
decompressedOffset += literalLength; |
|||
} |
|||
else if (headerByte == 0x80) |
|||
{ |
|||
compressedOffset += 1; |
|||
} |
|||
else |
|||
{ |
|||
byte repeatData = compressedData[compressedOffset + 1]; |
|||
int repeatLength = 257 - headerByte; |
|||
|
|||
ArrayCopyRepeat(repeatData, buffer, decompressedOffset, repeatLength); |
|||
|
|||
compressedOffset += 2; |
|||
decompressedOffset += repeatLength; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private static void ArrayCopyRepeat(byte value, Span<byte> destinationArray, int destinationIndex, int length) |
|||
{ |
|||
for (int i = 0; i < length; i++) |
|||
{ |
|||
destinationArray[i + destinationIndex] = value; |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) => this.compressedDataMemory?.Dispose(); |
|||
} |
|||
} |
|||
@ -0,0 +1,842 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers; |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Bitreader for reading compressed CCITT T4 1D data.
|
|||
/// </summary>
|
|||
internal class T4BitReader : IDisposable |
|||
{ |
|||
/// <summary>
|
|||
/// Number of bits read.
|
|||
/// </summary>
|
|||
private int bitsRead; |
|||
|
|||
/// <summary>
|
|||
/// Current value.
|
|||
/// </summary>
|
|||
private uint value; |
|||
|
|||
/// <summary>
|
|||
/// Number of bits read for the current run value.
|
|||
/// </summary>
|
|||
private int curValueBitsRead; |
|||
|
|||
/// <summary>
|
|||
/// Byte position in the buffer.
|
|||
/// </summary>
|
|||
private ulong position; |
|||
|
|||
/// <summary>
|
|||
/// Indicates whether its the first line of data which is read from the image.
|
|||
/// </summary>
|
|||
private bool isFirstScanLine; |
|||
|
|||
/// <summary>
|
|||
/// Indicates whether we have found a termination code which signals the end of a run.
|
|||
/// </summary>
|
|||
private bool terminationCodeFound; |
|||
|
|||
/// <summary>
|
|||
/// We keep track if its the start of the row, because each run is expected to start with a white run.
|
|||
/// If the image row itself starts with black, a white run of zero is expected.
|
|||
/// </summary>
|
|||
private bool isStartOfRow; |
|||
|
|||
/// <summary>
|
|||
/// Indicates whether the modified huffman compression, as specified in the TIFF spec in section 10, is used.
|
|||
/// </summary>
|
|||
private readonly bool isModifiedHuffmanRle; |
|||
|
|||
/// <summary>
|
|||
/// Indicates, if fill bits have been added as necessary before EOL codes such that EOL always ends on a byte boundary. Defaults to false.
|
|||
/// </summary>
|
|||
private readonly bool eolPadding; |
|||
|
|||
private readonly int dataLength; |
|||
|
|||
private const int MinCodeLength = 2; |
|||
|
|||
private readonly int maxCodeLength = 13; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen4TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x7, 2 }, { 0x8, 3 }, { 0xB, 4 }, { 0xC, 5 }, { 0xE, 6 }, { 0xF, 7 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen5TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x13, 8 }, { 0x14, 9 }, { 0x7, 10 }, { 0x8, 11 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen6TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x7, 1 }, { 0x8, 12 }, { 0x3, 13 }, { 0x34, 14 }, { 0x35, 15 }, { 0x2A, 16 }, { 0x2B, 17 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen7TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x27, 18 }, { 0xC, 19 }, { 0x8, 20 }, { 0x17, 21 }, { 0x3, 22 }, { 0x4, 23 }, { 0x28, 24 }, { 0x2B, 25 }, { 0x13, 26 }, |
|||
{ 0x24, 27 }, { 0x18, 28 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen8TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x35, 0 }, { 0x2, 29 }, { 0x3, 30 }, { 0x1A, 31 }, { 0x1B, 32 }, { 0x12, 33 }, { 0x13, 34 }, { 0x14, 35 }, { 0x15, 36 }, |
|||
{ 0x16, 37 }, { 0x17, 38 }, { 0x28, 39 }, { 0x29, 40 }, { 0x2A, 41 }, { 0x2B, 42 }, { 0x2C, 43 }, { 0x2D, 44 }, { 0x4, 45 }, |
|||
{ 0x5, 46 }, { 0xA, 47 }, { 0xB, 48 }, { 0x52, 49 }, { 0x53, 50 }, { 0x54, 51 }, { 0x55, 52 }, { 0x24, 53 }, { 0x25, 54 }, |
|||
{ 0x58, 55 }, { 0x59, 56 }, { 0x5A, 57 }, { 0x5B, 58 }, { 0x4A, 59 }, { 0x4B, 60 }, { 0x32, 61 }, { 0x33, 62 }, { 0x34, 63 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen2TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x3, 2 }, { 0x2, 3 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen3TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x2, 1 }, { 0x3, 4 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen4TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x3, 5 }, { 0x2, 6 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen5TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x3, 7 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen6TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x5, 8 }, { 0x4, 9 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen7TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x4, 10 }, { 0x5, 11 }, { 0x7, 12 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen8TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x4, 13 }, { 0x7, 14 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen9TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x18, 15 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen10TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x37, 0 }, { 0x17, 16 }, { 0x18, 17 }, { 0x8, 18 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen11TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x67, 19 }, { 0x68, 20 }, { 0x6C, 21 }, { 0x37, 22 }, { 0x28, 23 }, { 0x17, 24 }, { 0x18, 25 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen12TermCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0xCA, 26 }, { 0xCB, 27 }, { 0xCC, 28 }, { 0xCD, 29 }, { 0x68, 30 }, { 0x69, 31 }, { 0x6A, 32 }, { 0x6B, 33 }, { 0xD2, 34 }, |
|||
{ 0xD3, 35 }, { 0xD4, 36 }, { 0xD5, 37 }, { 0xD6, 38 }, { 0xD7, 39 }, { 0x6C, 40 }, { 0x6D, 41 }, { 0xDA, 42 }, { 0xDB, 43 }, |
|||
{ 0x54, 44 }, { 0x55, 45 }, { 0x56, 46 }, { 0x57, 47 }, { 0x64, 48 }, { 0x65, 49 }, { 0x52, 50 }, { 0x53, 51 }, { 0x24, 52 }, |
|||
{ 0x37, 53 }, { 0x38, 54 }, { 0x27, 55 }, { 0x28, 56 }, { 0x58, 57 }, { 0x59, 58 }, { 0x2B, 59 }, { 0x2C, 60 }, { 0x5A, 61 }, |
|||
{ 0x66, 62 }, { 0x67, 63 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen5MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x1B, 64 }, { 0x12, 128 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen6MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x17, 192 }, { 0x18, 1664 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen8MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x36, 320 }, { 0x37, 384 }, { 0x64, 448 }, { 0x65, 512 }, { 0x68, 576 }, { 0x67, 640 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen7MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x37, 256 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen9MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0xCC, 704 }, { 0xCD, 768 }, { 0xD2, 832 }, { 0xD3, 896 }, { 0xD4, 960 }, { 0xD5, 1024 }, { 0xD6, 1088 }, |
|||
{ 0xD7, 1152 }, { 0xD8, 1216 }, { 0xD9, 1280 }, { 0xDA, 1344 }, { 0xDB, 1408 }, { 0x98, 1472 }, { 0x99, 1536 }, |
|||
{ 0x9A, 1600 }, { 0x9B, 1728 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen11MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x8, 1792 }, { 0xC, 1856 }, { 0xD, 1920 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> WhiteLen12MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x12, 1984 }, { 0x13, 2048 }, { 0x14, 2112 }, { 0x15, 2176 }, { 0x16, 2240 }, { 0x17, 2304 }, { 0x1C, 2368 }, |
|||
{ 0x1D, 2432 }, { 0x1E, 2496 }, { 0x1F, 2560 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen10MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0xF, 64 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen11MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x8, 1792 }, { 0xC, 1856 }, { 0xD, 1920 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen12MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0xC8, 128 }, { 0xC9, 192 }, { 0x5B, 256 }, { 0x33, 320 }, { 0x34, 384 }, { 0x35, 448 }, |
|||
{ 0x12, 1984 }, { 0x13, 2048 }, { 0x14, 2112 }, { 0x15, 2176 }, { 0x16, 2240 }, { 0x17, 2304 }, { 0x1C, 2368 }, |
|||
{ 0x1D, 2432 }, { 0x1E, 2496 }, { 0x1F, 2560 } |
|||
}; |
|||
|
|||
private static readonly Dictionary<uint, uint> BlackLen13MakeupCodes = new Dictionary<uint, uint>() |
|||
{ |
|||
{ 0x6C, 512 }, { 0x6D, 576 }, { 0x4A, 640 }, { 0x4B, 704 }, { 0x4C, 768 }, { 0x4D, 832 }, { 0x72, 896 }, |
|||
{ 0x73, 960 }, { 0x74, 1024 }, { 0x75, 1088 }, { 0x76, 1152 }, { 0x77, 1216 }, { 0x52, 1280 }, { 0x53, 1344 }, |
|||
{ 0x54, 1408 }, { 0x55, 1472 }, { 0x5A, 1536 }, { 0x5B, 1600 }, { 0x64, 1664 }, { 0x65, 1728 } |
|||
}; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="T4BitReader" /> class.
|
|||
/// </summary>
|
|||
/// <param name="input">The compressed input stream.</param>
|
|||
/// <param name="bytesToRead">The number of bytes to read from the stream.</param>
|
|||
/// <param name="allocator">The memory allocator.</param>
|
|||
/// <param name="eolPadding">Indicates, if fill bits have been added as necessary before EOL codes such that EOL always ends on a byte boundary. Defaults to false.</param>
|
|||
/// <param name="isModifiedHuffman">Indicates, if its the modified huffman code variation. Defaults to false.</param>
|
|||
public T4BitReader(Stream input, int bytesToRead, MemoryAllocator allocator, bool eolPadding = false, bool isModifiedHuffman = false) |
|||
{ |
|||
this.Data = allocator.Allocate<byte>(bytesToRead); |
|||
this.ReadImageDataFromStream(input, bytesToRead); |
|||
|
|||
this.isModifiedHuffmanRle = isModifiedHuffman; |
|||
this.dataLength = bytesToRead; |
|||
this.bitsRead = 0; |
|||
this.value = 0; |
|||
this.curValueBitsRead = 0; |
|||
this.position = 0; |
|||
this.IsWhiteRun = true; |
|||
this.isFirstScanLine = true; |
|||
this.isStartOfRow = true; |
|||
this.terminationCodeFound = false; |
|||
this.RunLength = 0; |
|||
this.eolPadding = eolPadding; |
|||
|
|||
if (this.eolPadding) |
|||
{ |
|||
this.maxCodeLength = 24; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the compressed image data.
|
|||
/// </summary>
|
|||
public IMemoryOwner<byte> Data { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether there is more data to read left.
|
|||
/// </summary>
|
|||
public bool HasMoreData |
|||
{ |
|||
get |
|||
{ |
|||
if (this.isModifiedHuffmanRle) |
|||
{ |
|||
return this.position < (ulong)this.dataLength - 1 || (this.bitsRead > 0 && this.bitsRead < 7); |
|||
} |
|||
|
|||
return this.position < (ulong)this.dataLength - 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the current run is a white pixel run, otherwise its a black pixel run.
|
|||
/// </summary>
|
|||
public bool IsWhiteRun { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of pixels in the current run.
|
|||
/// </summary>
|
|||
public uint RunLength { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the end of a pixel row has been reached.
|
|||
/// </summary>
|
|||
public bool IsEndOfScanLine |
|||
{ |
|||
get |
|||
{ |
|||
if (this.eolPadding) |
|||
{ |
|||
return this.curValueBitsRead >= 12 && this.value == 1; |
|||
} |
|||
|
|||
return this.curValueBitsRead == 12 && this.value == 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read the next run of pixels.
|
|||
/// </summary>
|
|||
public void ReadNextRun() |
|||
{ |
|||
if (this.terminationCodeFound) |
|||
{ |
|||
this.IsWhiteRun = !this.IsWhiteRun; |
|||
this.terminationCodeFound = false; |
|||
} |
|||
|
|||
this.Reset(); |
|||
|
|||
if (this.isFirstScanLine && !this.isModifiedHuffmanRle) |
|||
{ |
|||
// We expect an EOL before the first data.
|
|||
this.value = this.ReadValue(this.eolPadding ? 16 : 12); |
|||
|
|||
if (!this.IsEndOfScanLine) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("t4 parsing error: expected start of data marker not found"); |
|||
} |
|||
|
|||
this.Reset(); |
|||
} |
|||
|
|||
// A code word must have at least 2 bits.
|
|||
this.value = this.ReadValue(MinCodeLength); |
|||
|
|||
do |
|||
{ |
|||
if (this.curValueBitsRead > this.maxCodeLength) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("t4 parsing error: invalid code length read"); |
|||
} |
|||
|
|||
bool isMakeupCode = this.IsMakeupCode(); |
|||
if (isMakeupCode) |
|||
{ |
|||
if (this.IsWhiteRun) |
|||
{ |
|||
this.RunLength += this.WhiteMakeupCodeRunLength(); |
|||
} |
|||
else |
|||
{ |
|||
this.RunLength += this.BlackMakeupCodeRunLength(); |
|||
} |
|||
|
|||
this.isStartOfRow = false; |
|||
this.Reset(resetRunLength: false); |
|||
continue; |
|||
} |
|||
|
|||
bool isTerminatingCode = this.IsTerminatingCode(); |
|||
if (isTerminatingCode) |
|||
{ |
|||
// Each line starts with a white run. If the image starts with black, a white run with length zero is written.
|
|||
if (this.isStartOfRow && this.IsWhiteRun && this.WhiteTerminatingCodeRunLength() == 0) |
|||
{ |
|||
this.IsWhiteRun = !this.IsWhiteRun; |
|||
this.Reset(); |
|||
this.isStartOfRow = false; |
|||
continue; |
|||
} |
|||
|
|||
if (this.IsWhiteRun) |
|||
{ |
|||
this.RunLength += this.WhiteTerminatingCodeRunLength(); |
|||
} |
|||
else |
|||
{ |
|||
this.RunLength += this.BlackTerminatingCodeRunLength(); |
|||
} |
|||
|
|||
this.terminationCodeFound = true; |
|||
this.isStartOfRow = false; |
|||
break; |
|||
} |
|||
|
|||
var currBit = this.ReadValue(1); |
|||
this.value = (this.value << 1) | currBit; |
|||
|
|||
if (this.IsEndOfScanLine) |
|||
{ |
|||
this.StartNewRow(); |
|||
} |
|||
} |
|||
while (!this.IsEndOfScanLine); |
|||
|
|||
this.isFirstScanLine = false; |
|||
} |
|||
|
|||
public void StartNewRow() |
|||
{ |
|||
// Each new row starts with a white run.
|
|||
this.IsWhiteRun = true; |
|||
this.isStartOfRow = true; |
|||
this.terminationCodeFound = false; |
|||
|
|||
if (this.isModifiedHuffmanRle) |
|||
{ |
|||
int pad = 8 - (this.bitsRead % 8); |
|||
if (pad != 8) |
|||
{ |
|||
// Skip padding bits, move to next byte.
|
|||
this.position++; |
|||
this.bitsRead = 0; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public void Dispose() => this.Data.Dispose(); |
|||
|
|||
private uint WhiteTerminatingCodeRunLength() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 4: |
|||
{ |
|||
return WhiteLen4TermCodes[this.value]; |
|||
} |
|||
|
|||
case 5: |
|||
{ |
|||
return WhiteLen5TermCodes[this.value]; |
|||
} |
|||
|
|||
case 6: |
|||
{ |
|||
return WhiteLen6TermCodes[this.value]; |
|||
} |
|||
|
|||
case 7: |
|||
{ |
|||
return WhiteLen7TermCodes[this.value]; |
|||
} |
|||
|
|||
case 8: |
|||
{ |
|||
return WhiteLen8TermCodes[this.value]; |
|||
} |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private uint BlackTerminatingCodeRunLength() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 2: |
|||
{ |
|||
return BlackLen2TermCodes[this.value]; |
|||
} |
|||
|
|||
case 3: |
|||
{ |
|||
return BlackLen3TermCodes[this.value]; |
|||
} |
|||
|
|||
case 4: |
|||
{ |
|||
return BlackLen4TermCodes[this.value]; |
|||
} |
|||
|
|||
case 5: |
|||
{ |
|||
return BlackLen5TermCodes[this.value]; |
|||
} |
|||
|
|||
case 6: |
|||
{ |
|||
return BlackLen6TermCodes[this.value]; |
|||
} |
|||
|
|||
case 7: |
|||
{ |
|||
return BlackLen7TermCodes[this.value]; |
|||
} |
|||
|
|||
case 8: |
|||
{ |
|||
return BlackLen8TermCodes[this.value]; |
|||
} |
|||
|
|||
case 9: |
|||
{ |
|||
return BlackLen9TermCodes[this.value]; |
|||
} |
|||
|
|||
case 10: |
|||
{ |
|||
return BlackLen10TermCodes[this.value]; |
|||
} |
|||
|
|||
case 11: |
|||
{ |
|||
return BlackLen11TermCodes[this.value]; |
|||
} |
|||
|
|||
case 12: |
|||
{ |
|||
return BlackLen12TermCodes[this.value]; |
|||
} |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private uint WhiteMakeupCodeRunLength() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 5: |
|||
{ |
|||
return WhiteLen5MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 6: |
|||
{ |
|||
return WhiteLen6MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 7: |
|||
{ |
|||
return WhiteLen7MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 8: |
|||
{ |
|||
return WhiteLen8MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 9: |
|||
{ |
|||
return WhiteLen9MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 11: |
|||
{ |
|||
return WhiteLen11MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 12: |
|||
{ |
|||
return WhiteLen12MakeupCodes[this.value]; |
|||
} |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private uint BlackMakeupCodeRunLength() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 10: |
|||
{ |
|||
return BlackLen10MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 11: |
|||
{ |
|||
return BlackLen11MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 12: |
|||
{ |
|||
return BlackLen12MakeupCodes[this.value]; |
|||
} |
|||
|
|||
case 13: |
|||
{ |
|||
return BlackLen13MakeupCodes[this.value]; |
|||
} |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
private bool IsMakeupCode() |
|||
{ |
|||
if (this.IsWhiteRun) |
|||
{ |
|||
return this.IsWhiteMakeupCode(); |
|||
} |
|||
|
|||
return this.IsBlackMakeupCode(); |
|||
} |
|||
|
|||
private bool IsWhiteMakeupCode() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 5: |
|||
{ |
|||
return WhiteLen5MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 6: |
|||
{ |
|||
return WhiteLen6MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 7: |
|||
{ |
|||
return WhiteLen7MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 8: |
|||
{ |
|||
return WhiteLen8MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 9: |
|||
{ |
|||
return WhiteLen9MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 11: |
|||
{ |
|||
return WhiteLen11MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 12: |
|||
{ |
|||
if (this.isModifiedHuffmanRle) |
|||
{ |
|||
if (this.value == 1) |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
return WhiteLen12MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private bool IsBlackMakeupCode() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 10: |
|||
{ |
|||
return BlackLen10MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 11: |
|||
{ |
|||
if (this.isModifiedHuffmanRle) |
|||
{ |
|||
if (this.value == 0) |
|||
{ |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
return BlackLen11MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 12: |
|||
{ |
|||
return BlackLen12MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 13: |
|||
{ |
|||
return BlackLen13MakeupCodes.ContainsKey(this.value); |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private bool IsTerminatingCode() |
|||
{ |
|||
if (this.IsWhiteRun) |
|||
{ |
|||
return this.IsWhiteTerminatingCode(); |
|||
} |
|||
|
|||
return this.IsBlackTerminatingCode(); |
|||
} |
|||
|
|||
private bool IsWhiteTerminatingCode() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 4: |
|||
{ |
|||
return WhiteLen4TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 5: |
|||
{ |
|||
return WhiteLen5TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 6: |
|||
{ |
|||
return WhiteLen6TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 7: |
|||
{ |
|||
return WhiteLen7TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 8: |
|||
{ |
|||
return WhiteLen8TermCodes.ContainsKey(this.value); |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private bool IsBlackTerminatingCode() |
|||
{ |
|||
switch (this.curValueBitsRead) |
|||
{ |
|||
case 2: |
|||
{ |
|||
return BlackLen2TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 3: |
|||
{ |
|||
return BlackLen3TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 4: |
|||
{ |
|||
return BlackLen4TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 5: |
|||
{ |
|||
return BlackLen5TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 6: |
|||
{ |
|||
return BlackLen6TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 7: |
|||
{ |
|||
return BlackLen7TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 8: |
|||
{ |
|||
return BlackLen8TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 9: |
|||
{ |
|||
return BlackLen9TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 10: |
|||
{ |
|||
return BlackLen10TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 11: |
|||
{ |
|||
return BlackLen11TermCodes.ContainsKey(this.value); |
|||
} |
|||
|
|||
case 12: |
|||
{ |
|||
return BlackLen12TermCodes.ContainsKey(this.value); |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private void Reset(bool resetRunLength = true) |
|||
{ |
|||
this.value = 0; |
|||
this.curValueBitsRead = 0; |
|||
|
|||
if (resetRunLength) |
|||
{ |
|||
this.RunLength = 0; |
|||
} |
|||
} |
|||
|
|||
private uint ReadValue(int nBits) |
|||
{ |
|||
Guard.MustBeGreaterThan(nBits, 0, nameof(nBits)); |
|||
|
|||
uint v = 0; |
|||
int shift = nBits; |
|||
while (shift-- > 0) |
|||
{ |
|||
uint bit = this.GetBit(); |
|||
v |= bit << shift; |
|||
this.curValueBitsRead++; |
|||
} |
|||
|
|||
return v; |
|||
} |
|||
|
|||
private uint GetBit() |
|||
{ |
|||
if (this.bitsRead >= 8) |
|||
{ |
|||
this.LoadNewByte(); |
|||
} |
|||
|
|||
Span<byte> dataSpan = this.Data.GetSpan(); |
|||
int shift = 8 - this.bitsRead - 1; |
|||
var bit = (uint)((dataSpan[(int)this.position] & (1 << shift)) != 0 ? 1 : 0); |
|||
this.bitsRead++; |
|||
|
|||
return bit; |
|||
} |
|||
|
|||
private void LoadNewByte() |
|||
{ |
|||
this.position++; |
|||
this.bitsRead = 0; |
|||
|
|||
if (this.position >= (ulong)this.dataLength) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("tiff image has invalid t4 compressed data"); |
|||
} |
|||
} |
|||
|
|||
private void ReadImageDataFromStream(Stream input, int bytesToRead) |
|||
{ |
|||
Span<byte> dataSpan = this.Data.GetSpan(); |
|||
input.Read(dataSpan, 0, bytesToRead); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,90 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/// <summary>
|
|||
/// Class to handle cases where TIFF image data is compressed using CCITT T4 compression.
|
|||
/// </summary>
|
|||
internal class T4TiffCompression : TiffBaseDecompressor |
|||
{ |
|||
private readonly FaxCompressionOptions faxCompressionOptions; |
|||
|
|||
private readonly byte whiteValue; |
|||
|
|||
private readonly byte blackValue; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="T4TiffCompression" /> class.
|
|||
/// </summary>
|
|||
/// <param name="allocator">The memory allocator.</param>
|
|||
/// <param name="width">The image width.</param>
|
|||
/// <param name="bitsPerPixel">The number of bits per pixel.</param>
|
|||
/// <param name="faxOptions">Fax compression options.</param>
|
|||
/// <param name="photometricInterpretation">The photometric interpretation.</param>
|
|||
public T4TiffCompression(MemoryAllocator allocator, int width, int bitsPerPixel, FaxCompressionOptions faxOptions, TiffPhotometricInterpretation photometricInterpretation) |
|||
: base(allocator, width, bitsPerPixel) |
|||
{ |
|||
this.faxCompressionOptions = faxOptions; |
|||
|
|||
bool isWhiteZero = photometricInterpretation == TiffPhotometricInterpretation.WhiteIsZero; |
|||
this.whiteValue = (byte)(isWhiteZero ? 0 : 1); |
|||
this.blackValue = (byte)(isWhiteZero ? 1 : 0); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer) |
|||
{ |
|||
if (this.faxCompressionOptions.HasFlag(FaxCompressionOptions.TwoDimensionalCoding)) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("TIFF CCITT 2D compression is not yet supported"); |
|||
} |
|||
|
|||
var eolPadding = this.faxCompressionOptions.HasFlag(FaxCompressionOptions.EolPadding); |
|||
using var bitReader = new T4BitReader(stream, byteCount, this.Allocator, eolPadding); |
|||
|
|||
buffer.Clear(); |
|||
uint bitsWritten = 0; |
|||
while (bitReader.HasMoreData) |
|||
{ |
|||
bitReader.ReadNextRun(); |
|||
|
|||
if (bitReader.RunLength > 0) |
|||
{ |
|||
if (bitReader.IsWhiteRun) |
|||
{ |
|||
BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.whiteValue); |
|||
bitsWritten += bitReader.RunLength; |
|||
} |
|||
else |
|||
{ |
|||
BitWriterUtils.WriteBits(buffer, (int)bitsWritten, bitReader.RunLength, this.blackValue); |
|||
bitsWritten += bitReader.RunLength; |
|||
} |
|||
} |
|||
|
|||
if (bitReader.IsEndOfScanLine) |
|||
{ |
|||
// Write padding bytes, if necessary.
|
|||
uint pad = 8 - (bitsWritten % 8); |
|||
if (pad != 8) |
|||
{ |
|||
BitWriterUtils.WriteBits(buffer, (int)bitsWritten, pad, 0); |
|||
bitsWritten += pad; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,257 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors |
|||
{ |
|||
/* |
|||
This implementation is based on a port of a java tiff decoder by Harald Kuhr: https://github.com/haraldk/TwelveMonkeys
|
|||
|
|||
Original licence: |
|||
|
|||
BSD 3-Clause License |
|||
|
|||
* Copyright (c) 2015, Harald Kuhr |
|||
* All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions are met: |
|||
* |
|||
* * Redistributions of source code must retain the above copyright notice, this |
|||
* list of conditions and the following disclaimer. |
|||
* |
|||
* * Redistributions in binary form must reproduce the above copyright notice, |
|||
* this list of conditions and the following disclaimer in the documentation |
|||
* and/or other materials provided with the distribution. |
|||
* |
|||
** Neither the name of the copyright holder nor the names of its |
|||
* contributors may be used to endorse or promote products derived from |
|||
* this software without specific prior written permission. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
|||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|||
* DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
|||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
|||
* OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|||
*/ |
|||
|
|||
/// <summary>
|
|||
/// Decompresses and decodes data using the dynamic LZW algorithms, see TIFF spec Section 13.
|
|||
/// </summary>
|
|||
internal sealed class TiffLzwDecoder |
|||
{ |
|||
/// <summary>
|
|||
/// The stream to decode.
|
|||
/// </summary>
|
|||
private readonly Stream stream; |
|||
|
|||
/// <summary>
|
|||
/// As soon as we use entry 4094 of the table (maxTableSize - 2), the lzw compressor write out a (12-bit) ClearCode.
|
|||
/// At this point, the compressor reinitializes the string table and then writes out 9-bit codes again.
|
|||
/// </summary>
|
|||
private const int ClearCode = 256; |
|||
|
|||
/// <summary>
|
|||
/// End of Information.
|
|||
/// </summary>
|
|||
private const int EoiCode = 257; |
|||
|
|||
/// <summary>
|
|||
/// Minimum code length of 9 bits.
|
|||
/// </summary>
|
|||
private const int MinBits = 9; |
|||
|
|||
/// <summary>
|
|||
/// Maximum code length of 12 bits.
|
|||
/// </summary>
|
|||
private const int MaxBits = 12; |
|||
|
|||
/// <summary>
|
|||
/// Maximum table size of 4096.
|
|||
/// </summary>
|
|||
private const int TableSize = 1 << MaxBits; |
|||
|
|||
private readonly LzwString[] table; |
|||
|
|||
private int tableLength; |
|||
private int bitsPerCode; |
|||
private int oldCode = ClearCode; |
|||
private int maxCode; |
|||
private int bitMask; |
|||
private int maxString; |
|||
private bool eofReached; |
|||
private int nextData; |
|||
private int nextBits; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffLzwDecoder" /> class
|
|||
/// and sets the stream, where the compressed data should be read from.
|
|||
/// </summary>
|
|||
/// <param name="stream">The stream to read from.</param>
|
|||
/// <exception cref="ArgumentNullException"><paramref name="stream" /> is null.</exception>
|
|||
public TiffLzwDecoder(Stream stream) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
this.stream = stream; |
|||
|
|||
// TODO: Investigate a manner by which we can avoid this allocation.
|
|||
this.table = new LzwString[TableSize]; |
|||
for (int i = 0; i < 256; i++) |
|||
{ |
|||
this.table[i] = new LzwString((byte)i); |
|||
} |
|||
|
|||
this.Init(); |
|||
} |
|||
|
|||
private void Init() |
|||
{ |
|||
// Table length is 256 + 2, because of special clear code and end of information code.
|
|||
this.tableLength = 258; |
|||
this.bitsPerCode = MinBits; |
|||
this.bitMask = BitmaskFor(this.bitsPerCode); |
|||
this.maxCode = this.MaxCode(); |
|||
this.maxString = 1; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes and decompresses all pixel indices from the stream.
|
|||
/// </summary>
|
|||
/// <param name="pixels">The pixel array to decode to.</param>
|
|||
public void DecodePixels(Span<byte> pixels) |
|||
{ |
|||
// Adapted from the pseudo-code example found in the TIFF 6.0 Specification, 1992.
|
|||
// See Section 13: "LZW Compression"/"LZW Decoding", page 61+
|
|||
int code; |
|||
int offset = 0; |
|||
|
|||
while ((code = this.GetNextCode()) != EoiCode) |
|||
{ |
|||
if (code == ClearCode) |
|||
{ |
|||
this.Init(); |
|||
code = this.GetNextCode(); |
|||
|
|||
if (code == EoiCode) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (this.table[code] == null) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException($"Corrupted TIFF LZW: code {code} (table size: {this.tableLength})"); |
|||
} |
|||
|
|||
offset += this.table[code].WriteTo(pixels, offset); |
|||
} |
|||
else |
|||
{ |
|||
if (this.table[this.oldCode] == null) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException($"Corrupted TIFF LZW: code {this.oldCode} (table size: {this.tableLength})"); |
|||
} |
|||
|
|||
if (this.IsInTable(code)) |
|||
{ |
|||
offset += this.table[code].WriteTo(pixels, offset); |
|||
|
|||
this.AddStringToTable(this.table[this.oldCode].Concatenate(this.table[code].FirstChar)); |
|||
} |
|||
else |
|||
{ |
|||
LzwString outString = this.table[this.oldCode].Concatenate(this.table[this.oldCode].FirstChar); |
|||
|
|||
offset += outString.WriteTo(pixels, offset); |
|||
this.AddStringToTable(outString); |
|||
} |
|||
} |
|||
|
|||
this.oldCode = code; |
|||
|
|||
if (offset >= pixels.Length) |
|||
{ |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void AddStringToTable(LzwString lzwString) |
|||
{ |
|||
if (this.tableLength > this.table.Length) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException($"TIFF LZW with more than {MaxBits} bits per code encountered (table overflow)"); |
|||
} |
|||
|
|||
this.table[this.tableLength++] = lzwString; |
|||
|
|||
if (this.tableLength > this.maxCode) |
|||
{ |
|||
this.bitsPerCode++; |
|||
|
|||
if (this.bitsPerCode > MaxBits) |
|||
{ |
|||
// Continue reading MaxBits (12 bit) length codes.
|
|||
this.bitsPerCode = MaxBits; |
|||
} |
|||
|
|||
this.bitMask = BitmaskFor(this.bitsPerCode); |
|||
this.maxCode = this.MaxCode(); |
|||
} |
|||
|
|||
if (lzwString.Length > this.maxString) |
|||
{ |
|||
this.maxString = lzwString.Length; |
|||
} |
|||
} |
|||
|
|||
private int GetNextCode() |
|||
{ |
|||
if (this.eofReached) |
|||
{ |
|||
return EoiCode; |
|||
} |
|||
|
|||
int read = this.stream.ReadByte(); |
|||
if (read < 0) |
|||
{ |
|||
this.eofReached = true; |
|||
return EoiCode; |
|||
} |
|||
|
|||
this.nextData = (this.nextData << 8) | read; |
|||
this.nextBits += 8; |
|||
|
|||
if (this.nextBits < this.bitsPerCode) |
|||
{ |
|||
read = this.stream.ReadByte(); |
|||
if (read < 0) |
|||
{ |
|||
this.eofReached = true; |
|||
return EoiCode; |
|||
} |
|||
|
|||
this.nextData = (this.nextData << 8) | read; |
|||
this.nextBits += 8; |
|||
} |
|||
|
|||
int code = (this.nextData >> (this.nextBits - this.bitsPerCode)) & this.bitMask; |
|||
this.nextBits -= this.bitsPerCode; |
|||
|
|||
return code; |
|||
} |
|||
|
|||
private bool IsInTable(int code) => code < this.tableLength; |
|||
|
|||
private int MaxCode() => this.bitMask - 1; |
|||
|
|||
private static int BitmaskFor(int bits) => (1 << bits) - 1; |
|||
} |
|||
} |
|||
@ -0,0 +1,36 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
/// <summary>
|
|||
/// Fax compression options, see TIFF spec page 51f (T4Options).
|
|||
/// </summary>
|
|||
[Flags] |
|||
public enum FaxCompressionOptions : uint |
|||
{ |
|||
/// <summary>
|
|||
/// No options.
|
|||
/// </summary>
|
|||
None = 0, |
|||
|
|||
/// <summary>
|
|||
/// If set, 2-dimensional coding is used (otherwise 1-dimensional is assumed).
|
|||
/// </summary>
|
|||
TwoDimensionalCoding = 1, |
|||
|
|||
/// <summary>
|
|||
/// If set, uncompressed mode is used.
|
|||
/// </summary>
|
|||
UncompressedMode = 2, |
|||
|
|||
/// <summary>
|
|||
/// If set, fill bits have been added as necessary before EOL codes such that
|
|||
/// EOL always ends on a byte boundary, thus ensuring an EOL-sequence of 1 byte
|
|||
/// preceded by a zero nibble: xxxx-0000 0000-0001.
|
|||
/// </summary>
|
|||
EolPadding = 4 |
|||
} |
|||
} |
|||
@ -0,0 +1,138 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
/// <summary>
|
|||
/// Methods for undoing the horizontal prediction used in combination with deflate and LZW compressed TIFF images.
|
|||
/// </summary>
|
|||
internal static class HorizontalPredictor |
|||
{ |
|||
/// <summary>
|
|||
/// Inverts the horizontal prediction.
|
|||
/// </summary>
|
|||
/// <param name="pixelBytes">Buffer with decompressed pixel data.</param>
|
|||
/// <param name="width">The width of the image or strip.</param>
|
|||
/// <param name="bitsPerPixel">Bits per pixel.</param>
|
|||
public static void Undo(Span<byte> pixelBytes, int width, int bitsPerPixel) |
|||
{ |
|||
if (bitsPerPixel == 8) |
|||
{ |
|||
Undo8Bit(pixelBytes, width); |
|||
} |
|||
else if (bitsPerPixel == 24) |
|||
{ |
|||
Undo24Bit(pixelBytes, width); |
|||
} |
|||
} |
|||
|
|||
public static void ApplyHorizontalPrediction(Span<byte> rows, int width, int bitsPerPixel) |
|||
{ |
|||
if (bitsPerPixel == 8) |
|||
{ |
|||
ApplyHorizontalPrediction8Bit(rows, width); |
|||
} |
|||
else if (bitsPerPixel == 24) |
|||
{ |
|||
ApplyHorizontalPrediction24Bit(rows, width); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Applies a horizontal predictor to the rgb row.
|
|||
/// Make use of the fact that many continuous-tone images rarely vary much in pixel value from one pixel to the next.
|
|||
/// In such images, if we replace the pixel values by differences between consecutive pixels, many of the differences should be 0, plus
|
|||
/// or minus 1, and so on.This reduces the apparent information content and allows LZW to encode the data more compactly.
|
|||
/// </summary>
|
|||
/// <param name="rows">The rgb pixel rows.</param>
|
|||
/// <param name="width">The width.</param>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
private static void ApplyHorizontalPrediction24Bit(Span<byte> rows, int width) |
|||
{ |
|||
DebugGuard.IsTrue(rows.Length % width == 0, "Values must be equals"); |
|||
int height = rows.Length / width; |
|||
for (int y = 0; y < height; y++) |
|||
{ |
|||
Span<byte> rowSpan = rows.Slice(y * width, width); |
|||
Span<Rgb24> rowRgb = MemoryMarshal.Cast<byte, Rgb24>(rowSpan); |
|||
|
|||
for (int x = rowRgb.Length - 1; x >= 1; x--) |
|||
{ |
|||
byte r = (byte)(rowRgb[x].R - rowRgb[x - 1].R); |
|||
byte g = (byte)(rowRgb[x].G - rowRgb[x - 1].G); |
|||
byte b = (byte)(rowRgb[x].B - rowRgb[x - 1].B); |
|||
var rgb = new Rgb24(r, g, b); |
|||
rowRgb[x].FromRgb24(rgb); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Applies a horizontal predictor to a gray pixel row.
|
|||
/// </summary>
|
|||
/// <param name="rows">The gray pixel rows.</param>
|
|||
/// <param name="width">The width.</param>
|
|||
[MethodImpl(InliningOptions.ShortMethod)] |
|||
private static void ApplyHorizontalPrediction8Bit(Span<byte> rows, int width) |
|||
{ |
|||
DebugGuard.IsTrue(rows.Length % width == 0, "Values must be equals"); |
|||
int height = rows.Length / width; |
|||
for (int y = 0; y < height; y++) |
|||
{ |
|||
Span<byte> rowSpan = rows.Slice(y * width, width); |
|||
for (int x = rowSpan.Length - 1; x >= 1; x--) |
|||
{ |
|||
rowSpan[x] -= rowSpan[x - 1]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private static void Undo8Bit(Span<byte> pixelBytes, int width) |
|||
{ |
|||
int rowBytesCount = width; |
|||
int height = pixelBytes.Length / rowBytesCount; |
|||
for (int y = 0; y < height; y++) |
|||
{ |
|||
Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount); |
|||
|
|||
byte pixelValue = rowBytes[0]; |
|||
for (int x = 1; x < width; x++) |
|||
{ |
|||
pixelValue += rowBytes[x]; |
|||
rowBytes[x] = pixelValue; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private static void Undo24Bit(Span<byte> pixelBytes, int width) |
|||
{ |
|||
int rowBytesCount = width * 3; |
|||
int height = pixelBytes.Length / rowBytesCount; |
|||
for (int y = 0; y < height; y++) |
|||
{ |
|||
Span<byte> rowBytes = pixelBytes.Slice(y * rowBytesCount, rowBytesCount); |
|||
Span<Rgb24> rowRgb = MemoryMarshal.Cast<byte, Rgb24>(rowBytes).Slice(0, width); |
|||
ref Rgb24 rowRgbBase = ref MemoryMarshal.GetReference(rowRgb); |
|||
byte r = rowRgbBase.R; |
|||
byte g = rowRgbBase.G; |
|||
byte b = rowRgbBase.B; |
|||
|
|||
for (int x = 1; x < rowRgb.Length; x++) |
|||
{ |
|||
ref Rgb24 pixel = ref rowRgb[x]; |
|||
r += pixel.R; |
|||
g += pixel.G; |
|||
b += pixel.B; |
|||
var rgb = new Rgb24(r, g, b); |
|||
pixel.FromRgb24(rgb); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,62 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
internal abstract class TiffBaseCompression : IDisposable |
|||
{ |
|||
private bool isDisposed; |
|||
|
|||
protected TiffBaseCompression(MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor = TiffPredictor.None) |
|||
{ |
|||
this.Allocator = allocator; |
|||
this.Width = width; |
|||
this.BitsPerPixel = bitsPerPixel; |
|||
this.Predictor = predictor; |
|||
this.BytesPerRow = ((width * bitsPerPixel) + 7) / 8; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the image width.
|
|||
/// </summary>
|
|||
public int Width { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the bits per pixel.
|
|||
/// </summary>
|
|||
public int BitsPerPixel { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the bytes per row.
|
|||
/// </summary>
|
|||
public int BytesPerRow { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the predictor to use. Should only be used with deflate or lzw compression.
|
|||
/// </summary>
|
|||
public TiffPredictor Predictor { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the memory allocator.
|
|||
/// </summary>
|
|||
protected MemoryAllocator Allocator { get; } |
|||
|
|||
/// <inheritdoc />
|
|||
public void Dispose() |
|||
{ |
|||
if (this.isDisposed) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
this.isDisposed = true; |
|||
this.Dispose(true); |
|||
} |
|||
|
|||
protected abstract void Dispose(bool disposing); |
|||
} |
|||
} |
|||
@ -0,0 +1,48 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
internal abstract class TiffBaseCompressor : TiffBaseCompression |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffBaseCompressor"/> class.
|
|||
/// </summary>
|
|||
/// <param name="output">The output stream to write the compressed image to.</param>
|
|||
/// <param name="allocator">The memory allocator.</param>
|
|||
/// <param name="width">The image width.</param>
|
|||
/// <param name="bitsPerPixel">Bits per pixel.</param>
|
|||
/// <param name="predictor">The predictor to use (should only be used with deflate or lzw compression). Defaults to none.</param>
|
|||
protected TiffBaseCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor = TiffPredictor.None) |
|||
: base(allocator, width, bitsPerPixel, predictor) |
|||
=> this.Output = output; |
|||
|
|||
/// <summary>
|
|||
/// Gets the compression method to use.
|
|||
/// </summary>
|
|||
public abstract TiffCompression Method { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the output stream to write the compressed image to.
|
|||
/// </summary>
|
|||
public Stream Output { get; } |
|||
|
|||
/// <summary>
|
|||
/// Does any initialization required for the compression.
|
|||
/// </summary>
|
|||
/// <param name="rowsPerStrip">The number of rows per strip.</param>
|
|||
public abstract void Initialize(int rowsPerStrip); |
|||
|
|||
/// <summary>
|
|||
/// Compresses a strip of the image.
|
|||
/// </summary>
|
|||
/// <param name="rows">Image rows to compress.</param>
|
|||
/// <param name="height">Image height.</param>
|
|||
public abstract void CompressStrip(Span<byte> rows, int height); |
|||
} |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
/// <summary>
|
|||
/// The base tiff decompressor class.
|
|||
/// </summary>
|
|||
internal abstract class TiffBaseDecompressor : TiffBaseCompression |
|||
{ |
|||
protected TiffBaseDecompressor(MemoryAllocator allocator, int width, int bitsPerPixel, TiffPredictor predictor = TiffPredictor.None) |
|||
: base(allocator, width, bitsPerPixel, predictor) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decompresses image data into the supplied buffer.
|
|||
/// </summary>
|
|||
/// <param name="stream">The <see cref="Stream" /> to read image data from.</param>
|
|||
/// <param name="stripOffset">The strip offset of stream.</param>
|
|||
/// <param name="stripByteCount">The number of bytes to read from the input stream.</param>
|
|||
/// <param name="buffer">The output buffer for uncompressed data.</param>
|
|||
public void Decompress(BufferedReadStream stream, uint stripOffset, uint stripByteCount, Span<byte> buffer) |
|||
{ |
|||
if (stripByteCount > int.MaxValue) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("The StripByteCount value is too big."); |
|||
} |
|||
|
|||
stream.Seek(stripOffset, SeekOrigin.Begin); |
|||
this.Decompress(stream, (int)stripByteCount, buffer); |
|||
|
|||
if (stripOffset + stripByteCount < stream.Position) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("Out of range when reading a strip."); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decompresses image data into the supplied buffer.
|
|||
/// </summary>
|
|||
/// <param name="stream">The <see cref="Stream" /> to read image data from.</param>
|
|||
/// <param name="byteCount">The number of bytes to read from the input stream.</param>
|
|||
/// <param name="buffer">The output buffer for uncompressed data.</param>
|
|||
protected abstract void Decompress(BufferedReadStream stream, int byteCount, Span<byte> buffer); |
|||
} |
|||
} |
|||
@ -0,0 +1,64 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Compression.Zlib; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Compression.Compressors; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
internal static class TiffCompressorFactory |
|||
{ |
|||
public static TiffBaseCompressor Create( |
|||
TiffCompression method, |
|||
Stream output, |
|||
MemoryAllocator allocator, |
|||
int width, |
|||
int bitsPerPixel, |
|||
DeflateCompressionLevel compressionLevel, |
|||
TiffPredictor predictor) |
|||
{ |
|||
switch (method) |
|||
{ |
|||
// The following compression types are not implemented in the encoder and will default to no compression instead.
|
|||
case TiffCompression.ItuTRecT43: |
|||
case TiffCompression.ItuTRecT82: |
|||
case TiffCompression.Jpeg: |
|||
case TiffCompression.OldJpeg: |
|||
case TiffCompression.OldDeflate: |
|||
case TiffCompression.None: |
|||
DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set"); |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
|
|||
return new NoCompressor(output, allocator, width, bitsPerPixel); |
|||
|
|||
case TiffCompression.PackBits: |
|||
DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set"); |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
return new PackBitsCompressor(output, allocator, width, bitsPerPixel); |
|||
|
|||
case TiffCompression.Deflate: |
|||
return new DeflateCompressor(output, allocator, width, bitsPerPixel, predictor, compressionLevel); |
|||
|
|||
case TiffCompression.Lzw: |
|||
DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set"); |
|||
return new LzwCompressor(output, allocator, width, bitsPerPixel, predictor); |
|||
|
|||
case TiffCompression.CcittGroup3Fax: |
|||
DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set"); |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
return new T4BitCompressor(output, allocator, width, bitsPerPixel, false); |
|||
|
|||
case TiffCompression.Ccitt1D: |
|||
DebugGuard.IsTrue(compressionLevel == DeflateCompressionLevel.DefaultCompression, "No deflate compression level is expected to be set"); |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
return new T4BitCompressor(output, allocator, width, bitsPerPixel, true); |
|||
|
|||
default: |
|||
throw TiffThrowHelper.NotSupportedCompressor(method.ToString()); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,41 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
/// <summary>
|
|||
/// Provides enumeration of the various TIFF compression types the decoder can handle.
|
|||
/// </summary>
|
|||
internal enum TiffDecoderCompressionType |
|||
{ |
|||
/// <summary>
|
|||
/// Image data is stored uncompressed in the TIFF file.
|
|||
/// </summary>
|
|||
None = 0, |
|||
|
|||
/// <summary>
|
|||
/// Image data is compressed using PackBits compression.
|
|||
/// </summary>
|
|||
PackBits = 1, |
|||
|
|||
/// <summary>
|
|||
/// Image data is compressed using Deflate compression.
|
|||
/// </summary>
|
|||
Deflate = 2, |
|||
|
|||
/// <summary>
|
|||
/// Image data is compressed using LZW compression.
|
|||
/// </summary>
|
|||
Lzw = 3, |
|||
|
|||
/// <summary>
|
|||
/// Image data is compressed using T4-encoding: CCITT T.4.
|
|||
/// </summary>
|
|||
T4 = 4, |
|||
|
|||
/// <summary>
|
|||
/// Image data is compressed using modified huffman compression.
|
|||
/// </summary>
|
|||
HuffmanRle = 5, |
|||
} |
|||
} |
|||
@ -0,0 +1,54 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Compression |
|||
{ |
|||
internal static class TiffDecompressorsFactory |
|||
{ |
|||
public static TiffBaseDecompressor Create( |
|||
TiffDecoderCompressionType method, |
|||
MemoryAllocator allocator, |
|||
TiffPhotometricInterpretation photometricInterpretation, |
|||
int width, |
|||
int bitsPerPixel, |
|||
TiffPredictor predictor, |
|||
FaxCompressionOptions faxOptions) |
|||
{ |
|||
switch (method) |
|||
{ |
|||
case TiffDecoderCompressionType.None: |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected"); |
|||
return new NoneTiffCompression(allocator, width, bitsPerPixel); |
|||
|
|||
case TiffDecoderCompressionType.PackBits: |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected"); |
|||
return new PackBitsTiffCompression(allocator, width, bitsPerPixel); |
|||
|
|||
case TiffDecoderCompressionType.Deflate: |
|||
DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected"); |
|||
return new DeflateTiffCompression(allocator, width, bitsPerPixel, predictor); |
|||
|
|||
case TiffDecoderCompressionType.Lzw: |
|||
DebugGuard.IsTrue(faxOptions == FaxCompressionOptions.None, "No fax compression options are expected"); |
|||
return new LzwTiffCompression(allocator, width, bitsPerPixel, predictor); |
|||
|
|||
case TiffDecoderCompressionType.T4: |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
return new T4TiffCompression(allocator, width, bitsPerPixel, faxOptions, photometricInterpretation); |
|||
|
|||
case TiffDecoderCompressionType.HuffmanRle: |
|||
DebugGuard.IsTrue(predictor == TiffPredictor.None, "Predictor should only be used with lzw or deflate compression"); |
|||
return new ModifiedHuffmanTiffCompression(allocator, width, bitsPerPixel, photometricInterpretation); |
|||
|
|||
default: |
|||
throw TiffThrowHelper.NotSupportedDecompressor(nameof(method)); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,94 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the compression formats defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
public enum TiffCompression : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// A invalid compression value.
|
|||
/// </summary>
|
|||
Invalid = 0, |
|||
|
|||
/// <summary>
|
|||
/// No compression.
|
|||
/// </summary>
|
|||
None = 1, |
|||
|
|||
/// <summary>
|
|||
/// CCITT Group 3 1-Dimensional Modified Huffman run-length encoding.
|
|||
/// </summary>
|
|||
Ccitt1D = 2, |
|||
|
|||
/// <summary>
|
|||
/// PackBits compression
|
|||
/// </summary>
|
|||
PackBits = 32773, |
|||
|
|||
/// <summary>
|
|||
/// T4-encoding: CCITT T.4 bi-level encoding (see Section 11 of the TIFF 6.0 specification).
|
|||
/// </summary>
|
|||
CcittGroup3Fax = 3, |
|||
|
|||
/// <summary>
|
|||
/// T6-encoding: CCITT T.6 bi-level encoding (see Section 11 of the TIFF 6.0 specification).
|
|||
///
|
|||
/// Note: The TIFF encoder does not yet support this compression and will default to use no compression instead,
|
|||
/// if this is choosen.
|
|||
/// </summary>
|
|||
CcittGroup4Fax = 4, |
|||
|
|||
/// <summary>
|
|||
/// LZW compression (see Section 13 of the TIFF 6.0 specification).
|
|||
/// </summary>
|
|||
Lzw = 5, |
|||
|
|||
/// <summary>
|
|||
/// JPEG compression - obsolete (see Section 22 of the TIFF 6.0 specification).
|
|||
///
|
|||
/// Note: The TIFF encoder does not support this compression and will default to use no compression instead,
|
|||
/// if this is chosen.
|
|||
/// </summary>
|
|||
OldJpeg = 6, |
|||
|
|||
/// <summary>
|
|||
/// JPEG compression (see TIFF Specification, supplement 2).
|
|||
///
|
|||
/// Note: The TIFF encoder does not yet support this compression and will default to use no compression instead,
|
|||
/// if this is chosen.
|
|||
/// </summary>
|
|||
Jpeg = 7, |
|||
|
|||
/// <summary>
|
|||
/// Deflate compression, using zlib data format (see TIFF Specification, supplement 2).
|
|||
/// </summary>
|
|||
Deflate = 8, |
|||
|
|||
/// <summary>
|
|||
/// Deflate compression - old.
|
|||
///
|
|||
/// Note: The TIFF encoder does not support this compression and will default to use no compression instead,
|
|||
/// if this is chosen.
|
|||
/// </summary>
|
|||
OldDeflate = 32946, |
|||
|
|||
/// <summary>
|
|||
/// ITU-T Rec. T.82 coding, applying ITU-T Rec. T.85 (JBIG) (see RFC2301).
|
|||
///
|
|||
/// Note: The TIFF encoder does not yet support this compression and will default to use no compression instead,
|
|||
/// if this is chosen.
|
|||
/// </summary>
|
|||
ItuTRecT82 = 9, |
|||
|
|||
/// <summary>
|
|||
/// ITU-T Rec. T.43 representation, using ITU-T Rec. T.82 (JBIG) (see RFC2301).
|
|||
///
|
|||
/// Note: The TIFF encoder does not yet support this compression and will default to use no compression instead,
|
|||
/// if this is chosen.
|
|||
/// </summary>
|
|||
ItuTRecT43 = 10 |
|||
} |
|||
} |
|||
@ -0,0 +1,83 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Defines constants defined in the TIFF specification.
|
|||
/// </summary>
|
|||
internal static class TiffConstants |
|||
{ |
|||
/// <summary>
|
|||
/// Byte order markers for indicating little endian encoding.
|
|||
/// </summary>
|
|||
public const byte ByteOrderLittleEndian = 0x49; |
|||
|
|||
/// <summary>
|
|||
/// Byte order markers for indicating big endian encoding.
|
|||
/// </summary>
|
|||
public const byte ByteOrderBigEndian = 0x4D; |
|||
|
|||
/// <summary>
|
|||
/// Byte order markers for indicating little endian encoding.
|
|||
/// </summary>
|
|||
public const ushort ByteOrderLittleEndianShort = 0x4949; |
|||
|
|||
/// <summary>
|
|||
/// Byte order markers for indicating big endian encoding.
|
|||
/// </summary>
|
|||
public const ushort ByteOrderBigEndianShort = 0x4D4D; |
|||
|
|||
/// <summary>
|
|||
/// Magic number used within the image file header to identify a TIFF format file.
|
|||
/// </summary>
|
|||
public const ushort HeaderMagicNumber = 42; |
|||
|
|||
/// <summary>
|
|||
/// RowsPerStrip default value, which is effectively infinity.
|
|||
/// </summary>
|
|||
public const int RowsPerStripInfinity = 2147483647; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of the Rational and SRational data types
|
|||
/// </summary>
|
|||
public const int SizeOfRational = 8; |
|||
|
|||
/// <summary>
|
|||
/// The default strip size is 8k.
|
|||
/// </summary>
|
|||
public const int DefaultStripSize = 8 * 1024; |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for 1 bit bicolor images.
|
|||
/// </summary>
|
|||
public static readonly TiffBitsPerSample BitsPerSample1Bit = new TiffBitsPerSample(1, 0, 0); |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for images with a 4 color palette.
|
|||
/// </summary>
|
|||
public static readonly TiffBitsPerSample BitsPerSample4Bit = new TiffBitsPerSample(4, 0, 0); |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for 8 bit images.
|
|||
/// </summary>
|
|||
public static readonly TiffBitsPerSample BitsPerSample8Bit = new TiffBitsPerSample(8, 0, 0); |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for color images with 8 bits for each color channel.
|
|||
/// </summary>
|
|||
public static readonly TiffBitsPerSample BitsPerSampleRgb8Bit = new TiffBitsPerSample(8, 8, 8); |
|||
|
|||
/// <summary>
|
|||
/// The list of mimetypes that equate to a tiff.
|
|||
/// </summary>
|
|||
public static readonly IEnumerable<string> MimeTypes = new[] { "image/tiff", "image/tiff-fx" }; |
|||
|
|||
/// <summary>
|
|||
/// The list of file extensions that equate to a tiff.
|
|||
/// </summary>
|
|||
public static readonly IEnumerable<string> FileExtensions = new[] { "tiff", "tif" }; |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the possible uses of extra components in TIFF format files.
|
|||
/// </summary>
|
|||
internal enum TiffExtraSamples |
|||
{ |
|||
/// <summary>
|
|||
/// Unspecified data.
|
|||
/// </summary>
|
|||
Unspecified = 0, |
|||
|
|||
/// <summary>
|
|||
/// Associated alpha data (with pre-multiplied color).
|
|||
/// </summary>
|
|||
AssociatedAlpha = 1, |
|||
|
|||
/// <summary>
|
|||
/// Unassociated alpha data.
|
|||
/// </summary>
|
|||
UnassociatedAlpha = 2 |
|||
} |
|||
} |
|||
@ -0,0 +1,21 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the fill orders defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
internal enum TiffFillOrder : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// Pixels with lower column values are stored in the higher-order bits of the byte.
|
|||
/// </summary>
|
|||
MostSignificantBitFirst = 1, |
|||
|
|||
/// <summary>
|
|||
/// Pixels with lower column values are stored in the lower-order bits of the byte.
|
|||
/// </summary>
|
|||
LeastSignificantBitFirst = 2 |
|||
} |
|||
} |
|||
@ -0,0 +1,44 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the sub-file types defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
[Flags] |
|||
public enum TiffNewSubfileType : uint |
|||
{ |
|||
/// <summary>
|
|||
/// A full-resolution image.
|
|||
/// </summary>
|
|||
FullImage = 0, |
|||
|
|||
/// <summary>
|
|||
/// Reduced-resolution version of another image in this TIFF file.
|
|||
/// </summary>
|
|||
Preview = 1, |
|||
|
|||
/// <summary>
|
|||
/// A single page of a multi-page image.
|
|||
/// </summary>
|
|||
SinglePage = 2, |
|||
|
|||
/// <summary>
|
|||
/// A transparency mask for another image in this TIFF file.
|
|||
/// </summary>
|
|||
TransparencyMask = 4, |
|||
|
|||
/// <summary>
|
|||
/// Alternative reduced-resolution version of another image in this TIFF file (see DNG specification).
|
|||
/// </summary>
|
|||
AlternativePreview = 65536, |
|||
|
|||
/// <summary>
|
|||
/// Mixed raster content (see RFC2301).
|
|||
/// </summary>
|
|||
MixedRasterContent = 8 |
|||
} |
|||
} |
|||
@ -0,0 +1,51 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the image orientations defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
internal enum TiffOrientation |
|||
{ |
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual top and left-hand side of the image respectively.
|
|||
/// </summary>
|
|||
TopLeft = 1, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual top and right-hand side of the image respectively.
|
|||
/// </summary>
|
|||
TopRight = 2, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual bottom and right-hand side of the image respectively.
|
|||
/// </summary>
|
|||
BottomRight = 3, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual bottom and left-hand side of the image respectively.
|
|||
/// </summary>
|
|||
BottomLeft = 4, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual left-hand side and top of the image respectively.
|
|||
/// </summary>
|
|||
LeftTop = 5, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual right-hand side and top of the image respectively.
|
|||
/// </summary>
|
|||
RightTop = 6, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual right-hand side and bottom of the image respectively.
|
|||
/// </summary>
|
|||
RightBottom = 7, |
|||
|
|||
/// <summary>
|
|||
/// The 0th row and 0th column represent the visual left-hand side and bottom of the image respectively.
|
|||
/// </summary>
|
|||
LeftBottom = 8 |
|||
} |
|||
} |
|||
@ -0,0 +1,89 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the photometric interpretation formats defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
public enum TiffPhotometricInterpretation : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// Bilevel and grayscale: 0 is imaged as white. The maximum value is imaged as black.
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
WhiteIsZero = 0, |
|||
|
|||
/// <summary>
|
|||
/// Bilevel and grayscale: 0 is imaged as black. The maximum value is imaged as white.
|
|||
/// </summary>
|
|||
BlackIsZero = 1, |
|||
|
|||
/// <summary>
|
|||
/// RGB image.
|
|||
/// </summary>
|
|||
Rgb = 2, |
|||
|
|||
/// <summary>
|
|||
/// Palette Color.
|
|||
/// </summary>
|
|||
PaletteColor = 3, |
|||
|
|||
/// <summary>
|
|||
/// A transparency mask.
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
TransparencyMask = 4, |
|||
|
|||
/// <summary>
|
|||
/// Separated: usually CMYK (see Section 16 of the TIFF 6.0 specification).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
Separated = 5, |
|||
|
|||
/// <summary>
|
|||
/// YCbCr (see Section 21 of the TIFF 6.0 specification).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
YCbCr = 6, |
|||
|
|||
/// <summary>
|
|||
/// 1976 CIE L*a*b* (see Section 23 of the TIFF 6.0 specification).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
CieLab = 8, |
|||
|
|||
/// <summary>
|
|||
/// ICC L*a*b* (see TIFF Specification, supplement 1).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
IccLab = 9, |
|||
|
|||
/// <summary>
|
|||
/// ITU L*a*b* (see RFC2301).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
ItuLab = 10, |
|||
|
|||
/// <summary>
|
|||
/// Color Filter Array (see the DNG specification).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
ColorFilterArray = 32803, |
|||
|
|||
/// <summary>
|
|||
/// Linear Raw (see the DNG specification).
|
|||
///
|
|||
/// Not supported by the TiffEncoder.
|
|||
/// </summary>
|
|||
LinearRaw = 34892 |
|||
} |
|||
} |
|||
@ -0,0 +1,31 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing how the components of each pixel are stored the Tiff file-format.
|
|||
/// </summary>
|
|||
public enum TiffPlanarConfiguration : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// Chunky format.
|
|||
/// The component values for each pixel are stored contiguously.
|
|||
/// The order of the components within the pixel is specified by
|
|||
/// PhotometricInterpretation. For example, for RGB data, the data is stored as RGBRGBRGB.
|
|||
/// </summary>
|
|||
Chunky = 1, |
|||
|
|||
/// <summary>
|
|||
/// Planar format.
|
|||
/// The components are stored in separate “component planes.” The
|
|||
/// values in StripOffsets and StripByteCounts are then arranged as a 2-dimensional
|
|||
/// array, with SamplesPerPixel rows and StripsPerImage columns. (All of the columns
|
|||
/// for row 0 are stored first, followed by the columns of row 1, and so on.)
|
|||
/// PhotometricInterpretation describes the type of data stored in each component
|
|||
/// plane. For example, RGB data is stored with the Red components in one component
|
|||
/// plane, the Green in another, and the Blue in another.
|
|||
/// </summary>
|
|||
Planar = 2 |
|||
} |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// A mathematical operator that is applied to the image data before an encoding scheme is applied.
|
|||
/// </summary>
|
|||
public enum TiffPredictor : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// No prediction.
|
|||
/// </summary>
|
|||
None = 1, |
|||
|
|||
/// <summary>
|
|||
/// Horizontal differencing.
|
|||
/// </summary>
|
|||
Horizontal = 2, |
|||
|
|||
/// <summary>
|
|||
/// Floating point horizontal differencing.
|
|||
///
|
|||
/// Note: The Tiff Encoder does not yet support this. If this is chosen, the encoder will fallback to none.
|
|||
/// </summary>
|
|||
FloatingPoint = 3 |
|||
} |
|||
} |
|||
@ -0,0 +1,41 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Specifies how to interpret each data sample in a pixel.
|
|||
/// </summary>
|
|||
public enum TiffSampleFormat : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// Unsigned integer data. Default value.
|
|||
/// </summary>
|
|||
UnsignedInteger = 1, |
|||
|
|||
/// <summary>
|
|||
/// Signed integer data.
|
|||
/// </summary>
|
|||
SignedInteger = 2, |
|||
|
|||
/// <summary>
|
|||
/// IEEE floating point data.
|
|||
/// </summary>
|
|||
Float = 3, |
|||
|
|||
/// <summary>
|
|||
/// Undefined data format.
|
|||
/// </summary>
|
|||
Undefined = 4, |
|||
|
|||
/// <summary>
|
|||
/// The complex int.
|
|||
/// </summary>
|
|||
ComplexInt = 5, |
|||
|
|||
/// <summary>
|
|||
/// The complex float.
|
|||
/// </summary>
|
|||
ComplexFloat = 6 |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the sub-file types defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
public enum TiffSubfileType : ushort |
|||
{ |
|||
/// <summary>
|
|||
/// Full-resolution image data.
|
|||
/// </summary>
|
|||
FullImage = 1, |
|||
|
|||
/// <summary>
|
|||
/// Reduced-resolution image data.
|
|||
/// </summary>
|
|||
Preview = 2, |
|||
|
|||
/// <summary>
|
|||
/// A single page of a multi-page image.
|
|||
/// </summary>
|
|||
SinglePage = 3 |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.Constants |
|||
{ |
|||
/// <summary>
|
|||
/// Enumeration representing the thresholding applied to image data defined by the Tiff file-format.
|
|||
/// </summary>
|
|||
internal enum TiffThresholding |
|||
{ |
|||
/// <summary>
|
|||
/// No dithering or halftoning.
|
|||
/// </summary>
|
|||
None = 1, |
|||
|
|||
/// <summary>
|
|||
/// An ordered dither or halftone technique.
|
|||
/// </summary>
|
|||
Ordered = 2, |
|||
|
|||
/// <summary>
|
|||
/// A randomized process such as error diffusion.
|
|||
/// </summary>
|
|||
Random = 3 |
|||
} |
|||
} |
|||
@ -0,0 +1,16 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Encapsulates the options for the <see cref="TiffDecoder"/>.
|
|||
/// </summary>
|
|||
internal interface ITiffDecoderOptions |
|||
{ |
|||
/// <summary>
|
|||
/// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
|
|||
/// </summary>
|
|||
bool IgnoreMetadata { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,47 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Compression.Zlib; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Processing.Processors.Quantization; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Encapsulates the options for the <see cref="TiffEncoder"/>.
|
|||
/// </summary>
|
|||
internal interface ITiffEncoderOptions |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the number of bits per pixel.
|
|||
/// </summary>
|
|||
TiffBitsPerPixel? BitsPerPixel { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the compression type to use.
|
|||
/// </summary>
|
|||
TiffCompression? Compression { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the compression level 1-9 for the deflate compression mode.
|
|||
/// <remarks>Defaults to <see cref="DeflateCompressionLevel.DefaultCompression"/>.</remarks>
|
|||
/// </summary>
|
|||
DeflateCompressionLevel? CompressionLevel { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the PhotometricInterpretation to use. Possible options are RGB, RGB with a color palette, gray or BiColor.
|
|||
/// If no PhotometricInterpretation is specified or it is unsupported by the encoder, RGB will be used.
|
|||
/// </summary>
|
|||
TiffPhotometricInterpretation? PhotometricInterpretation { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating which horizontal prediction to use. This can improve the compression ratio with deflate or lzw compression.
|
|||
/// </summary>
|
|||
TiffPredictor? HorizontalPredictor { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the quantizer for creating a color palette image.
|
|||
/// </summary>
|
|||
IQuantizer Quantizer { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,104 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// The TIFF IFD reader class.
|
|||
/// </summary>
|
|||
internal class DirectoryReader |
|||
{ |
|||
private readonly Stream stream; |
|||
|
|||
private uint nextIfdOffset; |
|||
|
|||
// used for sequential read big values (actual for multiframe big files)
|
|||
// todo: different tags can link to the same data (stream offset) - investigate
|
|||
private readonly SortedList<uint, Action> lazyLoaders = new SortedList<uint, Action>(new DuplicateKeyComparer<uint>()); |
|||
|
|||
public DirectoryReader(Stream stream) => this.stream = stream; |
|||
|
|||
/// <summary>
|
|||
/// Gets the byte order.
|
|||
/// </summary>
|
|||
public ByteOrder ByteOrder { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Reads image file directories.
|
|||
/// </summary>
|
|||
/// <returns>Image file directories.</returns>
|
|||
public IEnumerable<ExifProfile> Read() |
|||
{ |
|||
this.ByteOrder = ReadByteOrder(this.stream); |
|||
this.nextIfdOffset = new HeaderReader(this.stream, this.ByteOrder).ReadFileHeader(); |
|||
return this.ReadIfds(); |
|||
} |
|||
|
|||
private static ByteOrder ReadByteOrder(Stream stream) |
|||
{ |
|||
var headerBytes = new byte[2]; |
|||
stream.Read(headerBytes, 0, 2); |
|||
if (headerBytes[0] == TiffConstants.ByteOrderLittleEndian && headerBytes[1] == TiffConstants.ByteOrderLittleEndian) |
|||
{ |
|||
return ByteOrder.LittleEndian; |
|||
} |
|||
else if (headerBytes[0] == TiffConstants.ByteOrderBigEndian && headerBytes[1] == TiffConstants.ByteOrderBigEndian) |
|||
{ |
|||
return ByteOrder.BigEndian; |
|||
} |
|||
|
|||
throw TiffThrowHelper.ThrowInvalidHeader(); |
|||
} |
|||
|
|||
private IEnumerable<ExifProfile> ReadIfds() |
|||
{ |
|||
var readers = new List<EntryReader>(); |
|||
while (this.nextIfdOffset != 0 && this.nextIfdOffset < this.stream.Length) |
|||
{ |
|||
var reader = new EntryReader(this.stream, this.ByteOrder, this.nextIfdOffset, this.lazyLoaders); |
|||
reader.ReadTags(); |
|||
|
|||
this.nextIfdOffset = reader.NextIfdOffset; |
|||
|
|||
readers.Add(reader); |
|||
} |
|||
|
|||
// Sequential reading big values.
|
|||
foreach (Action loader in this.lazyLoaders.Values) |
|||
{ |
|||
loader(); |
|||
} |
|||
|
|||
var list = new List<ExifProfile>(); |
|||
foreach (EntryReader reader in readers) |
|||
{ |
|||
var profile = new ExifProfile(reader.Values, reader.InvalidTags); |
|||
list.Add(profile); |
|||
} |
|||
|
|||
return list; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// <see cref="DuplicateKeyComparer{TKey}"/> used for possibility add a duplicate offsets (but tags don't duplicate).
|
|||
/// </summary>
|
|||
/// <typeparam name="TKey">The type of the key.</typeparam>
|
|||
private class DuplicateKeyComparer<TKey> : IComparer<TKey> |
|||
where TKey : IComparable |
|||
{ |
|||
public int Compare(TKey x, TKey y) |
|||
{ |
|||
int result = x.CompareTo(y); |
|||
|
|||
// Handle equality as being greater.
|
|||
return (result == 0) ? 1 : result; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,65 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
internal class EntryReader : BaseExifReader |
|||
{ |
|||
private readonly uint startOffset; |
|||
|
|||
private readonly SortedList<uint, Action> lazyLoaders; |
|||
|
|||
public EntryReader(Stream stream, ByteOrder byteOrder, uint ifdOffset, SortedList<uint, Action> lazyLoaders) |
|||
: base(stream) |
|||
{ |
|||
this.IsBigEndian = byteOrder == ByteOrder.BigEndian; |
|||
this.startOffset = ifdOffset; |
|||
this.lazyLoaders = lazyLoaders; |
|||
} |
|||
|
|||
public List<IExifValue> Values { get; } = new List<IExifValue>(); |
|||
|
|||
public uint NextIfdOffset { get; private set; } |
|||
|
|||
public void ReadTags() |
|||
{ |
|||
this.ReadValues(this.Values, this.startOffset); |
|||
this.NextIfdOffset = this.ReadUInt32(); |
|||
|
|||
this.ReadSubIfd(this.Values); |
|||
} |
|||
|
|||
protected override void RegisterExtLoader(uint offset, Action reader) => |
|||
this.lazyLoaders.Add(offset, reader); |
|||
} |
|||
|
|||
internal class HeaderReader : BaseExifReader |
|||
{ |
|||
public HeaderReader(Stream stream, ByteOrder byteOrder) |
|||
: base(stream) => |
|||
this.IsBigEndian = byteOrder == ByteOrder.BigEndian; |
|||
|
|||
public uint FirstIfdOffset { get; private set; } |
|||
|
|||
public uint ReadFileHeader() |
|||
{ |
|||
ushort magic = this.ReadUInt16(); |
|||
if (magic != TiffConstants.HeaderMagicNumber) |
|||
{ |
|||
TiffThrowHelper.ThrowInvalidHeader(); |
|||
} |
|||
|
|||
this.FirstIfdOffset = this.ReadUInt32(); |
|||
return this.FirstIfdOffset; |
|||
} |
|||
|
|||
protected override void RegisterExtLoader(uint offset, Action reader) => throw new NotSupportedException(); |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue