public void Decompress(TiffDecompressionContext context, ReadOnlyMemory <byte> input, Memory <byte> output)
{
// Copy frame header
JpegFrameHeader frameHeader = _frameHeader;
frameHeader = new JpegFrameHeader(frameHeader.SamplePrecision, (ushort)context.ImageSize.Height, (ushort)context.ImageSize.Width, frameHeader.NumberOfComponents, frameHeader.Components);
var decoder = new JpegDecoder();
decoder.StartOfFrame = JpegMarker.StartOfFrame0;
decoder.MemoryPool = context.MemoryPool;
decoder.SetFrameHeader(frameHeader);
decoder.SetRestartInterval(_restartInterval);
foreach (ComponentInfo componentInfo in _components)
{
decoder.SetQuantizationTable(componentInfo.QuantizationTable);
decoder.SetHuffmanTable(componentInfo.DcTable);
decoder.SetHuffmanTable(componentInfo.AcTable);
}
var outputWriter = new JpegBuffer8BitOutputWriter(context.ImageSize.Width, context.SkippedScanlines, context.SkippedScanlines + context.RequestedScanlines, decoder.NumberOfComponents, output);
decoder.SetOutputWriter(outputWriter);
var reader = new JpegReader(input);
decoder.ProcessScan(ref reader, _scanHeader);
}
/// <summary>
/// Reads and writes complex EXIF tags
/// </summary>
private static void ProcessComplexExifTypes()
{
using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var jpegWriter = new JpegWriter("../../../../_Output/ProcessComplexExifTypes.jpg", 70))
{
var exif = new Aurigma.GraphicsMill.Codecs.ExifDictionary(jpegReader.Exif);
Object[] latitude = null;
if (exif.Contains(ExifDictionary.GpsLatitude))
{
latitude = exif.GetItemArray(ExifDictionary.GpsLatitude);
latitude[0] = new UnsignedRational(113, 12);
}
else
{ // Alexandria, Virginia
latitude = new Object[] { new UnsignedRational(38, 1), new UnsignedRational(48, 1), new UnsignedRational(17, 1) };
}
exif.SetItemArray(ExifDictionary.GpsLatitude, latitude);
var gpsVer = new Object[] { (byte)2, (byte)0, (byte)0, (byte)1 };
exif.SetItemArray(ExifDictionary.GpsVersionId, gpsVer);
exif[Aurigma.GraphicsMill.Codecs.ExifDictionary.Software] = "Aurigma Graphics Mill";
jpegWriter.Exif = exif;
Aurigma.GraphicsMill.Pipeline.Run(jpegReader + jpegWriter);
}
}
private static JpegDirectory ProcessBytes([NotNull] string filePath)
{
var directory = new JpegReader().Extract(File.ReadAllBytes(filePath), JpegSegmentType.Sof0);
Assert.NotNull(directory);
return(directory);
}
/// <summary>
/// Extracts and caches the metadata for an image.
/// </summary>
/// <param name="pictureFileInfo">The FileInfo to the image.</param>
/// <returns>The MetaData for the image.</returns>
internal static Metadata GetImageData(FileInfo pictureFileInfo)
{
try
{
string cacheKey = "data(" + pictureFileInfo.FullName + ")";
Cache cache = HttpContext.Current.Cache;
object cached = cache[cacheKey];
if (cached == null)
{
Metadata data = new Metadata();
ExifReader exif = new ExifReader(pictureFileInfo);
exif.Extract(data);
IptcReader iptc = new IptcReader(pictureFileInfo);
iptc.Extract(data);
JpegReader jpeg = new JpegReader(pictureFileInfo);
jpeg.Extract(data);
cache.Insert(cacheKey, data, new CacheDependency(pictureFileInfo.FullName));
return(data);
}
return((Metadata)cached);
}
catch
{
return(new Metadata());
}
}
public override void ProcessScan(ref JpegReader reader, JpegScanHeader scanHeader)
{
if (scanHeader.Components is null)
{
throw new InvalidOperationException();
}
if (Decoder.GetOutputWriter() is null)
{
throw new InvalidOperationException();
}
// Resolve each component
Span <JpegHuffmanDecodingComponent> components = _components.AsSpan(0, InitDecodeComponents(_frameHeader, scanHeader, _components));
foreach (JpegHuffmanDecodingComponent component in components)
{
if (component.QuantizationTable.IsEmpty)
{
ThrowInvalidDataException($"Quantization table of component {component.ComponentIndex} is not defined.");
}
}
_restartInterval = Decoder.GetRestartInterval();
_mcusBeforeRestart = _restartInterval;
_eobrun = 0;
if (components.Length == 1)
{
DecodeProgressiveDataNonInterleaved(ref reader, scanHeader, components[0]);
}
else
{
DecodeProgressiveDataInterleaved(ref reader, scanHeader, components);
}
}
public override void ProcessScan(ref JpegReader reader, JpegScanHeader scanHeader)
{
if (scanHeader.Components is null)
{
throw new InvalidOperationException();
}
if (Decoder.GetOutputWriter() is null)
{
throw new InvalidOperationException();
}
// Resolve each component
Span <JpegHuffmanDecodingComponent> components = _components.AsSpan(0, InitDecodeComponents(_frameHeader, scanHeader, _components));
_restartInterval = Decoder.GetRestartInterval();
_mcusBeforeRestart = _restartInterval;
_eobrun = 0;
if (components.Length == 1)
{
DecodeProgressiveDataNonInterleaved(ref reader, scanHeader, components[0]);
}
else
{
DecodeProgressiveDataInterleaved(ref reader, scanHeader, components);
}
}
/// <summary>
/// Reads EXIF and IPTC metadata
/// </summary>
private static void ReadExifIptc()
{
using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg"))
{
// Read metadata
var exif = jpegReader.Exif;
var iptc = jpegReader.Iptc;
// Show EXIF tags
if (exif != null)
{
Console.WriteLine("EXIF");
Console.WriteLine("---------------");
foreach (object key in exif.Keys)
{
Console.WriteLine("{0}: {1}, {2}", exif.GetKeyDescription(key),
exif[key], exif.GetItemString(key));
}
}
// Show IPTC tags
if (iptc != null)
{
Console.WriteLine("IPTC");
Console.WriteLine("---------------");
foreach (long key in iptc.Keys)
{
Console.WriteLine("{0}: {1}, {2}", iptc.GetKeyDescription(key),
iptc[key], iptc.GetItemString(key));
}
}
}
}
/// <summary>
/// Reads image in JPEG format and saves to WebP format using memory-friendly Pipeline API
/// </summary>
private static void WriteWebPMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var writer = new WebPWriter("../../../../_Output/WriteWebPMemoryFriendly.webp"))
{
Pipeline.Run(reader + writer);
}
}
/// <summary>
/// Saved bitmap to EPS format using memory-friendly Pipeline API
/// </summary>
private static void WriteBitmapToEpsMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var writer = new EpsWriter("../../../../_Output/WriteEpsMemoryFriendly.eps"))
{
Pipeline.Run(reader + writer);
}
}
/// <summary>
/// Reads image in JPEG format and saves to PNG format using memory-friendly Pipeline API
/// </summary>
private static void WritePngMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var flip = new Flip(FlipType.Vertical))
using (var writer = new PngWriter("../../../../_Output/WritePngMemoryFriendly.png"))
{
Pipeline.Run(reader + flip + writer);
}
}
/// <summary>
/// Loads and saves image to file with specified encoder options using memory-friendly Pipeline API
/// </summary>
private static void LoadSaveFileWithOptionsMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
// Set value of JPEG quality to 85
using (var writer = new JpegWriter("../../../../_Output/LoadSaveFileWithOptionsMemoryFriendly.jpg", 85))
{
Pipeline.Run(reader + writer);
}
}
/// <summary>
/// Gets thumbnail of image from its EXIF metadata
/// </summary>
private static void GetExifThumbnail(string inputPath, string outputPath)
{
using (var jpegReader = new JpegReader(inputPath))
using (var thumbnail = (Bitmap)jpegReader.Exif[ExifDictionary.Thumbnail])
using (var jpegWriter = new JpegWriter(outputPath))
{
Pipeline.Run(thumbnail + jpegWriter);
}
}
private static void ResizeAndPreserveMetadata()
{
using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var resizer = new Resize(jpegReader.Width / 2, 0))
using (var jpegWriter = new JpegWriter("../../../../_Output/ResizeAndPreserveMetadata.jpg"))
{
// Read EXIF
var exif = jpegReader.Exif;
// Check if loaded image contains EXIF metadata
if (exif == null)
{
exif = new ExifDictionary();
}
exif[ExifDictionary.Software] = "Aurigma Graphics Mill";
// Read IPTC
var iptc = jpegReader.Iptc;
// Check if loaded image contains IPTC metadata
if (iptc == null)
{
iptc = new IptcDictionary();
}
iptc[IptcDictionary.Keyword] = "mountain";
// Read Adobe resource blocks
var adobeResources = jpegReader.AdobeResources;
// Check if loaded image contains Adobe image resource blocks
if (adobeResources == null)
{
adobeResources = new AdobeResourceDictionary();
}
// Create new adobe image resource block containing copyright metadata
var arBlock = new AdobeResourceBlock("Copyright", new byte[] { 1 });
// Set this block to the item with 0x040A ID (copyright flag)
adobeResources[0x040A] = arBlock;
// Read XMP
var xmp = new XmpData();
//Check if loaded image contains XMP metadata
if (jpegReader.Xmp != null)
{
xmp.Load(jpegReader.Xmp);
}
// Create a node containing dc:contributor metadata
var node = new XmpValueNode(XmpNodeType.SimpleProperty, "John Doe", XmpTagNames.DCContributor);
xmp.AddNode(node);
// Write metadata
jpegWriter.Exif = exif;
jpegWriter.Iptc = iptc;
jpegWriter.AdobeResources = adobeResources;
jpegWriter.Xmp = xmp.Save();
Pipeline.Run(jpegReader + resizer + jpegWriter);
}
}
/// <summary>
/// Resizes while reading of JPEG image using memory-friendly Pipeline API
/// </summary>
private static void ResizeWhileReadingJpegMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var writer = new JpegWriter("../../../../_Output/ResizeWhileReadingJpegMemoryFriendly.jpg"))
{
reader.Scale = JpegScale.x2;
Pipeline.Run(reader + writer);
}
}
/// <summary>
/// Loads and saves image to stream using memory-friendly Pipeline API
/// </summary>
private static void LoadSaveStreamMemoryFriendly()
{
using (var readStream = System.IO.File.OpenRead("../../../../_Input/Chicago.jpg"))
using (var jpegReader = new JpegReader(readStream))
using (var writerStream = System.IO.File.OpenWrite("../../../../_Output/LoadSaveStreamMemoryFriendly.jpg"))
using (var jpegWriter = new JpegWriter(writerStream, 85))
{
Pipeline.Run(jpegReader + jpegWriter);
}
}
/// <summary>
/// Resizes image and clipping path using memory-friendly Pipeline API
/// </summary>
private static void ResizeImageAndClippingPathMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Apple.jpg"))
using (var writer = new JpegWriter("../../../../_Output/ResizeImageAndClippingPathMemoryFriendly.jpg"))
using (var resize = new Resize(reader.Width / 2, reader.Height / 2))
{
writer.AdobeResources = reader.AdobeResources;
Pipeline.Run(reader + resize + writer);
}
}
/// <summary>
/// Crops image and preserves clipping path
/// </summary>
private static void CropImageAndPreserveClippingPath()
{
using (var reader = new JpegReader("../../../../_Input/Apple.jpg"))
using (var writer = new JpegWriter("../../../../_Output/CropImageAndPreserveClippingPath.jpg"))
using (var crop = new Crop(reader.Width / 6, 0, reader.Width / 2, reader.Height / 2))
{
writer.AdobeResources = reader.AdobeResources;
Pipeline.Run(reader + crop + writer);
}
}
/// <summary>
/// Copies all Adobe resources including clipping path
/// </summary>
private static void CopyClippingPath()
{
using (var reader = new JpegReader("../../../../_Input/Apple.jpg"))
using (var bitmap = reader.Frames[0].GetBitmap())
{
var jpegSettings = new JpegSettings();
jpegSettings.AdobeResources = reader.AdobeResources;
bitmap.Save("../../../../_Output/CopyClippingPath.jpg", jpegSettings);
}
}
/// <summary>
/// Resizes while reading of JPEG image
/// </summary>
private static void ResizeWhileReadingJpeg()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
{
reader.Scale = JpegScale.x2;
using (var bitmap = reader.Frames[0].GetBitmap())
{
bitmap.Save("../../../../_Output/ResizeWhileReadingJpeg.jpg");
}
}
}
/// <summary>
/// Reads image in JPEG format and saves to TIFF format using memory-friendly Pipeline API
/// </summary>
private static void WriteTiffMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var flip = new Flip(FlipType.Vertical))
using (var writer = new TiffWriter("../../../../_Output/WriteTiffMemoryFriendly.tif"))
{
writer.Compression = CompressionType.Jpeg;
writer.Quality = 85;
Pipeline.Run(reader + flip + writer);
}
}
/// <summary>
/// Visualizes clipping path for demonstration purposes
/// </summary>
private static void VisualizeClippingPath(string inputPath, string outputPath)
{
using (var reader = new JpegReader(inputPath))
using (var bitmap = reader.Frames[0].GetBitmap())
using (var graphics = bitmap.GetAdvancedGraphics())
{
var graphicsPath = reader.ClippingPaths[0].CreateGraphicsPath(reader.Width, reader.Height);
graphics.DrawPath(new Pen(new RgbColor(0, 0, 255, 127), 4f), Path.Create(graphicsPath));
bitmap.Save(outputPath);
}
}
/// <summary>
/// Reads and writes image in JPEG format using memory-friendly Pipeline API
/// </summary>
private static void ReadAndWriteJpegMemoryFriendly()
{
using (var reader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var flip = new Flip(FlipType.Vertical))
using (var writer = new JpegWriter("../../../../_Output/ReadWriteJpegMemoryFriendly.jpg"))
{
writer.Quality = 90;
writer.UseSubsampling = false;
writer.IsProgressive = true;
Pipeline.Run(reader + flip + writer);
}
}
/// <summary>
/// Resizes image and clipping path
/// </summary>
private static void ResizeImageAndClippingPath()
{
using (var reader = new JpegReader("../../../../_Input/Apple.jpg"))
using (var bitmap = reader.Frames[0].GetBitmap())
{
var jpegSettings = new Aurigma.GraphicsMill.Codecs.JpegSettings();
jpegSettings.AdobeResources = reader.AdobeResources;
bitmap.Transforms.Resize(reader.Width / 2, reader.Height / 2);
bitmap.Save("../../../../_Output/ResizeImageAndClippingPath.jpg", jpegSettings);
}
}
/// <summary>
/// Writes multiframe image in TIFF format using memory-friendly Pipeline API
/// </summary>
private static void WriteMultiframeTiffMemoryFriendly()
{
using (var writer = new TiffWriter("../../../../_Output/WriteMultiframeTiffMemoryFriendly.tif"))
{
using (var reader1 = new JpegReader("../../../../_Input/Chicago.jpg"))
{
Pipeline.Run(reader1 + writer);
}
using (var reader2 = new JpegReader("../../../../_Input/Copenhagen_RGB.jpg"))
{
Pipeline.Run(reader2 + writer);
}
}
}
/// <summary>
/// Converts clipping path to alpha channel mask
/// </summary>
private static void ConvertClippingPathToMask()
{
using (var reader = new JpegReader("../../../../_Input/Apple.jpg"))
using (var bitmap = reader.Frames[0].GetBitmap())
using (var maskBitmap = new Bitmap(bitmap.Width, bitmap.Height, PixelFormat.Format8bppGrayscale, new GrayscaleColor(0)))
using (var graphics = maskBitmap.GetAdvancedGraphics())
{
var graphicsPath = reader.ClippingPaths[0].CreateGraphicsPath(reader.Width, reader.Height);
graphics.FillPath(new SolidBrush(new GrayscaleColor(255)), Path.Create(graphicsPath));
bitmap.Channels.SetAlpha(maskBitmap);
bitmap.Save("../../../../_Output/ConvertClippingPathToMask.png");
}
}
public void JpegReaderObject_Success()
{
DecodedImage decodedImage;
IImageReader reader = null;
string image = "anil.jpeg";
string format = image.Substring(image.IndexOf('.') + 1);
if (format.Equals("jpeg"))
{
reader = new JpegReader(image);
}
Assert.NotNull(reader);
Assert.IsType <JpegReader>(reader);
}
/// <summary>
/// Writes EXIF and IPTC metadata using memory-friendly Pipeline API
/// </summary>
private static void WriteExifIptcMemoryFriendly()
{
using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg"))
using (var jpegWriter = new JpegWriter("../../../../_Output/WriteExifIptcMemoryFriendly.jpg", 70))
{
var exif = new Aurigma.GraphicsMill.Codecs.ExifDictionary();
exif[Aurigma.GraphicsMill.Codecs.ExifDictionary.Software] = "Aurigma Graphics Mill";
jpegWriter.Exif = exif;
var iptc = new Aurigma.GraphicsMill.Codecs.IptcDictionary();
iptc[Aurigma.GraphicsMill.Codecs.IptcDictionary.Keyword] = "mountain";
iptc[Aurigma.GraphicsMill.Codecs.IptcDictionary.City] = "Olympia";
jpegWriter.Iptc = iptc;
Aurigma.GraphicsMill.Pipeline.Run(jpegReader + jpegWriter);
}
}
private void DecodeProgressiveDataInterleaved(ref JpegReader reader, JpegScanHeader scanHeader, Span <JpegArithmeticDecodingComponent> components)
{
foreach (JpegArithmeticDecodingComponent component in components)
{
if (component.DcTable is null || component.DcStatistics is null)
{
ThrowInvalidDataException();
}
}
JpegBlockAllocator allocator = _allocator;
JpegBitReader bitReader = new JpegBitReader(reader.RemainingBytes);
int mcusPerColumn = _mcusPerColumn;
int mcusPerLine = _mcusPerLine;
for (int rowMcu = 0; rowMcu < mcusPerColumn; rowMcu++)
{
for (int colMcu = 0; colMcu < mcusPerLine; colMcu++)
{
foreach (JpegArithmeticDecodingComponent component in components)
{
int index = component.ComponentIndex;
int h = component.HorizontalSamplingFactor;
int v = component.VerticalSamplingFactor;
int offsetX = colMcu * h;
int offsetY = rowMcu * v;
for (int y = 0; y < v; y++)
{
int blockOffsetY = offsetY + y;
for (int x = 0; x < h; x++)
{
ref JpegBlock8x8 blockRef = ref allocator.GetBlockReference(index, offsetX + x, blockOffsetY);
ReadBlockProgressiveDC(ref bitReader, component, scanHeader, ref blockRef);
}
}
}
if (!HandleRestart(ref bitReader, ref reader, ref scanHeader, ref MemoryMarshal.GetReference(components), components.Length))
{
return;
}
}
}
/// <summary>
/// Reads all XMP properties
/// </summary>
private static void ReadXmpMetadata()
{
using (var reader = new JpegReader(@"../../../../_Input/Chicago.jpg"))
{
if (reader.Xmp != null)
{
var xmp = new XmpData(reader.Xmp);
foreach (XmpNode node in xmp.Values)
{
if (node.NodeType == XmpNodeType.SimpleProperty)
{
Console.WriteLine("{0}: {1}", node.Name, node);
}
}
}
}
}
/// <summary>
/// Modifies clipping path explicitly using memory-friendly Pipeline API
/// </summary>
private static void ModifyClippingPathExplicitlyMemoryFriendly()
{
int width = 1000;
int height = 1000;
using (var reader = new JpegReader("../../../../_Input/Apple.jpg"))
using (var generator = new ImageGenerator(width, height, reader.PixelFormat, RgbColor.White))
using (var combiner = new Combiner(CombineMode.Copy))
using (var writer = new JpegWriter("../../../../_Output/ModifyClippingPathExplicitlyMemoryFriendly.jpg"))
{
combiner.TopImage = reader;
combiner.X = (width - reader.Width) / 2;
combiner.Y = (height - reader.Height) / 2;
// The clipping path has relatives coordinates (0.0f ... 1.f0). So we need to transform it.
var transform = new System.Drawing.Drawing2D.Matrix();
transform.Scale((float)reader.Width / (float)width, (float)reader.Height / (float)height);
transform.Translate((float)combiner.X / (float)reader.Width, (float)combiner.Y / (float)reader.Height);
var adobeResources = reader.AdobeResources;
// Remove clipping paths
foreach (long key in adobeResources.Keys)
{
if (key >= FirstPathId && key <= LastPathId)
{
adobeResources.Remove(key);
}
}
// Transform and save clipping paths
for (var i = 0; i < reader.ClippingPaths.Count; i++)
{
var clippingPath = reader.ClippingPaths[i];
clippingPath.ApplyTransform(transform);
adobeResources.Add(FirstPathId + i, new AdobeResourceBlock(clippingPath.Name, clippingPath.Data));
}
writer.AdobeResources = adobeResources;
Pipeline.Run(generator + combiner + writer);
}
}
