mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
5 years ago
382 changed files with 13254 additions and 990 deletions
@ -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, |
|||
} |
|||
} |
|||
@ -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,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.Compressors |
|||
{ |
|||
internal sealed class PackBitsCompressor : TiffBaseCompressor |
|||
{ |
|||
private IManagedByteBuffer 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.AllocateManagedByteBuffer(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,592 @@ |
|||
// 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,113 @@ |
|||
// 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 TIFF file header.
|
|||
/// </summary>
|
|||
public const int SizeOfTiffHeader = 8; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of each individual TIFF IFD entry
|
|||
/// </summary>
|
|||
public const int SizeOfIfdEntry = 12; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of the Short and SShort data types
|
|||
/// </summary>
|
|||
public const int SizeOfShort = 2; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of the Long and SLong data types
|
|||
/// </summary>
|
|||
public const int SizeOfLong = 4; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of the Rational and SRational data types
|
|||
/// </summary>
|
|||
public const int SizeOfRational = 8; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of the Float data type
|
|||
/// </summary>
|
|||
public const int SizeOfFloat = 4; |
|||
|
|||
/// <summary>
|
|||
/// Size (in bytes) of the Double data type
|
|||
/// </summary>
|
|||
public const int SizeOfDouble = 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 ushort[] BitsPerSample1Bit = { 1 }; |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for images with a 4 color palette.
|
|||
/// </summary>
|
|||
public static readonly ushort[] BitsPerSample4Bit = { 4 }; |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for 8 bit images.
|
|||
/// </summary>
|
|||
public static readonly ushort[] BitsPerSample8Bit = { 8 }; |
|||
|
|||
/// <summary>
|
|||
/// The bits per sample for images with 8 bits for each color channel.
|
|||
/// </summary>
|
|||
public static readonly ushort[] BitsPerSampleRgb8Bit = { 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(); |
|||
} |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff; |
|||
using SixLabors.ImageSharp.Metadata; |
|||
|
|||
namespace SixLabors.ImageSharp |
|||
{ |
|||
/// <summary>
|
|||
/// Extension methods for the <see cref="ImageMetadata"/> type.
|
|||
/// </summary>
|
|||
public static partial class MetadataExtensions |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the tiff format specific metadata for the image.
|
|||
/// </summary>
|
|||
/// <param name="metadata">The metadata this method extends.</param>
|
|||
/// <returns>The <see cref="TiffMetadata"/>.</returns>
|
|||
public static TiffMetadata GetTiffMetadata(this ImageMetadata metadata) => metadata.GetFormatMetadata(TiffFormat.Instance); |
|||
|
|||
/// <summary>
|
|||
/// Gets the tiff format specific metadata for the image frame.
|
|||
/// </summary>
|
|||
/// <param name="metadata">The metadata this method extends.</param>
|
|||
/// <returns>The <see cref="TiffFrameMetadata"/>.</returns>
|
|||
public static TiffFrameMetadata GetTiffMetadata(this ImageFrameMetadata metadata) => metadata.GetFormatMetadata(TiffFormat.Instance); |
|||
} |
|||
} |
|||
@ -0,0 +1,46 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'BlackIsZero' photometric interpretation (optimized for bilevel images).
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
internal class BlackIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
|
|||
Color black = Color.Black; |
|||
Color white = Color.White; |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x += 8) |
|||
{ |
|||
byte b = data[offset++]; |
|||
int maxShift = Math.Min(left + width - x, 8); |
|||
|
|||
for (int shift = 0; shift < maxShift; shift++) |
|||
{ |
|||
int bit = (b >> (7 - shift)) & 1; |
|||
|
|||
color.FromRgba32(bit == 0 ? black : white); |
|||
|
|||
pixels[x + shift, y] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,58 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'BlackIsZero' photometric interpretation (optimized for 4-bit grayscale images).
|
|||
/// </summary>
|
|||
internal class BlackIsZero4TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
bool isOddWidth = (width & 1) == 1; |
|||
|
|||
var l8 = default(L8); |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width - 1;) |
|||
{ |
|||
byte byteData = data[offset++]; |
|||
|
|||
byte intensity1 = (byte)(((byteData & 0xF0) >> 4) * 17); |
|||
l8.PackedValue = intensity1; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[x++, y] = color; |
|||
|
|||
byte intensity2 = (byte)((byteData & 0x0F) * 17); |
|||
l8.PackedValue = intensity2; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[x++, y] = color; |
|||
} |
|||
|
|||
if (isOddWidth) |
|||
{ |
|||
byte byteData = data[offset++]; |
|||
|
|||
byte intensity1 = (byte)(((byteData & 0xF0) >> 4) * 17); |
|||
l8.PackedValue = intensity1; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[left + width - 1, y] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'BlackIsZero' photometric interpretation (optimized for 8-bit grayscale images).
|
|||
/// </summary>
|
|||
internal class BlackIsZero8TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
|
|||
var l8 = default(L8); |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
byte intensity = data[offset++]; |
|||
|
|||
l8.PackedValue = intensity; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[x, y] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,50 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Utils; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'BlackIsZero' photometric interpretation (for all bit depths).
|
|||
/// </summary>
|
|||
internal class BlackIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
private readonly ushort bitsPerSample0; |
|||
|
|||
private readonly float factor; |
|||
|
|||
public BlackIsZeroTiffColor(ushort[] bitsPerSample) |
|||
{ |
|||
this.bitsPerSample0 = bitsPerSample[0]; |
|||
this.factor = (1 << this.bitsPerSample0) - 1.0f; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
var bitReader = new BitReader(data); |
|||
|
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
int value = bitReader.ReadBits(this.bitsPerSample0); |
|||
float intensity = value / this.factor; |
|||
|
|||
color.FromVector4(new Vector4(intensity, intensity, intensity, 1.0f)); |
|||
pixels[x, y] = color; |
|||
} |
|||
|
|||
bitReader.NextRow(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,67 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Utils; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'PaletteTiffColor' photometric interpretation (for all bit depths).
|
|||
/// </summary>
|
|||
internal class PaletteTiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
private readonly ushort bitsPerSample0; |
|||
|
|||
private readonly TPixel[] palette; |
|||
|
|||
/// <param name="bitsPerSample">The number of bits per sample for each pixel.</param>
|
|||
/// <param name="colorMap">The RGB color lookup table to use for decoding the image.</param>
|
|||
public PaletteTiffColor(ushort[] bitsPerSample, ushort[] colorMap) |
|||
{ |
|||
this.bitsPerSample0 = bitsPerSample[0]; |
|||
int colorCount = 1 << this.bitsPerSample0; |
|||
this.palette = GeneratePalette(colorMap, colorCount); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var bitReader = new BitReader(data); |
|||
|
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
int index = bitReader.ReadBits(this.bitsPerSample0); |
|||
pixels[x, y] = this.palette[index]; |
|||
} |
|||
|
|||
bitReader.NextRow(); |
|||
} |
|||
} |
|||
|
|||
private static TPixel[] GeneratePalette(ushort[] colorMap, int colorCount) |
|||
{ |
|||
var palette = new TPixel[colorCount]; |
|||
|
|||
const int rOffset = 0; |
|||
int gOffset = colorCount; |
|||
int bOffset = colorCount * 2; |
|||
|
|||
for (int i = 0; i < palette.Length; i++) |
|||
{ |
|||
float r = colorMap[rOffset + i] / 65535F; |
|||
float g = colorMap[gOffset + i] / 65535F; |
|||
float b = colorMap[bOffset + i] / 65535F; |
|||
palette[i].FromVector4(new Vector4(r, g, b, 1.0f)); |
|||
} |
|||
|
|||
return palette; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'RGB' photometric interpretation (optimized for 8-bit full color images).
|
|||
/// </summary>
|
|||
internal class Rgb888TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
|
|||
var rgba = default(Rgba32); |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
Span<TPixel> pixelRow = pixels.GetRowSpan(y); |
|||
|
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
byte r = data[offset++]; |
|||
byte g = data[offset++]; |
|||
byte b = data[offset++]; |
|||
|
|||
rgba.PackedValue = (uint)(r | (g << 8) | (b << 16) | (0xff << 24)); |
|||
color.FromRgba32(rgba); |
|||
|
|||
pixelRow[x] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,76 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Utils; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'RGB' photometric interpretation with 'Planar' layout (for all bit depths).
|
|||
/// </summary>
|
|||
internal class RgbPlanarTiffColor<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
private readonly float rFactor; |
|||
|
|||
private readonly float gFactor; |
|||
|
|||
private readonly float bFactor; |
|||
|
|||
private readonly ushort bitsPerSampleR; |
|||
|
|||
private readonly ushort bitsPerSampleG; |
|||
|
|||
private readonly ushort bitsPerSampleB; |
|||
|
|||
public RgbPlanarTiffColor(ushort[] bitsPerSample) |
|||
/* : base(bitsPerSample, null) */ |
|||
{ |
|||
this.bitsPerSampleR = bitsPerSample[0]; |
|||
this.bitsPerSampleG = bitsPerSample[1]; |
|||
this.bitsPerSampleB = bitsPerSample[2]; |
|||
|
|||
this.rFactor = (1 << this.bitsPerSampleR) - 1.0f; |
|||
this.gFactor = (1 << this.bitsPerSampleG) - 1.0f; |
|||
this.bFactor = (1 << this.bitsPerSampleB) - 1.0f; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes pixel data using the current photometric interpretation.
|
|||
/// </summary>
|
|||
/// <param name="data">The buffers to read image data from.</param>
|
|||
/// <param name="pixels">The image buffer to write pixels to.</param>
|
|||
/// <param name="left">The x-coordinate of the left-hand side of the image block.</param>
|
|||
/// <param name="top">The y-coordinate of the top of the image block.</param>
|
|||
/// <param name="width">The width of the image block.</param>
|
|||
/// <param name="height">The height of the image block.</param>
|
|||
public void Decode(IManagedByteBuffer[] data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
var rBitReader = new BitReader(data[0].GetSpan()); |
|||
var gBitReader = new BitReader(data[1].GetSpan()); |
|||
var bBitReader = new BitReader(data[2].GetSpan()); |
|||
|
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
float r = rBitReader.ReadBits(this.bitsPerSampleR) / this.rFactor; |
|||
float g = gBitReader.ReadBits(this.bitsPerSampleG) / this.gFactor; |
|||
float b = bBitReader.ReadBits(this.bitsPerSampleB) / this.bFactor; |
|||
|
|||
color.FromVector4(new Vector4(r, g, b, 1.0f)); |
|||
pixels[x, y] = color; |
|||
} |
|||
|
|||
rBitReader.NextRow(); |
|||
gBitReader.NextRow(); |
|||
bBitReader.NextRow(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,64 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Utils; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'RGB' photometric interpretation (for all bit depths).
|
|||
/// </summary>
|
|||
internal class RgbTiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
private readonly float rFactor; |
|||
|
|||
private readonly float gFactor; |
|||
|
|||
private readonly float bFactor; |
|||
|
|||
private readonly ushort bitsPerSampleR; |
|||
|
|||
private readonly ushort bitsPerSampleG; |
|||
|
|||
private readonly ushort bitsPerSampleB; |
|||
|
|||
public RgbTiffColor(ushort[] bitsPerSample) |
|||
{ |
|||
this.bitsPerSampleR = bitsPerSample[0]; |
|||
this.bitsPerSampleG = bitsPerSample[1]; |
|||
this.bitsPerSampleB = bitsPerSample[2]; |
|||
|
|||
this.rFactor = (1 << this.bitsPerSampleR) - 1.0f; |
|||
this.gFactor = (1 << this.bitsPerSampleG) - 1.0f; |
|||
this.bFactor = (1 << this.bitsPerSampleB) - 1.0f; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
var bitReader = new BitReader(data); |
|||
|
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
float r = bitReader.ReadBits(this.bitsPerSampleR) / this.rFactor; |
|||
float g = bitReader.ReadBits(this.bitsPerSampleG) / this.gFactor; |
|||
float b = bitReader.ReadBits(this.bitsPerSampleB) / this.bFactor; |
|||
|
|||
color.FromVector4(new Vector4(r, g, b, 1.0f)); |
|||
pixels[x, y] = color; |
|||
} |
|||
|
|||
bitReader.NextRow(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// The base class for photometric interpretation decoders.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
internal abstract class TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <summary>
|
|||
/// Decodes source raw pixel data using the current photometric interpretation.
|
|||
/// </summary>
|
|||
/// <param name="data">The buffer to read image data from.</param>
|
|||
/// <param name="pixels">The image buffer to write pixels to.</param>
|
|||
/// <param name="left">The x-coordinate of the left-hand side of the image block.</param>
|
|||
/// <param name="top">The y-coordinate of the top of the image block.</param>
|
|||
/// <param name="width">The width of the image block.</param>
|
|||
/// <param name="height">The height of the image block.</param>
|
|||
public abstract void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height); |
|||
} |
|||
} |
|||
@ -0,0 +1,94 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
internal static class TiffColorDecoderFactory<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
public static TiffBaseColorDecoder<TPixel> Create(TiffColorType colorType, ushort[] bitsPerSample, ushort[] colorMap) |
|||
{ |
|||
switch (colorType) |
|||
{ |
|||
case TiffColorType.WhiteIsZero: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new WhiteIsZeroTiffColor<TPixel>(bitsPerSample); |
|||
|
|||
case TiffColorType.WhiteIsZero1: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1 && bitsPerSample[0] == 1, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new WhiteIsZero1TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.WhiteIsZero4: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1 && bitsPerSample[0] == 4, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new WhiteIsZero4TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.WhiteIsZero8: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1 && bitsPerSample[0] == 8, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new WhiteIsZero8TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.BlackIsZero: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new BlackIsZeroTiffColor<TPixel>(bitsPerSample); |
|||
|
|||
case TiffColorType.BlackIsZero1: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1 && bitsPerSample[0] == 1, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new BlackIsZero1TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.BlackIsZero4: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1 && bitsPerSample[0] == 4, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new BlackIsZero4TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.BlackIsZero8: |
|||
DebugGuard.IsTrue(bitsPerSample.Length == 1 && bitsPerSample[0] == 8, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new BlackIsZero8TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.Rgb: |
|||
DebugGuard.NotNull(bitsPerSample, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new RgbTiffColor<TPixel>(bitsPerSample); |
|||
|
|||
case TiffColorType.Rgb888: |
|||
DebugGuard.IsTrue( |
|||
bitsPerSample.Length == 3 |
|||
&& bitsPerSample[0] == 8 |
|||
&& bitsPerSample[1] == 8 |
|||
&& bitsPerSample[2] == 8, |
|||
"bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new Rgb888TiffColor<TPixel>(); |
|||
|
|||
case TiffColorType.PaletteColor: |
|||
DebugGuard.NotNull(bitsPerSample, "bitsPerSample"); |
|||
DebugGuard.NotNull(colorMap, "colorMap"); |
|||
return new PaletteTiffColor<TPixel>(bitsPerSample, colorMap); |
|||
|
|||
default: |
|||
throw TiffThrowHelper.InvalidColorType(colorType.ToString()); |
|||
} |
|||
} |
|||
|
|||
public static RgbPlanarTiffColor<TPixel> CreatePlanar(TiffColorType colorType, ushort[] bitsPerSample, ushort[] colorMap) |
|||
{ |
|||
switch (colorType) |
|||
{ |
|||
case TiffColorType.RgbPlanar: |
|||
DebugGuard.NotNull(bitsPerSample, "bitsPerSample"); |
|||
DebugGuard.IsTrue(colorMap == null, "colorMap"); |
|||
return new RgbPlanarTiffColor<TPixel>(bitsPerSample); |
|||
|
|||
default: |
|||
throw TiffThrowHelper.InvalidColorType(colorType.ToString()); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,71 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Provides enumeration of the various TIFF photometric interpretation implementation types.
|
|||
/// </summary>
|
|||
internal enum TiffColorType |
|||
{ |
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as black. The maximum value is imaged as white.
|
|||
/// </summary>
|
|||
BlackIsZero, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as black. The maximum value is imaged as white. Optimized implementation for bilevel images.
|
|||
/// </summary>
|
|||
BlackIsZero1, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as black. The maximum value is imaged as white. Optimized implementation for 4-bit images.
|
|||
/// </summary>
|
|||
BlackIsZero4, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as black. The maximum value is imaged as white. Optimized implementation for 8-bit images.
|
|||
/// </summary>
|
|||
BlackIsZero8, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as white. The maximum value is imaged as black.
|
|||
/// </summary>
|
|||
WhiteIsZero, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as white. The maximum value is imaged as black. Optimized implementation for bilevel images.
|
|||
/// </summary>
|
|||
WhiteIsZero1, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as white. The maximum value is imaged as black. Optimized implementation for 4-bit images.
|
|||
/// </summary>
|
|||
WhiteIsZero4, |
|||
|
|||
/// <summary>
|
|||
/// Grayscale: 0 is imaged as white. The maximum value is imaged as black. Optimized implementation for 8-bit images.
|
|||
/// </summary>
|
|||
WhiteIsZero8, |
|||
|
|||
/// <summary>
|
|||
/// Palette-color.
|
|||
/// </summary>
|
|||
PaletteColor, |
|||
|
|||
/// <summary>
|
|||
/// RGB Full Color.
|
|||
/// </summary>
|
|||
Rgb, |
|||
|
|||
/// <summary>
|
|||
/// RGB Full Color. Optimized implementation for 8-bit images.
|
|||
/// </summary>
|
|||
Rgb888, |
|||
|
|||
/// <summary>
|
|||
/// RGB Full Color. Planar configuration of data.
|
|||
/// </summary>
|
|||
RgbPlanar, |
|||
} |
|||
} |
|||
@ -0,0 +1,45 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'WhiteIsZero' photometric interpretation (optimized for bilevel images).
|
|||
/// </summary>
|
|||
internal class WhiteIsZero1TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
|
|||
Color black = Color.Black; |
|||
Color white = Color.White; |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x += 8) |
|||
{ |
|||
byte b = data[offset++]; |
|||
int maxShift = Math.Min(left + width - x, 8); |
|||
|
|||
for (int shift = 0; shift < maxShift; shift++) |
|||
{ |
|||
int bit = (b >> (7 - shift)) & 1; |
|||
|
|||
color.FromRgba32(bit == 0 ? white : black); |
|||
|
|||
pixels[x + shift, y] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,58 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'WhiteIsZero' photometric interpretation (optimized for 4-bit grayscale images).
|
|||
/// </summary>
|
|||
internal class WhiteIsZero4TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
bool isOddWidth = (width & 1) == 1; |
|||
|
|||
var l8 = default(L8); |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width - 1;) |
|||
{ |
|||
byte byteData = data[offset++]; |
|||
|
|||
byte intensity1 = (byte)((15 - ((byteData & 0xF0) >> 4)) * 17); |
|||
l8.PackedValue = intensity1; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[x++, y] = color; |
|||
|
|||
byte intensity2 = (byte)((15 - (byteData & 0x0F)) * 17); |
|||
l8.PackedValue = intensity2; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[x++, y] = color; |
|||
} |
|||
|
|||
if (isOddWidth) |
|||
{ |
|||
byte byteData = data[offset++]; |
|||
|
|||
byte intensity1 = (byte)((15 - ((byteData & 0xF0) >> 4)) * 17); |
|||
l8.PackedValue = intensity1; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[left + width - 1, y] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'WhiteIsZero' photometric interpretation (optimized for 8-bit grayscale images).
|
|||
/// </summary>
|
|||
internal class WhiteIsZero8TiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
int offset = 0; |
|||
|
|||
var l8 = default(L8); |
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
byte intensity = (byte)(255 - data[offset++]); |
|||
|
|||
l8.PackedValue = intensity; |
|||
color.FromL8(l8); |
|||
|
|||
pixels[x, y] = color; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,50 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Utils; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation |
|||
{ |
|||
/// <summary>
|
|||
/// Implements the 'WhiteIsZero' photometric interpretation (for all bit depths).
|
|||
/// </summary>
|
|||
internal class WhiteIsZeroTiffColor<TPixel> : TiffBaseColorDecoder<TPixel> |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
private readonly ushort bitsPerSample0; |
|||
|
|||
private readonly float factor; |
|||
|
|||
public WhiteIsZeroTiffColor(ushort[] bitsPerSample) |
|||
{ |
|||
this.bitsPerSample0 = bitsPerSample[0]; |
|||
this.factor = (float)Math.Pow(2, this.bitsPerSample0) - 1.0f; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override void Decode(ReadOnlySpan<byte> data, Buffer2D<TPixel> pixels, int left, int top, int width, int height) |
|||
{ |
|||
var color = default(TPixel); |
|||
|
|||
var bitReader = new BitReader(data); |
|||
|
|||
for (int y = top; y < top + height; y++) |
|||
{ |
|||
for (int x = left; x < left + width; x++) |
|||
{ |
|||
int value = bitReader.ReadBits(this.bitsPerSample0); |
|||
float intensity = 1.0f - (value / this.factor); |
|||
|
|||
color.FromVector4(new Vector4(intensity, intensity, intensity, 1.0f)); |
|||
pixels[x, y] = color; |
|||
} |
|||
|
|||
bitReader.NextRow(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,253 @@ |
|||
# ImageSharp TIFF codec |
|||
|
|||
## References |
|||
- TIFF |
|||
- [TIFF 6.0 Specification](http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf),(http://www.npes.org/pdf/TIFF-v6.pdf) |
|||
- [TIFF Supplement 1](http://partners.adobe.com/public/developer/en/tiff/TIFFPM6.pdf) |
|||
- [TIFF Supplement 2](http://partners.adobe.com/public/developer/en/tiff/TIFFphotoshop.pdf) |
|||
- [TIFF Supplement 3](http://chriscox.org/TIFFTN3d1.pdf) |
|||
- [TIFF-F/FX Extension (RFC2301)](http://www.ietf.org/rfc/rfc2301.txt) |
|||
- [TIFF/EP Extension (Wikipedia)](https://en.wikipedia.org/wiki/TIFF/EP) |
|||
- [Adobe TIFF Pages](http://partners.adobe.com/public/developer/tiff/index.html) |
|||
- [Unofficial TIFF FAQ](http://www.awaresystems.be/imaging/tiff/faq.html) |
|||
- [CCITT T.4 Compression](https://www.itu.int/rec/T-REC-T.4-198811-S/_page.print) |
|||
- [CCITT T.6 Compression](https://www.itu.int/rec/T-REC-T.6/en) |
|||
|
|||
- DNG |
|||
- [Adobe DNG Pages](https://helpx.adobe.com/photoshop/digital-negative.html) |
|||
|
|||
- Metadata (EXIF) |
|||
- [EXIF 2.3 Specification](http://www.cipa.jp/std/documents/e/DC-008-2012_E.pdf) |
|||
|
|||
- Metadata (XMP) |
|||
- [Adobe XMP Pages](http://www.adobe.com/products/xmp.html) |
|||
- [Adobe XMP Developer Center](http://www.adobe.com/devnet/xmp.html) |
|||
|
|||
## Implementation Status |
|||
|
|||
- The Decoder and Encoder currently only supports a single frame per image. |
|||
- Some compression formats are not yet supported. See the list below. |
|||
|
|||
### Deviations from the TIFF spec (to be fixed) |
|||
|
|||
- Decoder |
|||
- A Baseline TIFF reader must skip over extra components (e.g. RGB with 4 samples per pixels) |
|||
- NB: Need to handle this for both planar and chunky data |
|||
- If the SampleFormat field is present and not 1 - fail gracefully if you cannot handle this |
|||
- Compression=None should treat 16/32-BitsPerSample for all samples as SHORT/LONG (for byte order and padding rows) |
|||
- Check Planar format data - is this encoded as strips in order RGBRGBRGB or RRRGGGBBB? |
|||
|
|||
### Compression Formats |
|||
|
|||
| |Encoder|Decoder|Comments | |
|||
|---------------------------|:-----:|:-----:|--------------------------| |
|||
|None | Y | Y | | |
|||
|Ccitt1D | Y | Y | | |
|||
|PackBits | Y | Y | | |
|||
|CcittGroup3Fax | Y | Y | | |
|||
|CcittGroup4Fax | | | | |
|||
|Lzw | Y | Y | Based on ImageSharp GIF LZW implementation - this code could be modified to be (i) shared, or (ii) optimised for each case | |
|||
|Old Jpeg | | | We should not even try to support this | |
|||
|Jpeg (Technote 2) | | | | |
|||
|Deflate (Technote 2) | Y | Y | Based on PNG Deflate. | |
|||
|Old Deflate (Technote 2) | | Y | | |
|||
|
|||
### Photometric Interpretation Formats |
|||
|
|||
| |Encoder|Decoder|Comments | |
|||
|---------------------------|:-----:|:-----:|--------------------------| |
|||
|WhiteIsZero | Y | Y | General + 1/4/8-bit optimised implementations | |
|||
|BlackIsZero | Y | Y | General + 1/4/8-bit optimised implementations | |
|||
|Rgb (Chunky) | Y | Y | General + Rgb888 optimised implementation | |
|||
|Rgb (Planar) | | Y | General implementation only | |
|||
|PaletteColor | Y | Y | General implementation only | |
|||
|TransparencyMask | | | | |
|||
|Separated (TIFF Extension) | | | | |
|||
|YCbCr (TIFF Extension) | | | | |
|||
|CieLab (TIFF Extension) | | | | |
|||
|IccLab (TechNote 1) | | | | |
|||
|
|||
### Baseline TIFF Tags |
|||
|
|||
| |Encoder|Decoder|Comments | |
|||
|---------------------------|:-----:|:-----:|--------------------------| |
|||
|NewSubfileType | | | | |
|||
|SubfileType | | | | |
|||
|ImageWidth | Y | Y | | |
|||
|ImageLength | Y | Y | | |
|||
|BitsPerSample | Y | Y | | |
|||
|Compression | Y | Y | | |
|||
|PhotometricInterpretation | Y | Y | | |
|||
|Thresholding | | | | |
|||
|CellWidth | | | | |
|||
|CellLength | | | | |
|||
|FillOrder | | - | Ignore. In practice is very uncommon, and is not recommended. | |
|||
|ImageDescription | Y | Y | | |
|||
|Make | Y | Y | | |
|||
|Model | Y | Y | | |
|||
|StripOffsets | Y | Y | | |
|||
|Orientation | | - | Ignore. Many readers ignore this tag. | |
|||
|SamplesPerPixel | Y | - | Currently ignored, as can be inferred from count of BitsPerSample | |
|||
|RowsPerStrip | Y | Y | | |
|||
|StripByteCounts | Y | Y | | |
|||
|MinSampleValue | | | | |
|||
|MaxSampleValue | | | | |
|||
|XResolution | Y | Y | | |
|||
|YResolution | Y | Y | | |
|||
|PlanarConfiguration | | Y | Encoding support only chunky. | |
|||
|FreeOffsets | | | | |
|||
|FreeByteCounts | | | | |
|||
|GrayResponseUnit | | | | |
|||
|GrayResponseCurve | | | | |
|||
|ResolutionUnit | Y | Y | | |
|||
|Software | Y | Y | | |
|||
|DateTime | Y | Y | | |
|||
|Artist | Y | Y | | |
|||
|HostComputer | Y | Y | | |
|||
|ColorMap | Y | Y | | |
|||
|ExtraSamples | | - | | |
|||
|Copyright | Y | Y | | |
|||
|
|||
### Extension TIFF Tags |
|||
|
|||
| |Encoder|Decoder|Comments | |
|||
|---------------------------|:-----:|:-----:|--------------------------| |
|||
|NewSubfileType | | | | |
|||
|DocumentName | Y | Y | | |
|||
|PageName | | | | |
|||
|XPosition | | | | |
|||
|YPosition | | | | |
|||
|T4Options | | Y | | |
|||
|T6Options | | | | |
|||
|PageNumber | | | | |
|||
|TransferFunction | | | | |
|||
|Predictor | Y | Y | only Horizontal | |
|||
|WhitePoint | | | | |
|||
|PrimaryChromaticities | | | | |
|||
|HalftoneHints | | | | |
|||
|TileWidth | | - | | |
|||
|TileLength | | - | | |
|||
|TileOffsets | | - | | |
|||
|TileByteCounts | | - | | |
|||
|BadFaxLines | | | | |
|||
|CleanFaxData | | | | |
|||
|ConsecutiveBadFaxLines | | | | |
|||
|SubIFDs | | - | | |
|||
|InkSet | | | | |
|||
|InkNames | | | | |
|||
|NumberOfInks | | | | |
|||
|DotRange | | | | |
|||
|TargetPrinter | | | | |
|||
|SampleFormat | | - | | |
|||
|SMinSampleValue | | | | |
|||
|SMaxSampleValue | | | | |
|||
|TransferRange | | | | |
|||
|ClipPath | | | | |
|||
|XClipPathUnits | | | | |
|||
|YClipPathUnits | | | | |
|||
|Indexed | | | | |
|||
|JPEGTables | | | | |
|||
|OPIProxy | | | | |
|||
|GlobalParametersIFD | | | | |
|||
|ProfileType | | | | |
|||
|FaxProfile | | | | |
|||
|CodingMethods | | | | |
|||
|VersionYear | | | | |
|||
|ModeNumber | | | | |
|||
|Decode | | | | |
|||
|DefaultImageColor | | | | |
|||
|JPEGProc | | | | |
|||
|JPEGInterchangeFormat | | | | |
|||
|JPEGInterchangeFormatLength| | | | |
|||
|JPEGRestartInterval | | | | |
|||
|JPEGLosslessPredictors | | | | |
|||
|JPEGPointTransforms | | | | |
|||
|JPEGQTables | | | | |
|||
|JPEGDCTables | | | | |
|||
|JPEGACTables | | | | |
|||
|YCbCrCoefficients | | | | |
|||
|YCbCrSubSampling | | | | |
|||
|YCbCrPositioning | | | | |
|||
|ReferenceBlackWhite | | | | |
|||
|StripRowCounts | - | - | See RFC 2301 (File Format for Internet Fax). | |
|||
|XMP | Y | Y | | |
|||
|ImageID | | | | |
|||
|ImageLayer | | | | |
|||
|
|||
### Private TIFF Tags |
|||
|
|||
| |Encoder|Decoder|Comments | |
|||
|---------------------------|:-----:|:-----:|--------------------------| |
|||
|Wang Annotation | | | | |
|||
|MD FileTag | | | | |
|||
|MD ScalePixel | | | | |
|||
|MD ColorTable | | | | |
|||
|MD LabName | | | | |
|||
|MD SampleInfo | | | | |
|||
|MD PrepDate | | | | |
|||
|MD PrepTime | | | | |
|||
|MD FileUnits | | | | |
|||
|ModelPixelScaleTag | | | | |
|||
|IPTC | Y | Y | | |
|||
|INGR Packet Data Tag | | | | |
|||
|INGR Flag Registers | | | | |
|||
|IrasB Transformation Matrix| | | | |
|||
|ModelTiepointTag | | | | |
|||
|ModelTransformationTag | | | | |
|||
|Photoshop | | | | |
|||
|Exif IFD | | - | 0x8769 SubExif | |
|||
|ICC Profile | Y | Y | | |
|||
|GeoKeyDirectoryTag | | | | |
|||
|GeoDoubleParamsTag | | | | |
|||
|GeoAsciiParamsTag | | | | |
|||
|GPS IFD | | | | |
|||
|HylaFAX FaxRecvParams | | | | |
|||
|HylaFAX FaxSubAddress | | | | |
|||
|HylaFAX FaxRecvTime | | | | |
|||
|ImageSourceData | | | | |
|||
|Interoperability IFD | | | | |
|||
|GDAL_METADATA | | | | |
|||
|GDAL_NODATA | | | | |
|||
|Oce Scanjob Description | | | | |
|||
|Oce Application Selector | | | | |
|||
|Oce Identification Number | | | | |
|||
|Oce ImageLogic Characteristics| | | | |
|||
|DNGVersion | | | | |
|||
|DNGBackwardVersion | | | | |
|||
|UniqueCameraModel | | | | |
|||
|LocalizedCameraModel | | | | |
|||
|CFAPlaneColor | | | | |
|||
|CFALayout | | | | |
|||
|LinearizationTable | | | | |
|||
|BlackLevelRepeatDim | | | | |
|||
|BlackLevel | | | | |
|||
|BlackLevelDeltaH | | | | |
|||
|BlackLevelDeltaV | | | | |
|||
|WhiteLevel | | | | |
|||
|DefaultScale | | | | |
|||
|DefaultCropOrigin | | | | |
|||
|DefaultCropSize | | | | |
|||
|ColorMatrix1 | | | | |
|||
|ColorMatrix2 | | | | |
|||
|CameraCalibration1 | | | | |
|||
|CameraCalibration2 | | | | |
|||
|ReductionMatrix1 | | | | |
|||
|ReductionMatrix2 | | | | |
|||
|AnalogBalance | | | | |
|||
|AsShotNeutral | | | | |
|||
|AsShotWhiteXY | | | | |
|||
|BaselineExposure | | | | |
|||
|BaselineNoise | | | | |
|||
|BaselineSharpness | | | | |
|||
|BayerGreenSplit | | | | |
|||
|LinearResponseLimit | | | | |
|||
|CameraSerialNumber | | | | |
|||
|LensInfo | | | | |
|||
|ChromaBlurRadius | | | | |
|||
|AntiAliasStrength | | | | |
|||
|DNGPrivateData | | | | |
|||
|MakerNoteSafety | | | | |
|||
|CalibrationIlluminant1 | | | | |
|||
|CalibrationIlluminant2 | | | | |
|||
|BestQualityScale | | | | |
|||
|Alias Layer Metadata | | | | |
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,31 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Enumerates the available bits per pixel for the tiff format.
|
|||
/// </summary>
|
|||
public enum TiffBitsPerPixel |
|||
{ |
|||
/// <summary>
|
|||
/// 1 bit per pixel, for bi-color image.
|
|||
/// </summary>
|
|||
Bit1 = 1, |
|||
|
|||
/// <summary>
|
|||
/// 4 bits per pixel, for images with a color palette.
|
|||
/// </summary>
|
|||
Bit4 = 4, |
|||
|
|||
/// <summary>
|
|||
/// 8 bits per pixel, grayscale or color palette images.
|
|||
/// </summary>
|
|||
Bit8 = 8, |
|||
|
|||
/// <summary>
|
|||
/// 24 bits per pixel. One byte for each color channel.
|
|||
/// </summary>
|
|||
Bit24 = 24, |
|||
} |
|||
} |
|||
@ -0,0 +1,36 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// The number of bits per component.
|
|||
/// </summary>
|
|||
public enum TiffBitsPerSample |
|||
{ |
|||
/// <summary>
|
|||
/// The Bits per samples is not known.
|
|||
/// </summary>
|
|||
Unknown = 0, |
|||
|
|||
/// <summary>
|
|||
/// One bit per sample for bicolor images.
|
|||
/// </summary>
|
|||
Bit1 = 1, |
|||
|
|||
/// <summary>
|
|||
/// Four bits per sample for grayscale images with 16 different levels of gray or paletted images with a palette of 16 colors.
|
|||
/// </summary>
|
|||
Bit4 = 4, |
|||
|
|||
/// <summary>
|
|||
/// Eight bits per sample for grayscale images with 256 different levels of gray or paletted images with a palette of 256 colors.
|
|||
/// </summary>
|
|||
Bit8 = 8, |
|||
|
|||
/// <summary>
|
|||
/// 24 bits per sample, each color channel has 8 Bits.
|
|||
/// </summary>
|
|||
Bit24 = 24, |
|||
} |
|||
} |
|||
@ -0,0 +1,75 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
internal static class TiffBitsPerSampleExtensions |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the bits per channel array for a given BitsPerSample value, e,g, for RGB888: [8, 8, 8]
|
|||
/// </summary>
|
|||
/// <param name="tiffBitsPerSample">The tiff bits per sample.</param>
|
|||
/// <returns>Bits per sample array.</returns>
|
|||
public static ushort[] Bits(this TiffBitsPerSample tiffBitsPerSample) |
|||
{ |
|||
switch (tiffBitsPerSample) |
|||
{ |
|||
case TiffBitsPerSample.Bit1: |
|||
return TiffConstants.BitsPerSample1Bit; |
|||
case TiffBitsPerSample.Bit4: |
|||
return TiffConstants.BitsPerSample4Bit; |
|||
case TiffBitsPerSample.Bit8: |
|||
return TiffConstants.BitsPerSample8Bit; |
|||
case TiffBitsPerSample.Bit24: |
|||
return TiffConstants.BitsPerSampleRgb8Bit; |
|||
|
|||
default: |
|||
return Array.Empty<ushort>(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Maps an array of bits per sample to a concrete enum value.
|
|||
/// </summary>
|
|||
/// <param name="bitsPerSample">The bits per sample array.</param>
|
|||
/// <returns>TiffBitsPerSample enum value.</returns>
|
|||
public static TiffBitsPerSample GetBitsPerSample(this ushort[] bitsPerSample) |
|||
{ |
|||
switch (bitsPerSample.Length) |
|||
{ |
|||
case 3: |
|||
if (bitsPerSample[0] == TiffConstants.BitsPerSampleRgb8Bit[0] && |
|||
bitsPerSample[1] == TiffConstants.BitsPerSampleRgb8Bit[1] && |
|||
bitsPerSample[2] == TiffConstants.BitsPerSampleRgb8Bit[2]) |
|||
{ |
|||
return TiffBitsPerSample.Bit24; |
|||
} |
|||
|
|||
break; |
|||
|
|||
case 1: |
|||
if (bitsPerSample[0] == TiffConstants.BitsPerSample1Bit[0]) |
|||
{ |
|||
return TiffBitsPerSample.Bit1; |
|||
} |
|||
|
|||
if (bitsPerSample[0] == TiffConstants.BitsPerSample4Bit[0]) |
|||
{ |
|||
return TiffBitsPerSample.Bit4; |
|||
} |
|||
|
|||
if (bitsPerSample[0] == TiffConstants.BitsPerSample8Bit[0]) |
|||
{ |
|||
return TiffBitsPerSample.Bit8; |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
return TiffBitsPerSample.Unknown; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,19 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Registers the image encoders, decoders and mime type detectors for the TIFF format.
|
|||
/// </summary>
|
|||
public sealed class TiffConfigurationModule : IConfigurationModule |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public void Configure(Configuration configuration) |
|||
{ |
|||
configuration.ImageFormatsManager.SetEncoder(TiffFormat.Instance, new TiffEncoder()); |
|||
configuration.ImageFormatsManager.SetDecoder(TiffFormat.Instance, new TiffDecoder()); |
|||
configuration.ImageFormatsManager.AddImageFormatDetector(new TiffImageFormatDetector()); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,67 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.IO; |
|||
using System.Threading; |
|||
using System.Threading.Tasks; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Image decoder for generating an image out of a TIFF stream.
|
|||
/// </summary>
|
|||
public class TiffDecoder : IImageDecoder, ITiffDecoderOptions, IImageInfoDetector |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
|
|||
/// </summary>
|
|||
public bool IgnoreMetadata { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
Guard.NotNull(stream, "stream"); |
|||
|
|||
var decoder = new TiffDecoderCore(configuration, this); |
|||
return decoder.Decode<TPixel>(configuration, stream); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public Image Decode(Configuration configuration, Stream stream) => this.Decode<Rgba32>(configuration, stream); |
|||
|
|||
/// <inheritdoc/>
|
|||
public Task<Image<TPixel>> DecodeAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
var decoder = new TiffDecoderCore(configuration, this); |
|||
return decoder.DecodeAsync<TPixel>(configuration, stream, cancellationToken); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken) |
|||
=> await this.DecodeAsync<Rgba32>(configuration, stream, cancellationToken) |
|||
.ConfigureAwait(false); |
|||
|
|||
/// <inheritdoc/>
|
|||
public IImageInfo Identify(Configuration configuration, Stream stream) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
var decoder = new TiffDecoderCore(configuration, this); |
|||
return decoder.Identify(configuration, stream); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
var decoder = new TiffDecoderCore(configuration, this); |
|||
return decoder.IdentifyAsync(configuration, stream, cancellationToken); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,339 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using System.Threading; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Compression; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.Metadata; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Performs the tiff decoding operation.
|
|||
/// </summary>
|
|||
internal class TiffDecoderCore : IImageDecoderInternals |
|||
{ |
|||
/// <summary>
|
|||
/// Used for allocating memory during processing operations.
|
|||
/// </summary>
|
|||
private readonly MemoryAllocator memoryAllocator; |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
|
|||
/// </summary>
|
|||
private readonly bool ignoreMetadata; |
|||
|
|||
/// <summary>
|
|||
/// The stream to decode from.
|
|||
/// </summary>
|
|||
private BufferedReadStream inputStream; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffDecoderCore" /> class.
|
|||
/// </summary>
|
|||
/// <param name="configuration">The configuration.</param>
|
|||
/// <param name="options">The decoder options.</param>
|
|||
public TiffDecoderCore(Configuration configuration, ITiffDecoderOptions options) |
|||
{ |
|||
options ??= new TiffDecoder(); |
|||
|
|||
this.Configuration = configuration ?? Configuration.Default; |
|||
this.ignoreMetadata = options.IgnoreMetadata; |
|||
this.memoryAllocator = this.Configuration.MemoryAllocator; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of bits per component of the pixel format used to decode the image.
|
|||
/// </summary>
|
|||
public TiffBitsPerSample BitsPerSample { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the bits per pixel.
|
|||
/// </summary>
|
|||
public int BitsPerPixel { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the lookup table for RGB palette colored images.
|
|||
/// </summary>
|
|||
public ushort[] ColorMap { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the photometric interpretation implementation to use when decoding the image.
|
|||
/// </summary>
|
|||
public TiffColorType ColorType { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the compression used, when the image was encoded.
|
|||
/// </summary>
|
|||
public TiffDecoderCompressionType CompressionType { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the Fax specific compression options.
|
|||
/// </summary>
|
|||
public FaxCompressionOptions FaxCompressionOptions { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the planar configuration type to use when decoding the image.
|
|||
/// </summary>
|
|||
public TiffPlanarConfiguration PlanarConfiguration { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the photometric interpretation.
|
|||
/// </summary>
|
|||
public TiffPhotometricInterpretation PhotometricInterpretation { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the horizontal predictor.
|
|||
/// </summary>
|
|||
public TiffPredictor Predictor { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public Configuration Configuration { get; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public Size Dimensions { get; private set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
this.inputStream = stream; |
|||
var reader = new DirectoryReader(stream); |
|||
|
|||
IEnumerable<ExifProfile> directories = reader.Read(); |
|||
|
|||
var frames = new List<ImageFrame<TPixel>>(); |
|||
foreach (ExifProfile ifd in directories) |
|||
{ |
|||
ImageFrame<TPixel> frame = this.DecodeFrame<TPixel>(ifd); |
|||
frames.Add(frame); |
|||
} |
|||
|
|||
ImageMetadata metadata = TiffDecoderMetadataCreator.Create(frames, this.ignoreMetadata, reader.ByteOrder); |
|||
|
|||
// TODO: Tiff frames can have different sizes
|
|||
ImageFrame<TPixel> root = frames[0]; |
|||
this.Dimensions = root.Size(); |
|||
foreach (ImageFrame<TPixel> frame in frames) |
|||
{ |
|||
if (frame.Size() != root.Size()) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("Images with different sizes are not supported"); |
|||
} |
|||
} |
|||
|
|||
return new Image<TPixel>(this.Configuration, metadata, frames); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken) |
|||
{ |
|||
this.inputStream = stream; |
|||
var reader = new DirectoryReader(stream); |
|||
IEnumerable<ExifProfile> directories = reader.Read(); |
|||
|
|||
ExifProfile rootFrameExifProfile = directories.First(); |
|||
var rootMetadata = TiffFrameMetadata.Parse(rootFrameExifProfile); |
|||
|
|||
ImageMetadata metadata = TiffDecoderMetadataCreator.Create(reader.ByteOrder, rootFrameExifProfile); |
|||
int width = GetImageWidth(rootFrameExifProfile); |
|||
int height = GetImageHeight(rootFrameExifProfile); |
|||
|
|||
return new ImageInfo(new PixelTypeInfo((int)rootMetadata.BitsPerPixel), width, height, metadata); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the image data from a specified IFD.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="tags">The IFD tags.</param>
|
|||
/// <returns>
|
|||
/// The tiff frame.
|
|||
/// </returns>
|
|||
private ImageFrame<TPixel> DecodeFrame<TPixel>(ExifProfile tags) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
ImageFrameMetadata imageFrameMetaData = this.ignoreMetadata ? |
|||
new ImageFrameMetadata() : |
|||
new ImageFrameMetadata { ExifProfile = tags, XmpProfile = tags.GetValue(ExifTag.XMP)?.Value }; |
|||
|
|||
TiffFrameMetadata tiffFrameMetaData = imageFrameMetaData.GetTiffMetadata(); |
|||
TiffFrameMetadata.Parse(tiffFrameMetaData, tags); |
|||
|
|||
this.VerifyAndParse(tags, tiffFrameMetaData); |
|||
|
|||
int width = GetImageWidth(tags); |
|||
int height = GetImageHeight(tags); |
|||
var frame = new ImageFrame<TPixel>(this.Configuration, width, height, imageFrameMetaData); |
|||
|
|||
int rowsPerStrip = tags.GetValue(ExifTag.RowsPerStrip) != null ? (int)tags.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity; |
|||
Number[] stripOffsets = tags.GetValue(ExifTag.StripOffsets)?.Value; |
|||
Number[] stripByteCounts = tags.GetValue(ExifTag.StripByteCounts)?.Value; |
|||
|
|||
if (this.PlanarConfiguration == TiffPlanarConfiguration.Planar) |
|||
{ |
|||
this.DecodeStripsPlanar(frame, rowsPerStrip, stripOffsets, stripByteCounts); |
|||
} |
|||
else |
|||
{ |
|||
this.DecodeStripsChunky(frame, rowsPerStrip, stripOffsets, stripByteCounts); |
|||
} |
|||
|
|||
return frame; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates the size (in bytes) for a pixel buffer using the determined color format.
|
|||
/// </summary>
|
|||
/// <param name="width">The width for the desired pixel buffer.</param>
|
|||
/// <param name="height">The height for the desired pixel buffer.</param>
|
|||
/// <param name="plane">The index of the plane for planar image configuration (or zero for chunky).</param>
|
|||
/// <returns>The size (in bytes) of the required pixel buffer.</returns>
|
|||
private int CalculateStripBufferSize(int width, int height, int plane = -1) |
|||
{ |
|||
int bitsPerPixel; |
|||
|
|||
if (this.PlanarConfiguration == TiffPlanarConfiguration.Chunky) |
|||
{ |
|||
DebugGuard.IsTrue(plane == -1, "Expected Chunky planar."); |
|||
bitsPerPixel = this.BitsPerPixel; |
|||
} |
|||
else |
|||
{ |
|||
bitsPerPixel = this.BitsPerSample.Bits()[plane]; |
|||
} |
|||
|
|||
int bytesPerRow = ((width * bitsPerPixel) + 7) / 8; |
|||
return bytesPerRow * height; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the image data for strip encoded data.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="frame">The image frame to decode data into.</param>
|
|||
/// <param name="rowsPerStrip">The number of rows per strip of data.</param>
|
|||
/// <param name="stripOffsets">An array of byte offsets to each strip in the image.</param>
|
|||
/// <param name="stripByteCounts">An array of the size of each strip (in bytes).</param>
|
|||
private void DecodeStripsPlanar<TPixel>(ImageFrame<TPixel> frame, int rowsPerStrip, Number[] stripOffsets, Number[] stripByteCounts) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
int stripsPerPixel = this.BitsPerSample.Bits().Length; |
|||
int stripsPerPlane = stripOffsets.Length / stripsPerPixel; |
|||
int bitsPerPixel = this.BitsPerPixel; |
|||
|
|||
Buffer2D<TPixel> pixels = frame.PixelBuffer; |
|||
|
|||
var stripBuffers = new IManagedByteBuffer[stripsPerPixel]; |
|||
|
|||
try |
|||
{ |
|||
for (int stripIndex = 0; stripIndex < stripBuffers.Length; stripIndex++) |
|||
{ |
|||
int uncompressedStripSize = this.CalculateStripBufferSize(frame.Width, rowsPerStrip, stripIndex); |
|||
stripBuffers[stripIndex] = this.memoryAllocator.AllocateManagedByteBuffer(uncompressedStripSize); |
|||
} |
|||
|
|||
using TiffBaseDecompressor decompressor = TiffDecompressorsFactory.Create(this.CompressionType, this.memoryAllocator, this.PhotometricInterpretation, frame.Width, bitsPerPixel, this.Predictor, this.FaxCompressionOptions); |
|||
|
|||
RgbPlanarTiffColor<TPixel> colorDecoder = TiffColorDecoderFactory<TPixel>.CreatePlanar(this.ColorType, this.BitsPerSample.Bits(), this.ColorMap); |
|||
|
|||
for (int i = 0; i < stripsPerPlane; i++) |
|||
{ |
|||
int stripHeight = i < stripsPerPlane - 1 || frame.Height % rowsPerStrip == 0 ? rowsPerStrip : frame.Height % rowsPerStrip; |
|||
|
|||
for (int planeIndex = 0; planeIndex < stripsPerPixel; planeIndex++) |
|||
{ |
|||
int stripIndex = (i * stripsPerPixel) + planeIndex; |
|||
|
|||
decompressor.Decompress(this.inputStream, (uint)stripOffsets[stripIndex], (uint)stripByteCounts[stripIndex], stripBuffers[planeIndex].GetSpan()); |
|||
} |
|||
|
|||
colorDecoder.Decode(stripBuffers, pixels, 0, rowsPerStrip * i, frame.Width, stripHeight); |
|||
} |
|||
} |
|||
finally |
|||
{ |
|||
foreach (IManagedByteBuffer buf in stripBuffers) |
|||
{ |
|||
buf?.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void DecodeStripsChunky<TPixel>(ImageFrame<TPixel> frame, int rowsPerStrip, Number[] stripOffsets, Number[] stripByteCounts) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
// If the rowsPerStrip has the default value, which is effectively infinity. That is, the entire image is one strip.
|
|||
if (rowsPerStrip == TiffConstants.RowsPerStripInfinity) |
|||
{ |
|||
rowsPerStrip = frame.Height; |
|||
} |
|||
|
|||
int uncompressedStripSize = this.CalculateStripBufferSize(frame.Width, rowsPerStrip); |
|||
int bitsPerPixel = this.BitsPerPixel; |
|||
|
|||
using IManagedByteBuffer stripBuffer = this.memoryAllocator.AllocateManagedByteBuffer(uncompressedStripSize, AllocationOptions.Clean); |
|||
|
|||
Buffer2D<TPixel> pixels = frame.PixelBuffer; |
|||
|
|||
using TiffBaseDecompressor decompressor = TiffDecompressorsFactory.Create(this.CompressionType, this.memoryAllocator, this.PhotometricInterpretation, frame.Width, bitsPerPixel, this.Predictor, this.FaxCompressionOptions); |
|||
|
|||
TiffBaseColorDecoder<TPixel> colorDecoder = TiffColorDecoderFactory<TPixel>.Create(this.ColorType, this.BitsPerSample.Bits(), this.ColorMap); |
|||
|
|||
for (int stripIndex = 0; stripIndex < stripOffsets.Length; stripIndex++) |
|||
{ |
|||
int stripHeight = stripIndex < stripOffsets.Length - 1 || frame.Height % rowsPerStrip == 0 ? rowsPerStrip : frame.Height % rowsPerStrip; |
|||
int top = rowsPerStrip * stripIndex; |
|||
if (top + stripHeight > frame.Height) |
|||
{ |
|||
// Make sure we ignore any strips that are not needed for the image (if too many are present)
|
|||
break; |
|||
} |
|||
|
|||
decompressor.Decompress(this.inputStream, (uint)stripOffsets[stripIndex], (uint)stripByteCounts[stripIndex], stripBuffer.GetSpan()); |
|||
|
|||
colorDecoder.Decode(stripBuffer.GetSpan(), pixels, 0, top, frame.Width, stripHeight); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the width of the image frame.
|
|||
/// </summary>
|
|||
/// <param name="exifProfile">The image frame exif profile.</param>
|
|||
/// <returns>The image width.</returns>
|
|||
private static int GetImageWidth(ExifProfile exifProfile) |
|||
{ |
|||
IExifValue<Number> width = exifProfile.GetValue(ExifTag.ImageWidth); |
|||
if (width == null) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("The TIFF image frame is missing the ImageWidth"); |
|||
} |
|||
|
|||
return (int)width.Value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the height of the image frame.
|
|||
/// </summary>
|
|||
/// <param name="exifProfile">The image frame exif profile.</param>
|
|||
/// <returns>The image height.</returns>
|
|||
private static int GetImageHeight(ExifProfile exifProfile) |
|||
{ |
|||
IExifValue<Number> height = exifProfile.GetValue(ExifTag.ImageLength); |
|||
if (height == null) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("The TIFF image frame is missing the ImageLength"); |
|||
} |
|||
|
|||
return (int)height.Value; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,133 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Linq; |
|||
using SixLabors.ImageSharp.Common.Helpers; |
|||
using SixLabors.ImageSharp.Metadata; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Icc; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Iptc; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// The decoder metadata creator.
|
|||
/// </summary>
|
|||
internal static class TiffDecoderMetadataCreator |
|||
{ |
|||
public static ImageMetadata Create<TPixel>(List<ImageFrame<TPixel>> frames, bool ignoreMetadata, ByteOrder byteOrder) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
if (frames.Count < 1) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("Expected at least one frame."); |
|||
} |
|||
|
|||
var imageMetaData = new ImageMetadata(); |
|||
ExifProfile exifProfileRootFrame = frames[0].Metadata.ExifProfile; |
|||
|
|||
SetResolution(imageMetaData, exifProfileRootFrame); |
|||
|
|||
TiffMetadata tiffMetadata = imageMetaData.GetTiffMetadata(); |
|||
tiffMetadata.ByteOrder = byteOrder; |
|||
|
|||
if (!ignoreMetadata) |
|||
{ |
|||
for (int i = 0; i < frames.Count; i++) |
|||
{ |
|||
ImageFrame<TPixel> frame = frames[i]; |
|||
ImageFrameMetadata frameMetaData = frame.Metadata; |
|||
if (TryGetIptc(frameMetaData.ExifProfile.Values, out byte[] iptcBytes)) |
|||
{ |
|||
frameMetaData.IptcProfile = new IptcProfile(iptcBytes); |
|||
} |
|||
|
|||
IExifValue<byte[]> iccProfileBytes = frameMetaData.ExifProfile.GetValue(ExifTag.IccProfile); |
|||
if (iccProfileBytes != null) |
|||
{ |
|||
frameMetaData.IccProfile = new IccProfile(iccProfileBytes.Value); |
|||
} |
|||
} |
|||
} |
|||
|
|||
return imageMetaData; |
|||
} |
|||
|
|||
public static ImageMetadata Create(ByteOrder byteOrder, ExifProfile exifProfile) |
|||
{ |
|||
var imageMetaData = new ImageMetadata(); |
|||
SetResolution(imageMetaData, exifProfile); |
|||
|
|||
TiffMetadata tiffMetadata = imageMetaData.GetTiffMetadata(); |
|||
tiffMetadata.ByteOrder = byteOrder; |
|||
|
|||
return imageMetaData; |
|||
} |
|||
|
|||
private static void SetResolution(ImageMetadata imageMetaData, ExifProfile exifProfile) |
|||
{ |
|||
imageMetaData.ResolutionUnits = exifProfile != null ? UnitConverter.ExifProfileToResolutionUnit(exifProfile) : PixelResolutionUnit.PixelsPerInch; |
|||
double? horizontalResolution = exifProfile?.GetValue(ExifTag.XResolution)?.Value.ToDouble(); |
|||
if (horizontalResolution != null) |
|||
{ |
|||
imageMetaData.HorizontalResolution = horizontalResolution.Value; |
|||
} |
|||
|
|||
double? verticalResolution = exifProfile?.GetValue(ExifTag.YResolution)?.Value.ToDouble(); |
|||
if (verticalResolution != null) |
|||
{ |
|||
imageMetaData.VerticalResolution = verticalResolution.Value; |
|||
} |
|||
} |
|||
|
|||
private static bool TryGetIptc(IReadOnlyList<IExifValue> exifValues, out byte[] iptcBytes) |
|||
{ |
|||
iptcBytes = null; |
|||
IExifValue iptc = exifValues.FirstOrDefault(f => f.Tag == ExifTag.IPTC); |
|||
|
|||
if (iptc != null) |
|||
{ |
|||
if (iptc.DataType == ExifDataType.Byte || iptc.DataType == ExifDataType.Undefined) |
|||
{ |
|||
iptcBytes = (byte[])iptc.GetValue(); |
|||
return true; |
|||
} |
|||
|
|||
// Some Encoders write the data type of IPTC as long.
|
|||
if (iptc.DataType == ExifDataType.Long) |
|||
{ |
|||
uint[] iptcValues = (uint[])iptc.GetValue(); |
|||
iptcBytes = new byte[iptcValues.Length * 4]; |
|||
Buffer.BlockCopy(iptcValues, 0, iptcBytes, 0, iptcValues.Length * 4); |
|||
if (iptcBytes[0] == 0x1c) |
|||
{ |
|||
return true; |
|||
} |
|||
else if (iptcBytes[3] != 0x1c) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
// Probably wrong endianess, swap byte order.
|
|||
Span<byte> iptcBytesSpan = iptcBytes.AsSpan(); |
|||
Span<byte> buffer = stackalloc byte[4]; |
|||
for (int i = 0; i < iptcBytes.Length; i += 4) |
|||
{ |
|||
iptcBytesSpan.Slice(i, 4).CopyTo(buffer); |
|||
iptcBytes[i] = buffer[3]; |
|||
iptcBytes[i + 1] = buffer[2]; |
|||
iptcBytes[i + 2] = buffer[1]; |
|||
iptcBytes[i + 3] = buffer[0]; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,281 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Linq; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Compression; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Formats.Tiff.PhotometricInterpretation; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// The decoder options parser.
|
|||
/// </summary>
|
|||
internal static class TiffDecoderOptionsParser |
|||
{ |
|||
private const TiffPlanarConfiguration DefaultPlanarConfiguration = TiffPlanarConfiguration.Chunky; |
|||
|
|||
/// <summary>
|
|||
/// Determines the TIFF compression and color types, and reads any associated parameters.
|
|||
/// </summary>
|
|||
/// <param name="options">The options.</param>
|
|||
/// <param name="exifProfile">The exif profile of the frame to decode.</param>
|
|||
/// <param name="frameMetadata">The IFD entries container to read the image format information for current frame.</param>
|
|||
public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata frameMetadata) |
|||
{ |
|||
if (exifProfile.GetValue(ExifTag.TileOffsets)?.Value != null) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("Tiled images are not supported."); |
|||
} |
|||
|
|||
if (exifProfile.GetValue(ExifTag.ExtraSamples)?.Value != null) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("ExtraSamples is not supported."); |
|||
} |
|||
|
|||
TiffFillOrder fillOrder = (TiffFillOrder?)exifProfile.GetValue(ExifTag.FillOrder)?.Value ?? TiffFillOrder.MostSignificantBitFirst; |
|||
if (fillOrder != TiffFillOrder.MostSignificantBitFirst) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The lower-order bits of the byte FillOrder is not supported."); |
|||
} |
|||
|
|||
if (frameMetadata.Predictor == TiffPredictor.FloatingPoint) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("TIFF images with FloatingPoint horizontal predictor are not supported."); |
|||
} |
|||
|
|||
TiffSampleFormat[] sampleFormat = exifProfile.GetValue(ExifTag.SampleFormat)?.Value?.Select(a => (TiffSampleFormat)a).ToArray(); |
|||
if (sampleFormat != null) |
|||
{ |
|||
foreach (TiffSampleFormat format in sampleFormat) |
|||
{ |
|||
if (format != TiffSampleFormat.UnsignedInteger) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("ImageSharp only supports the UnsignedInteger SampleFormat."); |
|||
} |
|||
} |
|||
} |
|||
|
|||
if (exifProfile.GetValue(ExifTag.StripRowCounts)?.Value != null) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("Variable-sized strips are not supported."); |
|||
} |
|||
|
|||
VerifyRequiredFieldsArePresent(exifProfile, frameMetadata); |
|||
|
|||
options.PlanarConfiguration = (TiffPlanarConfiguration?)exifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value ?? DefaultPlanarConfiguration; |
|||
options.Predictor = frameMetadata.Predictor ?? TiffPredictor.None; |
|||
options.PhotometricInterpretation = frameMetadata.PhotometricInterpretation ?? TiffPhotometricInterpretation.Rgb; |
|||
options.BitsPerPixel = frameMetadata.BitsPerPixel != null ? (int)frameMetadata.BitsPerPixel.Value : (int)TiffBitsPerPixel.Bit24; |
|||
options.BitsPerSample = GetBitsPerSample(frameMetadata.BitsPerPixel); |
|||
|
|||
options.ParseColorType(exifProfile); |
|||
options.ParseCompression(frameMetadata.Compression, exifProfile); |
|||
} |
|||
|
|||
private static void VerifyRequiredFieldsArePresent(ExifProfile exifProfile, TiffFrameMetadata frameMetadata) |
|||
{ |
|||
if (exifProfile.GetValue(ExifTag.StripOffsets) == null) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("StripOffsets are missing and are required for decoding the TIFF image!"); |
|||
} |
|||
|
|||
if (exifProfile.GetValue(ExifTag.StripByteCounts) == null) |
|||
{ |
|||
TiffThrowHelper.ThrowImageFormatException("StripByteCounts are missing and are required for decoding the TIFF image!"); |
|||
} |
|||
|
|||
if (frameMetadata.BitsPerPixel == null) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The TIFF BitsPerSample entry is missing which is required to decode the image!"); |
|||
} |
|||
} |
|||
|
|||
private static void ParseColorType(this TiffDecoderCore options, ExifProfile exifProfile) |
|||
{ |
|||
switch (options.PhotometricInterpretation) |
|||
{ |
|||
case TiffPhotometricInterpretation.WhiteIsZero: |
|||
{ |
|||
if (options.BitsPerSample.Bits().Length != 1) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The number of samples in the TIFF BitsPerSample entry is not supported."); |
|||
} |
|||
|
|||
switch (options.BitsPerSample) |
|||
{ |
|||
case TiffBitsPerSample.Bit8: |
|||
{ |
|||
options.ColorType = TiffColorType.WhiteIsZero8; |
|||
break; |
|||
} |
|||
|
|||
case TiffBitsPerSample.Bit4: |
|||
{ |
|||
options.ColorType = TiffColorType.WhiteIsZero4; |
|||
break; |
|||
} |
|||
|
|||
case TiffBitsPerSample.Bit1: |
|||
{ |
|||
options.ColorType = TiffColorType.WhiteIsZero1; |
|||
break; |
|||
} |
|||
|
|||
default: |
|||
{ |
|||
options.ColorType = TiffColorType.WhiteIsZero; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
case TiffPhotometricInterpretation.BlackIsZero: |
|||
{ |
|||
if (options.BitsPerSample.Bits().Length != 1) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The number of samples in the TIFF BitsPerSample entry is not supported."); |
|||
} |
|||
|
|||
switch (options.BitsPerSample) |
|||
{ |
|||
case TiffBitsPerSample.Bit8: |
|||
{ |
|||
options.ColorType = TiffColorType.BlackIsZero8; |
|||
break; |
|||
} |
|||
|
|||
case TiffBitsPerSample.Bit4: |
|||
{ |
|||
options.ColorType = TiffColorType.BlackIsZero4; |
|||
break; |
|||
} |
|||
|
|||
case TiffBitsPerSample.Bit1: |
|||
{ |
|||
options.ColorType = TiffColorType.BlackIsZero1; |
|||
break; |
|||
} |
|||
|
|||
default: |
|||
{ |
|||
options.ColorType = TiffColorType.BlackIsZero; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
case TiffPhotometricInterpretation.Rgb: |
|||
{ |
|||
if (options.BitsPerSample.Bits().Length != 3) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The number of samples in the TIFF BitsPerSample entry is not supported."); |
|||
} |
|||
|
|||
if (options.PlanarConfiguration == TiffPlanarConfiguration.Chunky) |
|||
{ |
|||
options.ColorType = options.BitsPerSample == TiffBitsPerSample.Bit24 ? TiffColorType.Rgb888 : TiffColorType.Rgb; |
|||
} |
|||
else |
|||
{ |
|||
options.ColorType = TiffColorType.RgbPlanar; |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
case TiffPhotometricInterpretation.PaletteColor: |
|||
{ |
|||
options.ColorMap = exifProfile.GetValue(ExifTag.ColorMap)?.Value; |
|||
if (options.ColorMap != null) |
|||
{ |
|||
if (options.BitsPerSample.Bits().Length != 1) |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The number of samples in the TIFF BitsPerSample entry is not supported."); |
|||
} |
|||
|
|||
options.ColorType = TiffColorType.PaletteColor; |
|||
} |
|||
else |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported("The TIFF ColorMap entry is missing for a palette color image."); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
default: |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported($"The specified TIFF photometric interpretation is not supported: {options.PhotometricInterpretation}"); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
private static void ParseCompression(this TiffDecoderCore options, TiffCompression? compression, ExifProfile exifProfile) |
|||
{ |
|||
switch (compression) |
|||
{ |
|||
case TiffCompression.None: |
|||
{ |
|||
options.CompressionType = TiffDecoderCompressionType.None; |
|||
break; |
|||
} |
|||
|
|||
case TiffCompression.PackBits: |
|||
{ |
|||
options.CompressionType = TiffDecoderCompressionType.PackBits; |
|||
break; |
|||
} |
|||
|
|||
case TiffCompression.Deflate: |
|||
case TiffCompression.OldDeflate: |
|||
{ |
|||
options.CompressionType = TiffDecoderCompressionType.Deflate; |
|||
break; |
|||
} |
|||
|
|||
case TiffCompression.Lzw: |
|||
{ |
|||
options.CompressionType = TiffDecoderCompressionType.Lzw; |
|||
break; |
|||
} |
|||
|
|||
case TiffCompression.CcittGroup3Fax: |
|||
{ |
|||
options.CompressionType = TiffDecoderCompressionType.T4; |
|||
options.FaxCompressionOptions = exifProfile.GetValue(ExifTag.T4Options) != null ? (FaxCompressionOptions)exifProfile.GetValue(ExifTag.T4Options).Value : FaxCompressionOptions.None; |
|||
|
|||
break; |
|||
} |
|||
|
|||
case TiffCompression.Ccitt1D: |
|||
{ |
|||
options.CompressionType = TiffDecoderCompressionType.HuffmanRle; |
|||
break; |
|||
} |
|||
|
|||
default: |
|||
{ |
|||
TiffThrowHelper.ThrowNotSupported($"The specified TIFF compression format {compression} is not supported"); |
|||
break; |
|||
} |
|||
} |
|||
} |
|||
|
|||
private static TiffBitsPerSample GetBitsPerSample(TiffBitsPerPixel? bitsPerPixel) => bitsPerPixel switch |
|||
{ |
|||
TiffBitsPerPixel.Bit1 => TiffBitsPerSample.Bit1, |
|||
TiffBitsPerPixel.Bit4 => TiffBitsPerSample.Bit4, |
|||
TiffBitsPerPixel.Bit8 => TiffBitsPerSample.Bit8, |
|||
TiffBitsPerPixel.Bit24 => TiffBitsPerSample.Bit24, |
|||
_ => TiffBitsPerSample.Bit24, |
|||
}; |
|||
} |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.IO; |
|||
using System.Threading; |
|||
using System.Threading.Tasks; |
|||
|
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.Compression.Zlib; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using SixLabors.ImageSharp.Processing.Processors.Quantization; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Encoder for writing the data image to a stream in TIFF format.
|
|||
/// </summary>
|
|||
public class TiffEncoder : IImageEncoder, ITiffEncoderOptions |
|||
{ |
|||
/// <inheritdoc/>
|
|||
public TiffBitsPerPixel? BitsPerPixel { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public TiffCompression? Compression { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public DeflateCompressionLevel? CompressionLevel { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public TiffPhotometricInterpretation? PhotometricInterpretation { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public TiffPredictor? HorizontalPredictor { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public IQuantizer Quantizer { get; set; } |
|||
|
|||
/// <inheritdoc/>
|
|||
public void Encode<TPixel>(Image<TPixel> image, Stream stream) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
var encode = new TiffEncoderCore(this, image.GetMemoryAllocator()); |
|||
encode.Encode(image, stream); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public Task EncodeAsync<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
var encoder = new TiffEncoderCore(this, image.GetMemoryAllocator()); |
|||
return encoder.EncodeAsync(image, stream, cancellationToken); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,381 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
using System.Threading; |
|||
|
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.Compression.Zlib; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Compression; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Writers; |
|||
using SixLabors.ImageSharp.Memory; |
|||
using SixLabors.ImageSharp.Metadata; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using SixLabors.ImageSharp.Processing; |
|||
using SixLabors.ImageSharp.Processing.Processors.Quantization; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Performs the TIFF encoding operation.
|
|||
/// </summary>
|
|||
internal sealed class TiffEncoderCore : IImageEncoderInternals |
|||
{ |
|||
private static readonly ushort ByteOrderMarker = BitConverter.IsLittleEndian |
|||
? TiffConstants.ByteOrderLittleEndianShort |
|||
: TiffConstants.ByteOrderBigEndianShort; |
|||
|
|||
/// <summary>
|
|||
/// Used for allocating memory during processing operations.
|
|||
/// </summary>
|
|||
private readonly MemoryAllocator memoryAllocator; |
|||
|
|||
/// <summary>
|
|||
/// A scratch buffer to reduce allocations.
|
|||
/// </summary>
|
|||
private readonly byte[] buffer = new byte[4]; |
|||
|
|||
/// <summary>
|
|||
/// The global configuration.
|
|||
/// </summary>
|
|||
private Configuration configuration; |
|||
|
|||
/// <summary>
|
|||
/// The quantizer for creating color palette image.
|
|||
/// </summary>
|
|||
private readonly IQuantizer quantizer; |
|||
|
|||
/// <summary>
|
|||
/// Sets the deflate compression level.
|
|||
/// </summary>
|
|||
private readonly DeflateCompressionLevel compressionLevel; |
|||
|
|||
/// <summary>
|
|||
/// The default predictor is None.
|
|||
/// </summary>
|
|||
private const TiffPredictor DefaultPredictor = TiffPredictor.None; |
|||
|
|||
/// <summary>
|
|||
/// The default bits per pixel is Bit24.
|
|||
/// </summary>
|
|||
private const TiffBitsPerPixel DefaultBitsPerPixel = TiffBitsPerPixel.Bit24; |
|||
|
|||
/// <summary>
|
|||
/// The default compression is None.
|
|||
/// </summary>
|
|||
private const TiffCompression DefaultCompression = TiffCompression.None; |
|||
|
|||
/// <summary>
|
|||
/// The default photometric interpretation is Rgb.
|
|||
/// </summary>
|
|||
private const TiffPhotometricInterpretation DefaultPhotometricInterpretation = TiffPhotometricInterpretation.Rgb; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffEncoderCore"/> class.
|
|||
/// </summary>
|
|||
/// <param name="options">The options for the encoder.</param>
|
|||
/// <param name="memoryAllocator">The memory allocator.</param>
|
|||
public TiffEncoderCore(ITiffEncoderOptions options, MemoryAllocator memoryAllocator) |
|||
{ |
|||
this.memoryAllocator = memoryAllocator; |
|||
this.PhotometricInterpretation = options.PhotometricInterpretation; |
|||
this.quantizer = options.Quantizer ?? KnownQuantizers.Octree; |
|||
this.BitsPerPixel = options.BitsPerPixel; |
|||
this.HorizontalPredictor = options.HorizontalPredictor; |
|||
this.CompressionType = options.Compression; |
|||
this.compressionLevel = options.CompressionLevel ?? DeflateCompressionLevel.DefaultCompression; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the photometric interpretation implementation to use when encoding the image.
|
|||
/// </summary>
|
|||
internal TiffPhotometricInterpretation? PhotometricInterpretation { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the compression implementation to use when encoding the image.
|
|||
/// </summary>
|
|||
internal TiffCompression? CompressionType { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a value indicating which horizontal predictor to use. This can improve the compression ratio with deflate compression.
|
|||
/// </summary>
|
|||
internal TiffPredictor? HorizontalPredictor { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the bits per pixel.
|
|||
/// </summary>
|
|||
internal TiffBitsPerPixel? BitsPerPixel { get; private set; } |
|||
|
|||
/// <summary>
|
|||
/// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
|
|||
/// <param name="stream">The <see cref="Stream"/> to encode the image data to.</param>
|
|||
/// <param name="cancellationToken">The token to request cancellation.</param>
|
|||
public void Encode<TPixel>(Image<TPixel> image, Stream stream, CancellationToken cancellationToken) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
Guard.NotNull(image, nameof(image)); |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
|
|||
this.configuration = image.GetConfiguration(); |
|||
|
|||
ImageFrameMetadata rootFrameMetaData = image.Frames.RootFrame.Metadata; |
|||
TiffFrameMetadata rootFrameTiffMetaData = rootFrameMetaData.GetTiffMetadata(); |
|||
|
|||
// Determine the correct values to encode with.
|
|||
// EncoderOptions > Metadata > Default.
|
|||
TiffBitsPerPixel? bitsPerPixel = this.BitsPerPixel ?? rootFrameTiffMetaData.BitsPerPixel; |
|||
|
|||
TiffPhotometricInterpretation? photometricInterpretation = this.PhotometricInterpretation ?? rootFrameTiffMetaData.PhotometricInterpretation; |
|||
|
|||
TiffPredictor predictor = |
|||
this.HorizontalPredictor |
|||
?? rootFrameTiffMetaData.Predictor |
|||
?? DefaultPredictor; |
|||
|
|||
TiffCompression compression = |
|||
this.CompressionType |
|||
?? rootFrameTiffMetaData.Compression |
|||
?? DefaultCompression; |
|||
|
|||
// Make sure, the Encoder options makes sense in combination with each other.
|
|||
this.SanitizeAndSetEncoderOptions(bitsPerPixel, image.PixelType.BitsPerPixel, photometricInterpretation, compression, predictor); |
|||
|
|||
using (var writer = new TiffStreamWriter(stream)) |
|||
{ |
|||
long firstIfdMarker = this.WriteHeader(writer); |
|||
|
|||
// TODO: multiframing is not supported
|
|||
this.WriteImage(writer, image, firstIfdMarker); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes the TIFF file header.
|
|||
/// </summary>
|
|||
/// <param name="writer">The <see cref="TiffStreamWriter" /> to write data to.</param>
|
|||
/// <returns>
|
|||
/// The marker to write the first IFD offset.
|
|||
/// </returns>
|
|||
public long WriteHeader(TiffStreamWriter writer) |
|||
{ |
|||
writer.Write(ByteOrderMarker); |
|||
writer.Write(TiffConstants.HeaderMagicNumber); |
|||
return writer.PlaceMarker(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes all data required to define an image.
|
|||
/// </summary>
|
|||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|||
/// <param name="writer">The <see cref="BinaryWriter"/> to write data to.</param>
|
|||
/// <param name="image">The <see cref="Image{TPixel}"/> to encode from.</param>
|
|||
/// <param name="ifdOffset">The marker to write this IFD offset.</param>
|
|||
private void WriteImage<TPixel>(TiffStreamWriter writer, Image<TPixel> image, long ifdOffset) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
var entriesCollector = new TiffEncoderEntriesCollector(); |
|||
|
|||
using TiffBaseCompressor compressor = TiffCompressorFactory.Create( |
|||
this.CompressionType ?? TiffCompression.None, |
|||
writer.BaseStream, |
|||
this.memoryAllocator, |
|||
image.Width, |
|||
(int)this.BitsPerPixel, |
|||
this.compressionLevel, |
|||
this.HorizontalPredictor == TiffPredictor.Horizontal ? this.HorizontalPredictor.Value : TiffPredictor.None); |
|||
|
|||
using TiffBaseColorWriter<TPixel> colorWriter = TiffColorWriterFactory.Create( |
|||
this.PhotometricInterpretation, |
|||
image.Frames.RootFrame, |
|||
this.quantizer, |
|||
this.memoryAllocator, |
|||
this.configuration, |
|||
entriesCollector, |
|||
(int)this.BitsPerPixel); |
|||
|
|||
int rowsPerStrip = this.CalcRowsPerStrip(image.Frames.RootFrame.Height, colorWriter.BytesPerRow); |
|||
|
|||
colorWriter.Write(compressor, rowsPerStrip); |
|||
|
|||
entriesCollector.ProcessImageFormat(this); |
|||
entriesCollector.ProcessGeneral(image); |
|||
|
|||
writer.WriteMarker(ifdOffset, (uint)writer.Position); |
|||
long nextIfdMarker = this.WriteIfd(writer, entriesCollector.Entries); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates the number of rows written per strip.
|
|||
/// </summary>
|
|||
/// <param name="height">The height of the image.</param>
|
|||
/// <param name="bytesPerRow">The number of bytes per row.</param>
|
|||
/// <returns>Number of rows per strip.</returns>
|
|||
private int CalcRowsPerStrip(int height, int bytesPerRow) |
|||
{ |
|||
DebugGuard.MustBeGreaterThan(height, 0, nameof(height)); |
|||
DebugGuard.MustBeGreaterThan(bytesPerRow, 0, nameof(bytesPerRow)); |
|||
|
|||
int rowsPerStrip = TiffConstants.DefaultStripSize / bytesPerRow; |
|||
|
|||
if (rowsPerStrip > 0) |
|||
{ |
|||
if (rowsPerStrip < height) |
|||
{ |
|||
return rowsPerStrip; |
|||
} |
|||
|
|||
return height; |
|||
} |
|||
|
|||
return 1; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a TIFF IFD block.
|
|||
/// </summary>
|
|||
/// <param name="writer">The <see cref="BinaryWriter"/> to write data to.</param>
|
|||
/// <param name="entries">The IFD entries to write to the file.</param>
|
|||
/// <returns>The marker to write the next IFD offset (if present).</returns>
|
|||
private long WriteIfd(TiffStreamWriter writer, List<IExifValue> entries) |
|||
{ |
|||
if (entries.Count == 0) |
|||
{ |
|||
TiffThrowHelper.ThrowArgumentException("There must be at least one entry per IFD."); |
|||
} |
|||
|
|||
uint dataOffset = (uint)writer.Position + (uint)(6 + (entries.Count * 12)); |
|||
var largeDataBlocks = new List<byte[]>(); |
|||
|
|||
entries.Sort((a, b) => (ushort)a.Tag - (ushort)b.Tag); |
|||
|
|||
writer.Write((ushort)entries.Count); |
|||
|
|||
foreach (IExifValue entry in entries) |
|||
{ |
|||
writer.Write((ushort)entry.Tag); |
|||
writer.Write((ushort)entry.DataType); |
|||
writer.Write(ExifWriter.GetNumberOfComponents(entry)); |
|||
|
|||
uint length = ExifWriter.GetLength(entry); |
|||
if (length <= 4) |
|||
{ |
|||
int sz = ExifWriter.WriteValue(entry, this.buffer, 0); |
|||
DebugGuard.IsTrue(sz == length, "Incorrect number of bytes written"); |
|||
writer.WritePadded(this.buffer.AsSpan(0, sz)); |
|||
} |
|||
else |
|||
{ |
|||
var raw = new byte[length]; |
|||
int sz = ExifWriter.WriteValue(entry, raw, 0); |
|||
DebugGuard.IsTrue(sz == raw.Length, "Incorrect number of bytes written"); |
|||
largeDataBlocks.Add(raw); |
|||
writer.Write(dataOffset); |
|||
dataOffset += (uint)(raw.Length + (raw.Length % 2)); |
|||
} |
|||
} |
|||
|
|||
long nextIfdMarker = writer.PlaceMarker(); |
|||
|
|||
foreach (byte[] dataBlock in largeDataBlocks) |
|||
{ |
|||
writer.Write(dataBlock); |
|||
|
|||
if (dataBlock.Length % 2 == 1) |
|||
{ |
|||
writer.Write(0); |
|||
} |
|||
} |
|||
|
|||
return nextIfdMarker; |
|||
} |
|||
|
|||
private void SanitizeAndSetEncoderOptions(TiffBitsPerPixel? bitsPerPixel, int inputBitsPerPixel, TiffPhotometricInterpretation? photometricInterpretation, TiffCompression compression, TiffPredictor predictor) |
|||
{ |
|||
// BitsPerPixel should be the primary source of truth for the encoder options.
|
|||
if (bitsPerPixel.HasValue) |
|||
{ |
|||
switch (bitsPerPixel) |
|||
{ |
|||
case TiffBitsPerPixel.Bit1: |
|||
if (compression == TiffCompression.Ccitt1D || compression == TiffCompression.CcittGroup3Fax || compression == TiffCompression.CcittGroup4Fax) |
|||
{ |
|||
// The “normal” PhotometricInterpretation for bilevel CCITT compressed data is WhiteIsZero.
|
|||
this.SetEncoderOptions(bitsPerPixel, TiffPhotometricInterpretation.WhiteIsZero, compression, TiffPredictor.None); |
|||
break; |
|||
} |
|||
|
|||
this.SetEncoderOptions(bitsPerPixel, TiffPhotometricInterpretation.BlackIsZero, compression, TiffPredictor.None); |
|||
break; |
|||
case TiffBitsPerPixel.Bit4: |
|||
this.SetEncoderOptions(bitsPerPixel, TiffPhotometricInterpretation.PaletteColor, compression, TiffPredictor.None); |
|||
break; |
|||
case TiffBitsPerPixel.Bit8: |
|||
this.SetEncoderOptions(bitsPerPixel, photometricInterpretation ?? TiffPhotometricInterpretation.BlackIsZero, compression, predictor); |
|||
break; |
|||
default: |
|||
this.SetEncoderOptions(bitsPerPixel, TiffPhotometricInterpretation.Rgb, compression, predictor); |
|||
break; |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
// If no photometric interpretation was chosen, the input image bit per pixel should be preserved.
|
|||
if (!photometricInterpretation.HasValue) |
|||
{ |
|||
// At the moment only 8 and 32 bits per pixel can be preserved by the tiff encoder.
|
|||
if (inputBitsPerPixel == 8) |
|||
{ |
|||
this.SetEncoderOptions(TiffBitsPerPixel.Bit8, TiffPhotometricInterpretation.BlackIsZero, compression, predictor); |
|||
return; |
|||
} |
|||
|
|||
this.SetEncoderOptions(TiffBitsPerPixel.Bit24, TiffPhotometricInterpretation.Rgb, compression, predictor); |
|||
return; |
|||
} |
|||
|
|||
switch (photometricInterpretation) |
|||
{ |
|||
case TiffPhotometricInterpretation.BlackIsZero: |
|||
case TiffPhotometricInterpretation.WhiteIsZero: |
|||
if (this.CompressionType == TiffCompression.Ccitt1D || |
|||
this.CompressionType == TiffCompression.CcittGroup3Fax || |
|||
this.CompressionType == TiffCompression.CcittGroup4Fax) |
|||
{ |
|||
this.SetEncoderOptions(TiffBitsPerPixel.Bit1, photometricInterpretation, compression, TiffPredictor.None); |
|||
return; |
|||
} |
|||
else |
|||
{ |
|||
this.SetEncoderOptions(TiffBitsPerPixel.Bit8, photometricInterpretation, compression, predictor); |
|||
return; |
|||
} |
|||
|
|||
case TiffPhotometricInterpretation.PaletteColor: |
|||
this.SetEncoderOptions(TiffBitsPerPixel.Bit8, photometricInterpretation, compression, predictor); |
|||
return; |
|||
|
|||
case TiffPhotometricInterpretation.Rgb: |
|||
this.SetEncoderOptions(TiffBitsPerPixel.Bit24, photometricInterpretation, compression, predictor); |
|||
return; |
|||
} |
|||
|
|||
this.SetEncoderOptions(DefaultBitsPerPixel, DefaultPhotometricInterpretation, compression, predictor); |
|||
} |
|||
|
|||
private void SetEncoderOptions(TiffBitsPerPixel? bitsPerPixel, TiffPhotometricInterpretation? photometricInterpretation, TiffCompression compression, TiffPredictor predictor) |
|||
{ |
|||
this.BitsPerPixel = bitsPerPixel; |
|||
this.PhotometricInterpretation = photometricInterpretation; |
|||
this.CompressionType = compression; |
|||
this.HorizontalPredictor = predictor; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,378 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
using SixLabors.ImageSharp.Common.Helpers; |
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Metadata; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
internal class TiffEncoderEntriesCollector |
|||
{ |
|||
private const string SoftwareValue = "ImageSharp"; |
|||
|
|||
public List<IExifValue> Entries { get; } = new List<IExifValue>(); |
|||
|
|||
public void ProcessGeneral<TPixel>(Image<TPixel> image) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
=> new GeneralProcessor(this).Process(image); |
|||
|
|||
public void ProcessImageFormat(TiffEncoderCore encoder) |
|||
=> new ImageFormatProcessor(this).Process(encoder); |
|||
|
|||
public void AddOrReplace(IExifValue entry) |
|||
{ |
|||
int index = this.Entries.FindIndex(t => t.Tag == entry.Tag); |
|||
if (index >= 0) |
|||
{ |
|||
this.Entries[index] = entry; |
|||
} |
|||
else |
|||
{ |
|||
this.Entries.Add(entry); |
|||
} |
|||
} |
|||
|
|||
private void Add(IExifValue entry) => this.Entries.Add(entry); |
|||
|
|||
private class GeneralProcessor |
|||
{ |
|||
private readonly TiffEncoderEntriesCollector collector; |
|||
|
|||
public GeneralProcessor(TiffEncoderEntriesCollector collector) => this.collector = collector; |
|||
|
|||
public void Process<TPixel>(Image<TPixel> image) |
|||
where TPixel : unmanaged, IPixel<TPixel> |
|||
{ |
|||
ImageFrame<TPixel> rootFrame = image.Frames.RootFrame; |
|||
ExifProfile rootFrameExifProfile = rootFrame.Metadata.ExifProfile ?? new ExifProfile(); |
|||
byte[] rootFrameXmpBytes = rootFrame.Metadata.XmpProfile; |
|||
|
|||
var width = new ExifLong(ExifTagValue.ImageWidth) |
|||
{ |
|||
Value = (uint)image.Width |
|||
}; |
|||
|
|||
var height = new ExifLong(ExifTagValue.ImageLength) |
|||
{ |
|||
Value = (uint)image.Height |
|||
}; |
|||
|
|||
var software = new ExifString(ExifTagValue.Software) |
|||
{ |
|||
Value = SoftwareValue |
|||
}; |
|||
|
|||
this.collector.Add(width); |
|||
this.collector.Add(height); |
|||
|
|||
this.ProcessResolution(image.Metadata, rootFrameExifProfile); |
|||
this.ProcessProfiles(image.Metadata, rootFrameExifProfile, rootFrameXmpBytes); |
|||
this.ProcessMetadata(rootFrameExifProfile); |
|||
|
|||
if (!this.collector.Entries.Exists(t => t.Tag == ExifTag.Software)) |
|||
{ |
|||
this.collector.Add(software); |
|||
} |
|||
} |
|||
|
|||
private static bool IsPureMetadata(ExifTag tag) |
|||
{ |
|||
switch ((ExifTagValue)(ushort)tag) |
|||
{ |
|||
case ExifTagValue.DocumentName: |
|||
case ExifTagValue.ImageDescription: |
|||
case ExifTagValue.Make: |
|||
case ExifTagValue.Model: |
|||
case ExifTagValue.Software: |
|||
case ExifTagValue.DateTime: |
|||
case ExifTagValue.Artist: |
|||
case ExifTagValue.HostComputer: |
|||
case ExifTagValue.TargetPrinter: |
|||
case ExifTagValue.XMP: |
|||
case ExifTagValue.Rating: |
|||
case ExifTagValue.RatingPercent: |
|||
case ExifTagValue.ImageID: |
|||
case ExifTagValue.Copyright: |
|||
case ExifTagValue.MDLabName: |
|||
case ExifTagValue.MDSampleInfo: |
|||
case ExifTagValue.MDPrepDate: |
|||
case ExifTagValue.MDPrepTime: |
|||
case ExifTagValue.MDFileUnits: |
|||
case ExifTagValue.SEMInfo: |
|||
case ExifTagValue.XPTitle: |
|||
case ExifTagValue.XPComment: |
|||
case ExifTagValue.XPAuthor: |
|||
case ExifTagValue.XPKeywords: |
|||
case ExifTagValue.XPSubject: |
|||
return true; |
|||
default: |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
private void ProcessResolution(ImageMetadata imageMetadata, ExifProfile exifProfile) |
|||
{ |
|||
UnitConverter.SetResolutionValues( |
|||
exifProfile, |
|||
imageMetadata.ResolutionUnits, |
|||
imageMetadata.HorizontalResolution, |
|||
imageMetadata.VerticalResolution); |
|||
|
|||
this.collector.Add(exifProfile.GetValue(ExifTag.ResolutionUnit).DeepClone()); |
|||
|
|||
IExifValue xResolution = exifProfile.GetValue(ExifTag.XResolution)?.DeepClone(); |
|||
IExifValue yResolution = exifProfile.GetValue(ExifTag.YResolution)?.DeepClone(); |
|||
|
|||
if (xResolution != null && yResolution != null) |
|||
{ |
|||
this.collector.Add(xResolution); |
|||
this.collector.Add(yResolution); |
|||
} |
|||
} |
|||
|
|||
private void ProcessMetadata(ExifProfile exifProfile) |
|||
{ |
|||
foreach (IExifValue entry in exifProfile.Values) |
|||
{ |
|||
// todo: skip subIfd
|
|||
if (entry.DataType == ExifDataType.Ifd) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
switch ((ExifTagValue)(ushort)entry.Tag) |
|||
{ |
|||
case ExifTagValue.SubIFDOffset: |
|||
case ExifTagValue.GPSIFDOffset: |
|||
case ExifTagValue.SubIFDs: |
|||
case ExifTagValue.XMP: |
|||
case ExifTagValue.IPTC: |
|||
case ExifTagValue.IccProfile: |
|||
continue; |
|||
} |
|||
|
|||
switch (ExifTags.GetPart(entry.Tag)) |
|||
{ |
|||
case ExifParts.ExifTags: |
|||
case ExifParts.GpsTags: |
|||
break; |
|||
|
|||
case ExifParts.IfdTags: |
|||
if (!IsPureMetadata(entry.Tag)) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
break; |
|||
} |
|||
|
|||
if (!this.collector.Entries.Exists(t => t.Tag == entry.Tag)) |
|||
{ |
|||
this.collector.AddOrReplace(entry.DeepClone()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void ProcessProfiles(ImageMetadata imageMetadata, ExifProfile exifProfile, byte[] xmpProfile) |
|||
{ |
|||
if (exifProfile != null && exifProfile.Parts != ExifParts.None) |
|||
{ |
|||
foreach (IExifValue entry in exifProfile.Values) |
|||
{ |
|||
if (!this.collector.Entries.Exists(t => t.Tag == entry.Tag) && entry.GetValue() != null) |
|||
{ |
|||
ExifParts entryPart = ExifTags.GetPart(entry.Tag); |
|||
if (entryPart != ExifParts.None && exifProfile.Parts.HasFlag(entryPart)) |
|||
{ |
|||
this.collector.AddOrReplace(entry.DeepClone()); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
exifProfile.RemoveValue(ExifTag.SubIFDOffset); |
|||
} |
|||
|
|||
if (imageMetadata.IptcProfile != null) |
|||
{ |
|||
imageMetadata.IptcProfile.UpdateData(); |
|||
var iptc = new ExifByteArray(ExifTagValue.IPTC, ExifDataType.Byte) |
|||
{ |
|||
Value = imageMetadata.IptcProfile.Data |
|||
}; |
|||
|
|||
this.collector.Add(iptc); |
|||
} |
|||
else |
|||
{ |
|||
exifProfile.RemoveValue(ExifTag.IPTC); |
|||
} |
|||
|
|||
if (imageMetadata.IccProfile != null) |
|||
{ |
|||
var icc = new ExifByteArray(ExifTagValue.IccProfile, ExifDataType.Undefined) |
|||
{ |
|||
Value = imageMetadata.IccProfile.ToByteArray() |
|||
}; |
|||
|
|||
this.collector.Add(icc); |
|||
} |
|||
else |
|||
{ |
|||
exifProfile.RemoveValue(ExifTag.IccProfile); |
|||
} |
|||
|
|||
TiffMetadata tiffMetadata = imageMetadata.GetTiffMetadata(); |
|||
if (xmpProfile != null) |
|||
{ |
|||
var xmp = new ExifByteArray(ExifTagValue.XMP, ExifDataType.Byte) |
|||
{ |
|||
Value = xmpProfile |
|||
}; |
|||
|
|||
this.collector.Add(xmp); |
|||
} |
|||
else |
|||
{ |
|||
exifProfile.RemoveValue(ExifTag.XMP); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private class ImageFormatProcessor |
|||
{ |
|||
private readonly TiffEncoderEntriesCollector collector; |
|||
|
|||
public ImageFormatProcessor(TiffEncoderEntriesCollector collector) => this.collector = collector; |
|||
|
|||
public void Process(TiffEncoderCore encoder) |
|||
{ |
|||
var samplesPerPixel = new ExifLong(ExifTagValue.SamplesPerPixel) |
|||
{ |
|||
Value = GetSamplesPerPixel(encoder) |
|||
}; |
|||
|
|||
ushort[] bitsPerSampleValue = GetBitsPerSampleValue(encoder); |
|||
var bitPerSample = new ExifShortArray(ExifTagValue.BitsPerSample) |
|||
{ |
|||
Value = bitsPerSampleValue |
|||
}; |
|||
|
|||
ushort compressionType = GetCompressionType(encoder); |
|||
var compression = new ExifShort(ExifTagValue.Compression) |
|||
{ |
|||
Value = compressionType |
|||
}; |
|||
|
|||
var photometricInterpretation = new ExifShort(ExifTagValue.PhotometricInterpretation) |
|||
{ |
|||
Value = (ushort)encoder.PhotometricInterpretation |
|||
}; |
|||
|
|||
this.collector.AddOrReplace(samplesPerPixel); |
|||
this.collector.AddOrReplace(bitPerSample); |
|||
this.collector.AddOrReplace(compression); |
|||
this.collector.AddOrReplace(photometricInterpretation); |
|||
|
|||
if (encoder.HorizontalPredictor == TiffPredictor.Horizontal) |
|||
{ |
|||
if (encoder.PhotometricInterpretation == TiffPhotometricInterpretation.Rgb || |
|||
encoder.PhotometricInterpretation == TiffPhotometricInterpretation.PaletteColor || |
|||
encoder.PhotometricInterpretation == TiffPhotometricInterpretation.BlackIsZero) |
|||
{ |
|||
var predictor = new ExifShort(ExifTagValue.Predictor) { Value = (ushort)TiffPredictor.Horizontal }; |
|||
|
|||
this.collector.AddOrReplace(predictor); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private static uint GetSamplesPerPixel(TiffEncoderCore encoder) |
|||
{ |
|||
switch (encoder.PhotometricInterpretation) |
|||
{ |
|||
case TiffPhotometricInterpretation.PaletteColor: |
|||
case TiffPhotometricInterpretation.BlackIsZero: |
|||
case TiffPhotometricInterpretation.WhiteIsZero: |
|||
return 1; |
|||
case TiffPhotometricInterpretation.Rgb: |
|||
default: |
|||
return 3; |
|||
} |
|||
} |
|||
|
|||
private static ushort[] GetBitsPerSampleValue(TiffEncoderCore encoder) |
|||
{ |
|||
switch (encoder.PhotometricInterpretation) |
|||
{ |
|||
case TiffPhotometricInterpretation.PaletteColor: |
|||
if (encoder.BitsPerPixel == TiffBitsPerPixel.Bit4) |
|||
{ |
|||
return TiffConstants.BitsPerSample4Bit; |
|||
} |
|||
else |
|||
{ |
|||
return TiffConstants.BitsPerSample8Bit; |
|||
} |
|||
|
|||
case TiffPhotometricInterpretation.Rgb: |
|||
return TiffConstants.BitsPerSampleRgb8Bit; |
|||
|
|||
case TiffPhotometricInterpretation.WhiteIsZero: |
|||
if (encoder.BitsPerPixel == TiffBitsPerPixel.Bit1) |
|||
{ |
|||
return TiffConstants.BitsPerSample1Bit; |
|||
} |
|||
|
|||
return TiffConstants.BitsPerSample8Bit; |
|||
|
|||
case TiffPhotometricInterpretation.BlackIsZero: |
|||
if (encoder.BitsPerPixel == TiffBitsPerPixel.Bit1) |
|||
{ |
|||
return TiffConstants.BitsPerSample1Bit; |
|||
} |
|||
|
|||
return TiffConstants.BitsPerSample8Bit; |
|||
|
|||
default: |
|||
return TiffConstants.BitsPerSampleRgb8Bit; |
|||
} |
|||
} |
|||
|
|||
private static ushort GetCompressionType(TiffEncoderCore encoder) |
|||
{ |
|||
switch (encoder.CompressionType) |
|||
{ |
|||
case TiffCompression.Deflate: |
|||
// Deflate is allowed for all modes.
|
|||
return (ushort)TiffCompression.Deflate; |
|||
case TiffCompression.PackBits: |
|||
// PackBits is allowed for all modes.
|
|||
return (ushort)TiffCompression.PackBits; |
|||
case TiffCompression.Lzw: |
|||
if (encoder.PhotometricInterpretation == TiffPhotometricInterpretation.Rgb || |
|||
encoder.PhotometricInterpretation == TiffPhotometricInterpretation.PaletteColor || |
|||
encoder.PhotometricInterpretation == TiffPhotometricInterpretation.BlackIsZero) |
|||
{ |
|||
return (ushort)TiffCompression.Lzw; |
|||
} |
|||
|
|||
break; |
|||
|
|||
case TiffCompression.CcittGroup3Fax: |
|||
return (ushort)TiffCompression.CcittGroup3Fax; |
|||
|
|||
case TiffCompression.Ccitt1D: |
|||
return (ushort)TiffCompression.Ccitt1D; |
|||
} |
|||
|
|||
return (ushort)TiffCompression.None; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,42 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Encapsulates the means to encode and decode Tiff images.
|
|||
/// </summary>
|
|||
public sealed class TiffFormat : IImageFormat<TiffMetadata, TiffFrameMetadata> |
|||
{ |
|||
private TiffFormat() |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current instance.
|
|||
/// </summary>
|
|||
public static TiffFormat Instance { get; } = new TiffFormat(); |
|||
|
|||
/// <inheritdoc/>
|
|||
public string Name => "TIFF"; |
|||
|
|||
/// <inheritdoc/>
|
|||
public string DefaultMimeType => "image/tiff"; |
|||
|
|||
/// <inheritdoc/>
|
|||
public IEnumerable<string> MimeTypes => TiffConstants.MimeTypes; |
|||
|
|||
/// <inheritdoc/>
|
|||
public IEnumerable<string> FileExtensions => TiffConstants.FileExtensions; |
|||
|
|||
/// <inheritdoc/>
|
|||
public TiffMetadata CreateDefaultFormatMetadata() => new TiffMetadata(); |
|||
|
|||
/// <inheritdoc/>
|
|||
public TiffFrameMetadata CreateDefaultFormatFrameMetadata() => new TiffFrameMetadata(); |
|||
} |
|||
} |
|||
@ -0,0 +1,113 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Tiff.Constants; |
|||
using SixLabors.ImageSharp.Metadata.Profiles.Exif; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Tiff |
|||
{ |
|||
/// <summary>
|
|||
/// Provides Tiff specific metadata information for the frame.
|
|||
/// </summary>
|
|||
public class TiffFrameMetadata : IDeepCloneable |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffFrameMetadata"/> class.
|
|||
/// </summary>
|
|||
public TiffFrameMetadata() |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="TiffFrameMetadata"/> class.
|
|||
/// </summary>
|
|||
/// <param name="other">The other tiff frame metadata.</param>
|
|||
private TiffFrameMetadata(TiffFrameMetadata other) |
|||
{ |
|||
this.BitsPerPixel = other.BitsPerPixel; |
|||
this.Compression = other.Compression; |
|||
this.PhotometricInterpretation = other.PhotometricInterpretation; |
|||
this.Predictor = other.Predictor; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the bits per pixel.
|
|||
/// </summary>
|
|||
public TiffBitsPerPixel? BitsPerPixel { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the compression scheme used on the image data.
|
|||
/// </summary>
|
|||
public TiffCompression? Compression { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the color space of the image data.
|
|||
/// </summary>
|
|||
public TiffPhotometricInterpretation? PhotometricInterpretation { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets a mathematical operator that is applied to the image data before an encoding scheme is applied.
|
|||
/// </summary>
|
|||
public TiffPredictor? Predictor { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Returns a new <see cref="TiffFrameMetadata"/> instance parsed from the given Exif profile.
|
|||
/// </summary>
|
|||
/// <param name="profile">The Exif profile containing tiff frame directory tags to parse.
|
|||
/// If null, a new instance is created and parsed instead.</param>
|
|||
/// <returns>The <see cref="TiffFrameMetadata"/>.</returns>
|
|||
internal static TiffFrameMetadata Parse(ExifProfile profile) |
|||
{ |
|||
var meta = new TiffFrameMetadata(); |
|||
Parse(meta, profile); |
|||
return meta; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Parses the given Exif profile to populate the properties of the tiff frame meta data..
|
|||
/// </summary>
|
|||
/// <param name="meta">The tiff frame meta data.</param>
|
|||
/// <param name="profile">The Exif profile containing tiff frame directory tags.</param>
|
|||
internal static void Parse(TiffFrameMetadata meta, ExifProfile profile) |
|||
{ |
|||
if (profile != null) |
|||
{ |
|||
ushort[] bitsPerSample = profile.GetValue(ExifTag.BitsPerSample)?.Value; |
|||
meta.BitsPerPixel = BitsPerPixelFromBitsPerSample(bitsPerSample); |
|||
meta.Compression = (TiffCompression?)profile.GetValue(ExifTag.Compression)?.Value; |
|||
meta.PhotometricInterpretation = |
|||
(TiffPhotometricInterpretation?)profile.GetValue(ExifTag.PhotometricInterpretation)?.Value; |
|||
meta.Predictor = (TiffPredictor?)profile.GetValue(ExifTag.Predictor)?.Value; |
|||
|
|||
profile.RemoveValue(ExifTag.BitsPerSample); |
|||
profile.RemoveValue(ExifTag.Compression); |
|||
profile.RemoveValue(ExifTag.PhotometricInterpretation); |
|||
profile.RemoveValue(ExifTag.Predictor); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the bits per pixel for the given bits per sample.
|
|||
/// </summary>
|
|||
/// <param name="bitsPerSample">The tiff bits per sample.</param>
|
|||
/// <returns>Bits per pixel.</returns>
|
|||
private static TiffBitsPerPixel? BitsPerPixelFromBitsPerSample(ushort[] bitsPerSample) |
|||
{ |
|||
if (bitsPerSample == null) |
|||
{ |
|||
return null; |
|||
} |
|||
|
|||
int bitsPerPixel = 0; |
|||
foreach (ushort bits in bitsPerSample) |
|||
{ |
|||
bitsPerPixel += bits; |
|||
} |
|||
|
|||
return (TiffBitsPerPixel)bitsPerPixel; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public IDeepCloneable DeepClone() => new TiffFrameMetadata(this); |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue