public async Task TestAsync(string reference, string test)
{
using var refImage = Image.Load <L8>(reference);
await using TiffFileReader tiff = await TiffFileReader.OpenAsync(test);
TiffStreamOffset ifdOffset = tiff.FirstImageFileDirectoryOffset;
while (!ifdOffset.IsZero)
{
TiffImageFileDirectory ifd = await tiff.ReadImageFileDirectoryAsync(ifdOffset);
TiffImageDecoder decoder = await tiff.CreateImageDecoderAsync(ifd, new TiffImageDecoderOptions { UndoColorPreMultiplying = true });
Assert.Equal(refImage.Width, decoder.Width);
Assert.Equal(refImage.Height, decoder.Height);
TiffGray8[] pixels = new TiffGray8[decoder.Width * decoder.Height];
await decoder.DecodeAsync(TiffPixelBuffer.Wrap(pixels, decoder.Width, decoder.Height));
AssertEqual(refImage, pixels);
using (var image = new Image <L8>(decoder.Width, decoder.Height))
{
decoder.Decode(image);
AssertEqual(refImage, image);
}
ifdOffset = ifd.NextOffset;
}
}
public override void Write(TiffStreamOffset offset, ReadOnlyMemory <byte> buffer)
{
Stream stream = _stream;
if (stream is null)
{
throw new ObjectDisposedException(nameof(ImageSharpContentReaderWriter));
}
stream.Seek(offset.Offset, SeekOrigin.Begin);
if (MemoryMarshal.TryGetArray(buffer, out ArraySegment <byte> arraySegment))
{
stream.Write(arraySegment.Array, arraySegment.Offset, arraySegment.Count);
return;
}
#if !NO_FAST_SPAN
stream.Write(buffer.Span);
#else
// Slow path
byte[] temp = ArrayPool <byte> .Shared.Rent(buffer.Length);
try
{
buffer.CopyTo(temp);
stream.Write(temp, 0, buffer.Length);
}
finally
{
ArrayPool <byte> .Shared.Return(temp);
}
#endif
}
public void Test(string reference, string test)
{
using var refImage = Image.Load <Rgb24>(reference);
using var tiff = TiffFileReader.Open(test);
TiffStreamOffset ifdOffset = tiff.FirstImageFileDirectoryOffset;
while (!ifdOffset.IsZero)
{
TiffImageFileDirectory ifd = tiff.ReadImageFileDirectory(ifdOffset);
TiffImageDecoder decoder = tiff.CreateImageDecoder(ifd, new TiffImageDecoderOptions {
UndoColorPreMultiplying = true
});
Assert.Equal(refImage.Width, decoder.Width);
Assert.Equal(refImage.Height, decoder.Height);
TiffRgb24[] pixels = new TiffRgb24[decoder.Width * decoder.Height];
decoder.Decode(TiffPixelBuffer.Wrap(pixels, decoder.Width, decoder.Height));
AssertEqual(refImage, pixels);
using (var image = new Image <Rgb24>(decoder.Width, decoder.Height))
{
decoder.Decode(image);
AssertEqual(refImage, image);
}
ifdOffset = ifd.NextOffset;
}
}
private static async Task CopyStrippedImageAsync(TiffFileContentReader contentReader, TiffTagReader tagReader, TiffImageFileDirectoryWriter dest, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
TiffValueCollection <ulong> offsets = await tagReader.ReadStripOffsetsAsync(cancellationToken);
TiffValueCollection <ulong> byteCounts = await tagReader.ReadStripByteCountsAsync(cancellationToken);
if (offsets.Count != byteCounts.Count)
{
throw new InvalidDataException("Failed to copy stripped image data. StripOffsets and StripByteCounts don't have the same amount of elements.");
}
uint[] offsets32 = new uint[offsets.Count];
uint[] byteCounts32 = new uint[offsets.Count];
byte[]? buffer = null;
try
{
for (int i = 0; i < offsets.Count; i++)
{
int offset = checked ((int)offsets[i]);
int byteCount = checked ((int)byteCounts[i]);
byteCounts32[i] = checked ((uint)byteCount);
if (buffer is null || byteCount > buffer.Length)
{
if (!(buffer is null))
{
ArrayPool <byte> .Shared.Return(buffer);
}
buffer = ArrayPool <byte> .Shared.Rent(byteCount);
}
if (await contentReader.ReadAsync(offset, new ArraySegment <byte>(buffer, 0, byteCount), cancellationToken) != byteCount)
{
throw new InvalidDataException("Invalid ByteCount field.");
}
TiffStreamOffset region = await dest.FileWriter.WriteAlignedBytesAsync(buffer, 0, byteCount);
offsets32[i] = checked ((uint)region.Offset);
}
}
finally
{
if (!(buffer is null))
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
await dest.WriteTagAsync(TiffTag.StripOffsets, TiffValueCollection.UnsafeWrap(offsets32));
await dest.WriteTagAsync(TiffTag.StripByteCounts, TiffValueCollection.UnsafeWrap(byteCounts32));
}
public static async Task <int> Merge(FileInfo[] source, FileInfo output, CancellationToken cancellationToken)
{
if (source is null || source.Length == 0)
{
Console.WriteLine("Input TIFF file are not specified.");
return(1);
}
if (output is null)
{
Console.WriteLine("Output TIFF file is not specified");
return(1);
}
await using TiffFileWriter writer = await TiffFileWriter.OpenAsync(output.FullName);
TiffStreamOffset fistIfdOffset = default;
TiffStreamOffset previousIfdOffset = default;
foreach (FileInfo sourceFile in source)
{
await using TiffFileReader reader = await TiffFileReader.OpenAsync(sourceFile.FullName);
await using TiffFileContentReader contentReader = await reader.CreateContentReaderAsync();
await using TiffFieldReader fieldReader = await reader.CreateFieldReaderAsync(cancellationToken);
TiffStreamOffset inputIfdOffset = reader.FirstImageFileDirectoryOffset;
while (!inputIfdOffset.IsZero)
{
TiffImageFileDirectory ifd = await reader.ReadImageFileDirectoryAsync(inputIfdOffset, cancellationToken);
using (TiffImageFileDirectoryWriter ifdWriter = writer.CreateImageFileDirectory())
{
await CopyIfdAsync(contentReader, fieldReader, ifd, ifdWriter, cancellationToken);
previousIfdOffset = await ifdWriter.FlushAsync(previousIfdOffset);
if (fistIfdOffset.IsZero)
{
fistIfdOffset = previousIfdOffset;
}
}
inputIfdOffset = ifd.NextOffset;
}
}
writer.SetFirstImageFileDirectoryOffset(fistIfdOffset);
await writer.FlushAsync();
return(0);
}
public static async Task <int> Dump(FileInfo file, long?offset, CancellationToken cancellationToken)
{
await using TiffFileReader tiff = await TiffFileReader.OpenAsync(file.FullName);
await using TiffFieldReader fieldReader = await tiff.CreateFieldReaderAsync(cancellationToken);
Console.WriteLine("Input File: " + file.FullName);
Console.WriteLine($"StandardTIFF: {tiff.IsStandardTiff}, BigTIFF: {tiff.IsBigTiff}, IsLittleEndian: {tiff.IsLittleEndian}");
Console.WriteLine("First IFD: " + tiff.FirstImageFileDirectoryOffset);
Console.WriteLine();
int ifdIndex = 0;
TiffStreamOffset ifdOffset = offset.HasValue ? new TiffStreamOffset(offset.GetValueOrDefault()) : tiff.FirstImageFileDirectoryOffset;
while (!ifdOffset.IsZero)
{
TiffImageFileDirectory ifd = await tiff.ReadImageFileDirectoryAsync(ifdOffset, cancellationToken);
Console.WriteLine($"IFD #{ifdIndex++} (Offset = {ifdOffset})");
Console.WriteLine(" Well-known Tags:");
await DumpWellKnownTagsAsync(fieldReader, ifd, cancellationToken);
Console.WriteLine();
Console.WriteLine(" Tags:");
for (int i = 0; i < ifd.Count; i++)
{
TiffImageFileDirectoryEntry entry = ifd[i];
await DumpIfdEntryAsync(i, fieldReader, entry, cancellationToken);
}
if (ifd.Count == 0)
{
Console.WriteLine(" No tags found.");
}
Console.WriteLine();
Console.WriteLine();
ifdOffset = ifd.NextOffset;
}
return(0);
}
public async Task GenerateReducedResolutionLayerAsync(IRipperReducedResolutionGenerationReporter reporter, CancellationToken cancellationToken)
{
_fileReader = await TiffFileReader.OpenAsync(_stream, leaveOpen : true);
TiffStreamOffset ifd = _fileReader.FirstImageFileDirectoryOffset;
int width = _manifest.Width;
int height = _manifest.Height;
// Calculate layer count
int outputTileSize = _options.OutputTileSize;
int layerCount = 0;
int calcWidth = width, calcHeight = height;
while (Math.Min(calcWidth, calcHeight) > outputTileSize && Math.Min(calcWidth, calcHeight) >= 32)
{
calcWidth = calcWidth / 2;
calcHeight = calcHeight / 2;
layerCount++;
}
// Actually generate the layers
int layer = 0;
reporter?.ReportStartReducedResolutionGeneration(layerCount);
while (Math.Min(width, height) > outputTileSize && Math.Min(width, height) >= 32)
{
cancellationToken.ThrowIfCancellationRequested();
ifd = await GenerateReducedResolutionLayerAsync(++layer, ifd, reporter, cancellationToken).ConfigureAwait(false);
width = width / 2;
height = height / 2;
}
reporter?.ReportCompleteReducedResolutionGeneration(layerCount);
}
/// <summary>
/// Apply compression to <see cref="TiffImageEncoderContext{TPixel}.UncompressedData"/> and writes the compressed image to <see cref="TiffImageEncoderContext{TPixel}.FileWriter"/>. Writes <see cref="TiffTag.Compression"/> to thhe IFD writer and runs the next middleware.
/// </summary>
/// <param name="context">The encoder context.</param>
/// <param name="next">The next middleware.</param>
/// <returns>A <see cref="Task"/> that completes when the image has been encoded.</returns>
public async ValueTask InvokeAsync(TiffImageEncoderContext <TPixel> context, ITiffImageEncoderPipelineNode <TPixel> next)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (next is null)
{
throw new ArgumentNullException(nameof(next));
}
if (context.FileWriter is null)
{
throw new InvalidOperationException("Failed to acquire FileWriter");
}
TiffValueCollection <ushort> bitsPerSample = context.BitsPerSample;
int totalBits = 0;
for (int i = 0; i < bitsPerSample.Count; i++)
{
totalBits += bitsPerSample[i];
}
int width = context.ImageSize.Width;
int bytesPerScanlines = (totalBits * width + 7) / 8;
var compressionContext = new TiffCompressionContext
{
MemoryPool = context.MemoryPool,
PhotometricInterpretation = context.PhotometricInterpretation,
ImageSize = context.ImageSize,
BitsPerSample = context.BitsPerSample,
BytesPerScanline = bytesPerScanlines
};
using (var bufferWriter = new MemoryPoolBufferWriter(context.MemoryPool))
{
_compressionAlgorithm.Compress(compressionContext, context.UncompressedData, bufferWriter);
int length = bufferWriter.Length;
using (await context.LockAsync().ConfigureAwait(false))
{
TiffStreamOffset offset = await context.FileWriter !.WriteAlignedBytesAsync(bufferWriter.GetReadOnlySequence(), context.CancellationToken).ConfigureAwait(false);
context.BitsPerSample = compressionContext.BitsPerSample;
context.OutputRegion = new TiffStreamRegion(offset, length);
}
}
TiffImageFileDirectoryWriter?ifdWriter = context.IfdWriter;
if (!(ifdWriter is null))
{
using (await context.LockAsync().ConfigureAwait(false))
{
CancellationToken cancellationToken = context.CancellationToken;
await ifdWriter.WriteTagAsync(TiffTag.Compression, TiffValueCollection.Single((ushort)_compression), cancellationToken).ConfigureAwait(false);
}
}
await next.RunAsync(context).ConfigureAwait(false);
}
public static async Task <int> Wrap(FileInfo source, FileInfo output, CancellationToken cancellationToken)
{
if (source is null || !source.Exists)
{
Console.WriteLine(source is null ? "Input JPEG image is not specified." : "File not found: " + source.FullName);
return(1);
}
if (output is null)
{
Console.WriteLine("Output TIFF file is not specified.");
return(1);
}
byte[] jpegFile = await File.ReadAllBytesAsync(source.FullName, cancellationToken);
var decoder = new JpegDecoder();
decoder.SetInput(jpegFile);
decoder.Identify(loadQuantizationTables: false);
ushort[] bitsPerSample = new ushort[decoder.NumberOfComponents];
ushort bits = (ushort)decoder.Precision;
for (int i = 0; i < bitsPerSample.Length; i++)
{
bitsPerSample[i] = bits;
}
TiffPhotometricInterpretation photometricInterpretation =
bitsPerSample.Length == 1 ? TiffPhotometricInterpretation.BlackIsZero :
bitsPerSample.Length == 3 ? TiffPhotometricInterpretation.YCbCr :
throw new InvalidDataException("Photometric interpretation not supported.");
using (TiffFileWriter writer = await TiffFileWriter.OpenAsync(output.FullName, useBigTiff: false))
{
TiffStreamOffset imageOffset = await writer.WriteAlignedBytesAsync(jpegFile);
TiffStreamOffset ifdOffset;
using (TiffImageFileDirectoryWriter ifdWriter = writer.CreateImageFileDirectory())
{
await ifdWriter.WriteTagAsync(TiffTag.ImageWidth, TiffValueCollection.Single((ushort)decoder.Width));
await ifdWriter.WriteTagAsync(TiffTag.ImageLength, TiffValueCollection.Single((ushort)decoder.Height));
await ifdWriter.WriteTagAsync(TiffTag.BitsPerSample, TiffValueCollection.UnsafeWrap(bitsPerSample));
await ifdWriter.WriteTagAsync(TiffTag.Compression, TiffValueCollection.Single((ushort)TiffCompression.Jpeg));
await ifdWriter.WriteTagAsync(TiffTag.PhotometricInterpretation, TiffValueCollection.Single((ushort)photometricInterpretation));
await ifdWriter.WriteTagAsync(TiffTag.SamplesPerPixel, TiffValueCollection.Single((ushort)bitsPerSample.Length));
await ifdWriter.WriteTagAsync(TiffTag.PlanarConfiguration, TiffValueCollection.Single((ushort)TiffPlanarConfiguration.Chunky));
await ifdWriter.WriteTagAsync(TiffTag.RowsPerStrip, TiffValueCollection.Single((ushort)decoder.Height));
await ifdWriter.WriteTagAsync(TiffTag.StripOffsets, TiffValueCollection.Single((uint)imageOffset.Offset));
await ifdWriter.WriteTagAsync(TiffTag.StripByteCounts, TiffValueCollection.Single((uint)jpegFile.Length));
if (photometricInterpretation == TiffPhotometricInterpretation.YCbCr)
{
int maxHorizontalSampling = decoder.GetMaximumHorizontalSampling();
int maxVerticalSampling = decoder.GetMaximumVerticalSampling();
int yHorizontalSubSampling = maxHorizontalSampling / decoder.GetHorizontalSampling(0);
int yVerticalSubSampling = maxVerticalSampling / decoder.GetVerticalSampling(0);
int cbHorizontalSubSampling = maxHorizontalSampling / decoder.GetHorizontalSampling(1) / yHorizontalSubSampling;
int cbVerticalSubSampling = maxVerticalSampling / decoder.GetVerticalSampling(1) / yVerticalSubSampling;
int crHorizontalSubSampling = maxHorizontalSampling / decoder.GetHorizontalSampling(2) / yHorizontalSubSampling;
int crVerticalSubSampling = maxVerticalSampling / decoder.GetVerticalSampling(2) / yVerticalSubSampling;
if (cbHorizontalSubSampling != crHorizontalSubSampling || cbVerticalSubSampling != crVerticalSubSampling)
{
throw new InvalidDataException("Unsupported JPEG image.");
}
await ifdWriter.WriteTagAsync(TiffTag.YCbCrSubSampling, TiffValueCollection.UnsafeWrap(new ushort[] { (ushort)cbHorizontalSubSampling, (ushort)cbVerticalSubSampling }));
}
// Write other properties here (eg, XResolution, YResolution)
await ifdWriter.WriteTagAsync(TiffTag.XResolution, TiffValueCollection.Single(new TiffRational(96, 1)));
await ifdWriter.WriteTagAsync(TiffTag.YResolution, TiffValueCollection.Single(new TiffRational(96, 1)));
await ifdWriter.WriteTagAsync(TiffTag.ResolutionUnit, TiffValueCollection.Single((ushort)TiffResolutionUnit.Inch));
ifdOffset = await ifdWriter.FlushAsync();
}
writer.SetFirstImageFileDirectoryOffset(ifdOffset);
await writer.FlushAsync();
}
return(0);
}
public override void Write(TiffStreamOffset offset, ReadOnlyMemory <byte> buffer)
{
}
public override int Read(TiffStreamOffset offset, Memory <byte> buffer) => 0;
internal async Task <TiffStreamOffset> GenerateReducedResolutionLayerAsync(int layer, TiffStreamOffset ifdOffset, IRipperReducedResolutionGenerationReporter reporter, CancellationToken cancellationToken)
{
int outputTileSize = _options.OutputTileSize;
int outputTileSize2 = 2 * outputTileSize;
TiffImageFileDirectory ifd = await _fileReader.ReadImageFileDirectoryAsync(ifdOffset).ConfigureAwait(false);
TiffImageDecoder image = await _fileReader.CreateImageDecoderAsync(ifd);
int width = image.Width;
int height = image.Height;
int tiffRowCount = (width / 2 + outputTileSize - 1) / outputTileSize;
int tiffColCount = (height / 2 + outputTileSize - 1) / outputTileSize;
int index = 0;
ulong[] offsets = new ulong[tiffRowCount * tiffColCount];
ulong[] byteCounts = new ulong[tiffRowCount * tiffColCount];
ulong totalByteCount = 0;
reporter?.ReportStartReducedResolutionLayerGeneration(layer, offsets.Length, width / 2, height / 2);
using (Image <Rgb24> canvas2 = new Image <Rgb24>(_configuration, outputTileSize2, outputTileSize2))
{
for (int y = 0; y < height; y += outputTileSize2)
{
for (int x = 0; x < width; x += outputTileSize2)
{
cancellationToken.ThrowIfCancellationRequested();
MemoryMarshal.AsBytes(canvas2.GetPixelSpan()).Clear();
await image.DecodeAsync(new TiffPoint(x, y), canvas2).ConfigureAwait(false);
using (Image <Rgb24> tile24 = canvas2.Clone(ctx =>
{
ctx.Resize(outputTileSize, outputTileSize);
}))
{
cancellationToken.ThrowIfCancellationRequested();
TiffStreamRegion region = await _encoder.EncodeAsync(_fileWriter, tile24).ConfigureAwait(false);
offsets[index] = (ulong)region.Offset.Offset;
byteCounts[index] = (uint)region.Length;
totalByteCount += (uint)region.Length;
index++;
reporter?.ReportReducedResolutionLayerGenerationProgress(layer, index, offsets.Length);
}
}
}
}
cancellationToken.ThrowIfCancellationRequested();
using (TiffImageFileDirectoryWriter ifdWriter = _fileWriter.CreateImageFileDirectory())
{
await ifdWriter.WriteTagAsync(TiffTag.NewSubfileType, new TiffValueCollection <ushort>((ushort)TiffNewSubfileType.ReducedResolution)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.PhotometricInterpretation, new TiffValueCollection <ushort>((ushort)TiffPhotometricInterpretation.YCbCr)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.Compression, new TiffValueCollection <ushort>((ushort)TiffCompression.Jpeg)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.SamplesPerPixel, new TiffValueCollection <ushort>((ushort)3)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.TileWidth, new TiffValueCollection <ushort>((ushort)outputTileSize)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.TileLength, new TiffValueCollection <ushort>((ushort)outputTileSize)).ConfigureAwait(false);
//ifdWriter.AddTag(TiffTag.ResolutionUnit, (ushort)TiffResolutionUnit.Inch);
//await ifdWriter.WriteTagAsync(TiffTag.XResolution, new TiffValueCollection<TiffRational>(new TiffRational(72, 1)));
//await ifdWriter.WriteTagAsync(TiffTag.YResolution, new TiffValueCollection<TiffRational>(new TiffRational(72, 1)));
await ifdWriter.WriteTagAsync(TiffTag.SampleFormat, new TiffValueCollection <ushort>(new ushort[] { 1, 1, 1 })).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.BitsPerSample, new TiffValueCollection <ushort>(new ushort[] { 8, 8, 8 })).ConfigureAwait(false);
if (UseBigTiff)
{
await ifdWriter.WriteTagAsync(TiffTag.ImageWidth, new TiffValueCollection <ulong>((ulong)(width / 2))).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.ImageLength, new TiffValueCollection <ulong>((ulong)(height / 2))).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.TileOffsets, new TiffValueCollection <ulong>(offsets)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.TileByteCounts, new TiffValueCollection <ulong>(byteCounts)).ConfigureAwait(false);
}
else
{
await ifdWriter.WriteTagAsync(TiffTag.ImageWidth, new TiffValueCollection <uint>((uint)(width / 2))).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.ImageLength, new TiffValueCollection <uint>((uint)(height / 2))).ConfigureAwait(false);
uint[] tempArr = new uint[offsets.Length];
for (int i = 0; i < tempArr.Length; i++)
{
tempArr[i] = (uint)offsets[i];
}
await ifdWriter.WriteTagAsync(TiffTag.TileOffsets, new TiffValueCollection <uint>(tempArr)).ConfigureAwait(false);
for (int i = 0; i < tempArr.Length; i++)
{
tempArr[i] = (uint)byteCounts[i];
}
await ifdWriter.WriteTagAsync(TiffTag.TileByteCounts, new TiffValueCollection <uint>(tempArr)).ConfigureAwait(false);
}
string software = Software;
if (!string.IsNullOrEmpty(software))
{
await ifdWriter.WriteTagAsync(TiffTag.Software, new TiffValueCollection <string>(software));
}
ifdOffset = await ifdWriter.FlushAsync(ifdOffset).ConfigureAwait(false);
}
reporter?.ReportCompleteReducedResolutionLayerGeneration(layer, offsets.Length, (long)totalByteCount);
return(ifdOffset);
}