public static NSData ToNSData(this Image image, Imaging.ImageFormat format)
{
using (var stream = new IO.MemoryStream()) {
image.Save(stream, format);
return(NSData.FromArray(stream.ToArray()));
}
}
private ImageDimensions CalculateImageDimensions(
Imaging.ImageFormat format,
PixelStorageOptions storageOptions,
ImageDimensions embeddedImageDimensions,
long totalBytes,
out int imageRepeats)
{
imageRepeats = 1;
int bitsPerPixel = storageOptions == null
? format.BytesPerPixel * 8
: storageOptions.BitsPerPixel;
long pixelsRequired = (long)Math.Ceiling(totalBytes / (bitsPerPixel / 8.0));
int frames;
if (!format.SupportsFrames)
{
frames = 1;
}
else if (embeddedImageDimensions != null)
{
frames = embeddedImageDimensions.Frames ?? 1;
}
else
{
frames = (int)Math.Ceiling(pixelsRequired / Math.Pow(ImageWidthFrameThreshold, 2));
}
int imageWidth;
int imageHeight;
if (embeddedImageDimensions != null)
{
imageWidth = embeddedImageDimensions.Width;
imageHeight = embeddedImageDimensions.Height;
}
else
{
imageWidth = (int)Math.Floor(Math.Sqrt(pixelsRequired / frames));
imageHeight = (int)(pixelsRequired / (imageWidth * frames));
}
while (Math.BigMul(imageHeight, (int)Math.Floor(imageWidth * (bitsPerPixel / 8.0) * frames)) <= totalBytes)
{
if (format.SupportsFrames)
{
imageRepeats++;
frames += (embeddedImageDimensions != null ? embeddedImageDimensions.Frames : null) ?? 1;
}
else
{
imageHeight++;
}
}
return(new ImageDimensions(format.SupportsFrames ? frames : (int?)null, imageWidth, imageHeight));
}
protected virtual async Task <Stream> CreateImageWriterStreamAsync(ImageConfiguration configuration, Stream output, long totalBytes)
{
Imaging.ImageFormat imageFormat = ImageFormatFactory.GetFormat(configuration.Format);
ImageOptions imageOptions = GenerateImageOptions(configuration, imageFormat, CalculateImageDimensions(imageFormat, totalBytes));
Stream imageStream = imageFormat.CreateWriter(imageOptions).CreateOutputStream(output, true, EncodingConfiguration.BufferSize);
await WriteHeaderAsync(imageStream);
return(imageStream);
}
private ImageDimensions CalculateImageDimensions(Imaging.ImageFormat format, long totalBytes)
{
long pixelsRequired = (long)Math.Ceiling((double)totalBytes / format.BytesPerPixel);
int frames = format.SupportsFrames ? (int)Math.Ceiling(pixelsRequired / Math.Pow(ImageWidthFrameThreshold, 2)) : 1;
int imageWidth = (int)Math.Floor(Math.Sqrt(pixelsRequired / frames));
var imageHeight = (int)(pixelsRequired / (imageWidth * frames));
while (Math.BigMul(imageHeight, (int)Math.Floor((double)imageWidth * format.BytesPerPixel * frames)) <= totalBytes)
{
imageHeight++;
}
return(new ImageDimensions(format.SupportsFrames ? frames : (int?)null, imageWidth, imageHeight));
}
protected override async Task <Stream> CreateImageWriterStreamAsync(ImageConfiguration configuration, Stream output, long totalBytes)
{
Imaging.ImageFormat imageFormat = ImageFormatFactory.GetFormat(configuration.Format);
var pixelStorageSerializer = new PixelStorageOptionsSerializer();
totalBytes += pixelStorageSerializer.CalculateStorageLength(imageFormat);
ImageDimensions embeddedImageDimensions = null;
PixelStorageOptions pixelStorageOptions;
Stream embeddedImageStream = null;
if (configuration.HasEmbeddedImage)
{
embeddedImageDimensions = new ImageDimensions(configuration.EmbeddedImage.Image);
pixelStorageOptions = _pixelStorageCalculator.CalculatePixelStorageOptions(
imageFormat,
configuration.EmbeddedImage.EmbeddedPixelStorage,
embeddedImageDimensions,
totalBytes);
embeddedImageStream = imageFormat.LoadPixelDataStream(configuration.EmbeddedImage.Image);
}
else
{
pixelStorageOptions = imageFormat.PixelStorageWithBitsPerChannel(
8,
PixelStorageOptions.BitStorageMode.MostSignificantBits);
}
byte[] pixelStorageBytes = await pixelStorageSerializer.SerializeToBytesAsync(pixelStorageOptions);
int embeddedImageRepeats;
ImageOptions imageOptions = GenerateImageOptions(
configuration,
imageFormat,
CalculateImageDimensions(imageFormat, pixelStorageOptions, embeddedImageDimensions, totalBytes, out embeddedImageRepeats));
Stream imageStream = imageFormat.CreateWriter(imageOptions).CreateOutputStream(output, true, EncodingConfiguration.BufferSize);
await WriteHeaderAsync(imageStream);
await imageStream.WriteAsync(pixelStorageBytes, 0, pixelStorageBytes.Length);
if (configuration.HasEmbeddedImage)
{
var repeatingImageStream = new RepeatingStream(embeddedImageStream, embeddedImageRepeats);
return(new PixelStorageWriterStream(
imageStream,
new SubStream(
repeatingImageStream,
imageStream.Position,
repeatingImageStream.Length - repeatingImageStream.Position - imageStream.Position),
pixelStorageOptions,
leaveOpen: false,
bufferSize: EncodingConfiguration.BufferSize));
}
return(imageStream);
}
public void Save(string path, Imaging.ImageFormat format)
{
}
