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 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);
}
}
/// <summary>Gets the set of JPEG segment type identifiers.</summary>
public virtual Iterable <JpegSegmentType> GetSegmentTypes()
{
ICollection <JpegSegmentType> segmentTypes = new HashSet <JpegSegmentType>();
foreach (sbyte segmentTypeByte in _segmentDataMap.Keys)
{
JpegSegmentType segmentType = JpegSegmentType.FromByte(segmentTypeByte);
if (segmentType == null)
{
throw new InvalidOperationException("Should not have a segmentTypeByte that is not in the enum: " + Sharpen.Extensions.ToHexString(segmentTypeByte));
}
segmentTypes.Add(segmentType);
}
return(segmentTypes.AsIterable());
}
public virtual Iterable <sbyte[]> GetSegments([NotNull] JpegSegmentType segmentType)
{
return(GetSegments(segmentType.byteValue));
}
public virtual sbyte[] GetSegment([NotNull] JpegSegmentType segmentType, int occurrence)
{
return(GetSegment(segmentType.byteValue, occurrence));
}
public virtual Iterable<sbyte[]> GetSegments(JpegSegmentType segmentType)
{
return GetSegments(segmentType.byteValue);
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return segmentBytes.Length > 12 && "Photoshop 3.0".Equals(Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, 13));
}
/// <summary>Removes a specified instance of a segment's data from the collection.</summary>
/// <remarks>
/// Removes a specified instance of a segment's data from the collection. Use this method when more than one
/// occurrence of segment data exists for a given type exists.
/// </remarks>
/// <param name="segmentType">identifies the required segment</param>
/// <param name="occurrence">the zero-based index of the segment occurrence to remove.</param>
public virtual void RemoveSegmentOccurrence(JpegSegmentType segmentType, int occurrence)
{
RemoveSegmentOccurrence(segmentType.byteValue, occurrence);
}
/// <summary>Removes all segments from the collection having the specified type.</summary>
/// <param name="segmentType">identifies the required segment</param>
public virtual void RemoveSegment([NotNull] JpegSegmentType segmentType)
{
RemoveSegment(segmentType.byteValue);
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return segmentBytes.Length == 12 && Sharpen.Runtime.EqualsIgnoreCase("Adobe", Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, 5));
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
// Check whether the first byte resembles
return segmentBytes.Length != 0 && segmentBytes[0] == unchecked((int)(0x1c));
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return segmentBytes.Length > 27 && Sharpen.Runtime.EqualsIgnoreCase("http://ns.adobe.com/xap/1.0/", Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, 28));
}
/// <summary>Version specifically for dealing with XMP found in JPEG segments.</summary>
/// <remarks>
/// Version specifically for dealing with XMP found in JPEG segments. This form of XMP has a peculiar preamble, which
/// must be removed before parsing the XML.
/// </remarks>
/// <param name="segmentBytes">The byte array from which the metadata should be extracted.</param>
/// <param name="metadata">
/// The
/// <see cref="Com.Drew.Metadata.Metadata"/>
/// object into which extracted values should be merged.
/// </param>
/// <param name="segmentType">
/// The
/// <see cref="Com.Drew.Imaging.Jpeg.JpegSegmentType"/>
/// being read.
/// </param>
public virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType)
{
XmpDirectory directory = metadata.GetOrCreateDirectory<XmpDirectory>();
// XMP in a JPEG file has a 29 byte preamble which is not valid XML.
int preambleLength = 29;
// check for the header length
if (segmentBytes.Length <= preambleLength + 1)
{
directory.AddError(Sharpen.Extensions.StringFormat("Xmp data segment must contain at least %d bytes", preambleLength + 1));
return;
}
ByteArrayReader reader = new ByteArrayReader(segmentBytes);
string preamble = Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, preambleLength);
if (!"http://ns.adobe.com/xap/1.0/\x0".Equals(preamble))
{
directory.AddError("XMP data segment doesn't begin with 'http://ns.adobe.com/xap/1.0/'");
return;
}
sbyte[] xmlBytes = new sbyte[segmentBytes.Length - preambleLength];
System.Array.Copy(segmentBytes, 29, xmlBytes, 0, xmlBytes.Length);
Extract(xmlBytes, metadata);
}
public virtual sbyte[] GetSegment(JpegSegmentType segmentType)
{
return GetSegment(segmentType.byteValue, 0);
}
/// <summary>Determines whether data is present for a given segment type.</summary>
/// <param name="segmentType">identifies the required segment</param>
/// <returns>true if data exists, otherwise false</returns>
public virtual bool ContainsSegment(JpegSegmentType segmentType)
{
return ContainsSegment(segmentType.byteValue);
}
/// <summary>Removes all segments from the collection having the specified type.</summary>
/// <param name="segmentType">identifies the required segment</param>
public virtual void RemoveSegment(JpegSegmentType segmentType)
{
RemoveSegment(segmentType.byteValue);
}
/// <summary>Returns the count of segment data byte arrays stored for a given segment type.</summary>
/// <param name="segmentType">identifies the required segment</param>
/// <returns>the segment count (zero if no segments exist).</returns>
public virtual int GetSegmentCount([NotNull] JpegSegmentType segmentType)
{
return(GetSegmentCount(segmentType.byteValue));
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return segmentBytes.Length > 10 && Sharpen.Runtime.EqualsIgnoreCase("ICC_PROFILE", Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, 11));
}
/// <summary>Removes a specified instance of a segment's data from the collection.</summary>
/// <remarks>
/// Removes a specified instance of a segment's data from the collection. Use this method when more than one
/// occurrence of segment data exists for a given type exists.
/// </remarks>
/// <param name="segmentType">identifies the required segment</param>
/// <param name="occurrence">the zero-based index of the segment occurrence to remove.</param>
public virtual void RemoveSegmentOccurrence([NotNull] JpegSegmentType segmentType, int occurrence)
{
RemoveSegmentOccurrence(segmentType.byteValue, occurrence);
}
// JpegSegmentType.SOF4,
// JpegSegmentType.SOF12,
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return true;
}
/// <summary>Determines whether data is present for a given segment type.</summary>
/// <param name="segmentType">identifies the required segment</param>
/// <returns>true if data exists, otherwise false</returns>
public virtual bool ContainsSegment([NotNull] JpegSegmentType segmentType)
{
return(ContainsSegment(segmentType.byteValue));
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return segmentBytes.Length >= JpegExifSegmentPreamble.Length && Sharpen.Runtime.EqualsIgnoreCase(Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, JpegExifSegmentPreamble.Length), JpegExifSegmentPreamble);
}
public virtual sbyte[] GetSegment([NotNull] JpegSegmentType segmentType)
{
return(GetSegment(segmentType.byteValue, 0));
}
/// <summary>Returns the count of segment data byte arrays stored for a given segment type.</summary>
/// <param name="segmentType">identifies the required segment</param>
/// <returns>the segment count (zero if no segments exist).</returns>
public virtual int GetSegmentCount(JpegSegmentType segmentType)
{
return GetSegmentCount(segmentType.byteValue);
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
return segmentBytes.Length > 3 && "JFIF".Equals(Sharpen.Runtime.GetStringForBytes(segmentBytes, 0, 4));
}
public virtual bool CanProcess(sbyte[] segmentBytes, JpegSegmentType segmentType)
{
// The entire contents of the byte[] is the comment. There's nothing here to discriminate upon.
return true;
}
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(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 virtual void Extract(sbyte[] segmentBytes, Com.Drew.Metadata.Metadata metadata, JpegSegmentType segmentType)
{
Extract(new ByteArrayReader(segmentBytes), metadata);
}
public virtual sbyte[] GetSegment(JpegSegmentType segmentType, int occurrence)
{
return GetSegment(segmentType.byteValue, occurrence);
}
