public virtual void TestLoadJpegWithNoExifData()
{
sbyte[] badExifData = new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new ExifReader().Extract(badExifData, metadata, JpegSegmentType.App1);
Sharpen.Tests.AreEqual(0, metadata.GetDirectoryCount());
}
public virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType)
{
// skip the first 14 bytes
sbyte[] iccProfileBytes = new sbyte[segmentBytes.Length - 14];
System.Array.Copy(segmentBytes, 14, iccProfileBytes, 0, segmentBytes.Length - 14);
Extract(new ByteArrayReader(iccProfileBytes), metadata);
}
public static Com.Drew.Metadata.Metadata ProcessBytes([NotNull] string filePath)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
sbyte[] bytes = FileUtil.ReadBytes(filePath);
new ExifReader().Extract(new ByteArrayReader(bytes), metadata, ExifReader.JpegSegmentPreamble.Length);
return(metadata);
}
// JpegSegmentType.SOF4,
// JpegSegmentType.SOF12,
public virtual void ReadJpegSegments([NotNull] Iterable <sbyte[]> segments, [NotNull] Com.Drew.Metadata.Metadata metadata, [NotNull] JpegSegmentType segmentType)
{
foreach (sbyte[] segmentBytes in segments)
{
Extract(segmentBytes, metadata, segmentType);
}
}
public virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType)
{
JpegDirectory directory = new JpegDirectory();
metadata.AddDirectory(directory);
// The value of TAG_COMPRESSION_TYPE is determined by the segment type found
directory.SetInt(JpegDirectory.TagCompressionType, segmentType.byteValue - JpegSegmentType.Sof0.byteValue);
SequentialReader reader = new SequentialByteArrayReader(segmentBytes);
try
{
directory.SetInt(JpegDirectory.TagDataPrecision, reader.GetUInt8());
directory.SetInt(JpegDirectory.TagImageHeight, reader.GetUInt16());
directory.SetInt(JpegDirectory.TagImageWidth, reader.GetUInt16());
short componentCount = reader.GetUInt8();
directory.SetInt(JpegDirectory.TagNumberOfComponents, componentCount);
// for each component, there are three bytes of data:
// 1 - Component ID: 1 = Y, 2 = Cb, 3 = Cr, 4 = I, 5 = Q
// 2 - Sampling factors: bit 0-3 vertical, 4-7 horizontal
// 3 - Quantization table number
for (int i = 0; i < (int)componentCount; i++)
{
int componentId = reader.GetUInt8();
int samplingFactorByte = reader.GetUInt8();
int quantizationTableNumber = reader.GetUInt8();
JpegComponent component = new JpegComponent(componentId, samplingFactorByte, quantizationTableNumber);
directory.SetObject(JpegDirectory.TagComponentData1 + i, component);
}
}
catch (IOException ex)
{
directory.AddError(ex.Message);
}
}
static bool PrintMetadata(Com.Drew.Metadata.Metadata metadata)
{
foreach (Com.Drew.Metadata.Directory dir in metadata.GetDirectories())
{
if (dir.HasErrors())
{
Console.ForegroundColor = ConsoleColor.Red;
foreach (string error in dir.GetErrors())
{
Console.Error.WriteLine("\t[{0}] {1}\n", dir.GetName(), error);
}
}
foreach (Com.Drew.Metadata.Tag tag in dir.GetTags())
{
string tagName = tag.GetTagName();
string directoryName = dir.GetName();
string description = tag.GetDescription();
// truncate the description if it's too long
if (description != null && description.Length > 1024)
{
description = description.Substring(0, 1024) + "...";
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("[{0}] {1} = {2}\n", directoryName, tagName, description);
}
}
return(metadata.GetDirectories().Any(d => d.HasErrors())); //True if there are any metadata errors;
}
public virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType)
{
JpegCommentDirectory directory = metadata.GetOrCreateDirectory <JpegCommentDirectory>();
// The entire contents of the directory are the comment
directory.SetString(JpegCommentDirectory.TagComment, Sharpen.Runtime.GetStringForBytes(segmentBytes));
}
public static JpegDirectory ProcessBytes(string filePath)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new JpegReader().Extract(FileUtil.ReadBytes(filePath), metadata, JpegSegmentType.Sof0);
JpegDirectory directory = metadata.GetFirstDirectoryOfType<JpegDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return directory;
}
/// <exception cref="System.IO.IOException"/>
public static XmpDirectory ProcessApp1Bytes(string filePath)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new XmpReader().Extract(FileUtil.ReadBytes(filePath), metadata, JpegSegmentType.App1);
XmpDirectory directory = metadata.GetDirectory<XmpDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return directory;
}
public static AdobeJpegDirectory ProcessBytes([NotNull] string filePath)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new AdobeJpegReader().Extract(new SequentialByteArrayReader(FileUtil.ReadBytes(filePath)), metadata);
AdobeJpegDirectory directory = metadata.GetFirstDirectoryOfType<AdobeJpegDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return directory;
}
public virtual void SetUp()
{
Com.Drew.Metadata.Metadata metadata = ExifReaderTest.ProcessBytes("Tests/Data/nikonMakernoteType1.jpg.app1");
_nikonDirectory = metadata.GetDirectory <NikonType1MakernoteDirectory>();
_exifSubIFDDirectory = metadata.GetDirectory <ExifSubIFDDirectory>();
_exifIFD0Directory = metadata.GetDirectory <ExifIFD0Directory>();
_thumbDirectory = metadata.GetDirectory <ExifThumbnailDirectory>();
}
public static JpegDirectory ProcessBytes(string filePath)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new JpegReader().Extract(FileUtil.ReadBytes(filePath), metadata, JpegSegmentType.Sof0);
JpegDirectory directory = metadata.GetDirectory <JpegDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return(directory);
}
public virtual void TestToString()
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
Sharpen.Tests.AreEqual("Metadata (0 directories)", Sharpen.Extensions.ConvertToString(metadata));
metadata.AddDirectory(new ExifIFD0Directory());
Sharpen.Tests.AreEqual("Metadata (1 directory)", Sharpen.Extensions.ConvertToString(metadata));
metadata.AddDirectory(new ExifSubIFDDirectory());
Sharpen.Tests.AreEqual("Metadata (2 directories)", Sharpen.Extensions.ConvertToString(metadata));
}
public static AdobeJpegDirectory ProcessBytes([NotNull] string filePath)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new AdobeJpegReader().Extract(new SequentialByteArrayReader(FileUtil.ReadBytes(filePath)), metadata);
AdobeJpegDirectory directory = metadata.GetFirstDirectoryOfType <AdobeJpegDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return(directory);
}
public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream)
{
// TIFF processing requires random access, as directories can be scattered throughout the byte sequence.
// InputStream does not support seeking backwards, and so is not a viable option for TIFF processing.
// We use RandomAccessStreamReader, which buffers data from the stream as we seek forward.
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new ExifReader().ExtractTiff(new RandomAccessStreamReader(inputStream), metadata);
return metadata;
}
public virtual void TestHasErrors()
{
ExifSubIFDDirectory directory = new ExifSubIFDDirectory();
directory.AddError("Test Error 1");
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
Sharpen.Tests.IsFalse(metadata.HasErrors());
metadata.AddDirectory(directory);
Sharpen.Tests.IsTrue(metadata.HasErrors());
}
public virtual void TestToString()
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
Sharpen.Tests.AreEqual("Metadata (0 directories)", Sharpen.Extensions.ConvertToString(metadata));
metadata.AddDirectory(new ExifIFD0Directory());
Sharpen.Tests.AreEqual("Metadata (1 directory)", Sharpen.Extensions.ConvertToString(metadata));
metadata.AddDirectory(new ExifSubIFDDirectory());
Sharpen.Tests.AreEqual("Metadata (2 directories)", Sharpen.Extensions.ConvertToString(metadata));
}
public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream)
{
// TIFF processing requires random access, as directories can be scattered throughout the byte sequence.
// InputStream does not support seeking backwards, and so is not a viable option for TIFF processing.
// We use RandomAccessStreamReader, which buffers data from the stream as we seek forward.
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new ExifReader().ExtractTiff(new RandomAccessStreamReader(inputStream), metadata);
return(metadata);
}
public virtual void TestStackOverflowOnRevisitationOfSameDirectory()
{
// An error has been discovered in Exif data segments where a directory is referenced
// repeatedly. Thanks to Alistair Dickie for providing the sample data used in this
// unit test.
Com.Drew.Metadata.Metadata metadata = ProcessBytes("Tests/Data/recursiveDirectories.jpg.app1");
// Mostly we're just happy at this point that we didn't get stuck in an infinite loop.
Sharpen.Tests.AreEqual(5, metadata.GetDirectoryCount());
}
public virtual void ReadJpegSegments([NotNull] Iterable <sbyte[]> segments, [NotNull] Com.Drew.Metadata.Metadata metadata, [NotNull] JpegSegmentType segmentType)
{
foreach (sbyte[] bytes in segments)
{
if (bytes.Length == 12 && Sharpen.Runtime.EqualsIgnoreCase(Preamble, Sharpen.Runtime.GetStringForBytes(bytes, 0, Preamble.Length)))
{
Extract(new SequentialByteArrayReader(bytes), metadata);
}
}
}
public virtual void TestHasErrors()
{
ExifSubIFDDirectory directory = new ExifSubIFDDirectory();
directory.AddError("Test Error 1");
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
Sharpen.Tests.IsFalse(metadata.HasErrors());
metadata.AddDirectory(directory);
Sharpen.Tests.IsTrue(metadata.HasErrors());
}
public static PsdHeaderDirectory ProcessBytes(string file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
RandomAccessFile randomAccessFile = new RandomAccessFile(new FilePath(file), "r");
new PsdReader().Extract(new RandomAccessFileReader(randomAccessFile), metadata);
randomAccessFile.Close();
PsdHeaderDirectory directory = metadata.GetDirectory<PsdHeaderDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return directory;
}
public virtual void ReadJpegSegments([NotNull] Iterable <sbyte[]> segments, [NotNull] Com.Drew.Metadata.Metadata metadata, [NotNull] JpegSegmentType segmentType)
{
foreach (sbyte[] segmentBytes in segments)
{
JpegCommentDirectory directory = new JpegCommentDirectory();
metadata.AddDirectory(directory);
// The entire contents of the directory are the comment
directory.SetString(JpegCommentDirectory.TagComment, Sharpen.Runtime.GetStringForBytes(segmentBytes));
}
}
public static GifHeaderDirectory ProcessBytes(string file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
InputStream stream = new FileInputStream(file);
new GifReader().Extract(new Com.Drew.Lang.StreamReader(stream), metadata);
stream.Close();
GifHeaderDirectory directory = metadata.GetDirectory<GifHeaderDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return directory;
}
public virtual void TestExtract()
{
sbyte[] app2Bytes = FileUtil.ReadBytes("Tests/Data/iccDataInvalid1.jpg.app2");
// ICC data starts after a 14-byte preamble
sbyte[] icc = TestHelper.SkipBytes(app2Bytes, 14);
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new IccReader().Extract(new ByteArrayReader(icc), metadata);
IccDirectory directory = metadata.GetDirectory<IccDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
}
public static Com.Drew.Metadata.Metadata ReadMetadata([NotNull] InputStream inputStream)
{
// TIFF processing requires random access, as directories can be scattered throughout the byte sequence.
// InputStream does not support seeking backwards, so we wrap it with RandomAccessStreamReader, which
// buffers data from the stream as we seek forward.
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
ExifTiffHandler handler = new ExifTiffHandler(metadata, false);
new TiffReader().ProcessTiff(new RandomAccessStreamReader(inputStream), handler, 0);
return metadata;
}
public virtual void SetUp()
{
Com.Drew.Metadata.Metadata metadata = ExifReaderTest.ProcessBytes("Tests/Data/nikonMakernoteType2b.jpg.app1");
_nikonDirectory = metadata.GetFirstDirectoryOfType <NikonType2MakernoteDirectory>();
_exifIFD0Directory = metadata.GetFirstDirectoryOfType <ExifIFD0Directory>();
_exifSubIFDDirectory = metadata.GetFirstDirectoryOfType <ExifSubIFDDirectory>();
_thumbDirectory = metadata.GetFirstDirectoryOfType <ExifThumbnailDirectory>();
NUnit.Framework.Assert.IsNotNull(_nikonDirectory);
NUnit.Framework.Assert.IsNotNull(_exifSubIFDDirectory);
}
public static Com.Drew.Metadata.Metadata ReadMetadata([NotNull] InputStream inputStream)
{
// TIFF processing requires random access, as directories can be scattered throughout the byte sequence.
// InputStream does not support seeking backwards, so we wrap it with RandomAccessStreamReader, which
// buffers data from the stream as we seek forward.
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
ExifTiffHandler handler = new ExifTiffHandler(metadata, false);
new TiffReader().ProcessTiff(new RandomAccessStreamReader(inputStream), handler, 0);
return(metadata);
}
public static void ProcessJpegSegmentData(Com.Drew.Metadata.Metadata metadata, Iterable <JpegSegmentMetadataReader> readers, JpegSegmentData segmentData)
{
// Pass the appropriate byte arrays to each reader.
foreach (JpegSegmentMetadataReader reader in readers)
{
foreach (JpegSegmentType segmentType in reader.GetSegmentTypes())
{
reader.ReadJpegSegments(segmentData.GetSegments(segmentType), metadata, segmentType);
}
}
}
public virtual void TestReadJpegSegmentWithNoExifData()
{
sbyte[] badExifData = new sbyte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
AList <sbyte[]> segments = new AList <sbyte[]>();
segments.Add(badExifData);
new ExifReader().ReadJpegSegments(segments.AsIterable(), metadata, JpegSegmentType.App1);
Sharpen.Tests.AreEqual(0, metadata.GetDirectoryCount());
Sharpen.Tests.IsFalse(metadata.HasErrors());
}
public virtual void TestExtract()
{
sbyte[] app2Bytes = FileUtil.ReadBytes("Tests/Data/iccDataInvalid1.jpg.app2");
// ICC data starts after a 14-byte preamble
sbyte[] icc = TestHelper.SkipBytes(app2Bytes, 14);
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new IccReader().Extract(new ByteArrayReader(icc), metadata);
IccDirectory directory = metadata.GetFirstDirectoryOfType <IccDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
}
public virtual void ReadJpegSegments([NotNull] Iterable <sbyte[]> segments, [NotNull] Com.Drew.Metadata.Metadata metadata, [NotNull] JpegSegmentType segmentType)
{
foreach (sbyte[] segmentBytes in segments)
{
// Ensure data starts with the IPTC marker byte
if (segmentBytes.Length != 0 && segmentBytes[0] == unchecked ((int)(0x1c)))
{
Extract(new SequentialByteArrayReader(segmentBytes), metadata, segmentBytes.Length);
}
}
}
public virtual void SetUp()
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
IList<sbyte[]> jpegSegments = new AList<sbyte[]>();
jpegSegments.Add(FileUtil.ReadBytes("Tests/Data/withXmpAndIptc.jpg.app1.1"));
new XmpReader().ReadJpegSegments(jpegSegments.AsIterable(), metadata, JpegSegmentType.App1);
ICollection<XmpDirectory> xmpDirectories = metadata.GetDirectoriesOfType<XmpDirectory>();
NUnit.Framework.Assert.IsNotNull(xmpDirectories);
Sharpen.Tests.AreEqual(1, xmpDirectories.Count);
_directory = xmpDirectories.Iterator().Next();
Sharpen.Tests.IsFalse(_directory.HasErrors());
}
public virtual void Extract(RandomAccessReader reader, Com.Drew.Metadata.Metadata metadata)
{
// TODO review whether the 'tagPtr' values below really do require ICC processing to work with a RandomAccessReader
IccDirectory directory = metadata.GetOrCreateDirectory <IccDirectory>();
try
{
directory.SetInt(IccDirectory.TagProfileByteCount, reader.GetInt32(IccDirectory.TagProfileByteCount));
// For these tags, the int value of the tag is in fact it's offset within the buffer.
Set4ByteString(directory, IccDirectory.TagCmmType, reader);
SetInt32(directory, IccDirectory.TagProfileVersion, reader);
Set4ByteString(directory, IccDirectory.TagProfileClass, reader);
Set4ByteString(directory, IccDirectory.TagColorSpace, reader);
Set4ByteString(directory, IccDirectory.TagProfileConnectionSpace, reader);
SetDate(directory, IccDirectory.TagProfileDatetime, reader);
Set4ByteString(directory, IccDirectory.TagSignature, reader);
Set4ByteString(directory, IccDirectory.TagPlatform, reader);
SetInt32(directory, IccDirectory.TagCmmFlags, reader);
Set4ByteString(directory, IccDirectory.TagDeviceMake, reader);
int temp = reader.GetInt32(IccDirectory.TagDeviceModel);
if (temp != 0)
{
if (temp <= unchecked ((int)(0x20202020)))
{
directory.SetInt(IccDirectory.TagDeviceModel, temp);
}
else
{
directory.SetString(IccDirectory.TagDeviceModel, GetStringFromInt32(temp));
}
}
SetInt32(directory, IccDirectory.TagRenderingIntent, reader);
SetInt64(directory, IccDirectory.TagDeviceAttr, reader);
float[] xyz = new float[] { reader.GetS15Fixed16(IccDirectory.TagXyzValues), reader.GetS15Fixed16(IccDirectory.TagXyzValues + 4), reader.GetS15Fixed16(IccDirectory.TagXyzValues + 8) };
directory.SetObject(IccDirectory.TagXyzValues, xyz);
// Process 'ICC tags'
int tagCount = reader.GetInt32(IccDirectory.TagTagCount);
directory.SetInt(IccDirectory.TagTagCount, tagCount);
for (int i = 0; i < tagCount; i++)
{
int pos = IccDirectory.TagTagCount + 4 + i * 12;
int tagType = reader.GetInt32(pos);
int tagPtr = reader.GetInt32(pos + 4);
int tagLen = reader.GetInt32(pos + 8);
sbyte[] b = reader.GetBytes(tagPtr, tagLen);
directory.SetByteArray(tagType, b);
}
}
catch (IOException ex)
{
directory.AddError("Exception reading ICC profile: " + ex.Message);
}
}
public static PsdHeaderDirectory ProcessBytes(string file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
RandomAccessFile randomAccessFile = new RandomAccessFile(new FilePath(file), "r");
new PsdReader().Extract(new RandomAccessFileReader(randomAccessFile), metadata);
randomAccessFile.Close();
PsdHeaderDirectory directory = metadata.GetDirectory <PsdHeaderDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return(directory);
}
public static GifHeaderDirectory ProcessBytes(string file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
InputStream stream = new FileInputStream(file);
new GifReader().Extract(new Com.Drew.Lang.StreamReader(stream), metadata);
stream.Close();
GifHeaderDirectory directory = metadata.GetDirectory <GifHeaderDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return(directory);
}
public virtual void TestResolution()
{
Com.Drew.Metadata.Metadata metadata = ExifReaderTest.ProcessBytes("Tests/Data/withUncompressedRGBThumbnail.jpg.app1");
ExifThumbnailDirectory thumbnailDirectory = metadata.GetDirectory <ExifThumbnailDirectory>();
NUnit.Framework.Assert.IsNotNull(thumbnailDirectory);
Sharpen.Tests.AreEqual(72, thumbnailDirectory.GetInt(ExifThumbnailDirectory.TagXResolution));
ExifIFD0Directory exifIFD0Directory = metadata.GetDirectory <ExifIFD0Directory>();
NUnit.Framework.Assert.IsNotNull(exifIFD0Directory);
Sharpen.Tests.AreEqual(216, exifIFD0Directory.GetInt(ExifIFD0Directory.TagXResolution));
}
public virtual void ExtractTiff(RandomAccessReader reader, Com.Drew.Metadata.Metadata metadata)
{
ExifIFD0Directory directory = metadata.GetOrCreateDirectory <ExifIFD0Directory>();
try
{
ExtractTiff(reader, metadata, directory, 0);
}
catch (IOException e)
{
directory.AddError("IO problem: " + e.Message);
}
}
public virtual void ReadJpegSegments([NotNull] Iterable <sbyte[]> segments, [NotNull] Com.Drew.Metadata.Metadata metadata, [NotNull] JpegSegmentType segmentType)
{
System.Diagnostics.Debug.Assert((segmentType == JpegSegmentType.App1));
foreach (sbyte[] segmentBytes in segments)
{
// Filter any segments containing unexpected preambles
if (segmentBytes.Length < JpegSegmentPreamble.Length || !Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, JpegSegmentPreamble.Length).Equals(JpegSegmentPreamble))
{
continue;
}
Extract(new ByteArrayReader(segmentBytes), metadata, JpegSegmentPreamble.Length);
}
}
public virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType)
{
if (segmentBytes == null)
{
throw new ArgumentNullException("segmentBytes cannot be null");
}
if (metadata == null)
{
throw new ArgumentNullException("metadata cannot be null");
}
if (segmentType == null)
{
throw new ArgumentNullException("segmentType cannot be null");
}
try
{
ByteArrayReader reader = new ByteArrayReader(segmentBytes);
//
// Check for the header preamble
//
try
{
if (!reader.GetString(0, JpegExifSegmentPreamble.Length).Equals(JpegExifSegmentPreamble))
{
// TODO what do to with this error state?
System.Console.Error.Println("Invalid JPEG Exif segment preamble");
return;
}
}
catch (IOException e)
{
// TODO what do to with this error state?
Sharpen.Runtime.PrintStackTrace(e, System.Console.Error);
return;
}
//
// Read the TIFF-formatted Exif data
//
new TiffReader().ProcessTiff(reader, new ExifTiffHandler(metadata, _storeThumbnailBytes), JpegExifSegmentPreamble.Length);
}
catch (TiffProcessingException e)
{
// TODO what do to with this error state?
Sharpen.Runtime.PrintStackTrace(e, System.Console.Error);
}
catch (IOException e)
{
// TODO what do to with this error state?
Sharpen.Runtime.PrintStackTrace(e, System.Console.Error);
}
}
public virtual void Extract([NotNull] SequentialReader reader, [NotNull] Com.Drew.Metadata.Metadata metadata)
{
reader.SetMotorolaByteOrder(false);
PcxDirectory directory = new PcxDirectory();
metadata.AddDirectory(directory);
try
{
sbyte identifier = reader.GetInt8();
if (identifier != unchecked ((int)(0x0A)))
{
throw new ImageProcessingException("Invalid PCX identifier byte");
}
directory.SetInt(PcxDirectory.TagVersion, reader.GetInt8());
sbyte encoding = reader.GetInt8();
if (encoding != unchecked ((int)(0x01)))
{
throw new ImageProcessingException("Invalid PCX encoding byte");
}
directory.SetInt(PcxDirectory.TagBitsPerPixel, reader.GetUInt8());
directory.SetInt(PcxDirectory.TagXmin, reader.GetUInt16());
directory.SetInt(PcxDirectory.TagYmin, reader.GetUInt16());
directory.SetInt(PcxDirectory.TagXmax, reader.GetUInt16());
directory.SetInt(PcxDirectory.TagYmax, reader.GetUInt16());
directory.SetInt(PcxDirectory.TagHorizontalDpi, reader.GetUInt16());
directory.SetInt(PcxDirectory.TagVerticalDpi, reader.GetUInt16());
directory.SetByteArray(PcxDirectory.TagPalette, reader.GetBytes(48));
reader.Skip(1);
directory.SetInt(PcxDirectory.TagColorPlanes, reader.GetUInt8());
directory.SetInt(PcxDirectory.TagBytesPerLine, reader.GetUInt16());
int paletteType = reader.GetUInt16();
if (paletteType != 0)
{
directory.SetInt(PcxDirectory.TagPaletteType, paletteType);
}
int hScrSize = reader.GetUInt16();
if (hScrSize != 0)
{
directory.SetInt(PcxDirectory.TagHscrSize, hScrSize);
}
int vScrSize = reader.GetUInt16();
if (vScrSize != 0)
{
directory.SetInt(PcxDirectory.TagVscrSize, vScrSize);
}
}
catch (Exception ex)
{
directory.AddError("Exception reading PCX file metadata: " + ex.Message);
}
}
public static Com.Drew.Metadata.Metadata ReadMetadata(FilePath file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
try
{
new ExifReader().ExtractTiff(new RandomAccessFileReader(randomAccessFile), metadata);
}
finally
{
randomAccessFile.Close();
}
return metadata;
}
public static Com.Drew.Metadata.Metadata ReadMetadata([NotNull] FilePath file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r");
try
{
ExifTiffHandler handler = new ExifTiffHandler(metadata, false);
new TiffReader().ProcessTiff(new RandomAccessFileReader(randomAccessFile), handler, 0);
}
finally
{
randomAccessFile.Close();
}
new FileMetadataReader().Read(file, metadata);
return metadata;
}
public static Com.Drew.Metadata.Metadata ReadMetadata([NotNull] InputStream inputStream)
{
Iterable<PngChunk> chunks = new PngChunkReader().Extract(new Com.Drew.Lang.StreamReader(inputStream), _desiredChunkTypes);
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
foreach (PngChunk chunk in chunks)
{
try
{
ProcessChunk(metadata, chunk);
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e, System.Console.Error);
}
}
return metadata;
}
protected internal DirectoryTiffHandler(Com.Drew.Metadata.Metadata metadata, Type initialDirectoryClass)
{
_metadata = metadata;
try
{
_currentDirectory = (Directory)System.Activator.CreateInstance(initialDirectoryClass);
}
catch (InstantiationException e)
{
throw new RuntimeException(e);
}
catch (MemberAccessException e)
{
throw new RuntimeException(e);
}
_metadata.AddDirectory(_currentDirectory);
}
public static PsdHeaderDirectory ProcessBytes([NotNull] string file)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
InputStream stream = new FileInputStream(new FilePath(file));
try
{
new PsdReader().Extract(new Com.Drew.Lang.StreamReader(stream), metadata);
}
catch (Exception e)
{
stream.Close();
throw;
}
PsdHeaderDirectory directory = metadata.GetFirstDirectoryOfType<PsdHeaderDirectory>();
NUnit.Framework.Assert.IsNotNull(directory);
return directory;
}
public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new PsdReader().Extract(new RandomAccessStreamReader(inputStream), metadata);
return metadata;
}
public static Com.Drew.Metadata.Metadata ReadMetadata([NotNull] InputStream inputStream)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new IcoReader().Extract(new Com.Drew.Lang.StreamReader(inputStream), metadata);
return metadata;
}
public static Com.Drew.Metadata.Metadata ReadMetadata([NotNull] InputStream inputStream)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
new RiffReader().ProcessRiff(new Com.Drew.Lang.StreamReader(inputStream), new WebpRiffHandler(metadata));
return metadata;
}
public WebpRiffHandler([NotNull] Com.Drew.Metadata.Metadata metadata)
{
_metadata = metadata;
}
public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream)
{
// TODO keep a single static hash of these
ICollection<PngChunkType> desiredChunkTypes = new HashSet<PngChunkType>();
desiredChunkTypes.Add(PngChunkType.Ihdr);
desiredChunkTypes.Add(PngChunkType.Plte);
desiredChunkTypes.Add(PngChunkType.tRNS);
desiredChunkTypes.Add(PngChunkType.cHRM);
desiredChunkTypes.Add(PngChunkType.sRGB);
desiredChunkTypes.Add(PngChunkType.gAMA);
desiredChunkTypes.Add(PngChunkType.iCCP);
desiredChunkTypes.Add(PngChunkType.bKGD);
desiredChunkTypes.Add(PngChunkType.tEXt);
desiredChunkTypes.Add(PngChunkType.iTXt);
desiredChunkTypes.Add(PngChunkType.tIME);
Iterable<PngChunk> chunks = new PngChunkReader().Extract(new Com.Drew.Lang.StreamReader(inputStream), desiredChunkTypes);
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
IList<KeyValuePair> textPairs = new AList<KeyValuePair>();
foreach (PngChunk chunk in chunks)
{
PngChunkType chunkType = chunk.GetChunkType();
sbyte[] bytes = chunk.GetBytes();
if (chunkType.Equals(PngChunkType.Ihdr))
{
PngHeader header = new PngHeader(bytes);
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetInt(PngDirectory.TagImageWidth, header.GetImageWidth());
directory.SetInt(PngDirectory.TagImageHeight, header.GetImageHeight());
directory.SetInt(PngDirectory.TagBitsPerSample, header.GetBitsPerSample());
directory.SetInt(PngDirectory.TagColorType, header.GetColorType().GetNumericValue());
directory.SetInt(PngDirectory.TagCompressionType, header.GetCompressionType());
directory.SetInt(PngDirectory.TagFilterMethod, header.GetFilterMethod());
directory.SetInt(PngDirectory.TagInterlaceMethod, header.GetInterlaceMethod());
}
else
{
if (chunkType.Equals(PngChunkType.Plte))
{
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetInt(PngDirectory.TagPaletteSize, bytes.Length / 3);
}
else
{
if (chunkType.Equals(PngChunkType.tRNS))
{
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetInt(PngDirectory.TagPaletteHasTransparency, 1);
}
else
{
if (chunkType.Equals(PngChunkType.sRGB))
{
int srgbRenderingIntent = new SequentialByteArrayReader(bytes).GetInt8();
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetInt(PngDirectory.TagSrgbRenderingIntent, srgbRenderingIntent);
}
else
{
if (chunkType.Equals(PngChunkType.cHRM))
{
PngChromaticities chromaticities = new PngChromaticities(bytes);
PngChromaticitiesDirectory directory = metadata.GetOrCreateDirectory<PngChromaticitiesDirectory>();
directory.SetInt(PngChromaticitiesDirectory.TagWhitePointX, chromaticities.GetWhitePointX());
directory.SetInt(PngChromaticitiesDirectory.TagWhitePointX, chromaticities.GetWhitePointX());
directory.SetInt(PngChromaticitiesDirectory.TagRedX, chromaticities.GetRedX());
directory.SetInt(PngChromaticitiesDirectory.TagRedY, chromaticities.GetRedY());
directory.SetInt(PngChromaticitiesDirectory.TagGreenX, chromaticities.GetGreenX());
directory.SetInt(PngChromaticitiesDirectory.TagGreenY, chromaticities.GetGreenY());
directory.SetInt(PngChromaticitiesDirectory.TagBlueX, chromaticities.GetBlueX());
directory.SetInt(PngChromaticitiesDirectory.TagBlueY, chromaticities.GetBlueY());
}
else
{
if (chunkType.Equals(PngChunkType.gAMA))
{
int gammaInt = new SequentialByteArrayReader(bytes).GetInt32();
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetDouble(PngDirectory.TagGamma, gammaInt / 100000.0);
}
else
{
if (chunkType.Equals(PngChunkType.iCCP))
{
SequentialReader reader = new SequentialByteArrayReader(bytes);
string profileName = reader.GetNullTerminatedString(79);
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetString(PngDirectory.TagProfileName, profileName);
sbyte compressionMethod = reader.GetInt8();
if (compressionMethod == 0)
{
// Only compression method allowed by the spec is zero: deflate
// This assumes 1-byte-per-char, which it is by spec.
int bytesLeft = bytes.Length - profileName.Length - 2;
sbyte[] compressedProfile = reader.GetBytes(bytesLeft);
InflaterInputStream inflateStream = new InflaterInputStream(new ByteArrayInputStream(compressedProfile));
new IccReader().Extract(new RandomAccessStreamReader(inflateStream), metadata);
inflateStream.Close();
}
}
else
{
if (chunkType.Equals(PngChunkType.bKGD))
{
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetByteArray(PngDirectory.TagBackgroundColor, bytes);
}
else
{
if (chunkType.Equals(PngChunkType.tEXt))
{
SequentialReader reader = new SequentialByteArrayReader(bytes);
string keyword = reader.GetNullTerminatedString(79);
int bytesLeft = bytes.Length - keyword.Length - 1;
string value = reader.GetNullTerminatedString(bytesLeft);
textPairs.Add(new KeyValuePair(keyword, value));
}
else
{
if (chunkType.Equals(PngChunkType.iTXt))
{
SequentialReader reader = new SequentialByteArrayReader(bytes);
string keyword = reader.GetNullTerminatedString(79);
sbyte compressionFlag = reader.GetInt8();
sbyte compressionMethod = reader.GetInt8();
string languageTag = reader.GetNullTerminatedString(bytes.Length);
string translatedKeyword = reader.GetNullTerminatedString(bytes.Length);
int bytesLeft = bytes.Length - keyword.Length - 1 - 1 - 1 - languageTag.Length - 1 - translatedKeyword.Length - 1;
string text = null;
if (compressionFlag == 0)
{
text = reader.GetNullTerminatedString(bytesLeft);
}
else
{
if (compressionFlag == 1)
{
if (compressionMethod == 0)
{
text = StringUtil.FromStream(new InflaterInputStream(new ByteArrayInputStream(bytes, bytes.Length - bytesLeft, bytesLeft)));
}
else
{
metadata.GetOrCreateDirectory<PngDirectory>().AddError("Invalid compression method value");
}
}
else
{
metadata.GetOrCreateDirectory<PngDirectory>().AddError("Invalid compression flag value");
}
}
if (text != null)
{
if (keyword.Equals("XML:com.adobe.xmp"))
{
// NOTE in testing images, the XMP has parsed successfully, but we are not extracting tags from it as necessary
new XmpReader().Extract(text, metadata);
}
else
{
textPairs.Add(new KeyValuePair(keyword, text));
}
}
}
else
{
if (chunkType.Equals(PngChunkType.tIME))
{
SequentialByteArrayReader reader = new SequentialByteArrayReader(bytes);
int year = reader.GetUInt16();
int month = reader.GetUInt8() - 1;
int day = reader.GetUInt8();
int hour = reader.GetUInt8();
int minute = reader.GetUInt8();
int second = reader.GetUInt8();
Sharpen.Calendar calendar = Sharpen.Calendar.GetInstance(Sharpen.Extensions.GetTimeZone("UTC"));
//noinspection MagicConstant
calendar.Set(year, month, day, hour, minute, second);
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetDate(PngDirectory.TagLastModificationTime, calendar.GetTime());
}
}
}
}
}
}
}
}
}
}
}
}
if (textPairs.Count != 0)
{
PngDirectory directory = metadata.GetOrCreateDirectory<PngDirectory>();
directory.SetObject(PngDirectory.TagTextualData, textPairs);
}
return metadata;
}
public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream, Iterable<JpegSegmentMetadataReader> readers)
{
Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
Process(metadata, inputStream, readers);
return metadata;
}
