private Task EncodeImageAsync <TPixel>(ImageFrame <TPixel> image, TiffImageFileDirectoryWriter ifdWriter, CancellationToken cancellationToken) where TPixel : unmanaged, IPixel <TPixel>
{
ITiffEncoderOptions options = _options;
var builder = new TiffImageEncoderBuilder();
builder.MemoryPool = _memoryPool;
builder.PhotometricInterpretation = options.PhotometricInterpretation;
builder.Compression = options.Compression;
builder.IsTiled = options.IsTiled;
builder.RowsPerStrip = options.RowsPerStrip;
builder.TileSize = new TiffSize(options.TileSize.Width, options.TileSize.Height);
builder.Predictor = options.Predictor;
builder.EnableTransparencyForRgb = options.EnableTransparencyForRgb;
builder.Orientation = options.Orientation;
builder.DeflateCompressionLevel = options.DeflateCompressionLevel;
builder.JpegOptions = new TiffJpegEncodingOptions {
Quality = options.JpegQuality, OptimizeCoding = options.JpegOptimizeCoding
};
builder.HorizontalChromaSubSampling = options.HorizontalChromaSubSampling;
builder.VerticalChromaSubSampling = options.VerticalChromaSubSampling;
TiffImageEncoder <TPixel> encoder = builder.BuildForImageSharp <TPixel>();
return(encoder.EncodeAsync(ifdWriter, image, cancellationToken));
}
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));
}
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();
}
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();
}
}
public async Task RipBaseLayerAsync(IRipperInitialLayerAcquisitionReporter reporter, CancellationToken cancellationToken)
{
int outputTileSize = _options.OutputTileSize;
int tiffRowCount = (ImageHeight + outputTileSize - 1) / outputTileSize;
int tiffColCount = (ImageWidth + outputTileSize - 1) / outputTileSize;
int index = 0;
ulong[] offsets = new ulong[tiffRowCount * tiffColCount];
ulong[] byteCounts = new ulong[tiffRowCount * tiffColCount];
ulong totalByteCount = 0;
reporter?.ReportStartInitialLayerAcquisition(offsets.Length);
using (var regionReader = new TileRegionReader(this))
using (Image <Rgb24> canvas = new Image <Rgb24>(_configuration, outputTileSize, outputTileSize))
{
for (int row = 0; row < tiffRowCount; row++)
{
int rowYOffset = row * outputTileSize;
for (int col = 0; col < tiffColCount; col++)
{
int colXOffset = col * outputTileSize;
MemoryMarshal.AsBytes(canvas.GetPixelSpan()).Clear();
await regionReader.FillRegionAsync(colXOffset, rowYOffset, canvas, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
TiffStreamRegion region = await _encoder.EncodeAsync(_fileWriter, canvas).ConfigureAwait(false);
offsets[index] = (ulong)region.Offset.Offset;
byteCounts[index] = (uint)region.Length;
totalByteCount += (uint)region.Length;
index++;
reporter?.ReportInitialLayerAcquisitionProgress(index, offsets.Length);
}
}
}
cancellationToken.ThrowIfCancellationRequested();
TiffStreamOffset ifdOffset;
using (TiffImageFileDirectoryWriter ifdWriter = _fileWriter.CreateImageFileDirectory())
{
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)_manifest.Width)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.ImageLength, new TiffValueCollection <ulong>((ulong)_manifest.Height)).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)_manifest.Width)).ConfigureAwait(false);
await ifdWriter.WriteTagAsync(TiffTag.ImageLength, new TiffValueCollection <uint>((uint)_manifest.Height)).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().ConfigureAwait(false);
}
_fileWriter.SetFirstImageFileDirectoryOffset(ifdOffset);
await _fileWriter.FlushAsync().ConfigureAwait(false);
reporter?.ReportCompleteInitialLayerAcquisition(offsets.Length, (long)totalByteCount);
}
