public void Short()
{
Assert.AreEqual(UInt16.MaxValue, ByteVector.FromUShort(UInt16.MaxValue).ToUShort());
Assert.AreEqual(UInt16.MinValue, ByteVector.FromUShort(UInt16.MinValue).ToUShort());
Assert.AreEqual(0, ByteVector.FromUShort(0).ToUShort());
Assert.AreEqual(8009, ByteVector.FromUShort(8009).ToUShort());
}
/// <summary>
/// Creates a <see cref="ByteVector"/> for the Xmp segment of this file
/// </summary>
/// <returns>
/// A <see cref="ByteVector"/> with the whole Xmp segment, if xmp tags
/// exists, otherwise null.
/// </returns>
private ByteVector RenderXMPSegment()
{
// Check, if XmpTag is contained
XmpTag xmp = ImageTag.Xmp;
if (xmp == null)
{
return(null);
}
ByteVector xmp_data = XmpTag.XAP_NS + "\0";
xmp_data.Add(xmp.Render());
uint segment_size = (uint)(2 + xmp_data.Count);
// do not render data segments, which cannot fit into the possible segment size
if (segment_size > ushort.MaxValue)
{
throw new Exception("XMP Segment is too big to render");
}
// Create whole segment
ByteVector data = new ByteVector(new byte [] { 0xFF, (byte)Marker.APP1 });
data.Add(ByteVector.FromUShort((ushort)segment_size));
data.Add(xmp_data);
return(data);
}
/// <summary>
/// Creates a <see cref="ByteVector"/> for the comment segment of this file
/// </summary>
/// <returns>
/// A <see cref="ByteVector"/> with the whole comment segment, if a comment tag
/// exists, otherwise null.
/// </returns>
private ByteVector RenderCOMSegment()
{
// check, if Comment is contained
JpegCommentTag com_tag = GetTag(TagTypes.JpegComment) as JpegCommentTag;
if (com_tag == null)
{
return(null);
}
// create comment data
ByteVector com_data =
ByteVector.FromString(com_tag.Value + "\0", StringType.Latin1);
uint segment_size = (uint)(2 + com_data.Count);
// do not render data segments, which cannot fit into the possible segment size
if (segment_size > ushort.MaxValue)
{
throw new Exception("Comment Segment is too big to render");
}
// create segment
ByteVector data = new ByteVector(new byte [] { 0xFF, (byte)Marker.COM });
data.Add(ByteVector.FromUShort((ushort)segment_size));
data.Add(com_data);
return(data);
}
/// <summary>
/// Adds the data of a single entry to <paramref name="entry_data"/>.
/// </summary>
/// <param name="entry_data">
/// A <see cref="ByteVector"/> to add the entry to.
/// </param>
/// <param name="tag">
/// A <see cref="System.UInt16"/> with the tag of the entry.
/// </param>
/// <param name="type">
/// A <see cref="System.UInt16"/> with the type of the entry.
/// </param>
/// <param name="count">
/// A <see cref="System.UInt32"/> with the data count of the entry,
/// </param>
/// <param name="offset">
/// A <see cref="System.UInt32"/> with the offset field of the entry.
/// </param>
protected void RenderEntry(ByteVector entry_data, ushort tag, ushort type, uint count, uint offset)
{
entry_data.Add(ByteVector.FromUShort(tag, is_bigendian));
entry_data.Add(ByteVector.FromUShort(type, is_bigendian));
entry_data.Add(ByteVector.FromUInt(count, is_bigendian));
entry_data.Add(ByteVector.FromUInt(offset, is_bigendian));
}
/// <summary>
/// Renders the current instance to a <see cref="ByteVector"/>
/// </summary>
/// <param name="is_bigendian">
/// A <see cref="System.Boolean"/> indicating the endianess for rendering.
/// </param>
/// <param name="offset">
/// A <see cref="System.UInt32"/> with the offset, the data is stored.
/// </param>
/// <param name="type">
/// A <see cref="System.UInt16"/> the ID of the type, which is rendered
/// </param>
/// <param name="count">
/// A <see cref="System.UInt32"/> with the count of the values which are
/// rendered.
/// </param>
/// <returns>
/// A <see cref="ByteVector"/> with the rendered data.
/// </returns>
public ByteVector Render(bool is_bigendian, uint offset, out ushort type, out uint count)
{
type = (ushort)IFDEntryType.SShort;
count = 1;
return(ByteVector.FromUShort((ushort)Value, is_bigendian));
}
public ByteVector Render(byte version)
{
ByteVector data = new ByteVector();
ByteVector id = ConvertId(frame_id, version, true);
if (id == null)
{
throw new NotImplementedException();
}
switch (version)
{
case 2:
data.Add(id);
data.Add(ByteVector.FromUInt(frame_size).Mid(1, 3));
return(data);
case 3:
ushort new_flags = (ushort)((((ushort)flags << 1) & 0xE000) | (((ushort)flags << 4) & 0x00C0) | (((ushort)flags >> 1) & 0x0020));
data.Add(id);
data.Add(ByteVector.FromUInt(frame_size));
data.Add(ByteVector.FromUShort(new_flags));
return(data);
case 4:
data.Add(id);
data.Add(SynchData.FromUInt(frame_size));
data.Add(ByteVector.FromUShort((ushort)flags));
return(data);
default:
throw new NotImplementedException("Unsupported tag version.");
}
}
private ByteVector RenderExifSegment()
{
IFDTag exif = ImageTag.Exif;
if (exif == null)
{
return(null);
}
uint first_ifd_offset = 8;
var renderer = new IFDRenderer(true, exif.Structure, first_ifd_offset);
ByteVector exif_data = renderer.Render();
uint segment_size = (uint)(first_ifd_offset + exif_data.Count + 2 + 6);
if (segment_size > ushort.MaxValue)
{
throw new Exception("Exif Segment is too big to render");
}
ByteVector data = new ByteVector(new byte[] { 0xFF, (byte)Marker.APP1 });
data.Add(ByteVector.FromUShort((ushort)segment_size));
data.Add("Exif\0\0");
data.Add(ByteVector.FromString("MM", StringType.Latin1));
data.Add(ByteVector.FromUShort(42));
data.Add(ByteVector.FromUInt(first_ifd_offset));
data.Add(exif_data);
return(data);
}
protected override ByteVector RenderFields(byte version)
{
ByteVector data = new ByteVector();
data.Add(ByteVector.FromString(identification, StringType.Latin1));
data.Add(ByteVector.TextDelimiter(StringType.Latin1));
for (byte i = 0; i < 9; i++)
{
if (!channels[i].IsSet)
{
continue;
}
data.Add(i);
unchecked
{
data.Add(ByteVector.FromUShort((ushort)channels[i].VolumeAdjustmentIndex));
}
byte bits = 0;
for (byte j = 0; j < 64; j++)
{
if ((channels[i].PeakVolumeIndex & (1UL << j)) != 0)
{
bits = (byte)(j + 1);
}
}
data.Add(bits);
if (bits > 0)
{
data.Add(ByteVector.FromULong(channels[i].PeakVolumeIndex).Mid(8 - BitsToBytes(bits)));
}
}
return(data);
}
/// <summary>
/// Renders the IFD to an ByteVector where the offset of the IFD
/// itself is <paramref name="ifd_offset"/> and all offsets
/// contained in the IFD are adjusted accroding it.
/// </summary>
/// <param name="directory">
/// A <see cref="IFDDirectory"/> with the directory to render.
/// </param>
/// <param name="ifd_offset">
/// A <see cref="System.UInt32"/> with the offset of the IFD
/// </param>
/// <param name="last">
/// A <see cref="System.Boolean"/> which is true, if the IFD is
/// the last one, i.e. the offset to the next IFD, which is
/// stored inside the IFD, is 0. If the value is false, the
/// offset to the next IFD is set that it starts directly after
/// the current one.
/// </param>
/// <returns>
/// A <see cref="ByteVector"/> with the rendered IFD.
/// </returns>
private ByteVector RenderIFD(IFDDirectory directory, uint ifd_offset, bool last)
{
if (directory.Count > (int)UInt16.MaxValue)
{
throw new Exception(String.Format("Directory has too much entries: {0}", directory.Count));
}
// Remove empty SUB ifds.
var tags = new List <ushort>(directory.Keys);
foreach (var tag in tags)
{
var entry = directory[tag];
if (entry is SubIFDEntry && (entry as SubIFDEntry).ChildCount == 0)
{
directory.Remove(tag);
}
}
ushort entry_count = (ushort)directory.Count;
// ifd_offset + size of entry_count + entries + next ifd offset
uint data_offset = ifd_offset + 2 + 12 * (uint)entry_count + 4;
// store the entries itself
ByteVector entry_data = new ByteVector();
// store the data referenced by the entries
ByteVector offset_data = new ByteVector();
entry_data.Add(ByteVector.FromUShort(entry_count, is_bigendian));
foreach (IFDEntry entry in directory.Values)
{
RenderEntryData(entry, entry_data, offset_data, data_offset);
}
if (last)
{
entry_data.Add("\0\0\0\0");
}
else
{
entry_data.Add(ByteVector.FromUInt((uint)(data_offset + offset_data.Count), is_bigendian));
}
if (data_offset - ifd_offset != entry_data.Count)
{
throw new Exception(String.Format("Expected IFD data size was {0} but is {1}", data_offset - ifd_offset, entry_data.Count));
}
entry_data.Add(offset_data);
return(entry_data);
}
public override ByteVector Render(bool is_bigendian, uint offset, out ushort type, out uint count)
{
type = (ushort)IFDEntryType.Short;
count = (uint)Values.Length;
ByteVector data = new ByteVector();
foreach (ushort value in Values)
{
data.Add(ByteVector.FromUShort(value, is_bigendian));
}
return(data);
}
protected ByteVector RenderHeader(uint first_ifd_offset)
{
ByteVector data = new ByteVector();
if (IsBigEndian)
{
data.Add("MM");
}
else
{
data.Add("II");
}
data.Add(ByteVector.FromUShort(Magic, IsBigEndian));
data.Add(ByteVector.FromUInt(first_ifd_offset, IsBigEndian));
return(data);
}
/// <summary>
/// Creates a <see cref="ByteVector"/> for the Exif segment of this file
/// </summary>
/// <returns>
/// A <see cref="ByteVector"/> with the whole Exif segment, if exif tags
/// exists, otherwise null.
/// </returns>
ByteVector RenderExifSegment()
{
// Check, if IFD0 is contained
IFDTag exif = ImageTag.Exif;
if (exif == null)
{
return(null);
}
// first IFD starts at 8
uint first_ifd_offset = 8;
// Render IFD0
// FIXME: store endianess and use it here
var renderer = new IFDRenderer(true, exif.Structure, first_ifd_offset);
ByteVector exif_data = renderer.Render();
uint segment_size = (uint)(first_ifd_offset + exif_data.Count + 2 + 6);
// do not render data segments, which cannot fit into the possible segment size
if (segment_size > ushort.MaxValue)
{
throw new Exception("Exif Segment is too big to render");
}
// Create whole segment
var data = new ByteVector(new byte[] { 0xFF, (byte)Marker.APP1 })
{
ByteVector.FromUShort((ushort)segment_size),
"Exif\0\0",
ByteVector.FromString("MM", StringType.Latin1),
ByteVector.FromUShort(42),
ByteVector.FromUInt(first_ifd_offset),
// Add ifd data itself
exif_data
};
return(data);
}
private ByteVector RenderCOMSegment()
{
JpegCommentTag com_tag = GetTag(TagTypes.JpegComment)
as JpegCommentTag;
if (com_tag == null)
{
return(null);
}
ByteVector com_data = ByteVector.FromString(com_tag.Value + "\0", StringType.Latin1);
uint segment_size = (uint)(2 + com_data.Count);
if (segment_size > ushort.MaxValue)
{
throw new Exception("Comment Segment is too big to render");
}
ByteVector data = new ByteVector(new byte[] { 0xFF, (byte)Marker.COM });
data.Add(ByteVector.FromUShort((ushort)segment_size));
data.Add(com_data);
return(data);
}
private ByteVector RenderXMPSegment()
{
XmpTag xmp = ImageTag.Xmp;
if (xmp == null)
{
return(null);
}
ByteVector xmp_data = XmpTag.XAP_NS + "\0";
xmp_data.Add(xmp.Render());
uint segment_size = (uint)(2 + xmp_data.Count);
if (segment_size > ushort.MaxValue)
{
throw new Exception("XMP Segment is too big to render");
}
ByteVector data = new ByteVector(new byte[] { 0xFF, (byte)Marker.APP1 });
data.Add(ByteVector.FromUShort((ushort)segment_size));
data.Add(xmp_data);
return(data);
}
/// <summary>
/// Renders a 2-byte WORD.
/// </summary>
/// <param name="value">
/// A <see cref="ushort" /> value containing the WORD to
/// render.
/// </param>
/// <returns>
/// A <see cref="ByteVector" /> object containing the
/// rendered value.
/// </returns>
public static ByteVector RenderWord(ushort value)
{
return(ByteVector.FromUShort(value, false));
}
