private async Task EncodeCoreAsync <TPixel>(Image <TPixel> image, Stream stream, bool isAsync, CancellationToken cancellationToken) where TPixel : unmanaged, IPixel <TPixel>
{
TiffFileWriter writer;
if (isAsync)
{
writer = await TiffFileWriter.OpenAsync(stream, leaveOpen : true, cancellationToken : cancellationToken).ConfigureAwait(false);
}
else
{
writer = await TiffFileWriter.OpenAsync(new ImageSharpContentReaderWriter(stream), leaveOpen : true, cancellationToken : cancellationToken).ConfigureAwait(false);
}
try
{
using (TiffImageFileDirectoryWriter ifdWriter = writer.CreateImageFileDirectory())
{
await EncodeImageAsync(image.Frames.RootFrame, ifdWriter, cancellationToken).ConfigureAwait(false);
writer.SetFirstImageFileDirectoryOffset(await ifdWriter.FlushAsync(cancellationToken).ConfigureAwait(false));
}
await writer.FlushAsync(cancellationToken).ConfigureAwait(false);
}
finally
{
await writer.DisposeAsync().ConfigureAwait(false);
}
}
public async Task EncodeTileImage()
{
await using TiffFileWriter writer = await TiffFileWriter.OpenAsync(new EmptyContentReaderWriter (), false, false);
using (TiffImageFileDirectoryWriter ifdWriter = writer.CreateImageFileDirectory())
{
await _tileEncoder.EncodeAsync(ifdWriter, _image);
writer.SetFirstImageFileDirectoryOffset(await ifdWriter.FlushAsync());
}
await writer.FlushAsync();
}
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 async Task InitializeAsync(Uri manifestUri, CancellationToken cancellationToken)
{
if (manifestUri == null)
{
throw new ArgumentNullException(nameof(manifestUri));
}
// Parse DZI file.
_manifest = await InitializeManifestAsync(manifestUri).ConfigureAwait(false);
// Calculate Deep Zoom layers
_layers = DeepZoomHelper.CalculateDeepZoomLayers(_manifest.Width, _manifest.Height);
// Get output file ready
_stream = new FileStream(_outputFile, FileMode.Create, FileAccess.ReadWrite);
_fileWriter = await TiffFileWriter.OpenAsync(_stream, leaveOpen : true, useBigTiff : UseBigTiff).ConfigureAwait(false);
}
private static async Task GenerateImageAsync(Stream stream, TiffImageEncoderBuilder builder, TiffPixelBuffer <TiffGray8> image)
{
using (TiffFileWriter writer = await TiffFileWriter.OpenAsync(stream, true))
{
TiffStreamOffset ifdOffset;
using (TiffImageFileDirectoryWriter ifdWriter = writer.CreateImageFileDirectory())
{
TiffImageEncoder <TiffGray8> encoder = builder.Build <TiffGray8>();
await encoder.EncodeAsync(ifdWriter, image);
ifdOffset = await ifdWriter.FlushAsync();
}
writer.SetFirstImageFileDirectoryOffset(ifdOffset);
await writer.FlushAsync();
}
}
private static async Task <Stream> GenerateTiffAsync(bool bigTiff, Func <TiffImageFileDirectoryWriter, Task> ifdAction)
{
var ms = new MemoryStream();
using (TiffFileWriter writer = await TiffFileWriter.OpenAsync(ms, leaveOpen: true, useBigTiff: bigTiff))
{
using (TiffImageFileDirectoryWriter ifd = writer.CreateImageFileDirectory())
{
await ifdAction(ifd);
writer.SetFirstImageFileDirectoryOffset(await ifd.FlushAsync());
}
await writer.FlushAsync();
}
ms.Seek(0, SeekOrigin.Begin);
return(ms);
}
public override Task <TiffStreamRegion> EncodeAsync(TiffFileWriter writer, TiffPoint offset, TiffSize size, ITiffPixelBufferReader <TExposedPixel> reader, CancellationToken cancellationToken = default)
{
if (writer is null)
{
throw new ArgumentNullException(nameof(writer));
}
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
if (typeof(TExposedPixel) == typeof(TIntermediate))
{
return(_encoder.EncodeAsync(writer, offset, size, new TiffPassthroughPixelBufferReader <TExposedPixel, TTiffPixel>(reader), cancellationToken));
}
return(_encoder.EncodeAsync(writer, offset, size, new ImageSharpConversionPixelBufferReader <TExposedPixel, TIntermediate, TTiffPixel>(reader), cancellationToken));
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_stream?.Dispose();
_fileWriter?.Dispose();
_fileReader?.Dispose();
}
_stream = null;
_fileWriter = null;
_fileReader = null;
disposedValue = true;
}
}
/// <inheritdoc />
public override async Task <TiffStreamRegion> EncodeAsync(TiffFileWriter writer, TiffPoint offset, TiffSize size, ITiffPixelBufferReader <TPixel> reader, CancellationToken cancellationToken)
{
if (writer is null)
{
throw new ArgumentNullException(nameof(writer));
}
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
if (_imageEncoder is null)
{
throw new InvalidOperationException("Image encoder is not configured.");
}
TiffPixelBufferReader <TPixel> structReader = reader.AsPixelBufferReader();
size = new TiffSize(Math.Max(0, Math.Min(structReader.Width - offset.X, size.Width)), Math.Max(0, Math.Min(structReader.Height - offset.Y, size.Height)));
if (size.IsAreaEmpty)
{
throw new ArgumentOutOfRangeException(nameof(size), "The image size is zero.");
}
var context = new TiffDefaultImageEncoderContext <TPixel>
{
MemoryPool = _memoryPool ?? MemoryPool <byte> .Shared,
CancellationToken = cancellationToken,
FileWriter = writer,
ImageSize = size,
PixelConverterFactory = TiffDefaultPixelConverterFactory.Instance,
PixelBufferReader = structReader
};
await _imageEncoder.RunAsync(context).ConfigureAwait(false);
return(context.OutputRegion);
}
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);
}
