pax_global_header 0000666 0000000 0000000 00000000064 14462226067 0014523 g ustar 00root root 0000000 0000000 52 comment=6d4c2fb50df13bc32a19ef83f3d8811e380cf4c9
quickroute-linux-upstream-2.5/ 0000775 0000000 0000000 00000000000 14462226067 0016557 5 ustar 00root root 0000000 0000000 quickroute-linux-upstream-2.5/.gitignore 0000664 0000000 0000000 00000000126 14462226067 0020546 0 ustar 00root root 0000000 0000000 *.pidb
*.resources
*.mdb
*.dll
*.dll.config
*~
bin
obj
/tmp.*
/QuickRoute.userprefs
quickroute-linux-upstream-2.5/3rdparty/ 0000775 0000000 0000000 00000000000 14462226067 0020327 5 ustar 00root root 0000000 0000000 quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ 0000775 0000000 0000000 00000000000 14462226067 0022547 5 ustar 00root root 0000000 0000000 quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/BitConverterEx.cs 0000664 0000000 0000000 00000033344 14462226067 0026010 0 ustar 00root root 0000000 0000000 using System;
namespace ExifLibrary
{
///
/// An endian-aware converter for converting between base data types
/// and an array of bytes.
///
public class BitConverterEx
{
#region Public Enums
///
/// Represents the byte order.
///
public enum ByteOrder
{
LittleEndian = 1,
BigEndian = 2,
}
#endregion
#region Member Variables
private ByteOrder mFrom, mTo;
#endregion
#region Constructors
public BitConverterEx(ByteOrder from, ByteOrder to)
{
mFrom = from;
mTo = to;
}
#endregion
#region Properties
///
/// Indicates the byte order in which data is stored in this platform.
///
public static ByteOrder SystemByteOrder
{
get
{
return (BitConverter.IsLittleEndian ? ByteOrder.LittleEndian : ByteOrder.BigEndian);
}
}
#endregion
#region Predefined Values
///
/// Returns a bit converter that converts between little-endian and system byte-order.
///
public static BitConverterEx LittleEndian
{
get
{
return new BitConverterEx(ByteOrder.LittleEndian, BitConverterEx.SystemByteOrder);
}
}
///
/// Returns a bit converter that converts between big-endian and system byte-order.
///
public static BitConverterEx BigEndian
{
get
{
return new BitConverterEx(ByteOrder.BigEndian, BitConverterEx.SystemByteOrder);
}
}
///
/// Returns a bit converter that does not do any byte-order conversion.
///
public static BitConverterEx SystemEndian
{
get
{
return new BitConverterEx(BitConverterEx.SystemByteOrder, BitConverterEx.SystemByteOrder);
}
}
#endregion
#region Static Methods
///
/// Converts the given array of bytes to a Unicode character.
///
public static char ToChar(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 2, from, to);
return BitConverter.ToChar(data, 0);
}
///
/// Converts the given array of bytes to a 16-bit unsigned integer.
///
public static ushort ToUInt16(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 2, from, to);
return BitConverter.ToUInt16(data, 0);
}
///
/// Converts the given array of bytes to a 32-bit unsigned integer.
///
public static uint ToUInt32(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 4, from, to);
return BitConverter.ToUInt32(data, 0);
}
///
/// Converts the given array of bytes to a 64-bit unsigned integer.
///
public static ulong ToUInt64(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 8, from, to);
return BitConverter.ToUInt64(data, 0);
}
///
/// Converts the given array of bytes to a 16-bit signed integer.
///
public static short ToInt16(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 2, from, to);
return BitConverter.ToInt16(data, 0);
}
///
/// Converts the given array of bytes to a 32-bit signed integer.
///
public static int ToInt32(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 4, from, to);
return BitConverter.ToInt32(data, 0);
}
///
/// Converts the given array of bytes to a 64-bit signed integer.
///
public static long ToInt64(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 8, from, to);
return BitConverter.ToInt64(data, 0);
}
///
/// Converts the given array of bytes to a single precision floating number.
///
public static float ToSingle(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 4, from, to);
return BitConverter.ToSingle(data, 0);
}
///
/// Converts the given array of bytes to a double precision floating number.
///
public static double ToDouble(byte[] value, long startIndex, ByteOrder from, ByteOrder to)
{
byte[] data = CheckData(value, startIndex, 8, from, to);
return BitConverter.ToDouble(data, 0);
}
///
/// Converts the given 16-bit unsigned integer to an array of bytes.
///
public static byte[] GetBytes(ushort value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given 32-bit unsigned integer to an array of bytes.
///
public static byte[] GetBytes(uint value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given 64-bit unsigned integer to an array of bytes.
///
public static byte[] GetBytes(ulong value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given 16-bit signed integer to an array of bytes.
///
public static byte[] GetBytes(short value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given 32-bit signed integer to an array of bytes.
///
public static byte[] GetBytes(int value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given 64-bit signed integer to an array of bytes.
///
public static byte[] GetBytes(long value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given single precision floating-point number to an array of bytes.
///
public static byte[] GetBytes(float value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
///
/// Converts the given double precision floating-point number to an array of bytes.
///
public static byte[] GetBytes(double value, ByteOrder from, ByteOrder to)
{
byte[] data = BitConverter.GetBytes(value);
data = CheckData(data, from, to);
return data;
}
#endregion
#region Instance Methods
///
/// Converts the given array of bytes to a 16-bit unsigned integer.
///
public char ToChar(byte[] value, long startIndex)
{
return BitConverterEx.ToChar(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a 16-bit unsigned integer.
///
public ushort ToUInt16(byte[] value, long startIndex)
{
return BitConverterEx.ToUInt16(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a 32-bit unsigned integer.
///
public uint ToUInt32(byte[] value, long startIndex)
{
return BitConverterEx.ToUInt32(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a 64-bit unsigned integer.
///
public ulong ToUInt64(byte[] value, long startIndex)
{
return BitConverterEx.ToUInt64(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a 16-bit signed integer.
///
public short ToInt16(byte[] value, long startIndex)
{
return BitConverterEx.ToInt16(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a 32-bit signed integer.
///
public int ToInt32(byte[] value, long startIndex)
{
return BitConverterEx.ToInt32(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a 64-bit signed integer.
///
public long ToInt64(byte[] value, long startIndex)
{
return BitConverterEx.ToInt64(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a single precision floating number.
///
public float ToSingle(byte[] value, long startIndex)
{
return BitConverterEx.ToSingle(value, startIndex, mFrom, mTo);
}
///
/// Converts the given array of bytes to a double precision floating number.
///
public double ToDouble(byte[] value, long startIndex)
{
return BitConverterEx.ToDouble(value, startIndex, mFrom, mTo);
}
///
/// Converts the given 16-bit unsigned integer to an array of bytes.
///
public byte[] GetBytes(ushort value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given 32-bit unsigned integer to an array of bytes.
///
public byte[] GetBytes(uint value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given 64-bit unsigned integer to an array of bytes.
///
public byte[] GetBytes(ulong value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given 16-bit signed integer to an array of bytes.
///
public byte[] GetBytes(short value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given 32-bit signed integer to an array of bytes.
///
public byte[] GetBytes(int value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given 64-bit signed integer to an array of bytes.
///
public byte[] GetBytes(long value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given single precision floating-point number to an array of bytes.
///
public byte[] GetBytes(float value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
///
/// Converts the given double precision floating-point number to an array of bytes.
///
public byte[] GetBytes(double value)
{
return BitConverterEx.GetBytes(value, mFrom, mTo);
}
#endregion
#region Private Helpers
///
/// Reverse the array of bytes as needed.
///
private static byte[] CheckData(byte[] value, long startIndex, long length, ByteOrder from, ByteOrder to)
{
byte[] data = new byte[length];
Array.Copy(value, startIndex, data, 0, length);
if (from != to)
Array.Reverse(data);
return data;
}
///
/// Reverse the array of bytes as needed.
///
private static byte[] CheckData(byte[] value, ByteOrder from, ByteOrder to)
{
return CheckData(value, 0, value.Length, from, to);
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifBitConverter.cs 0000664 0000000 0000000 00000035165 14462226067 0026332 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
namespace ExifLibrary
{
///
/// Converts between exif data types and array of bytes.
///
public class ExifBitConverter : BitConverterEx
{
#region Constructors
public ExifBitConverter(ByteOrder from, ByteOrder to)
: base(from, to)
{
;
}
#endregion
#region Static Methods
///
/// Returns an ASCII string converted from the given byte array.
///
public static string ToAscii(byte[] data, bool endatfirstnull, Encoding encoding)
{
int len = data.Length;
if (endatfirstnull)
{
len = Array.IndexOf(data, (byte)0);
if (len == -1) len = data.Length;
}
return encoding.GetString(data, 0, len);
}
///
/// Returns an ASCII string converted from the given byte array.
///
public static string ToAscii(byte[] data, Encoding encoding)
{
return ToAscii(data, true, encoding);
}
///
/// Returns a string converted from the given byte array.
/// from the numeric value of each byte.
///
public static string ToString(byte[] data)
{
StringBuilder sb = new StringBuilder();
foreach (byte b in data)
sb.Append(b);
return sb.ToString();
}
///
/// Returns a DateTime object converted from the given byte array.
///
public static DateTime ToDateTime(byte[] data, bool hastime)
{
string str = ToAscii(data, Encoding.ASCII);
string[] parts = str.Split(new char[] { ':', ' ' });
try
{
if (hastime && parts.Length == 6)
{
// yyyy:MM:dd HH:mm:ss
// This is the expected format though some cameras
// can use single digits. See Issue 21.
return new DateTime(int.Parse(parts[0]), int.Parse(parts[1]), int.Parse(parts[2]), int.Parse(parts[3]), int.Parse(parts[4]), int.Parse(parts[5]));
}
else if (!hastime && parts.Length == 3)
{
// yyyy:MM:dd
return new DateTime(int.Parse(parts[0]), int.Parse(parts[1]), int.Parse(parts[2]));
}
else
{
return DateTime.MinValue;
}
}
catch (ArgumentOutOfRangeException)
{
return DateTime.MinValue;
}
catch (ArgumentException)
{
return DateTime.MinValue;
}
}
///
/// Returns a DateTime object converted from the given byte array.
///
public static DateTime ToDateTime(byte[] data)
{
return ToDateTime(data, true);
}
///
/// Returns an unsigned rational number converted from the first
/// eight bytes of the given byte array. The first four bytes are
/// assumed to be the numerator and the next four bytes are the
/// denumerator.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static MathEx.UFraction32 ToURational(byte[] data, ByteOrder frombyteorder)
{
byte[] num = new byte[4];
byte[] den = new byte[4];
Array.Copy(data, 0, num, 0, 4);
Array.Copy(data, 4, den, 0, 4);
return new MathEx.UFraction32(ToUInt32(num, 0, frombyteorder, BitConverterEx.SystemByteOrder), ToUInt32(den, 0, frombyteorder, BitConverterEx.SystemByteOrder));
}
///
/// Returns a signed rational number converted from the first
/// eight bytes of the given byte array. The first four bytes are
/// assumed to be the numerator and the next four bytes are the
/// denumerator.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static MathEx.Fraction32 ToSRational(byte[] data, ByteOrder frombyteorder)
{
byte[] num = new byte[4];
byte[] den = new byte[4];
Array.Copy(data, 0, num, 0, 4);
Array.Copy(data, 4, den, 0, 4);
return new MathEx.Fraction32(ToInt32(num, 0, frombyteorder, BitConverterEx.SystemByteOrder), ToInt32(den, 0, frombyteorder, BitConverterEx.SystemByteOrder));
}
///
/// Returns an array of 16-bit unsigned integers converted from
/// the given byte array.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static ushort[] ToUShortArray(byte[] data, int count, ByteOrder frombyteorder)
{
ushort[] numbers = new ushort[count];
for (uint i = 0; i < count; i++)
{
byte[] num = new byte[2];
Array.Copy(data, i * 2, num, 0, 2);
numbers[i] = ToUInt16(num, 0, frombyteorder, BitConverterEx.SystemByteOrder);
}
return numbers;
}
///
/// Returns an array of 32-bit unsigned integers converted from
/// the given byte array.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static uint[] ToUIntArray(byte[] data, int count, ByteOrder frombyteorder)
{
uint[] numbers = new uint[count];
for (uint i = 0; i < count; i++)
{
byte[] num = new byte[4];
Array.Copy(data, i * 4, num, 0, 4);
numbers[i] = ToUInt32(num, 0, frombyteorder, BitConverterEx.SystemByteOrder);
}
return numbers;
}
///
/// Returns an array of 32-bit signed integers converted from
/// the given byte array.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static int[] ToSIntArray(byte[] data, int count, ByteOrder byteorder)
{
int[] numbers = new int[count];
for (uint i = 0; i < count; i++)
{
byte[] num = new byte[4];
Array.Copy(data, i * 4, num, 0, 4);
numbers[i] = ToInt32(num, 0, byteorder, BitConverterEx.SystemByteOrder);
}
return numbers;
}
///
/// Returns an array of unsigned rational numbers converted from
/// the given byte array.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static MathEx.UFraction32[] ToURationalArray(byte[] data, int count, ByteOrder frombyteorder)
{
MathEx.UFraction32[] numbers = new MathEx.UFraction32[count];
for (uint i = 0; i < count; i++)
{
byte[] num = new byte[4];
byte[] den = new byte[4];
Array.Copy(data, i * 8, num, 0, 4);
Array.Copy(data, i * 8 + 4, den, 0, 4);
numbers[i].Set(ToUInt32(num, 0, frombyteorder, BitConverterEx.SystemByteOrder), ToUInt32(den, 0, frombyteorder, BitConverterEx.SystemByteOrder));
}
return numbers;
}
///
/// Returns an array of signed rational numbers converted from
/// the given byte array.
/// Numbers are converted from the given byte-order to platform byte-order.
///
public static MathEx.Fraction32[] ToSRationalArray(byte[] data, int count, ByteOrder frombyteorder)
{
MathEx.Fraction32[] numbers = new MathEx.Fraction32[count];
for (uint i = 0; i < count; i++)
{
byte[] num = new byte[4];
byte[] den = new byte[4];
Array.Copy(data, i * 8, num, 0, 4);
Array.Copy(data, i * 8 + 4, den, 0, 4);
numbers[i].Set(ToInt32(num, 0, frombyteorder, BitConverterEx.SystemByteOrder), ToInt32(den, 0, frombyteorder, BitConverterEx.SystemByteOrder));
}
return numbers;
}
///
/// Converts the given ascii string to an array of bytes optionally adding a null terminator.
///
public static byte[] GetBytes(string value, bool addnull, Encoding encoding)
{
if (addnull) value += '\0';
return encoding.GetBytes(value);
}
///
/// Converts the given ascii string to an array of bytes without adding a null terminator.
///
public static byte[] GetBytes(string value, Encoding encoding)
{
return GetBytes(value, false, encoding);
}
///
/// Converts the given datetime to an array of bytes with a null terminator.
///
public static byte[] GetBytes(DateTime value, bool hastime)
{
string str = "";
if (hastime)
str = value.ToString("yyyy:MM:dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
else
str = value.ToString("yyyy:MM:dd", System.Globalization.CultureInfo.InvariantCulture);
return GetBytes(str, true, Encoding.ASCII);
}
///
/// Converts the given unsigned rational number to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(MathEx.UFraction32 value, ByteOrder tobyteorder)
{
byte[] num = GetBytes(value.Numerator, BitConverterEx.SystemByteOrder, tobyteorder);
byte[] den = GetBytes(value.Denominator, BitConverterEx.SystemByteOrder, tobyteorder);
byte[] data = new byte[8];
Array.Copy(num, 0, data, 0, 4);
Array.Copy(den, 0, data, 4, 4);
return data;
}
///
/// Converts the given signed rational number to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(MathEx.Fraction32 value, ByteOrder tobyteorder)
{
byte[] num = GetBytes(value.Numerator, BitConverterEx.SystemByteOrder, tobyteorder);
byte[] den = GetBytes(value.Denominator, BitConverterEx.SystemByteOrder, tobyteorder);
byte[] data = new byte[8];
Array.Copy(num, 0, data, 0, 4);
Array.Copy(den, 0, data, 4, 4);
return data;
}
///
/// Converts the given array of 16-bit unsigned integers to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(ushort[] value, ByteOrder tobyteorder)
{
byte[] data = new byte[2 * value.Length];
for (int i = 0; i < value.Length; i++)
{
byte[] num = GetBytes(value[i], BitConverterEx.SystemByteOrder, tobyteorder);
Array.Copy(num, 0, data, i * 2, 2);
}
return data;
}
///
/// Converts the given array of 32-bit unsigned integers to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(uint[] value, ByteOrder tobyteorder)
{
byte[] data = new byte[4 * value.Length];
for (int i = 0; i < value.Length; i++)
{
byte[] num = GetBytes(value[i], BitConverterEx.SystemByteOrder, tobyteorder);
Array.Copy(num, 0, data, i * 4, 4);
}
return data;
}
///
/// Converts the given array of 32-bit signed integers to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(int[] value, ByteOrder tobyteorder)
{
byte[] data = new byte[4 * value.Length];
for (int i = 0; i < value.Length; i++)
{
byte[] num = GetBytes(value[i], BitConverterEx.SystemByteOrder, tobyteorder);
Array.Copy(num, 0, data, i * 4, 4);
}
return data;
}
///
/// Converts the given array of unsigned rationals to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(MathEx.UFraction32[] value, ByteOrder tobyteorder)
{
byte[] data = new byte[8 * value.Length];
for (int i = 0; i < value.Length; i++)
{
byte[] num = GetBytes(value[i].Numerator, BitConverterEx.SystemByteOrder, tobyteorder);
byte[] den = GetBytes(value[i].Denominator, BitConverterEx.SystemByteOrder, tobyteorder);
Array.Copy(num, 0, data, i * 8, 4);
Array.Copy(den, 0, data, i * 8 + 4, 4);
}
return data;
}
///
/// Converts the given array of signed rationals to an array of bytes.
/// Numbers are converted from the platform byte-order to the given byte-order.
///
public static byte[] GetBytes(MathEx.Fraction32[] value, ByteOrder tobyteorder)
{
byte[] data = new byte[8 * value.Length];
for (int i = 0; i < value.Length; i++)
{
byte[] num = GetBytes(value[i].Numerator, BitConverterEx.SystemByteOrder, tobyteorder);
byte[] den = GetBytes(value[i].Denominator, BitConverterEx.SystemByteOrder, tobyteorder);
Array.Copy(num, 0, data, i * 8, 4);
Array.Copy(den, 0, data, i * 8 + 4, 4);
}
return data;
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifEnums.cs 0000664 0000000 0000000 00000036454 14462226067 0025015 0 ustar 00root root 0000000 0000000 using System;
namespace ExifLibrary
{
///
/// Represents a general indication of the kind of data contained in this subfile.
///
[Flags]
public enum NewSubfileType : uint
{
///
/// This image is a reduced resolution version of another image in the file.
///
ReducedResolution = 1,
///
/// The image is a single page of a multi-page image.
///
MultiPage = 2,
///
/// This image defines a transparency mask for another image in this file.
///
TransparencyMask = 4,
///
/// The IFD containing this tag is Mixed Raster Content (MRC) specific.
///
MRCSpecific = 16
}
///
/// Represents a general indication of the kind of data contained in this subfile.
///
public enum SubfileType : ushort
{
///
/// This image is a full resolution image.
///
FullResolution = 1,
///
/// This image is a reduced resolution version of another image in the file.
///
ReducedResolution = 2,
///
/// The image is a single page of a multi-page image.
///
MultiPage = 3
}
///
/// Represenst the compression scheme used for the image data.
///
public enum Compression : ushort
{
///
/// No compression.
///
Uncompressed = 1,
///
/// CCITT modified Huffman RLE compression.
///
CCITT1D = 2,
///
/// CCITT Group 3 fax encoding.
///
Group3Fax = 3,
///
/// CCITT Group 4 fax encoding.
///
Group4Fax = 4,
///
/// LZW compression.
///
LZW = 5,
///
/// JPEG compression.
///
JPEG = 6,
///
/// PackBits compression, aka Macintosh RLE.
///
PackBits = 32773
}
///
/// Represents the pixel composition.
///
public enum PhotometricInterpretation : ushort
{
///
/// For bilevel and grayscale images: 0 is imaged as white.
///
WhiteIsZero = 0,
///
/// For bilevel and grayscale images: 0 is imaged as black.
///
BlackIsZero = 1,
///
/// RGB value of (0,0,0) represents black, and (255,255,255) represents white,
/// assuming 8-bit components. The components are stored in the indicated order:
/// first Red, then Green, then Blue.
///
RGB = 2,
///
/// Palette color. In this model, a color is described with a single component.
/// The value of the component is used as an index into the red, green and blue
/// curves in the ColorMap field to retrieve an RGB triplet that defines the color.
/// With a palette, ColorMap must be present and SamplesPerPixel must be 1.
///
RGBPalette = 3,
///
/// The image is used to define an irregularly shaped region of another image
/// in the same file. SamplesPerPixel and BitsPerSample must be 1.
/// PackBits compression is recommended. The 1-bits define the interior
/// of the region; the 0-bits define the exterior of the region.
///
TransparencyMask = 4,
///
/// Seperated, usually CMYK.
///
Seperated = 5,
///
/// YCbCr color space.
///
YCbCr = 6,
///
/// CIE (L*, a*, b*) color space.
///
CIELab = 8,
///
/// ICC (L*, a*, b*) color space.
///
ICCLab = 9,
///
/// ITU (L*, a*, b*) color space.
///
ITULab = 10,
///
/// Color Filter Array color space.
///
CFA = 32803,
///
/// Linear Raw color space.
///
LinearRaw = 34892,
///
/// Pixar LogL color space.
///
Pixar_LOGL = 32844,
///
/// Pixar LogLUV color space.
///
PixarLOGLUV = 32845
}
///
/// Represents the technique used to convert from gray to black and white pixels.
///
public enum Threshholding : ushort
{
///
/// No dithering or halftoning has been applied to the image data.
///
BiLevel = 1,
///
/// An ordered dither or halftone technique has been applied to the image data.
///
HalfTone = 2,
///
/// A randomized process such as error diffusion has been applied to the image data.
///
ErrorDiffuse = 3
}
///
/// Represents the logical order of bits within a byte.
///
public enum FillOrder : ushort
{
///
/// Pixels with lower column values are stored in the higher-order bits of the byte.
///
MSB2LSB = 1,
///
/// Pixels with lower column values are stored in the lower-order bits of the byte.
///
LSB2MSB = 2
}
///
/// Represents the image orientation.
///
public enum Orientation : ushort
{
///
/// The 0th row is at the visual top of the image, and the 0th column is the
/// visual left-hand side.
///
Normal = 1,
///
/// The 0th row is at the visual top of the image, and the 0th column is
/// the visual right-hand side.
///
MirroredVertically = 2,
///
/// The 0th row is at the visual bottom of the image, and the 0th column is
/// the visual right-hand side.
///
Rotated180 = 3,
///
/// The 0th row is at the visual bottom of the image, and the 0th column is
/// the visual left-hand side.
///
MirroredHorizontally = 4,
///
/// The 0th row is the visual left-hand side of the image, and the 0th column
/// is the visual top.
///
RotatedLeftAndMirroredVertically = 5,
///
/// The 0th row is the visual right-hand side of the image, and the 0th column
/// is the visual top.
///
RotatedRight = 6,
///
/// The 0th row is the visual right-hand side of the image, and the 0th column
/// is the visual bottom.
///
RotatedLeft = 7,
///
/// The 0th row is the visual left-hand side of the image, and the 0th column
/// is the visual bottom.
///
RotatedRightAndMirroredVertically = 8
}
///
/// Represents the recording format of pixel components.
///
public enum PlanarConfiguration : ushort
{
///
/// Pixels are recorded in chunky format.
///
ChunkyFormat = 1,
///
/// Pixels are recorded in planar format.
///
PlanarFormat = 2
}
///
/// Represents the precision of the information contained in the gray response curve.
///
public enum GrayResponseUnit : ushort
{
///
/// Number represents tenths of a unit.
///
Tenth = 1,
///
/// Number represents hundredths of a unit.
///
Hundreth = 2,
///
/// Number represents thousandths of a unit.
///
Thousandth = 3,
///
/// Number represents ten-thousandths of a unit.
///
TenThousandth = 4,
///
/// Number represents hundred-thousandths of a unit.
///
HundredThousandth = 5
}
///
/// Represents the options for Group 3 Fax compression.
///
[Flags]
public enum T4Options : uint
{
///
/// 2-dimensional coding (otherwise 1-dimensional is assumed).
///
TwoDimensionalEncoding = 1,
///
/// Uncompressed mode is used.
///
Uncompressed = 2,
///
/// Fill bits have been added before EOL codes such that EOL always
/// ends on a byte boundary.
///
FillBits = 4
}
///
/// Represents the options for Group 4 Fax compression.
///
[Flags]
public enum T6Options : uint
{
///
/// Uncompressed mode is used.
///
Uncompressed = 2
}
///
/// The unit for measuring XResolution and YResolution.
///
public enum ResolutionUnit : ushort
{
Inches = 2,
Centimeters = 3
}
public enum YCbCrPositioning : ushort
{
Centered = 1,
CoSited = 2
}
public enum ColorSpace : ushort
{
sRGB = 1,
Uncalibrated = 0xfff
}
public enum ExposureProgram : ushort
{
NotDefined = 0,
Manual = 1,
Normal = 2,
AperturePriority = 3,
ShutterPriority = 4,
///
/// Biased toward depth of field.
///
Creative = 5,
///
/// Biased toward fast shutter speed.
///
Action = 6,
///
/// For closeup photos with the background out of focus.
///
Portrait = 7,
///
/// For landscape photos with the background in focus.
///
Landscape = 8
}
public enum MeteringMode : ushort
{
Unknown = 0,
Average = 1,
CenterWeightedAverage = 2,
Spot = 3,
MultiSpot = 4,
Pattern = 5,
Partial = 6,
Other = 255
}
public enum LightSource : ushort
{
Unknown = 0,
Daylight = 1,
Fluorescent = 2,
Tungsten = 3,
Flash = 4,
FineWeather = 9,
CloudyWeather = 10,
Shade = 11,
///
/// D 5700 – 7100K
///
DaylightFluorescent = 12,
///
/// N 4600 – 5400K
///
DayWhiteFluorescent = 13,
///
/// W 3900 – 4500K
///
CoolWhiteFluorescent = 14,
///
/// WW 3200 – 3700K
///
WhiteFluorescent = 15,
StandardLightA = 17,
StandardLightB = 18,
StandardLightC = 19,
D55 = 20,
D65 = 21,
D75 = 22,
D50 = 23,
ISOStudioTungsten = 24,
OtherLightSource = 255
}
[Flags]
public enum Flash : ushort
{
FlashDidNotFire = 0,
StrobeReturnLightNotDetected = 4,
StrobeReturnLightDetected = 2,
FlashFired = 1,
CompulsoryFlashMode = 8,
AutoMode = 16,
NoFlashFunction = 32,
RedEyeReductionMode = 64
}
public enum SensingMethod : ushort
{
NotDefined = 1,
OneChipColorAreaSensor = 2,
TwoChipColorAreaSensor = 3,
ThreeChipColorAreaSensor = 4,
ColorSequentialAreaSensor = 5,
TriLinearSensor = 7,
ColorSequentialLinearSensor = 8
}
public enum FileSource : byte
{
// UNDEFINED
DSC = 3
}
public enum SceneType : byte
{
// UNDEFINED
DirectlyPhotographedImage = 1
}
public enum CustomRendered : ushort
{
NormalProcess = 0,
CustomProcess = 1
}
public enum ExposureMode : ushort
{
Auto = 0,
Manual = 1,
AutoBracket = 2
}
public enum WhiteBalance : ushort
{
Auto = 0,
Manual = 1
}
public enum SceneCaptureType : ushort
{
Standard = 0,
Landscape = 1,
Portrait = 2,
NightScene = 3
}
public enum GainControl : ushort
{
None = 0,
LowGainUp = 1,
HighGainUp = 2,
LowGainDown = 3,
HighGainDown = 4
}
public enum Contrast : ushort
{
Normal = 0,
Soft = 1,
Hard = 2
}
public enum Saturation : ushort
{
Normal = 0,
Low = 1,
High = 2
}
public enum Sharpness : ushort
{
Normal = 0,
Soft = 1,
Hard = 2
}
public enum SubjectDistanceRange : ushort
{
Unknown = 0,
Macro = 1,
CloseView = 2,
DistantView = 3
}
public enum GPSLatitudeRef : byte
{
// ASCII
North = 78,
// 'N'
South = 83
// 'S'
}
public enum GPSLongitudeRef : byte
{
// ASCII
West = 87,
// 'W'
East = 69
// 'E'
}
public enum GPSAltitudeRef : byte
{
AboveSeaLevel = 0,
BelowSeaLevel = 1
}
public enum GPSStatus : byte
{
// ASCII
MeasurementInProgress = 65,
// 'A'
MeasurementInteroperability = 86
// 'V'
}
public enum GPSMeasureMode : byte
{
// ASCII
TwoDimensional = 50,
// '2'
ThreeDimensional = 51
// '3'
}
public enum GPSSpeedRef : byte
{
// ASCII
KilometersPerHour = 75,
// 'K'
MilesPerHour = 77,
// 'M'
Knots = 78
// 'N'
}
public enum GPSDirectionRef : byte
{
// ASCII
TrueDirection = 84,
// 'T'
MagneticDirection = 77
// 'M'
}
public enum GPSDistanceRef : byte
{
// ASCII
Kilometers = 75,
// 'K'
Miles = 77,
// 'M'
Knots = 78
// 'N'
}
public enum GPSDifferential : ushort
{
MeasurementWithoutDifferentialCorrection = 0,
DifferentialCorrectionApplied = 1
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifExceptions.cs 0000664 0000000 0000000 00000003545 14462226067 0026042 0 ustar 00root root 0000000 0000000 using System;
namespace ExifLibrary
{
///
/// The exception that is thrown when the format of the JPEG/Exif file
/// could not be understood.
///
public class NotValidExifFileException : Exception
{
public NotValidExifFileException()
: base("Not a valid JPEG/Exif file.")
{
;
}
public NotValidExifFileException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the IFD section ID could not be understood.
///
public class UnknownIFDSectionException : Exception
{
public UnknownIFDSectionException()
: base("Unknown IFD section.")
{
;
}
public UnknownIFDSectionException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when an invalid enum type is given to an
/// ExifEnumProperty.
///
public class UnknownEnumTypeException : Exception
{
public UnknownEnumTypeException()
: base("Unknown enum type.")
{
;
}
public UnknownEnumTypeException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the 0th IFD section does not contain any fields.
///
public class IFD0IsEmptyException : Exception
{
public IFD0IsEmptyException()
: base("0th IFD section cannot be empty.")
{
;
}
public IFD0IsEmptyException(string message)
: base(message)
{
;
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifExtendedProperty.cs 0000664 0000000 0000000 00000034016 14462226067 0027223 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
namespace ExifLibrary
{
///
/// Represents an enumerated value.
///
public class ExifEnumProperty : ExifProperty
{
protected T mValue;
protected bool mIsBitField;
protected override object _Value { get { return Value; } set { Value = (T)value; } }
public new T Value { get { return mValue; } set { mValue = value; } }
public bool IsBitField { get { return mIsBitField; } }
static public implicit operator T(ExifEnumProperty obj) { return (T)obj.mValue; }
public override string ToString() { return mValue.ToString(); }
public ExifEnumProperty(ExifTag tag, T value, bool isbitfield)
: base(tag)
{
mValue = value;
mIsBitField = isbitfield;
}
public ExifEnumProperty(ExifTag tag, T value)
: this(tag, value, false)
{
;
}
public override ExifInterOperability Interoperability
{
get
{
ushort tagid = ExifTagFactory.GetTagID(mTag);
Type type = typeof(T);
Type basetype = Enum.GetUnderlyingType(type);
if (type == typeof(FileSource) || type == typeof(SceneType))
{
// UNDEFINED
return new ExifInterOperability(tagid, 7, 1, new byte[] { (byte)((object)mValue) });
}
else if (type == typeof(GPSLatitudeRef) || type == typeof(GPSLongitudeRef) ||
type == typeof(GPSStatus) || type == typeof(GPSMeasureMode) ||
type == typeof(GPSSpeedRef) || type == typeof(GPSDirectionRef) ||
type == typeof(GPSDistanceRef))
{
// ASCII
return new ExifInterOperability(tagid, 2, 2, new byte[] { (byte)((object)mValue), 0 });
}
else if (basetype == typeof(byte))
{
// BYTE
return new ExifInterOperability(tagid, 1, 1, new byte[] { (byte)((object)mValue) });
}
else if (basetype == typeof(ushort))
{
// SHORT
return new ExifInterOperability(tagid, 3, 1, ExifBitConverter.GetBytes((ushort)((object)mValue), BitConverterEx.SystemByteOrder, BitConverterEx.SystemByteOrder));
}
else
throw new UnknownEnumTypeException();
}
}
}
///
/// Represents an ASCII string. (EXIF Specification: UNDEFINED) Used for the UserComment field.
///
public class ExifEncodedString : ExifProperty
{
protected string mValue;
private Encoding mEncoding;
protected override object _Value { get { return Value; } set { Value = (string)value; } }
public new string Value { get { return mValue; } set { mValue = value; } }
public Encoding Encoding { get { return mEncoding; } set { mEncoding = value; } }
static public implicit operator string(ExifEncodedString obj) { return obj.mValue; }
public override string ToString() { return mValue; }
public ExifEncodedString(ExifTag tag, string value, Encoding encoding)
: base(tag)
{
mValue = value;
mEncoding = encoding;
}
public override ExifInterOperability Interoperability
{
get
{
string enc = "";
if (mEncoding == null)
enc = "\0\0\0\0\0\0\0\0";
else if (mEncoding.EncodingName == "US-ASCII")
enc = "ASCII\0\0\0";
else if (mEncoding.EncodingName == "Japanese (JIS 0208-1990 and 0212-1990)")
enc = "JIS\0\0\0\0\0";
else if (mEncoding.EncodingName == "Unicode")
enc = "Unicode\0";
else
enc = "\0\0\0\0\0\0\0\0";
byte[] benc = Encoding.ASCII.GetBytes(enc);
byte[] bstr = (mEncoding == null ? Encoding.ASCII.GetBytes(mValue) : mEncoding.GetBytes(mValue));
byte[] data = new byte[benc.Length + bstr.Length];
Array.Copy(benc, 0, data, 0, benc.Length);
Array.Copy(bstr, 0, data, benc.Length, bstr.Length);
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 7, (uint)data.Length, data);
}
}
}
///
/// Represents an ASCII string formatted as DateTime. (EXIF Specification: ASCII) Used for the date time fields.
///
public class ExifDateTime : ExifProperty
{
protected DateTime mValue;
protected override object _Value { get { return Value; } set { Value = (DateTime)value; } }
public new DateTime Value { get { return mValue; } set { mValue = value; } }
static public implicit operator DateTime(ExifDateTime obj) { return obj.mValue; }
public override string ToString() { return mValue.ToString("yyyy.MM.dd HH:mm:ss"); }
public ExifDateTime(ExifTag tag, DateTime value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 2, (uint)20, ExifBitConverter.GetBytes(mValue, true));
}
}
}
///
/// Represents the exif version as a 4 byte ASCII string. (EXIF Specification: UNDEFINED)
/// Used for the ExifVersion, FlashpixVersion, InteroperabilityVersion and GPSVersionID fields.
///
public class ExifVersion : ExifProperty
{
protected string mValue;
protected override object _Value { get { return Value; } set { Value = (string)value; } }
public new string Value { get { return mValue; } set { mValue = value.Substring(0, 4); } }
public ExifVersion(ExifTag tag, string value)
: base(tag)
{
if (value.Length > 4)
mValue = value.Substring(0, 4);
else if (value.Length < 4)
mValue = value + new string(' ', 4 - value.Length);
else
mValue = value;
}
public override string ToString()
{
return mValue;
}
public override ExifInterOperability Interoperability
{
get
{
if (mTag == ExifTag.ExifVersion || mTag == ExifTag.FlashpixVersion || mTag == ExifTag.InteroperabilityVersion)
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 7, 4, Encoding.ASCII.GetBytes(mValue));
else
{
byte[] data = new byte[4];
for (int i = 0; i < 4; i++)
data[i] = byte.Parse(mValue[0].ToString());
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 7, 4, data);
}
}
}
}
///
/// Represents the location and area of the subject (EXIF Specification: 2xSHORT)
/// The coordinate values, width, and height are expressed in relation to the
/// upper left as origin, prior to rotation processing as per the Rotation tag.
///
public class ExifPointSubjectArea : ExifUShortArray
{
protected new ushort[] Value { get { return mValue; } set { mValue = value; } }
public ushort X { get { return mValue[0]; } set { mValue[0] = value; } }
public ushort Y { get { return mValue[1]; } set { mValue[1] = value; } }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("({0:d}, {1:d})", mValue[0], mValue[1]);
return sb.ToString();
}
public ExifPointSubjectArea(ExifTag tag, ushort[] value)
: base(tag, value)
{
;
}
public ExifPointSubjectArea(ExifTag tag, ushort x, ushort y)
: base(tag, new ushort[] { x, y })
{
;
}
}
///
/// Represents the location and area of the subject (EXIF Specification: 3xSHORT)
/// The coordinate values, width, and height are expressed in relation to the
/// upper left as origin, prior to rotation processing as per the Rotation tag.
///
public class ExifCircularSubjectArea : ExifPointSubjectArea
{
public ushort Diamater { get { return mValue[2]; } set { mValue[2] = value; } }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("({0:d}, {1:d}) {2:d}", mValue[0], mValue[1], mValue[2]);
return sb.ToString();
}
public ExifCircularSubjectArea(ExifTag tag, ushort[] value)
: base(tag, value)
{
;
}
public ExifCircularSubjectArea(ExifTag tag, ushort x, ushort y, ushort d)
: base(tag, new ushort[] { x, y, d })
{
;
}
}
///
/// Represents the location and area of the subject (EXIF Specification: 4xSHORT)
/// The coordinate values, width, and height are expressed in relation to the
/// upper left as origin, prior to rotation processing as per the Rotation tag.
///
public class ExifRectangularSubjectArea : ExifPointSubjectArea
{
public ushort Width { get { return mValue[2]; } set { mValue[2] = value; } }
public ushort Height { get { return mValue[3]; } set { mValue[3] = value; } }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("({0:d}, {1:d}) ({2:d} x {3:d})", mValue[0], mValue[1], mValue[2], mValue[3]);
return sb.ToString();
}
public ExifRectangularSubjectArea(ExifTag tag, ushort[] value)
: base(tag, value)
{
;
}
public ExifRectangularSubjectArea(ExifTag tag, ushort x, ushort y, ushort w, ushort h)
: base(tag, new ushort[] { x, y, w, h })
{
;
}
}
///
/// Represents GPS latitudes and longitudes (EXIF Specification: 3xRATIONAL)
///
public class GPSLatitudeLongitude : ExifURationalArray
{
protected new MathEx.UFraction32[] Value { get { return mValue; } set { mValue = value; } }
public MathEx.UFraction32 Degrees { get { return mValue[0]; } set { mValue[0] = value; } }
public MathEx.UFraction32 Minutes { get { return mValue[1]; } set { mValue[1] = value; } }
public MathEx.UFraction32 Seconds { get { return mValue[2]; } set { mValue[2] = value; } }
public static explicit operator float(GPSLatitudeLongitude obj) { return obj.ToFloat(); }
public float ToFloat()
{
return (float)Degrees + ((float)Minutes) / 60.0f + ((float)Seconds) / 3600.0f;
}
public override string ToString()
{
return string.Format("{0:F2}°{1:F2}'{2:F2}\"", (float)Degrees, (float)Minutes, (float)Seconds);
}
public GPSLatitudeLongitude(ExifTag tag, MathEx.UFraction32[] value)
: base(tag, value)
{
;
}
public GPSLatitudeLongitude(ExifTag tag, float d, float m, float s)
: base(tag, new MathEx.UFraction32[] { new MathEx.UFraction32(d), new MathEx.UFraction32(m), new MathEx.UFraction32(s) })
{
;
}
}
///
/// Represents a GPS time stamp as UTC (EXIF Specification: 3xRATIONAL)
///
public class GPSTimeStamp : ExifURationalArray
{
protected new MathEx.UFraction32[] Value { get { return mValue; } set { mValue = value; } }
public MathEx.UFraction32 Hour { get { return mValue[0]; } set { mValue[0] = value; } }
public MathEx.UFraction32 Minute { get { return mValue[1]; } set { mValue[1] = value; } }
public MathEx.UFraction32 Second { get { return mValue[2]; } set { mValue[2] = value; } }
public override string ToString()
{
return string.Format("{0:F2}:{1:F2}:{2:F2}\"", (float)Hour, (float)Minute, (float)Second);
}
public GPSTimeStamp(ExifTag tag, MathEx.UFraction32[] value)
: base(tag, value)
{
;
}
public GPSTimeStamp(ExifTag tag, float h, float m, float s)
: base(tag, new MathEx.UFraction32[] { new MathEx.UFraction32(h), new MathEx.UFraction32(m), new MathEx.UFraction32(s) })
{
;
}
}
///
/// Represents an ASCII string. (EXIF Specification: BYTE)
/// Used by Windows XP.
///
public class WindowsByteString : ExifProperty
{
protected string mValue;
protected override object _Value { get { return Value; } set { Value = (string)value; } }
public new string Value { get { return mValue; } set { mValue = value; } }
static public implicit operator string(WindowsByteString obj) { return obj.mValue; }
public override string ToString() { return mValue; }
public WindowsByteString(ExifTag tag, string value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
byte[] data = Encoding.Unicode.GetBytes(mValue);
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 1, (uint)data.Length, data);
}
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifFileTypeDescriptor.cs 0000664 0000000 0000000 00000010473 14462226067 0027477 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
namespace ExifLibrary
{
///
/// Provides a custom type descriptor for an ExifFile instance.
///
internal sealed class ExifFileTypeDescriptionProvider : TypeDescriptionProvider
{
public ExifFileTypeDescriptionProvider()
: this(TypeDescriptor.GetProvider(typeof(ImageFile)))
{
}
public ExifFileTypeDescriptionProvider(TypeDescriptionProvider parent)
: base(parent)
{
}
///
/// Gets a custom type descriptor for the given type and object.
///
/// The type of object for which to retrieve the type descriptor.
/// An instance of the type. Can be null if no instance was passed to the .
///
/// An that can provide metadata for the type.
///
public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
{
return new ExifFileTypeDescriptor(base.GetTypeDescriptor(objectType, instance), instance);
}
}
///
/// Expands ExifProperty objects contained in an ExifFile as seperate properties.
///
internal sealed class ExifFileTypeDescriptor : CustomTypeDescriptor
{
ImageFile owner;
public ExifFileTypeDescriptor(ICustomTypeDescriptor parent, object instance)
: base(parent)
{
owner = (ImageFile)instance;
}
public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
return GetProperties();
}
///
/// Returns a collection of property descriptors for the object represented by this type descriptor.
///
///
/// A containing the property descriptions for the object represented by this type descriptor. The default is .
///
public override PropertyDescriptorCollection GetProperties()
{
// Enumerate the original set of properties and create our new set with it
List properties = new List();
foreach (ExifProperty prop in owner.Properties)
{
ExifPropertyDescriptor pd = new ExifPropertyDescriptor(prop);
properties.Add(pd);
}
// Finally return the list
return new PropertyDescriptorCollection(properties.ToArray(), true);
}
}
internal sealed class ExifPropertyDescriptor : PropertyDescriptor
{
object originalValue;
ExifProperty linkedProperty;
public ExifPropertyDescriptor(ExifProperty property)
: base(property.Name, new Attribute[] { new BrowsableAttribute(true) })
{
linkedProperty = property;
originalValue = property.Value;
}
public override bool CanResetValue(object component)
{
return true;
}
public override Type ComponentType
{
get { return typeof(JPEGFile); }
}
public override object GetValue(object component)
{
return linkedProperty.Value;
}
public override bool IsReadOnly
{
get { return false; }
}
public override Type PropertyType
{
get { return linkedProperty.Value.GetType(); }
}
public override void ResetValue(object component)
{
linkedProperty.Value = originalValue;
}
public override void SetValue(object component, object value)
{
linkedProperty.Value = value;
}
public override bool ShouldSerializeValue(object component)
{
return false;
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifInterOperability.cs 0000664 0000000 0000000 00000004351 14462226067 0027202 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents interoperability data for an exif tag in the platform byte order.
///
public struct ExifInterOperability
{
private ushort mTagID;
private ushort mTypeID;
private uint mCount;
private byte[] mData;
///
/// Gets the tag ID defined in the Exif standard.
///
public ushort TagID { get { return mTagID; } }
///
/// Gets the type code defined in the Exif standard.
///
/// - 1 = BYTE (byte)
/// - 2 = ASCII (byte array)
/// - 3 = SHORT (ushort)
/// - 4 = LONG (uint)
/// - 5 = RATIONAL (2 x uint: numerator, denominator)
/// - 6 = BYTE (sbyte)
/// - 7 = UNDEFINED (byte array)
/// - 8 = SSHORT (short)
/// - 9 = SLONG (int)
/// - 10 = SRATIONAL (2 x int: numerator, denominator)
/// - 11 = FLOAT (float)
/// - 12 = DOUBLE (double)
///
///
public ushort TypeID { get { return mTypeID; } }
///
/// Gets the byte count or number of components.
///
public uint Count { get { return mCount; } }
///
/// Gets the field value as an array of bytes.
///
public byte[] Data { get { return mData; } }
///
/// Returns the string representation of this instance.
///
///
public override string ToString()
{
return string.Format("Tag: {0}, Type: {1}, Count: {2}, Data Length: {3}", mTagID, mTypeID, mCount, mData.Length);
}
public ExifInterOperability(ushort tagid, ushort typeid, uint count, byte[] data)
{
mTagID = tagid;
mTypeID = typeid;
mCount = count;
mData = data;
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifLibrary.csproj 0000664 0000000 0000000 00000007574 14462226067 0026226 0 ustar 00root root 0000000 0000000
Debug
AnyCPU
8.0.30703
2.0
{C29BA585-E27B-4AD0-9AD1-490B5E0E2A5E}
Library
Properties
ExifLibrary
ExifLibrary
512
false
Manina.snk
2.0
v2.0
true
full
false
bin\Debug\
DEBUG;TRACE
prompt
4
pdbonly
true
bin\Release\
TRACE
prompt
4
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifProperty.cs 0000664 0000000 0000000 00000046115 14462226067 0025545 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the abstract base class for an Exif property.
///
public abstract class ExifProperty
{
protected ExifTag mTag;
protected IFD mIFD;
protected string mName;
///
/// Gets the Exif tag associated with this property.
///
public ExifTag Tag { get { return mTag; } }
///
/// Gets the IFD section contaning this property.
///
public IFD IFD { get { return mIFD; } }
///
/// Gets or sets the name of this property.
///
public string Name
{
get
{
if (mName == null || mName.Length == 0)
return ExifTagFactory.GetTagName(mTag);
else
return mName;
}
set
{
mName = value;
}
}
protected abstract object _Value { get; set; }
///
/// Gets or sets the value of this property.
///
public object Value { get { return _Value; } set { _Value = value; } }
///
/// Gets interoperability data for this property.
///
public abstract ExifInterOperability Interoperability { get; }
public ExifProperty(ExifTag tag)
{
mTag = tag;
mIFD = ExifTagFactory.GetTagIFD(tag);
}
}
///
/// Represents an 8-bit unsigned integer. (EXIF Specification: BYTE)
///
public class ExifByte : ExifProperty
{
protected byte mValue;
protected override object _Value { get { return Value; } set { Value = Convert.ToByte(value); } }
public new byte Value { get { return mValue; } set { mValue = value; } }
static public implicit operator byte(ExifByte obj) { return obj.mValue; }
public override string ToString() { return mValue.ToString(); }
public ExifByte(ExifTag tag, byte value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 1, 1, new byte[] { mValue });
}
}
}
///
/// Represents an array of 8-bit unsigned integers. (EXIF Specification: BYTE with count > 1)
///
public class ExifByteArray : ExifProperty
{
protected byte[] mValue;
protected override object _Value { get { return Value; } set { Value = (byte[])value; } }
public new byte[] Value { get { return mValue; } set { mValue = value; } }
static public implicit operator byte[](ExifByteArray obj) { return obj.mValue; }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (byte b in mValue)
{
sb.Append(b);
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
public ExifByteArray(ExifTag tag, byte[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 1, (uint)mValue.Length, mValue);
}
}
}
///
/// Represents an ASCII string. (EXIF Specification: ASCII)
///
public class ExifAscii : ExifProperty
{
protected string mValue;
protected override object _Value { get { return Value; } set { Value = (string)value; } }
public new string Value { get { return mValue; } set { mValue = value; } }
public Encoding Encoding { get; private set; }
static public implicit operator string(ExifAscii obj) { return obj.mValue; }
public override string ToString() { return mValue; }
public ExifAscii(ExifTag tag, string value, Encoding encoding)
: base(tag)
{
mValue = value;
Encoding = encoding;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 2, (uint)mValue.Length + 1, ExifBitConverter.GetBytes(mValue, true, Encoding));
}
}
}
///
/// Represents a 16-bit unsigned integer. (EXIF Specification: SHORT)
///
public class ExifUShort : ExifProperty
{
protected ushort mValue;
protected override object _Value { get { return Value; } set { Value = Convert.ToUInt16(value); } }
public new ushort Value { get { return mValue; } set { mValue = value; } }
static public implicit operator ushort(ExifUShort obj) { return obj.mValue; }
public override string ToString() { return mValue.ToString(); }
public ExifUShort(ExifTag tag, ushort value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 3, 1, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents an array of 16-bit unsigned integers.
/// (EXIF Specification: SHORT with count > 1)
///
public class ExifUShortArray : ExifProperty
{
protected ushort[] mValue;
protected override object _Value { get { return Value; } set { Value = (ushort[])value; } }
public new ushort[] Value { get { return mValue; } set { mValue = value; } }
static public implicit operator ushort[](ExifUShortArray obj) { return obj.mValue; }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (ushort b in mValue)
{
sb.Append(b);
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
public ExifUShortArray(ExifTag tag, ushort[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 3, (uint)mValue.Length, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents a 32-bit unsigned integer. (EXIF Specification: LONG)
///
public class ExifUInt : ExifProperty
{
protected uint mValue;
protected override object _Value { get { return Value; } set { Value = Convert.ToUInt32(value); } }
public new uint Value { get { return mValue; } set { mValue = value; } }
static public implicit operator uint(ExifUInt obj) { return obj.mValue; }
public override string ToString() { return mValue.ToString(); }
public ExifUInt(ExifTag tag, uint value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 4, 1, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents an array of 16-bit unsigned integers.
/// (EXIF Specification: LONG with count > 1)
///
public class ExifUIntArray : ExifProperty
{
protected uint[] mValue;
protected override object _Value { get { return Value; } set { Value = (uint[])value; } }
public new uint[] Value { get { return mValue; } set { mValue = value; } }
static public implicit operator uint[](ExifUIntArray obj) { return obj.mValue; }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (uint b in mValue)
{
sb.Append(b);
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
public ExifUIntArray(ExifTag tag, uint[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 3, (uint)mValue.Length, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents a rational number defined with a 32-bit unsigned numerator
/// and denominator. (EXIF Specification: RATIONAL)
///
public class ExifURational : ExifProperty
{
protected MathEx.UFraction32 mValue;
protected override object _Value { get { return Value; } set { Value = (MathEx.UFraction32)value; } }
public new MathEx.UFraction32 Value { get { return mValue; } set { mValue = value; } }
public override string ToString() { return mValue.ToString(); }
public float ToFloat() { return (float)mValue; }
static public explicit operator float(ExifURational obj) { return (float)obj.mValue; }
public uint[] ToArray()
{
return new uint[] { mValue.Numerator, mValue.Denominator };
}
public ExifURational(ExifTag tag, uint numerator, uint denominator)
: base(tag)
{
mValue = new MathEx.UFraction32(numerator, denominator);
}
public ExifURational(ExifTag tag, MathEx.UFraction32 value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 5, 1, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents an array of unsigned rational numbers.
/// (EXIF Specification: RATIONAL with count > 1)
///
public class ExifURationalArray : ExifProperty
{
protected MathEx.UFraction32[] mValue;
protected override object _Value { get { return Value; } set { Value = (MathEx.UFraction32[])value; } }
public new MathEx.UFraction32[] Value { get { return mValue; } set { mValue = value; } }
static public explicit operator float[](ExifURationalArray obj)
{
float[] result = new float[obj.mValue.Length];
for (int i = 0; i < obj.mValue.Length; i++)
result[i] = (float)obj.mValue[i];
return result;
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (MathEx.UFraction32 b in mValue)
{
sb.Append(b.ToString());
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
public ExifURationalArray(ExifTag tag, MathEx.UFraction32[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 5, (uint)mValue.Length, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents a byte array that can take any value. (EXIF Specification: UNDEFINED)
///
public class ExifUndefined : ExifProperty
{
protected byte[] mValue;
protected override object _Value { get { return Value; } set { Value = (byte[])value; } }
public new byte[] Value { get { return mValue; } set { mValue = value; } }
static public implicit operator byte[](ExifUndefined obj) { return obj.mValue; }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (byte b in mValue)
{
sb.Append(b);
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
public ExifUndefined(ExifTag tag, byte[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 7, (uint)mValue.Length, mValue);
}
}
}
///
/// Represents a 32-bit signed integer. (EXIF Specification: SLONG)
///
public class ExifSInt : ExifProperty
{
protected int mValue;
protected override object _Value { get { return Value; } set { Value = Convert.ToInt32(value); } }
public new int Value { get { return mValue; } set { mValue = value; } }
public override string ToString() { return mValue.ToString(); }
static public implicit operator int(ExifSInt obj) { return obj.mValue; }
public ExifSInt(ExifTag tag, int value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 9, 1, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents an array of 32-bit signed integers.
/// (EXIF Specification: SLONG with count > 1)
///
public class ExifSIntArray : ExifProperty
{
protected int[] mValue;
protected override object _Value { get { return Value; } set { Value = (int[])value; } }
public new int[] Value { get { return mValue; } set { mValue = value; } }
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (int b in mValue)
{
sb.Append(b);
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
static public implicit operator int[](ExifSIntArray obj) { return obj.mValue; }
public ExifSIntArray(ExifTag tag, int[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 9, (uint)mValue.Length, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents a rational number defined with a 32-bit signed numerator
/// and denominator. (EXIF Specification: SRATIONAL)
///
public class ExifSRational : ExifProperty
{
protected MathEx.Fraction32 mValue;
protected override object _Value { get { return Value; } set { Value = (MathEx.Fraction32)value; } }
public new MathEx.Fraction32 Value { get { return mValue; } set { mValue = value; } }
public override string ToString() { return mValue.ToString(); }
public float ToFloat() { return (float)mValue; }
static public explicit operator float(ExifSRational obj) { return (float)obj.mValue; }
public int[] ToArray()
{
return new int[] { mValue.Numerator, mValue.Denominator };
}
public ExifSRational(ExifTag tag, int numerator, int denominator)
: base(tag)
{
mValue = new MathEx.Fraction32(numerator, denominator);
}
public ExifSRational(ExifTag tag, MathEx.Fraction32 value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 10, 1, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
///
/// Represents an array of signed rational numbers.
/// (EXIF Specification: SRATIONAL with count > 1)
///
public class ExifSRationalArray : ExifProperty
{
protected MathEx.Fraction32[] mValue;
protected override object _Value { get { return Value; } set { Value = (MathEx.Fraction32[])value; } }
public new MathEx.Fraction32[] Value { get { return mValue; } set { mValue = value; } }
static public explicit operator float[](ExifSRationalArray obj)
{
float[] result = new float[obj.mValue.Length];
for (int i = 0; i < obj.mValue.Length; i++)
result[i] = (float)obj.mValue[i];
return result;
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
foreach (MathEx.Fraction32 b in mValue)
{
sb.Append(b.ToString());
sb.Append(' ');
}
sb.Remove(sb.Length - 1, 1);
sb.Append(']');
return sb.ToString();
}
public ExifSRationalArray(ExifTag tag, MathEx.Fraction32[] value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 10, (uint)mValue.Length, ExifBitConverter.GetBytes(mValue, BitConverterEx.SystemByteOrder));
}
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifPropertyCollection.cs 0000664 0000000 0000000 00000024136 14462226067 0027560 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents a collection of objects.
///
public class ExifPropertyCollection : IList
{
#region Member Variables
private List items;
#endregion
#region Constructor
internal ExifPropertyCollection()
{
items = new List();
}
#endregion
#region Properties
///
/// Gets the number of elements contained in the collection.
///
public int Count
{
get { return items.Count; }
}
///
/// Gets or sets the with the specified index.
///
public ExifProperty this[int index]
{
get { return items[index]; }
set { items[index] = value; }
}
#endregion
#region ExifProperty Collection Setters
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, byte value)
{
items.Add(new ExifByte(key, value));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, string value, Encoding encoding)
{
if (key == ExifTag.WindowsTitle || key == ExifTag.WindowsTitle || key == ExifTag.WindowsComment || key == ExifTag.WindowsAuthor || key == ExifTag.WindowsKeywords || key == ExifTag.WindowsSubject)
{
items.Add(new WindowsByteString(key, value));
}
else if (key == ExifTag.UserComment)
{
items.Add(new ExifEncodedString(key, value, encoding));
}
else
{
items.Add(new ExifAscii(key, value, encoding));
}
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, string value)
{
Add(key, value, Encoding.Default);
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, ushort value)
{
items.Add(new ExifUShort(key, value));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, int value)
{
items.Add(new ExifSInt(key, value));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, uint value)
{
items.Add(new ExifUInt(key, value));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, float value)
{
items.Add(new ExifURational(key, new MathEx.UFraction32(value)));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, double value)
{
items.Add(new ExifURational(key, new MathEx.UFraction32(value)));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, object value)
{
Type type = value.GetType();
if (type.IsEnum)
{
Type etype = typeof(ExifEnumProperty<>).MakeGenericType(new Type[] { type });
object prop = Activator.CreateInstance(etype, new object[] { key, value });
items.Add((ExifProperty)prop);
}
else
throw new ArgumentException("No exif property exists for this tag.", "value");
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// The value of tag.
public void Add(ExifTag key, DateTime value)
{
items.Add(new ExifDateTime(key, value));
}
///
/// Sets the with the specified key.
///
/// The tag to set.
/// Angular degrees (or clock hours for a timestamp).
/// Angular minutes (or clock minutes for a timestamp).
/// Angular seconds (or clock seconds for a timestamp).
public void Add(ExifTag key, float d, float m, float s)
{
items.Add(new ExifURationalArray(key, new MathEx.UFraction32[] { new MathEx.UFraction32(d), new MathEx.UFraction32(m), new MathEx.UFraction32(s) }));
}
#endregion
#region Instance Methods
///
/// Adds the specified item to the collection.
///
/// The to add to the collection.
public void Add(ExifProperty item)
{
items.Add(item);
}
///
/// Removes all items from the collection.
///
public void Clear()
{
items.Clear();
}
///
/// Determines whether the collection contains an element with the specified key.
///
/// The key to locate in the collection.
///
/// true if the collection contains an element with the key; otherwise, false.
///
///
/// is null.
public bool Contains(ExifProperty key)
{
return items.Contains(key);
}
///
/// Removes the element with the specified key from the collection.
///
/// The key of the element to remove.
///
/// true if the element is successfully removed; otherwise, false. This method also returns false if was not found in the original collection.
///
///
/// is null.
public bool Remove(ExifProperty key)
{
return items.Remove(key);
}
///
/// Removes the item at the given index.
///
/// The index of the item to remove.
public void RemoveAt(int index)
{
items.RemoveAt(index);
}
///
/// Removes all items with the given IFD from the collection.
///
/// The IFD section to remove.
public void Remove(IFD ifd)
{
List toRemove = new List();
foreach (ExifProperty item in items)
{
if (item.IFD == ifd)
toRemove.Add(item);
}
foreach (ExifProperty tag in toRemove)
items.Remove(tag);
}
///
/// Returns the index of the given item.
///
/// The item to look for in the collection.
///
public int IndexOf(ExifProperty item)
{
return items.IndexOf(item);
}
///
/// Returns an enumerator to iterate the collection.
///
public IEnumerator GetEnumerator()
{
return items.GetEnumerator();
}
#endregion
#region Hidden Interface
void IList.Insert(int index, ExifProperty item)
{
items.Insert(index, item);
}
void ICollection.CopyTo(ExifProperty[] array, int arrayIndex)
{
items.CopyTo(array, arrayIndex);
}
bool ICollection.IsReadOnly
{
get { return false; }
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifPropertyFactory.cs 0000664 0000000 0000000 00000042360 14462226067 0027073 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
namespace ExifLibrary
{
///
/// Creates exif properties from interoperability parameters.
///
public static class ExifPropertyFactory
{
#region Static Methods
///
/// Creates an ExifProperty from the given interoperability parameters.
///
/// The tag id of the exif property.
/// The type id of the exif property.
/// Byte or component count.
/// Field data as an array of bytes.
/// Byte order of value.
/// IFD section containing this propery.
/// The encoding to be used for text metadata when the source encoding is unknown.
/// an ExifProperty initialized from the interoperability parameters.
public static ExifProperty Get(ushort tag, ushort type, uint count, byte[] value, BitConverterEx.ByteOrder byteOrder, IFD ifd, Encoding encoding)
{
BitConverterEx conv = new BitConverterEx(byteOrder, BitConverterEx.SystemByteOrder);
// Find the exif tag corresponding to given tag id
ExifTag etag = ExifTagFactory.GetExifTag(ifd, tag);
if (ifd == IFD.Zeroth)
{
if (tag == 0x103) // Compression
return new ExifEnumProperty(ExifTag.Compression, (Compression)conv.ToUInt16(value, 0));
else if (tag == 0x106) // PhotometricInterpretation
return new ExifEnumProperty(ExifTag.PhotometricInterpretation, (PhotometricInterpretation)conv.ToUInt16(value, 0));
else if (tag == 0x112) // Orientation
return new ExifEnumProperty(ExifTag.Orientation, (Orientation)conv.ToUInt16(value, 0));
else if (tag == 0x11c) // PlanarConfiguration
return new ExifEnumProperty(ExifTag.PlanarConfiguration, (PlanarConfiguration)conv.ToUInt16(value, 0));
else if (tag == 0x213) // YCbCrPositioning
return new ExifEnumProperty(ExifTag.YCbCrPositioning, (YCbCrPositioning)conv.ToUInt16(value, 0));
else if (tag == 0x128) // ResolutionUnit
return new ExifEnumProperty(ExifTag.ResolutionUnit, (ResolutionUnit)conv.ToUInt16(value, 0));
else if (tag == 0x132) // DateTime
return new ExifDateTime(ExifTag.DateTime, ExifBitConverter.ToDateTime(value));
else if (tag == 0x9c9b || tag == 0x9c9c || // Windows tags
tag == 0x9c9d || tag == 0x9c9e || tag == 0x9c9f)
return new WindowsByteString(etag, Encoding.Unicode.GetString(value).TrimEnd('\0'));
}
else if (ifd == IFD.EXIF)
{
if (tag == 0x9000) // ExifVersion
return new ExifVersion(ExifTag.ExifVersion, ExifBitConverter.ToAscii(value, Encoding.ASCII));
else if (tag == 0xa000) // FlashpixVersion
return new ExifVersion(ExifTag.FlashpixVersion, ExifBitConverter.ToAscii(value, Encoding.ASCII));
else if (tag == 0xa001) // ColorSpace
return new ExifEnumProperty(ExifTag.ColorSpace, (ColorSpace)conv.ToUInt16(value, 0));
else if (tag == 0x9286) // UserComment
{
// Default to ASCII
Encoding enc = Encoding.ASCII;
bool hasenc;
if (value.Length < 8)
hasenc = false;
else
{
hasenc = true;
string encstr = enc.GetString(value, 0, 8);
if (string.Compare(encstr, "ASCII\0\0\0", StringComparison.OrdinalIgnoreCase) == 0)
enc = Encoding.ASCII;
else if (string.Compare(encstr, "JIS\0\0\0\0\0", StringComparison.OrdinalIgnoreCase) == 0)
enc = Encoding.GetEncoding("Japanese (JIS 0208-1990 and 0212-1990)");
else if (string.Compare(encstr, "Unicode\0", StringComparison.OrdinalIgnoreCase) == 0)
enc = Encoding.Unicode;
else
hasenc = false;
}
string val = (hasenc ? enc.GetString(value, 8, value.Length - 8) : enc.GetString(value)).Trim('\0');
return new ExifEncodedString(ExifTag.UserComment, val, enc);
}
else if (tag == 0x9003) // DateTimeOriginal
return new ExifDateTime(ExifTag.DateTimeOriginal, ExifBitConverter.ToDateTime(value));
else if (tag == 0x9004) // DateTimeDigitized
return new ExifDateTime(ExifTag.DateTimeDigitized, ExifBitConverter.ToDateTime(value));
else if (tag == 0x8822) // ExposureProgram
return new ExifEnumProperty(ExifTag.ExposureProgram, (ExposureProgram)conv.ToUInt16(value, 0));
else if (tag == 0x9207) // MeteringMode
return new ExifEnumProperty(ExifTag.MeteringMode, (MeteringMode)conv.ToUInt16(value, 0));
else if (tag == 0x9208) // LightSource
return new ExifEnumProperty(ExifTag.LightSource, (LightSource)conv.ToUInt16(value, 0));
else if (tag == 0x9209) // Flash
return new ExifEnumProperty(ExifTag.Flash, (Flash)conv.ToUInt16(value, 0), true);
else if (tag == 0x9214) // SubjectArea
{
if (count == 3)
return new ExifCircularSubjectArea(ExifTag.SubjectArea, ExifBitConverter.ToUShortArray(value, (int)count, byteOrder));
else if (count == 4)
return new ExifRectangularSubjectArea(ExifTag.SubjectArea, ExifBitConverter.ToUShortArray(value, (int)count, byteOrder));
else // count == 2
return new ExifPointSubjectArea(ExifTag.SubjectArea, ExifBitConverter.ToUShortArray(value, (int)count, byteOrder));
}
else if (tag == 0xa210) // FocalPlaneResolutionUnit
return new ExifEnumProperty(ExifTag.FocalPlaneResolutionUnit, (ResolutionUnit)conv.ToUInt16(value, 0), true);
else if (tag == 0xa214) // SubjectLocation
return new ExifPointSubjectArea(ExifTag.SubjectLocation, ExifBitConverter.ToUShortArray(value, (int)count, byteOrder));
else if (tag == 0xa217) // SensingMethod
return new ExifEnumProperty(ExifTag.SensingMethod, (SensingMethod)conv.ToUInt16(value, 0), true);
else if (tag == 0xa300) // FileSource
return new ExifEnumProperty(ExifTag.FileSource, (FileSource)conv.ToUInt16(value, 0), true);
else if (tag == 0xa301) // SceneType
return new ExifEnumProperty(ExifTag.SceneType, (SceneType)conv.ToUInt16(value, 0), true);
else if (tag == 0xa401) // CustomRendered
return new ExifEnumProperty(ExifTag.CustomRendered, (CustomRendered)conv.ToUInt16(value, 0), true);
else if (tag == 0xa402) // ExposureMode
return new ExifEnumProperty(ExifTag.ExposureMode, (ExposureMode)conv.ToUInt16(value, 0), true);
else if (tag == 0xa403) // WhiteBalance
return new ExifEnumProperty(ExifTag.WhiteBalance, (WhiteBalance)conv.ToUInt16(value, 0), true);
else if (tag == 0xa406) // SceneCaptureType
return new ExifEnumProperty(ExifTag.SceneCaptureType, (SceneCaptureType)conv.ToUInt16(value, 0), true);
else if (tag == 0xa407) // GainControl
return new ExifEnumProperty(ExifTag.GainControl, (GainControl)conv.ToUInt16(value, 0), true);
else if (tag == 0xa408) // Contrast
return new ExifEnumProperty(ExifTag.Contrast, (Contrast)conv.ToUInt16(value, 0), true);
else if (tag == 0xa409) // Saturation
return new ExifEnumProperty(ExifTag.Saturation, (Saturation)conv.ToUInt16(value, 0), true);
else if (tag == 0xa40a) // Sharpness
return new ExifEnumProperty(ExifTag.Sharpness, (Sharpness)conv.ToUInt16(value, 0), true);
else if (tag == 0xa40c) // SubjectDistanceRange
return new ExifEnumProperty(ExifTag.SubjectDistanceRange, (SubjectDistanceRange)conv.ToUInt16(value, 0), true);
}
else if (ifd == IFD.GPS)
{
if (tag == 0) // GPSVersionID
return new ExifVersion(ExifTag.GPSVersionID, ExifBitConverter.ToString(value));
else if (tag == 1) // GPSLatitudeRef
return new ExifEnumProperty(ExifTag.GPSLatitudeRef, (GPSLatitudeRef)value[0]);
else if (tag == 2) // GPSLatitude
return new GPSLatitudeLongitude(ExifTag.GPSLatitude, ExifBitConverter.ToURationalArray(value, (int)count, byteOrder));
else if (tag == 3) // GPSLongitudeRef
return new ExifEnumProperty(ExifTag.GPSLongitudeRef, (GPSLongitudeRef)value[0]);
else if (tag == 4) // GPSLongitude
return new GPSLatitudeLongitude(ExifTag.GPSLongitude, ExifBitConverter.ToURationalArray(value, (int)count, byteOrder));
else if (tag == 5) // GPSAltitudeRef
return new ExifEnumProperty(ExifTag.GPSAltitudeRef, (GPSAltitudeRef)value[0]);
else if (tag == 7) // GPSTimeStamp
return new GPSTimeStamp(ExifTag.GPSTimeStamp, ExifBitConverter.ToURationalArray(value, (int)count, byteOrder));
else if (tag == 9) // GPSStatus
return new ExifEnumProperty(ExifTag.GPSStatus, (GPSStatus)value[0]);
else if (tag == 10) // GPSMeasureMode
return new ExifEnumProperty(ExifTag.GPSMeasureMode, (GPSMeasureMode)value[0]);
else if (tag == 12) // GPSSpeedRef
return new ExifEnumProperty(ExifTag.GPSSpeedRef, (GPSSpeedRef)value[0]);
else if (tag == 14) // GPSTrackRef
return new ExifEnumProperty(ExifTag.GPSTrackRef, (GPSDirectionRef)value[0]);
else if (tag == 16) // GPSImgDirectionRef
return new ExifEnumProperty(ExifTag.GPSImgDirectionRef, (GPSDirectionRef)value[0]);
else if (tag == 19) // GPSDestLatitudeRef
return new ExifEnumProperty(ExifTag.GPSDestLatitudeRef, (GPSLatitudeRef)value[0]);
else if (tag == 20) // GPSDestLatitude
return new GPSLatitudeLongitude(ExifTag.GPSDestLatitude, ExifBitConverter.ToURationalArray(value, (int)count, byteOrder));
else if (tag == 21) // GPSDestLongitudeRef
return new ExifEnumProperty(ExifTag.GPSDestLongitudeRef, (GPSLongitudeRef)value[0]);
else if (tag == 22) // GPSDestLongitude
return new GPSLatitudeLongitude(ExifTag.GPSDestLongitude, ExifBitConverter.ToURationalArray(value, (int)count, byteOrder));
else if (tag == 23) // GPSDestBearingRef
return new ExifEnumProperty(ExifTag.GPSDestBearingRef, (GPSDirectionRef)value[0]);
else if (tag == 25) // GPSDestDistanceRef
return new ExifEnumProperty(ExifTag.GPSDestDistanceRef, (GPSDistanceRef)value[0]);
else if (tag == 29) // GPSDate
return new ExifDateTime(ExifTag.GPSDateStamp, ExifBitConverter.ToDateTime(value, false));
else if (tag == 30) // GPSDifferential
return new ExifEnumProperty(ExifTag.GPSDifferential, (GPSDifferential)conv.ToUInt16(value, 0));
}
else if (ifd == IFD.Interop)
{
if (tag == 1) // InteroperabilityIndex
return new ExifAscii(ExifTag.InteroperabilityIndex, ExifBitConverter.ToAscii(value, Encoding.ASCII), Encoding.ASCII);
else if (tag == 2) // InteroperabilityVersion
return new ExifVersion(ExifTag.InteroperabilityVersion, ExifBitConverter.ToAscii(value, Encoding.ASCII));
}
else if (ifd == IFD.First)
{
if (tag == 0x103) // Compression
return new ExifEnumProperty(ExifTag.ThumbnailCompression, (Compression)conv.ToUInt16(value, 0));
else if (tag == 0x106) // PhotometricInterpretation
return new ExifEnumProperty(ExifTag.ThumbnailPhotometricInterpretation, (PhotometricInterpretation)conv.ToUInt16(value, 0));
else if (tag == 0x112) // Orientation
return new ExifEnumProperty(ExifTag.ThumbnailOrientation, (Orientation)conv.ToUInt16(value, 0));
else if (tag == 0x11c) // PlanarConfiguration
return new ExifEnumProperty(ExifTag.ThumbnailPlanarConfiguration, (PlanarConfiguration)conv.ToUInt16(value, 0));
else if (tag == 0x213) // YCbCrPositioning
return new ExifEnumProperty(ExifTag.ThumbnailYCbCrPositioning, (YCbCrPositioning)conv.ToUInt16(value, 0));
else if (tag == 0x128) // ResolutionUnit
return new ExifEnumProperty(ExifTag.ThumbnailResolutionUnit, (ResolutionUnit)conv.ToUInt16(value, 0));
else if (tag == 0x132) // DateTime
return new ExifDateTime(ExifTag.ThumbnailDateTime, ExifBitConverter.ToDateTime(value));
}
if (type == 1) // 1 = BYTE An 8-bit unsigned integer.
{
if (count == 1)
return new ExifByte(etag, value[0]);
else
return new ExifByteArray(etag, value);
}
else if (type == 2) // 2 = ASCII An 8-bit byte containing one 7-bit ASCII code.
{
return new ExifAscii(etag, ExifBitConverter.ToAscii(value, encoding), encoding);
}
else if (type == 3) // 3 = SHORT A 16-bit (2-byte) unsigned integer.
{
if (count == 1)
return new ExifUShort(etag, conv.ToUInt16(value, 0));
else
return new ExifUShortArray(etag, ExifBitConverter.ToUShortArray(value, (int)count, byteOrder));
}
else if (type == 4) // 4 = LONG A 32-bit (4-byte) unsigned integer.
{
if (count == 1)
return new ExifUInt(etag, conv.ToUInt32(value, 0));
else
return new ExifUIntArray(etag, ExifBitConverter.ToUIntArray(value, (int)count, byteOrder));
}
else if (type == 5) // 5 = RATIONAL Two LONGs. The first LONG is the numerator and the second LONG expresses the denominator.
{
if (count == 1)
return new ExifURational(etag, ExifBitConverter.ToURational(value, byteOrder));
else
return new ExifURationalArray(etag, ExifBitConverter.ToURationalArray(value, (int)count, byteOrder));
}
else if (type == 7) // 7 = UNDEFINED An 8-bit byte that can take any value depending on the field definition.
return new ExifUndefined(etag, value);
else if (type == 9) // 9 = SLONG A 32-bit (4-byte) signed integer (2's complement notation).
{
if (count == 1)
return new ExifSInt(etag, conv.ToInt32(value, 0));
else
return new ExifSIntArray(etag, ExifBitConverter.ToSIntArray(value, (int)count, byteOrder));
}
else if (type == 10) // 10 = SRATIONAL Two SLONGs. The first SLONG is the numerator and the second SLONG is the denominator.
{
if (count == 1)
return new ExifSRational(etag, ExifBitConverter.ToSRational(value, byteOrder));
else
return new ExifSRationalArray(etag, ExifBitConverter.ToSRationalArray(value, (int)count, byteOrder));
}
else
throw new ArgumentException("Unknown property type.");
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifTag.cs 0000664 0000000 0000000 00000032242 14462226067 0024430 0 ustar 00root root 0000000 0000000
namespace ExifLibrary
{
///
/// Represents the tags associated with exif fields.
///
public enum ExifTag : int
{
// ****************************
// Zeroth IFD
// ****************************
NewSubfileType = IFD.Zeroth + 254,
SubfileType = IFD.Zeroth + 255,
ImageWidth = IFD.Zeroth + 256,
ImageLength = IFD.Zeroth + 257,
BitsPerSample = IFD.Zeroth + 258,
Compression = IFD.Zeroth + 259,
PhotometricInterpretation = IFD.Zeroth + 262,
Threshholding = IFD.Zeroth + 263,
CellWidth = IFD.Zeroth + 264,
CellLength = IFD.Zeroth + 265,
FillOrder = IFD.Zeroth + 266,
DocumentName = IFD.Zeroth + 269,
ImageDescription = IFD.Zeroth + 270,
Make = IFD.Zeroth + 271,
Model = IFD.Zeroth + 272,
StripOffsets = IFD.Zeroth + 273,
Orientation = IFD.Zeroth + 274,
SamplesPerPixel = IFD.Zeroth + 277,
RowsPerStrip = IFD.Zeroth + 278,
StripByteCounts = IFD.Zeroth + 279,
MinSampleValue = IFD.Zeroth + 280,
MaxSampleValue = IFD.Zeroth + 281,
XResolution = IFD.Zeroth + 282,
YResolution = IFD.Zeroth + 283,
PlanarConfiguration = IFD.Zeroth + 284,
PageName = IFD.Zeroth + 285,
XPosition = IFD.Zeroth + 286,
YPosition = IFD.Zeroth + 287,
FreeOffsets = IFD.Zeroth + 288,
FreeByteCounts = IFD.Zeroth + 289,
GrayResponseUnit = IFD.Zeroth + 290,
GrayResponseCurve = IFD.Zeroth + 291,
T4Options = IFD.Zeroth + 292,
T6Options = IFD.Zeroth + 293,
ResolutionUnit = IFD.Zeroth + 296,
PageNumber = IFD.Zeroth + 297,
TransferFunction = IFD.Zeroth + 301,
Software = IFD.Zeroth + 305,
DateTime = IFD.Zeroth + 306,
Artist = IFD.Zeroth + 315,
HostComputer = IFD.Zeroth + 316,
Predictor = IFD.Zeroth + 317,
WhitePoint = IFD.Zeroth + 318,
PrimaryChromaticities = IFD.Zeroth + 319,
ColorMap = IFD.Zeroth + 320,
HalftoneHints = IFD.Zeroth + 321,
TileWidth = IFD.Zeroth + 322,
TileLength = IFD.Zeroth + 323,
TileOffsets = IFD.Zeroth + 324,
TileByteCounts = IFD.Zeroth + 325,
InkSet = IFD.Zeroth + 332,
InkNames = IFD.Zeroth + 333,
NumberOfInks = IFD.Zeroth + 334,
DotRange = IFD.Zeroth + 336,
TargetPrinter = IFD.Zeroth + 337,
ExtraSamples = IFD.Zeroth + 338,
SampleFormat = IFD.Zeroth + 339,
SMinSampleValue = IFD.Zeroth + 340,
SMaxSampleValue = IFD.Zeroth + 341,
TransferRange = IFD.Zeroth + 342,
JPEGProc = IFD.Zeroth + 512,
JPEGInterchangeFormat = IFD.Zeroth + 513,
JPEGInterchangeFormatLength = IFD.Zeroth + 514,
JPEGRestartInterval = IFD.Zeroth + 515,
JPEGLosslessPredictors = IFD.Zeroth + 517,
JPEGPointTransforms = IFD.Zeroth + 518,
JPEGQTables = IFD.Zeroth + 519,
JPEGDCTables = IFD.Zeroth + 520,
JPEGACTables = IFD.Zeroth + 521,
YCbCrCoefficients = IFD.Zeroth + 529,
YCbCrSubSampling = IFD.Zeroth + 530,
YCbCrPositioning = IFD.Zeroth + 531,
ReferenceBlackWhite = IFD.Zeroth + 532,
Copyright = IFD.Zeroth + 33432,
// Pointers to other IFDs
EXIFIFDPointer = IFD.Zeroth + 34665,
GPSIFDPointer = IFD.Zeroth + 34853,
// Windows Tags
WindowsTitle = IFD.Zeroth + 0x9c9b,
WindowsComment = IFD.Zeroth + 0x9c9c,
WindowsAuthor = IFD.Zeroth + 0x9c9d,
WindowsKeywords = IFD.Zeroth + 0x9c9e,
WindowsSubject = IFD.Zeroth + 0x9c9f,
// Rating
Rating = IFD.Zeroth + 0x4746,
RatingPercent = IFD.Zeroth + 0x4749,
// Microsoft specifing padding and offset tags
ZerothIFDPadding = IFD.Zeroth + 0xea1c,
// ****************************
// EXIF Tags
// ****************************
ExifVersion = IFD.EXIF + 36864,
FlashpixVersion = IFD.EXIF + 40960,
ColorSpace = IFD.EXIF + 40961,
ComponentsConfiguration = IFD.EXIF + 37121,
CompressedBitsPerPixel = IFD.EXIF + 37122,
PixelXDimension = IFD.EXIF + 40962,
PixelYDimension = IFD.EXIF + 40963,
MakerNote = IFD.EXIF + 37500,
UserComment = IFD.EXIF + 37510,
RelatedSoundFile = IFD.EXIF + 40964,
DateTimeOriginal = IFD.EXIF + 36867,
DateTimeDigitized = IFD.EXIF + 36868,
SubSecTime = IFD.EXIF + 37520,
SubSecTimeOriginal = IFD.EXIF + 37521,
SubSecTimeDigitized = IFD.EXIF + 37522,
ExposureTime = IFD.EXIF + 33434,
FNumber = IFD.EXIF + 33437,
ExposureProgram = IFD.EXIF + 34850,
SpectralSensitivity = IFD.EXIF + 34852,
ISOSpeedRatings = IFD.EXIF + 34855,
OECF = IFD.EXIF + 34856,
ShutterSpeedValue = IFD.EXIF + 37377,
ApertureValue = IFD.EXIF + 37378,
BrightnessValue = IFD.EXIF + 37379,
ExposureBiasValue = IFD.EXIF + 37380,
MaxApertureValue = IFD.EXIF + 37381,
SubjectDistance = IFD.EXIF + 37382,
MeteringMode = IFD.EXIF + 37383,
LightSource = IFD.EXIF + 37384,
Flash = IFD.EXIF + 37385,
FocalLength = IFD.EXIF + 37386,
SubjectArea = IFD.EXIF + 37396,
FlashEnergy = IFD.EXIF + 41483,
SpatialFrequencyResponse = IFD.EXIF + 41484,
FocalPlaneXResolution = IFD.EXIF + 41486,
FocalPlaneYResolution = IFD.EXIF + 41487,
FocalPlaneResolutionUnit = IFD.EXIF + 41488,
SubjectLocation = IFD.EXIF + 41492,
ExposureIndex = IFD.EXIF + 41493,
SensingMethod = IFD.EXIF + 41495,
FileSource = IFD.EXIF + 41728,
SceneType = IFD.EXIF + 41729,
CFAPattern = IFD.EXIF + 41730,
CustomRendered = IFD.EXIF + 41985,
ExposureMode = IFD.EXIF + 41986,
WhiteBalance = IFD.EXIF + 41987,
DigitalZoomRatio = IFD.EXIF + 41988,
FocalLengthIn35mmFilm = IFD.EXIF + 41989,
SceneCaptureType = IFD.EXIF + 41990,
GainControl = IFD.EXIF + 41991,
Contrast = IFD.EXIF + 41992,
Saturation = IFD.EXIF + 41993,
Sharpness = IFD.EXIF + 41994,
DeviceSettingDescription = IFD.EXIF + 41995,
SubjectDistanceRange = IFD.EXIF + 41996,
ImageUniqueID = IFD.EXIF + 42016,
InteroperabilityIFDPointer = IFD.EXIF + 40965,
// Microsoft specifing padding and offset tags
ExifIFDPadding = IFD.EXIF + 0xea1c,
OffsetSchema = IFD.EXIF + 0xea1d,
// ****************************
// GPS Tags
// ****************************
GPSVersionID = IFD.GPS + 0,
GPSLatitudeRef = IFD.GPS + 1,
GPSLatitude = IFD.GPS + 2,
GPSLongitudeRef = IFD.GPS + 3,
GPSLongitude = IFD.GPS + 4,
GPSAltitudeRef = IFD.GPS + 5,
GPSAltitude = IFD.GPS + 6,
GPSTimeStamp = IFD.GPS + 7,
GPSSatellites = IFD.GPS + 8,
GPSStatus = IFD.GPS + 9,
GPSMeasureMode = IFD.GPS + 10,
GPSDOP = IFD.GPS + 11,
GPSSpeedRef = IFD.GPS + 12,
GPSSpeed = IFD.GPS + 13,
GPSTrackRef = IFD.GPS + 14,
GPSTrack = IFD.GPS + 15,
GPSImgDirectionRef = IFD.GPS + 16,
GPSImgDirection = IFD.GPS + 17,
GPSMapDatum = IFD.GPS + 18,
GPSDestLatitudeRef = IFD.GPS + 19,
GPSDestLatitude = IFD.GPS + 20,
GPSDestLongitudeRef = IFD.GPS + 21,
GPSDestLongitude = IFD.GPS + 22,
GPSDestBearingRef = IFD.GPS + 23,
GPSDestBearing = IFD.GPS + 24,
GPSDestDistanceRef = IFD.GPS + 25,
GPSDestDistance = IFD.GPS + 26,
GPSProcessingMethod = IFD.GPS + 27,
GPSAreaInformation = IFD.GPS + 28,
GPSDateStamp = IFD.GPS + 29,
GPSDifferential = IFD.GPS + 30,
// ****************************
// InterOp Tags
// ****************************
InteroperabilityIndex = IFD.Interop + 1,
InteroperabilityVersion = IFD.Interop + 2,
RelatedImageWidth = IFD.Interop + 0x1001,
RelatedImageHeight = IFD.Interop + 0x1002,
// ****************************
// First IFD TIFF Tags
// ****************************
ThumbnailImageWidth = IFD.First + 256,
ThumbnailImageLength = IFD.First + 257,
ThumbnailBitsPerSample = IFD.First + 258,
ThumbnailCompression = IFD.First + 259,
ThumbnailPhotometricInterpretation = IFD.First + 262,
ThumbnailOrientation = IFD.First + 274,
ThumbnailSamplesPerPixel = IFD.First + 277,
ThumbnailPlanarConfiguration = IFD.First + 284,
ThumbnailYCbCrSubSampling = IFD.First + 530,
ThumbnailYCbCrPositioning = IFD.First + 531,
ThumbnailXResolution = IFD.First + 282,
ThumbnailYResolution = IFD.First + 283,
ThumbnailResolutionUnit = IFD.First + 296,
ThumbnailStripOffsets = IFD.First + 273,
ThumbnailRowsPerStrip = IFD.First + 278,
ThumbnailStripByteCounts = IFD.First + 279,
ThumbnailJPEGInterchangeFormat = IFD.First + 513,
ThumbnailJPEGInterchangeFormatLength = IFD.First + 514,
ThumbnailTransferFunction = IFD.First + 301,
ThumbnailWhitePoint = IFD.First + 318,
ThumbnailPrimaryChromaticities = IFD.First + 319,
ThumbnailYCbCrCoefficients = IFD.First + 529,
ThumbnailReferenceBlackWhite = IFD.First + 532,
ThumbnailDateTime = IFD.First + 306,
ThumbnailImageDescription = IFD.First + 270,
ThumbnailMake = IFD.First + 271,
ThumbnailModel = IFD.First + 272,
ThumbnailSoftware = IFD.First + 305,
ThumbnailArtist = IFD.First + 315,
ThumbnailCopyright = IFD.First + 33432,
// ****************************
// JFIF Tags
// ****************************
///
/// Represents the JFIF version.
///
JFIFVersion = IFD.JFIF + 1,
///
/// Represents units for X and Y densities.
///
JFIFUnits = IFD.JFIF + 101,
///
/// Horizontal pixel density.
///
XDensity = IFD.JFIF + 102,
///
/// Vertical pixel density
///
YDensity = IFD.JFIF + 103,
///
/// Thumbnail horizontal pixel count.
///
JFIFXThumbnail = IFD.JFIF + 201,
///
/// Thumbnail vertical pixel count.
///
JFIFYThumbnail = IFD.JFIF + 202,
///
/// JFIF JPEG thumbnail.
///
JFIFThumbnail = IFD.JFIF + 203,
///
/// Code which identifies the JFIF extension.
///
JFXXExtensionCode = IFD.JFXX + 1,
///
/// Thumbnail horizontal pixel count.
///
JFXXXThumbnail = IFD.JFXX + 101,
///
/// Thumbnail vertical pixel count.
///
JFXXYThumbnail = IFD.JFXX + 102,
///
/// The 256-Color RGB palette.
///
JFXXPalette = IFD.JFXX + 201,
///
/// JFIF thumbnail. The thumbnail will be either a JPEG,
/// a 256 color palette bitmap, or a 24-bit RGB bitmap.
///
JFXXThumbnail = IFD.JFXX + 202,
// ****************************
// PNG Tags
// ****************************
///
/// Short (one line) title or caption for image
///
PNGTitle = IFD.PNG + 0,
///
/// Name of image's creator
///
PNGAuthor = IFD.PNG + 1,
///
/// Description of image (possibly long)
///
PNGDescription = IFD.PNG + 2,
///
/// Copyright notice
///
PNGCopyright = IFD.PNG + 3,
///
/// Time of original image creation
///
PNGCreationTime = IFD.PNG + 4,
///
/// Software used to create the image
///
PNGSoftware = IFD.PNG + 5,
///
/// Legal disclaimer
///
PNGDisclaimer = IFD.PNG + 6,
///
/// Warning of nature of content
///
PNGWarning = IFD.PNG + 7,
///
/// Device used to create the image
///
PNGSource = IFD.PNG + 8,
///
/// Miscellaneous comment
///
PNGComment = IFD.PNG + 9,
///
/// Generic text metadata
///
PNGText = IFD.PNG + 100,
///
/// The time of the last image modification
///
PNGTimeStamp = IFD.PNG + 200,
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ExifTagFactory.cs 0000664 0000000 0000000 00000004137 14462226067 0025762 0 ustar 00root root 0000000 0000000 using System;
namespace ExifLibrary
{
public static class ExifTagFactory
{
#region Static Methods
///
/// Returns the ExifTag corresponding to the given tag id.
///
public static ExifTag GetExifTag(IFD ifd, ushort tagid)
{
return (ExifTag)(ifd + tagid);
}
///
/// Returns the tag id corresponding to the given ExifTag.
///
public static ushort GetTagID(ExifTag exiftag)
{
IFD ifd = GetTagIFD(exiftag);
return (ushort)((int)exiftag - (int)ifd);
}
///
/// Returns the IFD section containing the given tag.
///
public static IFD GetTagIFD(ExifTag tag)
{
return (IFD)(((int)tag / 100000) * 100000);
}
///
/// Returns the string representation for the given exif tag.
///
public static string GetTagName(ExifTag tag)
{
string name = Enum.GetName(typeof(ExifTag), tag);
if (name == null)
return "Unknown";
else
return name;
}
///
/// Returns the string representation for the given tag id.
///
public static string GetTagName(IFD ifd, ushort tagid)
{
return GetTagName(GetExifTag(ifd, tagid));
}
///
/// Returns the string representation for the given exif tag including
/// IFD section and tag id.
///
public static string GetTagLongName(ExifTag tag)
{
string ifdname = Enum.GetName(typeof(IFD), GetTagIFD(tag));
string name = Enum.GetName(typeof(ExifTag), tag);
if (name == null)
name = "Unknown";
string tagidname = GetTagID(tag).ToString();
return ifdname + ": " + name + " (" + tagidname + ")";
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/IFD.cs 0000664 0000000 0000000 00000000744 14462226067 0023505 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the IFD section containing tags.
///
public enum IFD : int
{
Unknown = 0,
Zeroth = 100000,
EXIF = 200000,
GPS = 300000,
Interop = 400000,
First = 500000,
MakerNote = 600000,
JFIF = 700000,
JFXX = 800000,
PNG = 900000,
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ImageFile.cs 0000664 0000000 0000000 00000013250 14462226067 0024721 0 ustar 00root root 0000000 0000000 using System;
using System.Drawing;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
namespace ExifLibrary
{
///
/// Represents the base class for image files.
///
[TypeDescriptionProvider(typeof(ExifFileTypeDescriptionProvider))]
public abstract class ImageFile
{
#region Constructor
///
/// Initializes a new instance of the class.
///
protected ImageFile ()
{
Format = ImageFileFormat.Unknown;
Properties = new ExifPropertyCollection ();
Encoding = Encoding.Default;
}
#endregion
#region Properties
///
/// Returns the format of the .
///
public ImageFileFormat Format { get; protected set; }
///
/// Gets the collection of Exif properties contained in the .
///
public ExifPropertyCollection Properties { get; private set; }
///
/// Gets or sets the embedded thumbnail image.
///
public ImageFile Thumbnail { get; set; }
///
/// Gets or sets the Exif property with the given key.
///
/// The Exif tag associated with the Exif property.
public ExifProperty this[int index] {
get { return Properties[index]; }
set { Properties[index] = value; }
}
///
/// Gets the encoding used for text metadata when the source encoding is unknown.
///
public Encoding Encoding { get; protected set; }
#endregion
#region Instance Methods
///
/// Converts the to a .
///
/// Returns a containing image data.
public virtual Image ToImage()
{
MemoryStream stream = new MemoryStream();
Save(stream);
return Image.FromStream(stream);
}
///
/// Saves the to the specified file.
///
/// A string that contains the name of the file.
public virtual void Save (string filename)
{
using (FileStream stream = new FileStream (filename, FileMode.Create, FileAccess.Write, FileShare.None)) {
Save (stream);
}
}
///
/// Saves the to the specified stream.
///
/// A to save image data to.
public abstract void Save (Stream stream);
///
/// Decreases file size by removing all metadata.
///
public abstract void Crush();
#endregion
#region Static Methods
///
/// Creates an from the specified file.
///
/// A string that contains the name of the file.
/// The created from the file.
public static ImageFile FromFile (string filename)
{
return FromFile(filename, Encoding.Default);
}
///
/// Creates an from the specified file.
///
/// A string that contains the name of the file.
/// The encoding to be used for text metadata when the source encoding is unknown.
/// The created from the file.
public static ImageFile FromFile(string filename, Encoding encoding)
{
using (FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
return FromStream(stream, encoding);
}
}
///
/// Creates an from the specified data stream.
///
/// A that contains image data.
/// The created from the file.
public static ImageFile FromStream(Stream stream)
{
return FromStream(stream, Encoding.Default);
}
///
/// Creates an from the specified data stream.
///
/// A that contains image data.
/// The encoding to be used for text metadata when the source encoding is unknown.
/// The created from the file.
public static ImageFile FromStream(Stream stream, Encoding encoding)
{
stream.Seek (0, SeekOrigin.Begin);
byte[] header = new byte[8];
stream.Seek (0, SeekOrigin.Begin);
if (stream.Read (header, 0, header.Length) != header.Length)
throw new NotValidImageFileException ();
// JPEG
if (header[0] == 0xFF && header[1] == 0xD8)
return new JPEGFile (stream, encoding);
// TIFF
string tiffHeader = Encoding.ASCII.GetString (header, 0, 4);
if (tiffHeader == "MM\x00\x2a" || tiffHeader == "II\x2a\x00")
return new TIFFFile (stream, encoding);
// PNG
if (header[0] == 0x89 && header[1] == 0x50 && header[2] == 0x4E && header[3] == 0x47 &&
header[4] == 0x0D && header[5] == 0x0A && header[6] == 0x1A && header[7] == 0x0A)
return new PNGFile(stream, encoding);
throw new NotValidImageFileException ();
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ImageFileDirectory.cs 0000664 0000000 0000000 00000007575 14462226067 0026623 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents an image file directory.
///
public class ImageFileDirectory
{
///
/// The fields contained in this IFD.
///
public List Fields { get; private set; }
///
/// Offset to the next IFD.
///
public uint NextIFDOffset { get; private set; }
///
/// Compressed image data.
///
public List Strips { get; private set; }
///
/// Initializes a new instance of the class.
///
public ImageFileDirectory()
{
Fields = new List();
Strips = new List();
}
///
/// Returns a initialized from the given byte data.
///
/// The data.
/// The offset into .
/// The byte order of .
/// A initialized from the given byte data.
public static ImageFileDirectory FromBytes(byte[] data, uint offset, BitConverterEx.ByteOrder byteOrder)
{
ImageFileDirectory ifd = new ImageFileDirectory();
BitConverterEx conv = new BitConverterEx(byteOrder, BitConverterEx.SystemByteOrder);
List stripOffsets = new List();
List stripLengths = new List();
// Count
ushort fieldcount = conv.ToUInt16(data, offset);
// Read fields
for (uint i = 0; i < fieldcount; i++)
{
uint fieldoffset = offset + 2 + 12 * i;
ImageFileDirectoryEntry field = ImageFileDirectoryEntry.FromBytes(data, fieldoffset, byteOrder);
ifd.Fields.Add(field);
// Read strip offsets
if (field.Tag == 273)
{
int baselen = field.Data.Length / (int)field.Count;
for (uint j = 0; j < field.Count; j++)
{
byte[] val = new byte[baselen];
Array.Copy(field.Data, j * baselen, val, 0, baselen);
uint stripOffset = (field.Type == 3 ? (uint)BitConverter.ToUInt16(val, 0) : BitConverter.ToUInt32(val, 0));
stripOffsets.Add(stripOffset);
}
}
// Read strip lengths
if (field.Tag == 279)
{
int baselen = field.Data.Length / (int)field.Count;
for (uint j = 0; j < field.Count; j++)
{
byte[] val = new byte[baselen];
Array.Copy(field.Data, j * baselen, val, 0, baselen);
uint stripLength = (field.Type == 3 ? (uint)BitConverter.ToUInt16(val, 0) : BitConverter.ToUInt32(val, 0));
stripLengths.Add(stripLength);
}
}
}
// Save strips
if (stripOffsets.Count != stripLengths.Count)
throw new NotValidTIFFileException();
for (int i = 0; i < stripOffsets.Count; i++)
ifd.Strips.Add(new TIFFStrip(data, stripOffsets[i], stripLengths[i]));
// Offset to next ifd
ifd.NextIFDOffset = conv.ToUInt32(data, offset + 2 + 12 * fieldcount);
return ifd;
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ImageFileDirectoryEntry.cs 0000664 0000000 0000000 00000010774 14462226067 0027640 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents an entry in the image file directory.
///
public struct ImageFileDirectoryEntry
{
///
/// The tag that identifies the field.
///
public ushort Tag;
///
/// Field type identifier.
///
public ushort Type;
///
/// Count of Type.
///
public uint Count;
///
/// Field data.
///
public byte[] Data;
///
/// Initializes a new instance of the struct.
///
/// The tag that identifies the field.
/// Field type identifier.
/// Count of Type.
/// Field data.
public ImageFileDirectoryEntry(ushort tag, ushort type, uint count, byte[] data)
{
Tag = tag;
Type = type;
Count = count;
Data = data;
}
///
/// Returns a initialized from the given byte data.
///
/// The data.
/// The offset into .
/// The byte order of .
/// A initialized from the given byte data.
public static ImageFileDirectoryEntry FromBytes(byte[] data, uint offset, BitConverterEx.ByteOrder byteOrder)
{
// Tag ID
ushort tag = BitConverterEx.ToUInt16(data, offset, byteOrder, BitConverterEx.SystemByteOrder);
// Tag Type
ushort type = BitConverterEx.ToUInt16(data, offset + 2, byteOrder, BitConverterEx.SystemByteOrder);
// Count of Type
uint count = BitConverterEx.ToUInt32(data, offset + 4, byteOrder, BitConverterEx.SystemByteOrder);
// Field value or offset to field data
byte[] value = new byte[4];
Array.Copy(data, offset + 8, value, 0, 4);
// Calculate the bytes we need to read
uint baselength = GetBaseLength(type);
uint totallength = count * baselength;
// If field value does not fit in 4 bytes
// the value field is an offset to the actual
// field value
if (totallength > 4)
{
uint dataoffset = BitConverterEx.ToUInt32(value, 0, byteOrder, BitConverterEx.SystemByteOrder);
value = new byte[totallength];
Array.Copy(data, dataoffset, value, 0, totallength);
}
// Reverse array order if byte orders are different
if (byteOrder != BitConverterEx.SystemByteOrder)
{
for (uint i = 0; i < count; i++)
{
byte[] val = new byte[baselength];
Array.Copy(value, i * baselength, val, 0, baselength);
Array.Reverse(val);
Array.Copy(val, 0, value, i * baselength, baselength);
}
}
return new ImageFileDirectoryEntry(tag, type, count, value);
}
///
/// Gets the base byte length for the given type.
///
/// Type identifier.
private static uint GetBaseLength(ushort type)
{
if (type == 1 || type == 6) // BYTE and SBYTE
return 1;
else if (type == 2 || type == 7) // ASCII and UNDEFINED
return 1;
else if (type == 3 || type == 8) // SHORT and SSHORT
return 2;
else if (type == 4 || type == 9) // LONG and SLONG
return 4;
else if (type == 5 || type == 10) // RATIONAL (2xLONG) and SRATIONAL (2xSLONG)
return 8;
else if (type == 11) // FLOAT
return 4;
else if (type == 12) // DOUBLE
return 8;
throw new ArgumentException("Unknown type identifier.", "type");
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/ImageFileFormat.cs 0000664 0000000 0000000 00000001243 14462226067 0026071 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the format of the .
///
public enum ImageFileFormat
{
///
/// The file is not recognized.
///
Unknown,
///
/// The file is a JPEG/Exif or JPEG/JFIF file.
///
JPEG,
///
/// The file is a TIFF File.
///
TIFF,
///
/// The file is a PNG File.
///
PNG,
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JFIFEnums.cs 0000664 0000000 0000000 00000002304 14462226067 0024623 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the units for the X and Y densities
/// for a JFIF file.
///
public enum JFIFDensityUnit : byte
{
///
/// No units, XDensity and YDensity specify the pixel aspect ratio.
///
None = 0,
///
/// XDensity and YDensity are dots per inch.
///
DotsPerInch = 1,
///
/// XDensity and YDensity are dots per cm.
///
DotsPerCm = 2,
}
///
/// Represents the JFIF extension.
///
public enum JFIFExtension : byte
{
///
/// Thumbnail coded using JPEG.
///
ThumbnailJPEG = 0x10,
///
/// Thumbnail stored using a 256-Color RGB palette.
///
ThumbnailPaletteRGB = 0x11,
///
/// Thumbnail stored using 3 bytes/pixel (24-bit) RGB values.
///
Thumbnail24BitRGB = 0x13,
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JFIFExtendedProperty.cs 0000664 0000000 0000000 00000005203 14462226067 0027042 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the JFIF version as a 16 bit unsigned integer. (EXIF Specification: SHORT)
///
public class JFIFVersion : ExifUShort
{
///
/// Gets the major version.
///
public byte Major { get { return (byte)(mValue >> 8); } }
///
/// Gets the minor version.
///
public byte Minor { get { return (byte)(mValue - (mValue >> 8) * 256); } }
public JFIFVersion(ExifTag tag, ushort value)
: base(tag, value)
{
;
}
public override string ToString()
{
return string.Format("{0}.{1:00}", Major, Minor);
}
}
///
/// Represents a JFIF thumbnail. (EXIF Specification: BYTE)
///
public class JFIFThumbnailProperty : ExifProperty
{
protected JFIFThumbnail mValue;
protected override object _Value { get { return Value; } set { Value = (JFIFThumbnail)value; } }
public new JFIFThumbnail Value { get { return mValue; } set { mValue = value; } }
public override string ToString() { return mValue.Format.ToString(); }
public JFIFThumbnailProperty(ExifTag tag, JFIFThumbnail value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
if (mValue.Format == JFIFThumbnail.ImageFormat.BMP24Bit)
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 1, (uint)mValue.PixelData.Length, mValue.PixelData);
else if (mValue.Format == JFIFThumbnail.ImageFormat.BMPPalette)
{
byte[] data = new byte[mValue.Palette.Length + mValue.PixelData.Length];
Array.Copy(mValue.Palette, data, mValue.Palette.Length);
Array.Copy(mValue.PixelData, 0, data, mValue.Palette.Length, mValue.PixelData.Length);
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 1, (uint)data.Length, data);
}
else if (mValue.Format == JFIFThumbnail.ImageFormat.JPEG)
return new ExifInterOperability(ExifTagFactory.GetTagID(mTag), 1, (uint)mValue.PixelData.Length, mValue.PixelData);
else
throw new InvalidOperationException("Unknown thumbnail type.");
}
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JFIFThumbnail.cs 0000664 0000000 0000000 00000002664 14462226067 0025470 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
namespace ExifLibrary
{
///
/// Represents a JFIF thumbnail.
///
public class JFIFThumbnail
{
#region Properties
///
/// Gets the 256 color RGB palette.
///
public byte[] Palette { get; private set; }
///
/// Gets raw image data.
///
public byte[] PixelData { get; private set; }
///
/// Gets the image format.
///
public ImageFormat Format { get; private set; }
#endregion
#region Public Enums
public enum ImageFormat
{
JPEG,
BMPPalette,
BMP24Bit,
}
#endregion
#region Constructors
protected JFIFThumbnail()
{
Palette = new byte[0];
PixelData = new byte[0];
}
public JFIFThumbnail(ImageFormat format, byte[] data)
: this()
{
Format = format;
PixelData = data;
}
public JFIFThumbnail(byte[] palette, byte[] data)
: this()
{
Format = ImageFormat.BMPPalette;
Palette = palette;
PixelData = data;
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JPEGExceptions.cs 0000664 0000000 0000000 00000006440 14462226067 0025671 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// The exception that is thrown when the format of the image file
/// could not be understood.
///
public class UnknownImageFormatException : Exception
{
public UnknownImageFormatException()
: base("Unkown image format.")
{
;
}
public UnknownImageFormatException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the format of the image file
/// could not be understood.
///
public class NotValidImageFileException : Exception
{
public NotValidImageFileException()
: base("Not a valid image file.")
{
;
}
public NotValidImageFileException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the format of the JPEG file
/// could not be understood.
///
public class NotValidJPEGFileException : Exception
{
public NotValidJPEGFileException()
: base("Not a valid JPEG file.")
{
;
}
public NotValidJPEGFileException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the format of the TIFF file
/// could not be understood.
///
public class NotValidTIFFileException : Exception
{
public NotValidTIFFileException()
: base("Not a valid TIFF file.")
{
;
}
public NotValidTIFFileException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the format of the PNG file
/// could not be understood.
///
public class NotValidPNGFileException : Exception
{
public NotValidPNGFileException()
: base("Not a valid PNG file.")
{
;
}
public NotValidPNGFileException(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the format of the TIFF header
/// could not be understood.
///
public class NotValidTIFFHeader : Exception
{
public NotValidTIFFHeader()
: base("Not a valid TIFF header.")
{
;
}
public NotValidTIFFHeader(string message)
: base(message)
{
;
}
}
///
/// The exception that is thrown when the length of a section exceeds 64 kB.
///
public class SectionExceeds64KBException : Exception
{
public SectionExceeds64KBException()
: base("Section length exceeds 64 kB.")
{
;
}
public SectionExceeds64KBException(string message)
: base(message)
{
;
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JPEGFile.cs 0000664 0000000 0000000 00000123413 14462226067 0024427 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the binary view of a JPEG compressed file.
///
public class JPEGFile : ImageFile
{
#region Member Variables
private JPEGSection jfifApp0;
private JPEGSection jfxxApp0;
private JPEGSection exifApp1;
private uint makerNoteOffset;
private long exifIFDFieldOffset, gpsIFDFieldOffset, interopIFDFieldOffset, firstIFDFieldOffset;
private long thumbOffsetLocation, thumbSizeLocation;
private uint thumbOffsetValue, thumbSizeValue;
private bool makerNoteProcessed;
#endregion
#region Properties
///
/// Gets or sets the byte-order of the Exif properties.
///
public BitConverterEx.ByteOrder ByteOrder { get; set; }
///
/// Gets or sets the sections contained in the .
///
public List Sections { get; private set; }
///
/// Gets or sets non-standard trailing data following the End of Image (EOI) marker.
///
public byte[] TrailingData { get; private set; }
#endregion
#region Constructor
///
/// Initializes a new instance of the class.
///
/// A that contains image data.
/// The encoding to be used for text metadata when the source encoding is unknown.
protected internal JPEGFile(Stream stream, Encoding encoding)
{
Format = ImageFileFormat.JPEG;
Sections = new List();
TrailingData = new byte[0];
Encoding = encoding;
stream.Seek(0, SeekOrigin.Begin);
// Read the Start of Image (SOI) marker. SOI marker is represented
// with two bytes: 0xFF, 0xD8.
byte[] markerbytes = new byte[2];
if (stream.Read(markerbytes, 0, 2) != 2 || markerbytes[0] != 0xFF || markerbytes[1] != 0xD8)
throw new NotValidJPEGFileException();
stream.Seek(0, SeekOrigin.Begin);
// Search and read sections until we reach the end of file.
while (stream.Position != stream.Length)
{
// Read the next section marker. Section markers are two bytes
// with values 0xFF, 0x?? where ?? must not be 0x00 or 0xFF.
if (stream.Read(markerbytes, 0, 2) != 2 || markerbytes[0] != 0xFF || markerbytes[1] == 0x00 || markerbytes[1] == 0xFF)
throw new NotValidJPEGFileException();
JPEGMarker marker = (JPEGMarker)markerbytes[1];
byte[] header = new byte[0];
// SOI, EOI and RST markers do not contain any header
if (marker != JPEGMarker.SOI && marker != JPEGMarker.EOI && !(marker >= JPEGMarker.RST0 && marker <= JPEGMarker.RST7))
{
// Length of the header including the length bytes.
// This value is a 16-bit unsigned integer
// in big endian byte-order.
byte[] lengthbytes = new byte[2];
if (stream.Read(lengthbytes, 0, 2) != 2)
throw new NotValidJPEGFileException();
long length = (long)BitConverterEx.BigEndian.ToUInt16(lengthbytes, 0);
// Read section header.
header = new byte[length - 2];
int bytestoread = header.Length;
while (bytestoread > 0)
{
int count = Math.Min(bytestoread, 4 * 1024);
int bytesread = stream.Read(header, header.Length - bytestoread, count);
if (bytesread == 0)
throw new NotValidJPEGFileException();
bytestoread -= bytesread;
}
}
// Start of Scan (SOS) sections and RST sections are immediately
// followed by entropy coded data. For that, we need to read until
// the next section marker once we reach a SOS or RST.
byte[] entropydata = new byte[0];
if (marker == JPEGMarker.SOS || (marker >= JPEGMarker.RST0 && marker <= JPEGMarker.RST7))
{
long position = stream.Position;
// Search for the next section marker
while (true)
{
// Search for an 0xFF indicating start of a marker
int nextbyte = 0;
do
{
nextbyte = stream.ReadByte();
if (nextbyte == -1)
throw new NotValidJPEGFileException();
} while ((byte)nextbyte != 0xFF);
// Skip filler bytes (0xFF)
do
{
nextbyte = stream.ReadByte();
if (nextbyte == -1)
throw new NotValidJPEGFileException();
} while ((byte)nextbyte == 0xFF);
// Looks like a section marker. The next byte must not be 0x00.
if ((byte)nextbyte != 0x00)
{
// We reached a section marker. Calculate the
// length of the entropy coded data.
stream.Seek(-2, SeekOrigin.Current);
long edlength = stream.Position - position;
stream.Seek(-edlength, SeekOrigin.Current);
// Read entropy coded data
entropydata = new byte[edlength];
int bytestoread = entropydata.Length;
while (bytestoread > 0)
{
int count = Math.Min(bytestoread, 4 * 1024);
int bytesread = stream.Read(entropydata, entropydata.Length - bytestoread, count);
if (bytesread == 0)
throw new NotValidJPEGFileException();
bytestoread -= bytesread;
}
break;
}
}
}
// Store section.
JPEGSection section = new JPEGSection(marker, header, entropydata);
Sections.Add(section);
// Some propriety formats store data past the EOI marker
if (marker == JPEGMarker.EOI)
{
int bytestoread = (int)(stream.Length - stream.Position);
TrailingData = new byte[bytestoread];
while (bytestoread > 0)
{
int count = (int)Math.Min(bytestoread, 4 * 1024);
int bytesread = stream.Read(TrailingData, TrailingData.Length - bytestoread, count);
if (bytesread == 0)
throw new NotValidJPEGFileException();
bytestoread -= bytesread;
}
}
}
// Read metadata sections
ReadJFIFAPP0();
ReadJFXXAPP0();
ReadExifAPP1();
// Process the maker note
makerNoteProcessed = false;
}
#endregion
#region Instance Methods
///
/// Decreases file size by removing all metadata.
///
public override void Crush()
{
// Keep JFIF Tags
List jfifProperties = new List();
foreach (ExifProperty prop in Properties)
{
if (prop.IFD == IFD.JFIF)
{
if (prop.Tag == ExifTag.JFIFXThumbnail)
prop.Value = 0;
if (prop.Tag == ExifTag.JFIFYThumbnail)
prop.Value = 0;
if (prop.Tag == ExifTag.JFIFThumbnail)
prop.Value = new JFIFThumbnail(JFIFThumbnail.ImageFormat.JPEG, new byte[0]);
}
}
Properties.Clear();
foreach (ExifProperty prop in jfifProperties)
Properties.Add(prop);
// Remove metadata sections.
// Keep the sections in this whitelist only:
// SOF0 - SOF15
// DHT
// DAC
// RST0 - RST7
// SOI, EOI
// DQT
// DNL
// DRI
// DHP
// EXP
Sections.RemoveAll((section) =>
{
return (section.Marker < JPEGMarker.SOF0 || section.Marker > JPEGMarker.EXP);
});
}
///
/// Saves the JPEG/Exif image to the given stream.
///
/// The path to the JPEG/Exif file.
/// Determines whether the maker note offset of
/// the original file will be preserved.
public void Save(Stream stream, bool preserveMakerNote)
{
WriteJFIFApp0();
WriteJFXXApp0();
WriteExifApp1(preserveMakerNote);
// Write sections
foreach (JPEGSection section in Sections)
{
// Section header (including length bytes and section marker)
// must not exceed 64 kB.
if (section.Header.Length + 2 + 2 > 64 * 1024)
throw new SectionExceeds64KBException();
// APP sections must have a header.
// Otherwise skip the entire section.
if (section.Marker >= JPEGMarker.APP0 && section.Marker <= JPEGMarker.APP15 && section.Header.Length == 0)
continue;
// Write section marker
stream.Write(new byte[] { 0xFF, (byte)section.Marker }, 0, 2);
// SOI, EOI and RST markers do not contain any header
if (section.Marker != JPEGMarker.SOI && section.Marker != JPEGMarker.EOI && !(section.Marker >= JPEGMarker.RST0 && section.Marker <= JPEGMarker.RST7))
{
// Header length including the length field itself
stream.Write(BitConverterEx.BigEndian.GetBytes((ushort)(section.Header.Length + 2)), 0, 2);
// Write section header
if (section.Header.Length != 0)
stream.Write(section.Header, 0, section.Header.Length);
}
// Write entropy coded data
if (section.EntropyData.Length != 0)
stream.Write(section.EntropyData, 0, section.EntropyData.Length);
}
// Write trailing data, if any
if (TrailingData.Length != 0)
stream.Write(TrailingData, 0, TrailingData.Length);
}
///
/// Saves the JPEG/Exif image with the given filename.
///
/// The path to the JPEG/Exif file.
/// Determines whether the maker note offset of
/// the original file will be preserved.
public void Save(string filename, bool preserveMakerNote)
{
using (FileStream stream = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None))
{
Save(stream, preserveMakerNote);
}
}
///
/// Saves the JPEG/Exif image with the given filename.
///
/// The path to the JPEG/Exif file.
public override void Save(string filename)
{
Save(filename, true);
}
///
/// Saves the JPEG/Exif image to the given stream.
///
/// The path to the JPEG/Exif file.
public override void Save(Stream stream)
{
Save(stream, true);
}
#endregion
#region Private Helper Methods
///
/// Reads the APP0 section containing JFIF metadata.
///
private void ReadJFIFAPP0()
{
// Find the APP0 section containing JFIF metadata
jfifApp0 = Sections.Find(a => (a.Marker == JPEGMarker.APP0) &&
a.Header.Length >= 5 &&
(Encoding.ASCII.GetString(a.Header, 0, 5) == "JFIF\0"));
// If there is no APP0 section, return.
if (jfifApp0 == null)
return;
byte[] header = jfifApp0.Header;
BitConverterEx jfifConv = BitConverterEx.BigEndian;
// Version
ushort version = jfifConv.ToUInt16(header, 5);
Properties.Add(new JFIFVersion(ExifTag.JFIFVersion, version));
// Units
byte unit = header[7];
Properties.Add(new ExifEnumProperty(ExifTag.JFIFUnits, (JFIFDensityUnit)unit));
// X and Y densities
ushort xdensity = jfifConv.ToUInt16(header, 8);
Properties.Add(new ExifUShort(ExifTag.XDensity, xdensity));
ushort ydensity = jfifConv.ToUInt16(header, 10);
Properties.Add(new ExifUShort(ExifTag.YDensity, ydensity));
// Thumbnails pixel count
byte xthumbnail = header[12];
Properties.Add(new ExifByte(ExifTag.JFIFXThumbnail, xthumbnail));
byte ythumbnail = header[13];
Properties.Add(new ExifByte(ExifTag.JFIFYThumbnail, ythumbnail));
// Read JFIF thumbnail
int n = xthumbnail * ythumbnail;
byte[] jfifThumbnail = new byte[n];
Array.Copy(header, 14, jfifThumbnail, 0, n);
Properties.Add(new JFIFThumbnailProperty(ExifTag.JFIFThumbnail, new JFIFThumbnail(JFIFThumbnail.ImageFormat.JPEG, jfifThumbnail)));
}
///
/// Replaces the contents of the APP0 section with the JFIF properties.
///
private bool WriteJFIFApp0()
{
// Which IFD sections do we have?
List ifdjfef = new List();
foreach (ExifProperty prop in Properties)
{
if (prop.IFD == IFD.JFIF)
ifdjfef.Add(prop);
}
if (ifdjfef.Count == 0)
{
// Nothing to write
return false;
}
// Create a memory stream to write the APP0 section to
MemoryStream ms = new MemoryStream();
// JFIF identifer
ms.Write(Encoding.ASCII.GetBytes("JFIF\0"), 0, 5);
// Write tags
foreach (ExifProperty prop in ifdjfef)
{
ExifInterOperability interop = prop.Interoperability;
byte[] data = interop.Data;
if (BitConverterEx.SystemByteOrder != BitConverterEx.ByteOrder.BigEndian && interop.TypeID == 3)
Array.Reverse(data);
ms.Write(data, 0, data.Length);
}
ms.Close();
// Return APP0 header
jfifApp0.Header = ms.ToArray();
return true;
}
///
/// Reads the APP0 section containing JFIF extension metadata.
///
private void ReadJFXXAPP0()
{
// Find the APP0 section containing JFIF metadata
jfxxApp0 = Sections.Find(a => (a.Marker == JPEGMarker.APP0) &&
a.Header.Length >= 5 &&
(Encoding.ASCII.GetString(a.Header, 0, 5) == "JFXX\0"));
// If there is no APP0 section, return.
if (jfxxApp0 == null)
return;
byte[] header = jfxxApp0.Header;
// Version
JFIFExtension version = (JFIFExtension)header[5];
Properties.Add(new ExifEnumProperty(ExifTag.JFXXExtensionCode, version));
// Read thumbnail
if (version == JFIFExtension.ThumbnailJPEG)
{
byte[] data = new byte[header.Length - 6];
Array.Copy(header, 6, data, 0, data.Length);
Properties.Add(new JFIFThumbnailProperty(ExifTag.JFXXThumbnail, new JFIFThumbnail(JFIFThumbnail.ImageFormat.JPEG, data)));
}
else if (version == JFIFExtension.Thumbnail24BitRGB)
{
// Thumbnails pixel count
byte xthumbnail = header[6];
Properties.Add(new ExifByte(ExifTag.JFXXXThumbnail, xthumbnail));
byte ythumbnail = header[7];
Properties.Add(new ExifByte(ExifTag.JFXXYThumbnail, ythumbnail));
byte[] data = new byte[3 * xthumbnail * ythumbnail];
Array.Copy(header, 8, data, 0, data.Length);
Properties.Add(new JFIFThumbnailProperty(ExifTag.JFXXThumbnail, new JFIFThumbnail(JFIFThumbnail.ImageFormat.BMP24Bit, data)));
}
else if (version == JFIFExtension.ThumbnailPaletteRGB)
{
// Thumbnails pixel count
byte xthumbnail = header[6];
Properties.Add(new ExifByte(ExifTag.JFXXXThumbnail, xthumbnail));
byte ythumbnail = header[7];
Properties.Add(new ExifByte(ExifTag.JFXXYThumbnail, ythumbnail));
byte[] palette = new byte[768];
Array.Copy(header, 8, palette, 0, palette.Length);
byte[] data = new byte[xthumbnail * ythumbnail];
Array.Copy(header, 8 + 768, data, 0, data.Length);
Properties.Add(new JFIFThumbnailProperty(ExifTag.JFXXThumbnail, new JFIFThumbnail(palette, data)));
}
}
///
/// Replaces the contents of the APP0 section with the JFIF extension properties.
///
private bool WriteJFXXApp0()
{
// Which IFD sections do we have?
List ifdjfef = new List();
foreach (ExifProperty prop in Properties)
{
if (prop.IFD == IFD.JFXX)
ifdjfef.Add(prop);
}
if (ifdjfef.Count == 0)
{
// Nothing to write
return false;
}
// Create a memory stream to write the APP0 section to
MemoryStream ms = new MemoryStream();
// JFIF identifer
ms.Write(Encoding.ASCII.GetBytes("JFXX\0"), 0, 5);
// Write tags
foreach (ExifProperty prop in ifdjfef)
{
ExifInterOperability interop = prop.Interoperability;
byte[] data = interop.Data;
if (BitConverterEx.SystemByteOrder != BitConverterEx.ByteOrder.BigEndian && interop.TypeID == 3)
Array.Reverse(data);
ms.Write(data, 0, data.Length);
}
ms.Close();
// Return APP0 header
jfxxApp0.Header = ms.ToArray();
return true;
}
///
/// Reads the APP1 section containing Exif metadata.
///
private void ReadExifAPP1()
{
// Find the APP1 section containing Exif metadata
exifApp1 = Sections.Find(a => (a.Marker == JPEGMarker.APP1) &&
a.Header.Length >= 6 &&
(Encoding.ASCII.GetString(a.Header, 0, 6) == "Exif\0\0"));
// If there is no APP1 section, add a new one after the last APP0 section (if any).
if (exifApp1 == null)
{
int insertionIndex = Sections.FindLastIndex(a => a.Marker == JPEGMarker.APP0);
if (insertionIndex == -1) insertionIndex = 0;
insertionIndex++;
exifApp1 = new JPEGSection(JPEGMarker.APP1);
Sections.Insert(insertionIndex, exifApp1);
if (BitConverterEx.SystemByteOrder == BitConverterEx.ByteOrder.LittleEndian)
ByteOrder = BitConverterEx.ByteOrder.LittleEndian;
else
ByteOrder = BitConverterEx.ByteOrder.BigEndian;
return;
}
byte[] header = exifApp1.Header;
SortedList ifdqueue = new SortedList();
makerNoteOffset = 0;
// TIFF header
int tiffoffset = 6;
if (header[tiffoffset] == 0x49 && header[tiffoffset + 1] == 0x49)
ByteOrder = BitConverterEx.ByteOrder.LittleEndian;
else if (header[tiffoffset] == 0x4D && header[tiffoffset + 1] == 0x4D)
ByteOrder = BitConverterEx.ByteOrder.BigEndian;
else
throw new NotValidExifFileException();
// TIFF header may have a different byte order
BitConverterEx.ByteOrder tiffByteOrder = ByteOrder;
if (BitConverterEx.LittleEndian.ToUInt16(header, tiffoffset + 2) == 42)
tiffByteOrder = BitConverterEx.ByteOrder.LittleEndian;
else if (BitConverterEx.BigEndian.ToUInt16(header, tiffoffset + 2) == 42)
tiffByteOrder = BitConverterEx.ByteOrder.BigEndian;
else
throw new NotValidExifFileException();
// Offset to 0th IFD
int ifd0offset = (int)BitConverterEx.ToUInt32(header, tiffoffset + 4, tiffByteOrder, BitConverterEx.SystemByteOrder);
ifdqueue.Add(ifd0offset, IFD.Zeroth);
BitConverterEx conv = new BitConverterEx(ByteOrder, BitConverterEx.SystemByteOrder);
int thumboffset = -1;
int thumblength = 0;
int thumbtype = -1;
// Read IFDs
while (ifdqueue.Count != 0)
{
int ifdoffset = tiffoffset + ifdqueue.Keys[0];
IFD currentifd = ifdqueue.Values[0];
ifdqueue.RemoveAt(0);
// Field count
ushort fieldcount = conv.ToUInt16(header, ifdoffset);
for (short i = 0; i < fieldcount; i++)
{
// Read field info
int fieldoffset = ifdoffset + 2 + 12 * i;
ushort tag = conv.ToUInt16(header, fieldoffset);
ushort type = conv.ToUInt16(header, fieldoffset + 2);
uint count = conv.ToUInt32(header, fieldoffset + 4);
byte[] value = new byte[4];
Array.Copy(header, fieldoffset + 8, value, 0, 4);
// Fields containing offsets to other IFDs
if (currentifd == IFD.Zeroth && tag == 0x8769)
{
int exififdpointer = (int)conv.ToUInt32(value, 0);
ifdqueue.Add(exififdpointer, IFD.EXIF);
}
else if (currentifd == IFD.Zeroth && tag == 0x8825)
{
int gpsifdpointer = (int)conv.ToUInt32(value, 0);
ifdqueue.Add(gpsifdpointer, IFD.GPS);
}
else if (currentifd == IFD.EXIF && tag == 0xa005)
{
int interopifdpointer = (int)conv.ToUInt32(value, 0);
ifdqueue.Add(interopifdpointer, IFD.Interop);
}
// Save the offset to maker note data
if (currentifd == IFD.EXIF && tag == 37500)
makerNoteOffset = conv.ToUInt32(value, 0);
// Calculate the bytes we need to read
uint baselength = 0;
if (type == 1 || type == 2 || type == 7)
baselength = 1;
else if (type == 3)
baselength = 2;
else if (type == 4 || type == 9)
baselength = 4;
else if (type == 5 || type == 10)
baselength = 8;
uint totallength = count * baselength;
// If field value does not fit in 4 bytes
// the value field is an offset to the actual
// field value
int fieldposition = 0;
if (totallength > 4)
{
fieldposition = tiffoffset + (int)conv.ToUInt32(value, 0);
value = new byte[totallength];
Array.Copy(header, fieldposition, value, 0, totallength);
}
// Compressed thumbnail data
if (currentifd == IFD.First && tag == 0x201)
{
thumbtype = 0;
thumboffset = (int)conv.ToUInt32(value, 0);
}
else if (currentifd == IFD.First && tag == 0x202)
thumblength = (int)conv.ToUInt32(value, 0);
// Uncompressed thumbnail data
if (currentifd == IFD.First && tag == 0x111)
{
thumbtype = 1;
// Offset to first strip
if (type == 3)
thumboffset = (int)conv.ToUInt16(value, 0);
else
thumboffset = (int)conv.ToUInt32(value, 0);
}
else if (currentifd == IFD.First && tag == 0x117)
{
thumblength = 0;
for (int j = 0; j < count; j++)
{
if (type == 3)
thumblength += (int)conv.ToUInt16(value, 0);
else
thumblength += (int)conv.ToUInt32(value, 0);
}
}
// Create the exif property from the interop data
ExifProperty prop = ExifPropertyFactory.Get(tag, type, count, value, ByteOrder, currentifd, Encoding);
Properties.Add(prop);
}
// 1st IFD pointer
int firstifdpointer = (int)conv.ToUInt32(header, ifdoffset + 2 + 12 * fieldcount);
if (firstifdpointer != 0)
ifdqueue.Add(firstifdpointer, IFD.First);
// Read thumbnail
if (thumboffset != -1 && thumblength != 0 && Thumbnail == null)
{
if (thumbtype == 0)
{
using (MemoryStream ts = new MemoryStream(header, tiffoffset + thumboffset, thumblength))
{
Thumbnail = ImageFile.FromStream(ts);
}
}
}
}
}
///
/// Replaces the contents of the APP1 section with the Exif properties.
///
private bool WriteExifApp1(bool preserveMakerNote)
{
// Zero out IFD field offsets. We will fill those as we write the IFD sections
exifIFDFieldOffset = 0;
gpsIFDFieldOffset = 0;
interopIFDFieldOffset = 0;
firstIFDFieldOffset = 0;
// We also do not know the location of the embedded thumbnail yet
thumbOffsetLocation = 0;
thumbOffsetValue = 0;
thumbSizeLocation = 0;
thumbSizeValue = 0;
// Write thumbnail tags if they are missing, remove otherwise
int indexf = -1;
int indexl = -1;
for (int i = 0; i < Properties.Count; i++)
{
ExifProperty prop = Properties[i];
if (prop.Tag == ExifTag.ThumbnailJPEGInterchangeFormat) indexf = i;
if (prop.Tag == ExifTag.ThumbnailJPEGInterchangeFormatLength) indexl = i;
if (indexf != -1 && indexl != -1) break;
}
if (Thumbnail == null)
{
if (indexf != -1)
Properties.RemoveAt(indexf);
if (indexl != -1)
Properties.RemoveAt(indexl);
}
else
{
if (indexf == -1)
Properties.Add(new ExifUInt(ExifTag.ThumbnailJPEGInterchangeFormat, 0));
if (indexl == -1)
Properties.Add(new ExifUInt(ExifTag.ThumbnailJPEGInterchangeFormatLength, 0));
}
// Which IFD sections do we have?
Dictionary ifdzeroth = new Dictionary();
Dictionary ifdexif = new Dictionary();
Dictionary ifdgps = new Dictionary();
Dictionary ifdinterop = new Dictionary();
Dictionary ifdfirst = new Dictionary();
foreach (ExifProperty prop in Properties)
{
switch (prop.IFD)
{
case IFD.Zeroth:
ifdzeroth.Add(prop.Tag, prop);
break;
case IFD.EXIF:
ifdexif.Add(prop.Tag, prop);
break;
case IFD.GPS:
ifdgps.Add(prop.Tag, prop);
break;
case IFD.Interop:
ifdinterop.Add(prop.Tag, prop);
break;
case IFD.First:
ifdfirst.Add(prop.Tag, prop);
break;
}
}
// Add IFD pointers if they are missing
// We will write the pointer values later on
if (ifdexif.Count != 0 && !ifdzeroth.ContainsKey(ExifTag.EXIFIFDPointer))
ifdzeroth.Add(ExifTag.EXIFIFDPointer, new ExifUInt(ExifTag.EXIFIFDPointer, 0));
if (ifdgps.Count != 0 && !ifdzeroth.ContainsKey(ExifTag.GPSIFDPointer))
ifdzeroth.Add(ExifTag.GPSIFDPointer, new ExifUInt(ExifTag.GPSIFDPointer, 0));
if (ifdinterop.Count != 0 && !ifdexif.ContainsKey(ExifTag.InteroperabilityIFDPointer))
ifdexif.Add(ExifTag.InteroperabilityIFDPointer, new ExifUInt(ExifTag.InteroperabilityIFDPointer, 0));
// Remove IFD pointers if IFD sections are missing
if (ifdexif.Count == 0 && ifdzeroth.ContainsKey(ExifTag.EXIFIFDPointer))
ifdzeroth.Remove(ExifTag.EXIFIFDPointer);
if (ifdgps.Count == 0 && ifdzeroth.ContainsKey(ExifTag.GPSIFDPointer))
ifdzeroth.Remove(ExifTag.GPSIFDPointer);
if (ifdinterop.Count == 0 && ifdexif.ContainsKey(ExifTag.InteroperabilityIFDPointer))
ifdexif.Remove(ExifTag.InteroperabilityIFDPointer);
if (ifdzeroth.Count == 0 && ifdgps.Count == 0 && ifdinterop.Count == 0 && ifdfirst.Count == 0 && Thumbnail == null)
{
// Nothing to write
return false;
}
// We will need these bitconverter to write byte-ordered data
BitConverterEx bceExif = new BitConverterEx(BitConverterEx.SystemByteOrder, ByteOrder);
// Create a memory stream to write the APP1 section to
MemoryStream ms = new MemoryStream();
// Exif identifer
ms.Write(Encoding.ASCII.GetBytes("Exif\0\0"), 0, 6);
// TIFF header
// Byte order
long tiffoffset = ms.Position;
ms.Write((ByteOrder == BitConverterEx.ByteOrder.LittleEndian ? new byte[] { 0x49, 0x49 } : new byte[] { 0x4D, 0x4D }), 0, 2);
// TIFF ID
ms.Write(bceExif.GetBytes((ushort)42), 0, 2);
// Offset to 0th IFD
ms.Write(bceExif.GetBytes((uint)8), 0, 4);
// Write IFDs
WriteIFD(ms, ifdzeroth, IFD.Zeroth, tiffoffset, preserveMakerNote);
uint exififdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdexif, IFD.EXIF, tiffoffset, preserveMakerNote);
uint gpsifdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdgps, IFD.GPS, tiffoffset, preserveMakerNote);
uint interopifdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdinterop, IFD.Interop, tiffoffset, preserveMakerNote);
uint firstifdrelativeoffset = (uint)(ms.Position - tiffoffset);
WriteIFD(ms, ifdfirst, IFD.First, tiffoffset, preserveMakerNote);
// Now that we now the location of IFDs we can go back and write IFD offsets
if (exifIFDFieldOffset != 0)
{
ms.Seek(exifIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(exififdrelativeoffset), 0, 4);
}
if (gpsIFDFieldOffset != 0)
{
ms.Seek(gpsIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(gpsifdrelativeoffset), 0, 4);
}
if (interopIFDFieldOffset != 0)
{
ms.Seek(interopIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(interopifdrelativeoffset), 0, 4);
}
if (firstIFDFieldOffset != 0)
{
ms.Seek(firstIFDFieldOffset, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(firstifdrelativeoffset), 0, 4);
}
// We can write thumbnail location now
if (thumbOffsetLocation != 0)
{
ms.Seek(thumbOffsetLocation, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(thumbOffsetValue), 0, 4);
}
if (thumbSizeLocation != 0)
{
ms.Seek(thumbSizeLocation, SeekOrigin.Begin);
ms.Write(bceExif.GetBytes(thumbSizeValue), 0, 4);
}
ms.Close();
// Return APP1 header
exifApp1.Header = ms.ToArray();
return true;
}
private void WriteIFD(MemoryStream stream, Dictionary ifd, IFD ifdtype, long tiffoffset, bool preserveMakerNote)
{
BitConverterEx conv = new BitConverterEx(BitConverterEx.SystemByteOrder, ByteOrder);
// Create a queue of fields to write
Queue fieldqueue = new Queue();
foreach (ExifProperty prop in ifd.Values)
if (prop.Tag != ExifTag.MakerNote)
fieldqueue.Enqueue(prop);
// Push the maker note data to the end
if (ifd.ContainsKey(ExifTag.MakerNote))
fieldqueue.Enqueue(ifd[ExifTag.MakerNote]);
// Offset to start of field data from start of TIFF header
uint dataoffset = (uint)(2 + ifd.Count * 12 + 4 + stream.Position - tiffoffset);
uint currentdataoffset = dataoffset;
long absolutedataoffset = stream.Position + (2 + ifd.Count * 12 + 4);
bool makernotewritten = false;
// Field count
stream.Write(conv.GetBytes((ushort)ifd.Count), 0, 2);
// Fields
while (fieldqueue.Count != 0)
{
ExifProperty field = fieldqueue.Dequeue();
ExifInterOperability interop = field.Interoperability;
uint fillerbytecount = 0;
// Try to preserve the makernote data offset
if (!makernotewritten &&
!makerNoteProcessed &&
makerNoteOffset != 0 &&
ifdtype == IFD.EXIF &&
field.Tag != ExifTag.MakerNote &&
interop.Data.Length > 4 &&
currentdataoffset + interop.Data.Length > makerNoteOffset &&
ifd.ContainsKey(ExifTag.MakerNote))
{
// Delay writing this field until we write makernote data
fieldqueue.Enqueue(field);
continue;
}
else if (field.Tag == ExifTag.MakerNote)
{
makernotewritten = true;
// We may need to write filler bytes to preserve maker note offset
if (preserveMakerNote && !makerNoteProcessed && (makerNoteOffset > currentdataoffset))
fillerbytecount = makerNoteOffset - currentdataoffset;
else
fillerbytecount = 0;
}
// Tag
stream.Write(conv.GetBytes(interop.TagID), 0, 2);
// Type
stream.Write(conv.GetBytes(interop.TypeID), 0, 2);
// Count
stream.Write(conv.GetBytes(interop.Count), 0, 4);
// Field data
byte[] data = interop.Data;
if (ByteOrder != BitConverterEx.SystemByteOrder &&
(interop.TypeID == 3 || interop.TypeID == 4 || interop.TypeID == 9 ||
interop.TypeID == 5 || interop.TypeID == 10))
{
int vlen = 4;
if (interop.TypeID == 3) vlen = 2;
int n = data.Length / vlen;
for (int i = 0; i < n; i++)
Array.Reverse(data, i * vlen, vlen);
}
// Fields containing offsets to other IFDs
// Just store their offets, we will write the values later on when we know the lengths of IFDs
if (ifdtype == IFD.Zeroth && interop.TagID == 0x8769)
exifIFDFieldOffset = stream.Position;
else if (ifdtype == IFD.Zeroth && interop.TagID == 0x8825)
gpsIFDFieldOffset = stream.Position;
else if (ifdtype == IFD.EXIF && interop.TagID == 0xa005)
interopIFDFieldOffset = stream.Position;
else if (ifdtype == IFD.First && interop.TagID == 0x201)
thumbOffsetLocation = stream.Position;
else if (ifdtype == IFD.First && interop.TagID == 0x202)
thumbSizeLocation = stream.Position;
// Write 4 byte field value or field data
if (data.Length <= 4)
{
stream.Write(data, 0, data.Length);
for (int i = data.Length; i < 4; i++)
stream.WriteByte(0);
}
else
{
// Pointer to data area relative to TIFF header
stream.Write(conv.GetBytes(currentdataoffset + fillerbytecount), 0, 4);
// Actual data
long currentoffset = stream.Position;
stream.Seek(absolutedataoffset, SeekOrigin.Begin);
// Write filler bytes
for (int i = 0; i < fillerbytecount; i++)
stream.WriteByte(0xFF);
stream.Write(data, 0, data.Length);
stream.Seek(currentoffset, SeekOrigin.Begin);
// Increment pointers
currentdataoffset += fillerbytecount + (uint)data.Length;
absolutedataoffset += fillerbytecount + data.Length;
}
}
// Offset to 1st IFD
// We will write zeros for now. This will be filled after we write all IFDs
if (ifdtype == IFD.Zeroth)
firstIFDFieldOffset = stream.Position;
stream.Write(new byte[] { 0, 0, 0, 0 }, 0, 4);
// Seek to end of IFD
stream.Seek(absolutedataoffset, SeekOrigin.Begin);
// Write thumbnail data
if (ifdtype == IFD.First)
{
if (Thumbnail != null)
{
MemoryStream ts = new MemoryStream();
Thumbnail.Save(ts);
ts.Close();
byte[] thumb = ts.ToArray();
thumbOffsetValue = (uint)(stream.Position - tiffoffset);
thumbSizeValue = (uint)thumb.Length;
stream.Write(thumb, 0, thumb.Length);
ts.Dispose();
}
else
{
thumbOffsetValue = 0;
thumbSizeValue = 0;
}
}
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JPEGMarker.cs 0000664 0000000 0000000 00000004207 14462226067 0024770 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents a JPEG marker byte.
///
public enum JPEGMarker : byte
{
// Start Of Frame markers, non-differential, Huffman coding
SOF0 = 0xc0,
SOF1 = 0xc1,
SOF2 = 0xc2,
SOF3 = 0xc3,
// Start Of Frame markers, differential, Huffman coding
SOF5 = 0xc5,
SOF6 = 0xc6,
SOF7 = 0xc7,
// Start Of Frame markers, non-differential, arithmetic coding
JPG = 0xc8,
SOF9 = 0xc9,
SOF10 = 0xca,
SOF11 = 0xcb,
// Start Of Frame markers, differential, arithmetic coding
SOF13 = 0xcd,
SOF14 = 0xce,
SOF15 = 0xcf,
// Huffman table specification
DHT = 0xc4,
// Arithmetic coding conditioning specification
DAC = 0xcc,
// Restart interval termination
RST0 = 0xd0,
RST1 = 0xd1,
RST2 = 0xd2,
RST3 = 0xd3,
RST4 = 0xd4,
RST5 = 0xd5,
RST6 = 0xd6,
RST7 = 0xd7,
// Other markers
SOI = 0xd8,
EOI = 0xd9,
SOS = 0xda,
DQT = 0xdb,
DNL = 0xdc,
DRI = 0xdd,
DHP = 0xde,
EXP = 0xdf,
// application segments
APP0 = 0xe0,
APP1 = 0xe1,
APP2 = 0xe2,
APP3 = 0xe3,
APP4 = 0xe4,
APP5 = 0xe5,
APP6 = 0xe6,
APP7 = 0xe7,
APP8 = 0xe8,
APP9 = 0xe9,
APP10 = 0xea,
APP11 = 0xeb,
APP12 = 0xec,
APP13 = 0xed,
APP14 = 0xee,
APP15 = 0xef,
// JPEG extensions
JPG0 = 0xf0,
JPG1 = 0xf1,
JPG2 = 0xf2,
JPG3 = 0xf3,
JPG4 = 0xf4,
JPG5 = 0xf5,
JPG6 = 0xf6,
JPG7 = 0xf7,
JPG8 = 0xf8,
JPG9 = 0xf9,
JPG10 = 0xfa,
JPG11 = 0xfb,
JP1G2 = 0xfc,
JPG13 = 0xfd,
// Comment
COM = 0xfe,
// Temporary
TEM = 0x01,
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/JPEGSection.cs 0000664 0000000 0000000 00000004530 14462226067 0025152 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the memory view of a JPEG section.
/// A JPEG section is the data between markers of the JPEG file.
///
public class JPEGSection
{
#region Properties
///
/// The marker byte representing the section.
///
public JPEGMarker Marker { get; private set; }
///
/// Section header as a byte array. This is different from the header
/// definition in JPEG specification in that it does not include the
/// two byte section length.
///
public byte[] Header { get; set; }
///
/// For the SOS and RST markers, this contains the entropy coded data.
///
public byte[] EntropyData { get; set; }
#endregion
#region Constructors
///
/// Constructs a JPEGSection represented by the marker byte and containing
/// the given data.
///
/// The marker byte representing the section.
/// Section data.
/// Entropy coded data.
public JPEGSection(JPEGMarker marker, byte[] data, byte[] entropydata)
{
Marker = marker;
Header = data;
EntropyData = entropydata;
}
///
/// Constructs a JPEGSection represented by the marker byte.
///
/// The marker byte representing the section.
public JPEGSection(JPEGMarker marker)
: this(marker, new byte[0], new byte[0])
{
;
}
#endregion
#region Instance Methods
///
/// Returns a string representation of the current section.
///
/// A System.String that represents the current section.
public override string ToString()
{
return string.Format("{0} => Header: {1} bytes, Entropy Data: {2} bytes", Marker, Header.Length, EntropyData.Length);
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/MathEx.cs 0000664 0000000 0000000 00000150235 14462226067 0024272 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
namespace ExifLibrary
{
///
/// Contains extended Math functions.
///
public static class MathEx
{
///
/// Returns the greatest common divisor of two numbers.
///
/// First number.
/// Second number.
public static uint GCD(uint a, uint b)
{
while (b != 0)
{
uint rem = a % b;
a = b;
b = rem;
}
return a;
}
///
/// Returns the greatest common divisor of two numbers.
///
/// First number.
/// Second number.
public static ulong GCD(ulong a, ulong b)
{
while (b != 0)
{
ulong rem = a % b;
a = b;
b = rem;
}
return a;
}
///
/// Represents a generic rational number represented by 32-bit signed numerator and denominator.
///
public struct Fraction32 : IComparable, IFormattable, IComparable, IEquatable
{
#region Constants
private const uint MaximumIterations = 10000000;
#endregion
#region Member Variables
private bool mIsNegative;
private int mNumerator;
private int mDenominator;
private double mError;
#endregion
#region Properties
///
/// Gets or sets the numerator.
///
public int Numerator
{
get
{
return (mIsNegative ? -1 : 1) * mNumerator;
}
set
{
if (value < 0)
{
mIsNegative = true;
mNumerator = -1 * value;
}
else
{
mIsNegative = false;
mNumerator = value;
}
Reduce(ref mNumerator, ref mDenominator);
}
}
///
/// Gets or sets the denominator.
///
public int Denominator
{
get
{
return ((int)mDenominator);
}
set
{
mDenominator = System.Math.Abs(value);
Reduce(ref mNumerator, ref mDenominator);
}
}
///
/// Gets the error term.
///
public double Error
{
get
{
return mError;
}
}
///
/// Gets or sets a value determining id the fraction is a negative value.
///
public bool IsNegative
{
get
{
return mIsNegative;
}
set
{
mIsNegative = value;
}
}
#endregion
#region Predefined Values
public static readonly Fraction32 NaN = new Fraction32(0, 0);
public static readonly Fraction32 NegativeInfinity = new Fraction32(-1, 0);
public static readonly Fraction32 PositiveInfinity = new Fraction32(1, 0);
#endregion
#region Static Methods
///
/// Returns a value indicating whether the specified number evaluates to a value
/// that is not a number.
///
/// A fraction.
/// true if f evaluates to Fraction.NaN; otherwise, false.
public static bool IsNan(Fraction32 f)
{
return (f.Numerator == 0 && f.Denominator == 0);
}
///
/// Returns a value indicating whether the specified number evaluates to negative
/// infinity.
///
/// A fraction.
/// true if f evaluates to Fraction.NegativeInfinity; otherwise, false.
public static bool IsNegativeInfinity(Fraction32 f)
{
return (f.Numerator < 0 && f.Denominator == 0);
}
///
/// Returns a value indicating whether the specified number evaluates to positive
/// infinity.
///
/// A fraction.
/// true if f evaluates to Fraction.PositiveInfinity; otherwise, false.
public static bool IsPositiveInfinity(Fraction32 f)
{
return (f.Numerator > 0 && f.Denominator == 0);
}
///
/// Returns a value indicating whether the specified number evaluates to negative
/// or positive infinity.
///
/// A fraction.
/// true if f evaluates to Fraction.NegativeInfinity or Fraction.PositiveInfinity; otherwise, false.
public static bool IsInfinity(Fraction32 f)
{
return (f.Denominator == 0);
}
///
/// Returns the multiplicative inverse of a given value.
///
/// A fraction.
/// Multiplicative inverse of f.
public static Fraction32 Inverse(Fraction32 f)
{
return new Fraction32(f.Denominator, f.Numerator);
}
///
/// Converts the string representation of a fraction to a fraction object.
///
/// A string formatted as numerator/denominator
/// A fraction object converted from s.
/// s is null
/// s is not in the correct format
///
/// s represents a number less than System.UInt32.MinValue or greater than
/// System.UInt32.MaxValue.
///
public static Fraction32 Parse(string s)
{
return FromString(s);
}
///
/// Converts the string representation of a fraction to a fraction object.
/// A return value indicates whether the conversion succeeded.
///
/// A string formatted as numerator/denominator
/// true if s was converted successfully; otherwise, false.
public static bool TryParse(string s, out Fraction32 f)
{
try
{
f = Parse(s);
return true;
}
catch
{
f = new Fraction32();
return false;
}
}
#endregion
#region Operators
#region Arithmetic Operators
// Multiplication
public static Fraction32 operator *(Fraction32 f, int n)
{
return new Fraction32(f.Numerator * n, f.Denominator * System.Math.Abs(n));
}
public static Fraction32 operator *(int n, Fraction32 f)
{
return f * n;
}
public static Fraction32 operator *(Fraction32 f, float n)
{
return new Fraction32(((float)f) * n);
}
public static Fraction32 operator *(float n, Fraction32 f)
{
return f * n;
}
public static Fraction32 operator *(Fraction32 f, double n)
{
return new Fraction32(((double)f) * n);
}
public static Fraction32 operator *(double n, Fraction32 f)
{
return f * n;
}
public static Fraction32 operator *(Fraction32 f1, Fraction32 f2)
{
return new Fraction32(f1.Numerator * f2.Numerator, f1.Denominator * f2.Denominator);
}
// Divison
public static Fraction32 operator /(Fraction32 f, int n)
{
return new Fraction32(f.Numerator / n, f.Denominator / System.Math.Abs(n));
}
public static Fraction32 operator /(Fraction32 f, float n)
{
return new Fraction32(((float)f) / n);
}
public static Fraction32 operator /(Fraction32 f, double n)
{
return new Fraction32(((double)f) / n);
}
public static Fraction32 operator /(Fraction32 f1, Fraction32 f2)
{
return f1 * Inverse(f2);
}
// Addition
public static Fraction32 operator +(Fraction32 f, int n)
{
return f + new Fraction32(n, 1);
}
public static Fraction32 operator +(int n, Fraction32 f)
{
return f + n;
}
public static Fraction32 operator +(Fraction32 f, float n)
{
return new Fraction32(((float)f) + n);
}
public static Fraction32 operator +(float n, Fraction32 f)
{
return f + n;
}
public static Fraction32 operator +(Fraction32 f, double n)
{
return new Fraction32(((double)f) + n);
}
public static Fraction32 operator +(double n, Fraction32 f)
{
return f + n;
}
public static Fraction32 operator +(Fraction32 f1, Fraction32 f2)
{
int n1 = f1.Numerator, d1 = f1.Denominator;
int n2 = f2.Numerator, d2 = f2.Denominator;
return new Fraction32(n1 * d2 + n2 * d1, d1 * d2);
}
// Subtraction
public static Fraction32 operator -(Fraction32 f, int n)
{
return f - new Fraction32(n, 1);
}
public static Fraction32 operator -(int n, Fraction32 f)
{
return new Fraction32(n, 1) - f;
}
public static Fraction32 operator -(Fraction32 f, float n)
{
return new Fraction32(((float)f) - n);
}
public static Fraction32 operator -(float n, Fraction32 f)
{
return new Fraction32(n) - f;
}
public static Fraction32 operator -(Fraction32 f, double n)
{
return new Fraction32(((double)f) - n);
}
public static Fraction32 operator -(double n, Fraction32 f)
{
return new Fraction32(n) - f;
}
public static Fraction32 operator -(Fraction32 f1, Fraction32 f2)
{
int n1 = f1.Numerator, d1 = f1.Denominator;
int n2 = f2.Numerator, d2 = f2.Denominator;
return new Fraction32(n1 * d2 - n2 * d1, d1 * d2);
}
// Increment
public static Fraction32 operator ++(Fraction32 f)
{
return f + new Fraction32(1, 1);
}
// Decrement
public static Fraction32 operator --(Fraction32 f)
{
return f - new Fraction32(1, 1);
}
#endregion
#region Casts To Integral Types
public static explicit operator int(Fraction32 f)
{
return f.Numerator / f.Denominator;
}
public static explicit operator float(Fraction32 f)
{
return ((float)f.Numerator) / ((float)f.Denominator);
}
public static explicit operator double(Fraction32 f)
{
return ((double)f.Numerator) / ((double)f.Denominator);
}
#endregion
#region Comparison Operators
public static bool operator ==(Fraction32 f1, Fraction32 f2)
{
return (f1.Numerator == f2.Numerator) && (f1.Denominator == f2.Denominator);
}
public static bool operator !=(Fraction32 f1, Fraction32 f2)
{
return (f1.Numerator != f2.Numerator) || (f1.Denominator != f2.Denominator);
}
public static bool operator <(Fraction32 f1, Fraction32 f2)
{
return (f1.Numerator * f2.Denominator) < (f2.Numerator * f1.Denominator);
}
public static bool operator >(Fraction32 f1, Fraction32 f2)
{
return (f1.Numerator * f2.Denominator) > (f2.Numerator * f1.Denominator);
}
#endregion
#endregion
#region Constructors
private Fraction32(int numerator, int denominator, double error)
{
mIsNegative = false;
if (numerator < 0)
{
numerator = -numerator;
mIsNegative = !mIsNegative;
}
if (denominator < 0)
{
denominator = -denominator;
mIsNegative = !mIsNegative;
}
mNumerator = numerator;
mDenominator = denominator;
mError = error;
if (mDenominator != 0)
Reduce(ref mNumerator, ref mDenominator);
}
public Fraction32(int numerator, int denominator)
: this(numerator, denominator, 0)
{
;
}
public Fraction32(int numerator)
: this(numerator, (int)1)
{
;
}
public Fraction32(Fraction32 f)
: this(f.Numerator, f.Denominator, f.Error)
{
;
}
public Fraction32(float value)
: this((double)value)
{
;
}
public Fraction32(double value)
: this(FromDouble(value))
{
;
}
public Fraction32(string s)
: this(FromString(s))
{
;
}
#endregion
#region Instance Methods
///
/// Sets the value of this instance to the fraction represented
/// by the given numerator and denominator.
///
/// The new numerator.
/// The new denominator.
public void Set(int numerator, int denominator)
{
mIsNegative = false;
if (numerator < 0)
{
mIsNegative = !mIsNegative;
numerator = -numerator;
}
if (denominator < 0)
{
mIsNegative = !mIsNegative;
denominator = -denominator;
}
mNumerator = numerator;
mDenominator = denominator;
if (mDenominator != 0)
Reduce(ref mNumerator, ref mDenominator);
}
///
/// Indicates whether this instance and a specified object are equal value-wise.
///
/// Another object to compare to.
/// true if obj and this instance are the same type and represent
/// the same value; otherwise, false.
public override bool Equals(object obj)
{
if (obj == null)
return false;
if (obj is Fraction32)
return Equals((Fraction32)obj);
else
return false;
}
///
/// Indicates whether this instance and a specified object are equal value-wise.
///
/// Another fraction object to compare to.
/// true if obj and this instance represent the same value;
/// otherwise, false.
public bool Equals(Fraction32 obj)
{
return (mIsNegative == obj.IsNegative) && (mNumerator == obj.Numerator) && (mDenominator == obj.Denominator);
}
///
/// Returns the hash code for this instance.
///
/// A 32-bit signed integer that is the hash code for this instance.
public override int GetHashCode()
{
return mDenominator ^ ((mIsNegative ? -1 : 1) * mNumerator);
}
///
/// Returns a string representation of the fraction.
///
/// A numeric format string.
///
/// An System.IFormatProvider that supplies culture-specific
/// formatting information.
///
///
/// The string representation of the value of this instance as
/// specified by format and provider.
///
///
/// format is invalid or not supported.
///
public string ToString(string format, IFormatProvider formatProvider)
{
StringBuilder sb = new StringBuilder();
sb.Append(((mIsNegative ? -1 : 1) * mNumerator).ToString(format, formatProvider));
sb.Append('/');
sb.Append(mDenominator.ToString(format, formatProvider));
return sb.ToString();
}
///
/// Returns a string representation of the fraction.
///
/// A numeric format string.
///
/// The string representation of the value of this instance as
/// specified by format.
///
///
/// format is invalid or not supported.
///
public string ToString(string format)
{
StringBuilder sb = new StringBuilder();
sb.Append(((mIsNegative ? -1 : 1) * mNumerator).ToString(format));
sb.Append('/');
sb.Append(mDenominator.ToString(format));
return sb.ToString();
}
///
/// Returns a string representation of the fraction.
///
///
/// An System.IFormatProvider that supplies culture-specific
/// formatting information.
///
///
/// The string representation of the value of this instance as
/// specified by provider.
///
public string ToString(IFormatProvider formatProvider)
{
StringBuilder sb = new StringBuilder();
sb.Append(((mIsNegative ? -1 : 1) * mNumerator).ToString(formatProvider));
sb.Append('/');
sb.Append(mDenominator.ToString(formatProvider));
return sb.ToString();
}
///
/// Returns a string representation of the fraction.
///
/// A string formatted as numerator/denominator.
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append(((mIsNegative ? -1 : 1) * mNumerator).ToString());
sb.Append('/');
sb.Append(mDenominator.ToString());
return sb.ToString();
}
///
/// Compares this instance to a specified object and returns an indication of
/// their relative values.
///
/// An object to compare, or null.
///
/// A signed number indicating the relative values of this instance and value.
/// Less than zero: This instance is less than obj.
/// Zero: This instance is equal to obj.
/// Greater than zero: This instance is greater than obj or obj is null.
///
/// obj is not a Fraction.
public int CompareTo(object obj)
{
if (!(obj is Fraction32))
throw new ArgumentException("obj must be of type Fraction", "obj");
return CompareTo((Fraction32)obj);
}
///
/// Compares this instance to a specified object and returns an indication of
/// their relative values.
///
/// An fraction to compare with this instance.
///
/// A signed number indicating the relative values of this instance and value.
/// Less than zero: This instance is less than obj.
/// Zero: This instance is equal to obj.
/// Greater than zero: This instance is greater than obj or obj is null.
///
public int CompareTo(Fraction32 obj)
{
if (this < obj)
return -1;
else if (this > obj)
return 1;
return 0;
}
#endregion
#region Private Helper Methods
///
/// Converts the given floating-point number to its rational representation.
///
/// The floating-point number to be converted.
/// The rational representation of value.
private static Fraction32 FromDouble(double value)
{
if (double.IsNaN(value))
return Fraction32.NaN;
else if (double.IsNegativeInfinity(value))
return Fraction32.NegativeInfinity;
else if (double.IsPositiveInfinity(value))
return Fraction32.PositiveInfinity;
bool isneg = (value < 0);
if (isneg) value = -value;
double f = value;
double forg = f;
int lnum = 0;
int lden = 1;
int num = 1;
int den = 0;
double lasterr = 1.0;
int a = 0;
int currIteration = 0;
while (true)
{
if (++currIteration > MaximumIterations) break;
a = (int)Math.Floor(f);
f = f - (double)a;
if (Math.Abs(f) < double.Epsilon)
break;
f = 1.0 / f;
if (double.IsInfinity(f))
break;
int cnum = num * a + lnum;
int cden = den * a + lden;
if (Math.Abs((double)cnum / (double)cden - forg) < double.Epsilon)
break;
double err = ((double)cnum / (double)cden - (double)num / (double)den) / ((double)num / (double)den);
// Are we converging?
if (err >= lasterr)
break;
lasterr = err;
lnum = num;
lden = den;
num = cnum;
den = cden;
}
if (den > 0)
lasterr = value - ((double)num / (double)den);
else
lasterr = double.PositiveInfinity;
return new Fraction32((isneg ? -1 : 1) * num, den, lasterr);
}
/// Converts the string representation of a fraction to a Fraction type.
/// The input string formatted as numerator/denominator.
/// s is null.
/// s is not formatted as numerator/denominator.
///
/// s represents numbers less than System.Int32.MinValue or greater than
/// System.Int32.MaxValue.
///
private static Fraction32 FromString(string s)
{
if (s == null)
throw new ArgumentNullException("s");
string[] sa = s.Split('/');
int numerator = 1;
int denominator = 1;
if (sa.Length == 1)
{
// Try to parse as int
if (int.TryParse(sa[0], out numerator))
{
denominator = 1;
}
else
{
// Parse as double
double dval = double.Parse(sa[0]);
return FromDouble(dval);
}
}
else if (sa.Length == 2)
{
numerator = int.Parse(sa[0]);
denominator = int.Parse(sa[1]);
}
else
throw new FormatException("The input string must be formatted as n/d where n and d are integers");
return new Fraction32(numerator, denominator);
}
///
/// Reduces the given numerator and denominator by dividing with their
/// greatest common divisor.
///
/// numerator to be reduced.
/// denominator to be reduced.
private static void Reduce(ref int numerator, ref int denominator)
{
uint gcd = MathEx.GCD((uint)numerator, (uint)denominator);
if (gcd == 0) gcd = 1;
numerator = numerator / (int)gcd;
denominator = denominator / (int)gcd;
}
#endregion
}
///
/// Represents a generic rational number represented by 32-bit unsigned numerator and denominator.
///
public struct UFraction32 : IComparable, IFormattable, IComparable, IEquatable
{
#region Constants
private const uint MaximumIterations = 10000000;
#endregion
#region Member Variables
private uint mNumerator;
private uint mDenominator;
private double mError;
#endregion
#region Properties
///
/// Gets or sets the numerator.
///
public uint Numerator
{
get
{
return mNumerator;
}
set
{
mNumerator = value;
Reduce(ref mNumerator, ref mDenominator);
}
}
///
/// Gets or sets the denominator.
///
public uint Denominator
{
get
{
return mDenominator;
}
set
{
mDenominator = value;
Reduce(ref mNumerator, ref mDenominator);
}
}
///
/// Gets the error term.
///
public double Error
{
get
{
return mError;
}
}
#endregion
#region Predefined Values
public static readonly UFraction32 NaN = new UFraction32(0, 0);
public static readonly UFraction32 Infinity = new UFraction32(1, 0);
#endregion
#region Static Methods
///
/// Returns a value indicating whether the specified number evaluates to a value
/// that is not a number.
///
/// A fraction.
/// true if f evaluates to Fraction.NaN; otherwise, false.
public static bool IsNan(UFraction32 f)
{
return (f.Numerator == 0 && f.Denominator == 0);
}
///
/// Returns a value indicating whether the specified number evaluates to infinity.
///
/// A fraction.
/// true if f evaluates to Fraction.Infinity; otherwise, false.
public static bool IsInfinity(UFraction32 f)
{
return (f.Denominator == 0);
}
///
/// Converts the string representation of a fraction to a fraction object.
///
/// A string formatted as numerator/denominator
/// A fraction object converted from s.
/// s is null
/// s is not in the correct format
///
/// s represents a number less than System.UInt32.MinValue or greater than
/// System.UInt32.MaxValue.
///
public static UFraction32 Parse(string s)
{
return FromString(s);
}
///
/// Converts the string representation of a fraction to a fraction object.
/// A return value indicates whether the conversion succeeded.
///
/// A string formatted as numerator/denominator
/// true if s was converted successfully; otherwise, false.
public static bool TryParse(string s, out UFraction32 f)
{
try
{
f = Parse(s);
return true;
}
catch
{
f = new UFraction32();
return false;
}
}
#endregion
#region Operators
#region Arithmetic Operators
// Multiplication
public static UFraction32 operator *(UFraction32 f, uint n)
{
return new UFraction32(f.Numerator * n, f.Denominator * n);
}
public static UFraction32 operator *(uint n, UFraction32 f)
{
return f * n;
}
public static UFraction32 operator *(UFraction32 f, float n)
{
return new UFraction32(((float)f) * n);
}
public static UFraction32 operator *(float n, UFraction32 f)
{
return f * n;
}
public static UFraction32 operator *(UFraction32 f, double n)
{
return new UFraction32(((double)f) * n);
}
public static UFraction32 operator *(double n, UFraction32 f)
{
return f * n;
}
public static UFraction32 operator *(UFraction32 f1, UFraction32 f2)
{
return new UFraction32(f1.Numerator * f2.Numerator, f1.Denominator * f2.Denominator);
}
// Divison
public static UFraction32 operator /(UFraction32 f, uint n)
{
return new UFraction32(f.Numerator / n, f.Denominator / n);
}
public static UFraction32 operator /(UFraction32 f, float n)
{
return new UFraction32(((float)f) / n);
}
public static UFraction32 operator /(UFraction32 f, double n)
{
return new UFraction32(((double)f) / n);
}
public static UFraction32 operator /(UFraction32 f1, UFraction32 f2)
{
return f1 * Inverse(f2);
}
// Addition
public static UFraction32 operator +(UFraction32 f, uint n)
{
return f + new UFraction32(n, 1);
}
public static UFraction32 operator +(uint n, UFraction32 f)
{
return f + n;
}
public static UFraction32 operator +(UFraction32 f, float n)
{
return new UFraction32(((float)f) + n);
}
public static UFraction32 operator +(float n, UFraction32 f)
{
return f + n;
}
public static UFraction32 operator +(UFraction32 f, double n)
{
return new UFraction32(((double)f) + n);
}
public static UFraction32 operator +(double n, UFraction32 f)
{
return f + n;
}
public static UFraction32 operator +(UFraction32 f1, UFraction32 f2)
{
uint n1 = f1.Numerator, d1 = f1.Denominator;
uint n2 = f2.Numerator, d2 = f2.Denominator;
return new UFraction32(n1 * d2 + n2 * d1, d1 * d2);
}
// Subtraction
public static UFraction32 operator -(UFraction32 f, uint n)
{
return f - new UFraction32(n, 1);
}
public static UFraction32 operator -(uint n, UFraction32 f)
{
return new UFraction32(n, 1) - f;
}
public static UFraction32 operator -(UFraction32 f, float n)
{
return new UFraction32(((float)f) - n);
}
public static UFraction32 operator -(float n, UFraction32 f)
{
return new UFraction32(n) - f;
}
public static UFraction32 operator -(UFraction32 f, double n)
{
return new UFraction32(((double)f) - n);
}
public static UFraction32 operator -(double n, UFraction32 f)
{
return new UFraction32(n) - f;
}
public static UFraction32 operator -(UFraction32 f1, UFraction32 f2)
{
uint n1 = f1.Numerator, d1 = f1.Denominator;
uint n2 = f2.Numerator, d2 = f2.Denominator;
return new UFraction32(n1 * d2 - n2 * d1, d1 * d2);
}
// Increment
public static UFraction32 operator ++(UFraction32 f)
{
return f + new UFraction32(1, 1);
}
// Decrement
public static UFraction32 operator --(UFraction32 f)
{
return f - new UFraction32(1, 1);
}
#endregion
#region Casts To Integral Types
public static explicit operator uint(UFraction32 f)
{
return ((uint)f.Numerator) / ((uint)f.Denominator);
}
public static explicit operator float(UFraction32 f)
{
return ((float)f.Numerator) / ((float)f.Denominator);
}
public static explicit operator double(UFraction32 f)
{
return ((double)f.Numerator) / ((double)f.Denominator);
}
#endregion
#region Comparison Operators
public static bool operator ==(UFraction32 f1, UFraction32 f2)
{
return (f1.Numerator == f2.Numerator) && (f1.Denominator == f2.Denominator);
}
public static bool operator !=(UFraction32 f1, UFraction32 f2)
{
return (f1.Numerator != f2.Numerator) || (f1.Denominator != f2.Denominator);
}
public static bool operator <(UFraction32 f1, UFraction32 f2)
{
return (f1.Numerator * f2.Denominator) < (f2.Numerator * f1.Denominator);
}
public static bool operator >(UFraction32 f1, UFraction32 f2)
{
return (f1.Numerator * f2.Denominator) > (f2.Numerator * f1.Denominator);
}
#endregion
#endregion
#region Constructors
public UFraction32(uint numerator, uint denominator, double error)
{
mNumerator = numerator;
mDenominator = denominator;
mError = error;
if (mDenominator != 0)
Reduce(ref mNumerator, ref mDenominator);
}
public UFraction32(uint numerator, uint denominator)
: this(numerator, denominator, 0)
{
;
}
public UFraction32(uint numerator)
: this(numerator, (uint)1)
{
;
}
public UFraction32(UFraction32 f)
: this(f.Numerator, f.Denominator, f.Error)
{
;
}
public UFraction32(float value)
: this((double)value)
{
;
}
public UFraction32(double value)
: this(FromDouble(value))
{
;
}
public UFraction32(string s)
: this(FromString(s))
{
;
}
#endregion
#region Instance Methods
///
/// Sets the value of this instance to the fraction represented
/// by the given numerator and denominator.
///
/// The new numerator.
/// The new denominator.
public void Set(uint numerator, uint denominator)
{
mNumerator = numerator;
mDenominator = denominator;
if (mDenominator != 0)
Reduce(ref mNumerator, ref mDenominator);
}
///
/// Returns the multiplicative inverse of a given value.
///
/// A fraction.
/// Multiplicative inverse of f.
public static UFraction32 Inverse(UFraction32 f)
{
return new UFraction32(f.Denominator, f.Numerator);
}
///
/// Indicates whether this instance and a specified object are equal value-wise.
///
/// Another object to compare to.
/// true if obj and this instance are the same type and represent
/// the same value; otherwise, false.
public override bool Equals(object obj)
{
if (obj == null)
return false;
if (obj is UFraction32)
return Equals((UFraction32)obj);
else
return false;
}
///
/// Indicates whether this instance and a specified object are equal value-wise.
///
/// Another fraction object to compare to.
/// true if obj and this instance represent the same value;
/// otherwise, false.
public bool Equals(UFraction32 obj)
{
return (mNumerator == obj.Numerator) && (mDenominator == obj.Denominator);
}
///
/// Returns the hash code for this instance.
///
/// A 32-bit signed integer that is the hash code for this instance.
public override int GetHashCode()
{
return ((int)mDenominator) ^ ((int)mNumerator);
}
///
/// Returns a string representation of the fraction.
///
/// A numeric format string.
///
/// An System.IFormatProvider that supplies culture-specific
/// formatting information.
///
///
/// The string representation of the value of this instance as
/// specified by format and provider.
///
///
/// format is invalid or not supported.
///
public string ToString(string format, IFormatProvider formatProvider)
{
StringBuilder sb = new StringBuilder();
sb.Append(mNumerator.ToString(format, formatProvider));
sb.Append('/');
sb.Append(mDenominator.ToString(format, formatProvider));
return sb.ToString();
}
///
/// Returns a string representation of the fraction.
///
/// A numeric format string.
///
/// The string representation of the value of this instance as
/// specified by format.
///
///
/// format is invalid or not supported.
///
public string ToString(string format)
{
StringBuilder sb = new StringBuilder();
sb.Append(mNumerator.ToString(format));
sb.Append('/');
sb.Append(mDenominator.ToString(format));
return sb.ToString();
}
///
/// Returns a string representation of the fraction.
///
///
/// An System.IFormatProvider that supplies culture-specific
/// formatting information.
///
///
/// The string representation of the value of this instance as
/// specified by provider.
///
public string ToString(IFormatProvider formatProvider)
{
StringBuilder sb = new StringBuilder();
sb.Append(mNumerator.ToString(formatProvider));
sb.Append('/');
sb.Append(mDenominator.ToString(formatProvider));
return sb.ToString();
}
///
/// Returns a string representation of the fraction.
///
/// A string formatted as numerator/denominator.
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append(mNumerator.ToString());
sb.Append('/');
sb.Append(mDenominator.ToString());
return sb.ToString();
}
///
/// Compares this instance to a specified object and returns an indication of
/// their relative values.
///
/// An object to compare, or null.
///
/// A signed number indicating the relative values of this instance and value.
/// Less than zero: This instance is less than obj.
/// Zero: This instance is equal to obj.
/// Greater than zero: This instance is greater than obj or obj is null.
///
/// obj is not a Fraction.
public int CompareTo(object obj)
{
if (!(obj is UFraction32))
throw new ArgumentException("obj must be of type UFraction32", "obj");
return CompareTo((UFraction32)obj);
}
///
/// Compares this instance to a specified object and returns an indication of
/// their relative values.
///
/// An fraction to compare with this instance.
///
/// A signed number indicating the relative values of this instance and value.
/// Less than zero: This instance is less than obj.
/// Zero: This instance is equal to obj.
/// Greater than zero: This instance is greater than obj or obj is null.
///
public int CompareTo(UFraction32 obj)
{
if (this < obj)
return -1;
else if (this > obj)
return 1;
return 0;
}
#endregion
#region Private Helper Methods
///
/// Converts the given floating-point number to its rational representation.
///
/// The floating-point number to be converted.
/// The rational representation of value.
private static UFraction32 FromDouble(double value)
{
if (value < 0)
throw new ArgumentException("value cannot be negative.", "value");
if (double.IsNaN(value))
return UFraction32.NaN;
else if (double.IsInfinity(value))
return UFraction32.Infinity;
double f = value;
double forg = f;
uint lnum = 0;
uint lden = 1;
uint num = 1;
uint den = 0;
double lasterr = 1.0;
uint a = 0;
int currIteration = 0;
while (true)
{
if (++currIteration > MaximumIterations) break;
a = (uint)Math.Floor(f);
f = f - (double)a;
if (Math.Abs(f) < double.Epsilon)
break;
f = 1.0 / f;
if (double.IsInfinity(f))
break;
uint cnum = num * a + lnum;
uint cden = den * a + lden;
if (Math.Abs((double)cnum / (double)cden - forg) < double.Epsilon)
break;
double err = ((double)cnum / (double)cden - (double)num / (double)den) / ((double)num / (double)den);
// Are we converging?
if (err >= lasterr)
break;
lasterr = err;
lnum = num;
lden = den;
num = cnum;
den = cden;
}
uint fnum = num * a + lnum;
uint fden = den * a + lden;
if (fden > 0)
lasterr = value - ((double)fnum / (double)fden);
else
lasterr = double.PositiveInfinity;
return new UFraction32(fnum, fden, lasterr);
}
/// Converts the string representation of a fraction to a Fraction type.
/// The input string formatted as numerator/denominator.
/// s is null.
/// s is not formatted as numerator/denominator.
///
/// s represents numbers less than System.UInt32.MinValue or greater than
/// System.UInt32.MaxValue.
///
private static UFraction32 FromString(string s)
{
if (s == null)
throw new ArgumentNullException("s");
string[] sa = s.Split('/');
uint numerator = 1;
uint denominator = 1;
if (sa.Length == 1)
{
// Try to parse as uint
if (uint.TryParse(sa[0], out numerator))
{
denominator = 1;
}
else
{
// Parse as double
double dval = double.Parse(sa[0]);
return FromDouble(dval);
}
}
else if (sa.Length == 2)
{
numerator = uint.Parse(sa[0]);
denominator = uint.Parse(sa[1]);
}
else
throw new FormatException("The input string must be formatted as n/d where n and d are integers");
return new UFraction32(numerator, denominator);
}
///
/// Reduces the given numerator and denominator by dividing with their
/// greatest common divisor.
///
/// numerator to be reduced.
/// denominator to be reduced.
private static void Reduce(ref uint numerator, ref uint denominator)
{
uint gcd = MathEx.GCD(numerator, denominator);
numerator = numerator / gcd;
denominator = denominator / gcd;
}
#endregion
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/PNGChunk.cs 0000664 0000000 0000000 00000004706 14462226067 0024522 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents the memory view of a PNG chunk.
///
public class PNGChunk
{
#region Properties
///
/// The four character ASCII chunk name/type.
///
public string Type { get; set; }
///
/// Chunk data.
///
public byte[] Data { get; set; }
///
/// The CRC computed over the chunk type and chunk data
///
public uint CRC { get; private set; }
///
/// Determines if this is a critical chunk.
///
public bool IsCritical { get { return (Type[0] >= 'A') && (Type[0] <= 'Z'); } }
///
/// Determines if this is a public chunk.
///
public bool IsPublic { get { return (Type[1] >= 'A') && (Type[1] <= 'Z'); } }
///
/// Determines if the chunk may be safely copied
/// regardless of the extent of modifications to the file.
///
public bool IsSafeToCopy { get { return (Type[3] >= 'a') && (Type[3] <= 'z'); } }
#endregion
#region Constructors
///
/// Constructs a PNGChunk represented by the type name and containing
/// the given data.
///
/// The type of chuck.
/// Chunk data.
public PNGChunk(string type, byte[] data)
{
Type = type;
Data = data;
UpdateCRC();
}
#endregion
#region Instance Methods
///
/// Updates the CRC value.
///
public void UpdateCRC()
{
CRC = (uint)Utility.CRC32.Hash(0, Encoding.ASCII.GetBytes(Type));
CRC = (uint)Utility.CRC32.Hash(CRC, Data);
}
///
/// Returns a string representation of the current chunk.
///
/// A System.String that represents the current chunk.
public override string ToString()
{
return string.Format("{0} => Data: {1} bytes, CRC32: {2}", Type, Data.Length, CRC);
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/PNGFile.cs 0000664 0000000 0000000 00000032152 14462226067 0024325 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.IO;
using System.ComponentModel;
namespace ExifLibrary
{
///
/// Represents the binary view of a PNG file.
///
public class PNGFile : ImageFile
{
#region Properties
///
/// Gets or sets the chunks contained in the .
///
public List Chunks { get; private set; }
#endregion
#region Constructor
///
/// Initializes a new instance of the class from the
/// specified data stream.
///
/// A that contains image data.
/// The encoding to be used for text metadata when the source encoding is unknown.
protected internal PNGFile(Stream stream, System.Text.Encoding encoding)
{
Format = ImageFileFormat.PNG;
Chunks = new List();
Encoding = encoding;
BitConverterEx conv = BitConverterEx.BigEndian;
// Skip header
stream.Seek(8, SeekOrigin.Begin);
// Read chunks in order until we reach the end of file.
while (stream.Position != stream.Length)
{
// Length of chunk data
byte[] lengthBytes = new byte[4];
if (stream.Read(lengthBytes, 0, 4) != 4)
throw new NotValidPNGFileException();
uint length = conv.ToUInt32(lengthBytes, 0);
// Chunk type
byte[] typeBytes = new byte[4];
if (stream.Read(typeBytes, 0, 4) != 4)
throw new NotValidPNGFileException();
string type = Encoding.ASCII.GetString(typeBytes);
// Chunk data
byte[] data = Utility.GetStreamBytes(stream, length);
// CRC of type name and data
byte[] crcBytes = new byte[4];
if (stream.Read(crcBytes, 0, 4) != 4)
throw new NotValidPNGFileException();
uint crc = conv.ToUInt32(crcBytes, 0);
// Add to chunks list
PNGChunk chunk = new PNGChunk(type, data);
if (chunk.CRC != crc)
throw new NotValidPNGFileException();
Chunks.Add(chunk);
}
ReadPNGMetadata();
}
#endregion
#region Instance Methods
///
/// Decreases file size by removing all ancillary chunks.
///
public override void Crush()
{
Properties.Clear();
Chunks.RemoveAll(c => !c.IsCritical);
}
///
/// Saves the to the given stream.
///
/// The data stream used to save the image.
public override void Save(Stream stream)
{
// Add end chunk if it does not exist
if (Chunks[Chunks.Count - 1].Type != "IEND")
{
Chunks.Add(new PNGChunk("IEND", new byte[0]));
}
// Save metadata
WritePNGMetadata();
BitConverterEx conv = BitConverterEx.BigEndian;
// Write header
stream.WriteByte(0x89);
stream.WriteByte(0x50);
stream.WriteByte(0x4E);
stream.WriteByte(0x47);
stream.WriteByte(0x0D);
stream.WriteByte(0x0A);
stream.WriteByte(0x1A);
stream.WriteByte(0x0A);
// Write chunks in order
foreach (PNGChunk chunk in Chunks)
{
// Length of chunk data
stream.Write(conv.GetBytes((uint)chunk.Data.LongLength), 0, 4);
// Chunk type
stream.Write(Encoding.ASCII.GetBytes(chunk.Type), 0, 4);
// Chunk data
long rem = chunk.Data.LongLength;
long offset = 0;
byte[] b = new byte[32768];
while (rem > 0)
{
int len = (int)Math.Min(rem, b.LongLength);
Array.Copy(chunk.Data, offset, b, 0, len);
stream.Write(b, 0, len);
rem -= len;
offset += len;
}
// CRC of type name and data
stream.Write(conv.GetBytes(chunk.CRC), 0, 4);
}
}
#endregion
#region Private Helper Methods
///
/// Reads the metadata from chunks.
///
private void ReadPNGMetadata()
{
// Find the [ISO-8859-1] encoding (codepage: 28591)
Encoding latin1 = Encoding.GetEncoding(28591);
// tEXt and zTXt
foreach (PNGChunk textChunk in Chunks.FindAll(c => c.Type == "tEXt" || c.Type == "zTXt"))
{
for (long i = 0; i < textChunk.Data.Length; i++)
{
if (textChunk.Data[i] == 0)
{
long sepIndex = i;
byte[] keywordBytes = new byte[sepIndex];
Array.Copy(textChunk.Data, 0, keywordBytes, 0, keywordBytes.Length);
string keyword = latin1.GetString(keywordBytes);
if (textChunk.Type == "tEXt")
{
byte[] valueBytes = new byte[textChunk.Data.Length - (sepIndex + 1)];
Array.Copy(textChunk.Data, sepIndex + 1, valueBytes, 0, valueBytes.Length);
string value = latin1.GetString(valueBytes);
Properties.Add(new PNGText(TagFromKeyword(keyword), keyword, value, false));
}
else
{
byte[] valueBytes = new byte[textChunk.Data.Length - (sepIndex + 2)];
Array.Copy(textChunk.Data, sepIndex + 2, valueBytes, 0, valueBytes.Length);
string value = Utility.DecompressString(valueBytes, latin1);
Properties.Add(new PNGText(TagFromKeyword(keyword), keyword, value, true));
}
break;
}
}
}
// iTXt
foreach (PNGChunk textChunk in Chunks.FindAll(c => c.Type == "iTXt"))
{
for (long i = 0; i < textChunk.Data.Length; i++)
{
if (textChunk.Data[i] == 0)
{
long sepIndex = i;
byte[] keywordBytes = new byte[sepIndex];
Array.Copy(textChunk.Data, 0, keywordBytes, 0, keywordBytes.Length);
string keyword = latin1.GetString(keywordBytes);
bool compressed = (textChunk.Data[sepIndex + 1] == 1);
for (long j = sepIndex + 3; j < textChunk.Data.Length; j++)
{
if (textChunk.Data[j] == 0)
{
long sepLangIndex = j;
byte[] langBytes = new byte[sepLangIndex - (sepIndex + 3)];
Array.Copy(textChunk.Data, sepIndex + 3, langBytes, 0, langBytes.Length);
string lang = latin1.GetString(langBytes);
for (long k = sepLangIndex + 1; k < textChunk.Data.Length; k++)
{
if (textChunk.Data[k] == 0)
{
long sepTransIndex = k;
byte[] transBytes = new byte[sepTransIndex - (sepLangIndex + 1)];
Array.Copy(textChunk.Data, sepLangIndex + 1, transBytes, 0, transBytes.Length);
string trans = Encoding.UTF8.GetString(transBytes);
byte[] valueBytes = new byte[textChunk.Data.Length - (sepTransIndex + 1)];
Array.Copy(textChunk.Data, sepTransIndex + 1, valueBytes, 0, valueBytes.Length);
string value = string.Empty;
if (compressed)
value = Utility.DecompressString(valueBytes, Encoding.UTF8);
else
value = Encoding.UTF8.GetString(valueBytes);
Properties.Add(new PNGInternationalText(TagFromKeyword(keyword), keyword, value, compressed, lang, trans));
break;
}
}
break;
}
}
break;
}
}
}
// tIME
foreach (PNGChunk timeChunk in Chunks.FindAll(c => c.Type == "tIME"))
{
ushort year = ExifBitConverter.BigEndian.ToUInt16(timeChunk.Data, 0);
DateTime mtime = new DateTime(year, timeChunk.Data[2], timeChunk.Data[3], timeChunk.Data[4], timeChunk.Data[5], timeChunk.Data[6]);
Properties.Add(new PNGTimeStamp(ExifTag.PNGTimeStamp, mtime));
}
}
///
/// Returns the tag corresponding to the given keyword.
///
/// The keyword to match.
private ExifTag TagFromKeyword(string keyword)
{
if (string.Compare(keyword, "Title", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGTitle;
else if (string.Compare(keyword, "Author", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGAuthor;
else if (string.Compare(keyword, "Description", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGDescription;
else if (string.Compare(keyword, "Copyright", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGCopyright;
else if (string.Compare(keyword, "Creation Time", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGCreationTime;
else if (string.Compare(keyword, "Software", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGSoftware;
else if (string.Compare(keyword, "Disclaimer", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGDisclaimer;
else if (string.Compare(keyword, "Warning", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGWarning;
else if (string.Compare(keyword, "Source", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGSource;
else if (string.Compare(keyword, "Comment", StringComparison.InvariantCultureIgnoreCase) == 0)
return ExifTag.PNGComment;
else
return ExifTag.PNGText;
}
///
/// Writes metadata back into PNG chunks.
///
private void WritePNGMetadata()
{
// Remove old chunks
Chunks.RemoveAll(c => c.Type == "tEXt" || c.Type == "zTXt" || c.Type == "iTXt" || c.Type == "tIME");
// Add chunks
foreach (ExifProperty prop in Properties)
{
if (prop is PNGText)
{
PNGText exprop = prop as PNGText;
if (!exprop.Compressed)
Chunks.Insert(Chunks.Count - 1, new PNGChunk("tEXt", prop.Interoperability.Data));
else
Chunks.Insert(Chunks.Count - 1, new PNGChunk("zTXt", prop.Interoperability.Data));
}
else if (prop is PNGInternationalText)
{
PNGInternationalText exprop = prop as PNGInternationalText;
Chunks.Insert(Chunks.Count - 1, new PNGChunk("iTXt", prop.Interoperability.Data));
}
else if (prop is PNGTimeStamp)
{
PNGTimeStamp exprop = prop as PNGTimeStamp;
Chunks.Insert(Chunks.Count - 1, new PNGChunk("tIME", prop.Interoperability.Data));
}
}
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/PNGProperty.cs 0000664 0000000 0000000 00000015106 14462226067 0025272 0 ustar 00root root 0000000 0000000 using System;
using System.Text;
namespace ExifLibrary
{
///
/// Represents an Latin-1 [ISO-8859-1] string. (PNG Specification: tEXt, zTXt)
///
public class PNGText : ExifProperty
{
protected string mValue;
protected override object _Value { get { return Value; } set { Value = (string)value; } }
public new string Value { get { return mValue; } set { mValue = value; } }
public string Keyword { get; private set; }
public bool Compressed { get; private set; }
static public implicit operator string(PNGText obj) { return obj.mValue; }
public override string ToString() { return mValue; }
public PNGText(ExifTag tag, string keyword, string value, bool compressed)
: base(tag)
{
Keyword = keyword;
mValue = value;
Compressed = compressed;
}
public override ExifInterOperability Interoperability
{
get
{
Encoding latin1 = Encoding.GetEncoding(28591);
if (Compressed)
{
byte[] keyword = latin1.GetBytes(Keyword);
byte[] value = Utility.CompressString(mValue, latin1);
byte[] data = new byte[keyword.Length + 2 + value.Length];
Array.Copy(keyword, 0, data, 0, keyword.Length);
data[keyword.Length] = 0; // Null separator
data[keyword.Length + 1] = 0; // Compression method, 0 for zlib
Array.Copy(value, 0, data, keyword.Length + 2, value.Length);
return new ExifInterOperability((ushort)mTag, 2, (uint)data.Length, data);
}
else
{
byte[] keyword = latin1.GetBytes(Keyword);
byte[] value = latin1.GetBytes(mValue);
byte[] data = new byte[keyword.Length + 1 + value.Length];
Array.Copy(keyword, 0, data, 0, keyword.Length);
data[keyword.Length] = 0; // Null separator
Array.Copy(value, 0, data, keyword.Length + 1, value.Length);
return new ExifInterOperability((ushort)mTag, 2, (uint)data.Length, data);
}
}
}
}
///
/// Represents an internationalized Latin-1 [ISO-8859-1] string. (PNG Specification: iTXt)
///
public class PNGInternationalText : ExifProperty
{
protected string mValue;
protected override object _Value { get { return Value; } set { Value = (string)value; } }
public new string Value { get { return mValue; } set { mValue = value; } }
public string Keyword { get; private set; }
public string Language { get; private set; }
public string TranslatedKeyword { get; private set; }
public bool Compressed { get; private set; }
static public implicit operator string(PNGInternationalText obj) { return obj.mValue; }
public override string ToString() { return mValue; }
public PNGInternationalText(ExifTag tag, string keyword, string value, bool compressed, string language, string translatedKeyword)
: base(tag)
{
Keyword = keyword;
mValue = value;
Compressed = compressed;
Language = language;
TranslatedKeyword = translatedKeyword;
}
public override ExifInterOperability Interoperability
{
get
{
Encoding latin1 = Encoding.GetEncoding(28591);
byte[] keyword = latin1.GetBytes(Keyword);
byte[] value = new byte[0];
if (Compressed)
value = Utility.CompressString(mValue, Encoding.UTF8);
else
value = Encoding.UTF8.GetBytes(mValue);
byte[] language = latin1.GetBytes(Language);
byte[] translatedKeyword = Encoding.UTF8.GetBytes(TranslatedKeyword);
byte[] data = new byte[keyword.Length + 3 + language.Length + 1 + translatedKeyword.Length + 1 + value.Length];
Array.Copy(keyword, 0, data, 0, keyword.Length);
data[keyword.Length] = 0; // Null separator
data[keyword.Length + 1] = (byte)(Compressed ? 1 : 0); // Compressed flag
data[keyword.Length + 2] = 0; // Compression method, 0 for zlib
Array.Copy(language, 0, data, keyword.Length + 3, language.Length);
data[keyword.Length + 3 + language.Length] = 0; // Null separator
Array.Copy(translatedKeyword, 0, data, keyword.Length + 3 + language.Length + 1, translatedKeyword.Length);
data[keyword.Length + 3 + language.Length + 1 + translatedKeyword.Length] = 0; // Null separator
Array.Copy(value, 0, data, keyword.Length + 3 + language.Length + 1 + translatedKeyword.Length + 1, value.Length);
return new ExifInterOperability((ushort)mTag, 2, (uint)data.Length, data);
}
}
}
///
/// Represents time stamp information. (PNG Specification: tIME)
///
public class PNGTimeStamp : ExifProperty
{
protected DateTime mValue;
protected override object _Value { get { return Value; } set { Value = (DateTime)value; } }
public new DateTime Value { get { return mValue; } set { mValue = value; } }
static public implicit operator DateTime(PNGTimeStamp obj) { return obj.mValue; }
public override string ToString() { return mValue.ToString("yyyy.MM.dd HH:mm:ss"); }
public PNGTimeStamp(ExifTag tag, DateTime value)
: base(tag)
{
mValue = value;
}
public override ExifInterOperability Interoperability
{
get
{
byte[] valueBytes = new byte[7];
byte[] yearBytes = ExifBitConverter.BigEndian.GetBytes((ushort)mValue.Year);
Array.Copy(yearBytes, valueBytes, 2);
valueBytes[2] = (byte)mValue.Month;
valueBytes[3] = (byte)mValue.Day;
valueBytes[4] = (byte)mValue.Hour;
valueBytes[5] = (byte)mValue.Minute;
valueBytes[6] = (byte)mValue.Second;
return new ExifInterOperability((ushort)mTag, 2, (uint)7, valueBytes);
}
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/Properties/ 0000775 0000000 0000000 00000000000 14462226067 0024703 5 ustar 00root root 0000000 0000000 quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/Properties/AssemblyInfo.cs 0000664 0000000 0000000 00000003353 14462226067 0027631 0 ustar 00root root 0000000 0000000 using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ExifLibrary")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ExifLibrary")]
[assembly: AssemblyCopyright("Copyright © 2009")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// The AllowPartiallyTrustedCallersAttribute requires the assembly to be signed with a strong name key.
// This attribute is necessary since the control is called by either an intranet or Internet
// Web page that should be running under restricted permissions.
[assembly: AllowPartiallyTrustedCallers()]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("5227932c-ad04-4aad-b584-f7be2902a4e0")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("0.18.0.0")]
[assembly: AssemblyFileVersion("0.18.0.0")]
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/TIFFFile.cs 0000664 0000000 0000000 00000024500 14462226067 0024427 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.IO;
using System.ComponentModel;
namespace ExifLibrary
{
///
/// Represents the binary view of a TIFF file.
///
public class TIFFFile : ImageFile
{
#region White List
///
/// The whitelist of tags to keep.
///
private static Dictionary WhiteList = new Dictionary()
{
{ ExifTag.BitsPerSample, false },
{ ExifTag.CellLength, false },
{ ExifTag.CellWidth, false },
{ ExifTag.ColorMap, false },
{ ExifTag.Compression, false },
{ ExifTag.DotRange, false },
{ ExifTag.ExtraSamples, false },
{ ExifTag.FillOrder, false },
{ ExifTag.FreeByteCounts, false },
{ ExifTag.FreeOffsets, false },
{ ExifTag.GrayResponseCurve, false },
{ ExifTag.GrayResponseUnit, false },
{ ExifTag.HalftoneHints, false },
{ ExifTag.ImageLength, false },
{ ExifTag.ImageWidth, false },
{ ExifTag.InkNames, false },
{ ExifTag.InkSet, false },
{ ExifTag.JPEGACTables, false },
{ ExifTag.JPEGDCTables, false },
{ ExifTag.JPEGInterchangeFormat, false },
{ ExifTag.JPEGInterchangeFormatLength, false },
{ ExifTag.JPEGLosslessPredictors, false },
{ ExifTag.JPEGPointTransforms, false },
{ ExifTag.JPEGProc, false },
{ ExifTag.JPEGQTables, false },
{ ExifTag.JPEGRestartInterval, false },
{ ExifTag.MaxSampleValue, false },
{ ExifTag.MinSampleValue, false },
{ ExifTag.NewSubfileType, false },
{ ExifTag.NumberOfInks, false },
{ ExifTag.Orientation, false },
{ ExifTag.PhotometricInterpretation, false },
{ ExifTag.PlanarConfiguration, false },
{ ExifTag.Predictor, false },
{ ExifTag.PrimaryChromaticities, false },
{ ExifTag.ReferenceBlackWhite, false },
{ ExifTag.ResolutionUnit, false },
{ ExifTag.RowsPerStrip, false },
{ ExifTag.SampleFormat, false },
{ ExifTag.SamplesPerPixel, false },
{ ExifTag.SMaxSampleValue, false },
{ ExifTag.SMinSampleValue, false },
{ ExifTag.StripByteCounts, false },
{ ExifTag.StripOffsets, false },
{ ExifTag.SubfileType, false },
{ ExifTag.T4Options, false },
{ ExifTag.T6Options, false },
{ ExifTag.Threshholding, false },
{ ExifTag.TileByteCounts, false },
{ ExifTag.TileLength, false },
{ ExifTag.TileOffsets, false },
{ ExifTag.TileWidth, false },
{ ExifTag.TransferFunction, false },
{ ExifTag.TransferRange, false },
{ ExifTag.WhitePoint, false },
{ ExifTag.XPosition, false },
{ ExifTag.XResolution, false },
{ ExifTag.YCbCrCoefficients, false },
{ ExifTag.YCbCrPositioning, false },
{ ExifTag.YCbCrSubSampling, false },
{ ExifTag.YPosition, false },
{ ExifTag.YResolution, false },
};
#endregion
#region Properties
///
/// Gets the TIFF header.
///
public TIFFHeader TIFFHeader { get; private set; }
///
/// Gets the image file directories.
///
public List IFDs { get; private set; }
#endregion
#region Constructor
///
/// Initializes a new instance of the class from the
/// specified data stream.
///
/// A that contains image data.
/// The encoding to be used for text metadata when the source encoding is unknown.
protected internal TIFFFile(Stream stream, System.Text.Encoding encoding)
{
Format = ImageFileFormat.TIFF;
IFDs = new List();
Encoding = encoding;
// Read the entire stream
byte[] data = Utility.GetStreamBytes(stream);
// Read the TIFF header
TIFFHeader = TIFFHeader.FromBytes(data, 0);
uint nextIFDOffset = TIFFHeader.IFDOffset;
if (nextIFDOffset == 0)
throw new NotValidTIFFileException("The first IFD offset is zero.");
// Read IFDs in order
while (nextIFDOffset != 0)
{
ImageFileDirectory ifd = ImageFileDirectory.FromBytes(data, nextIFDOffset, TIFFHeader.ByteOrder);
nextIFDOffset = ifd.NextIFDOffset;
IFDs.Add(ifd);
}
// Process IFDs
// TODO: Add support for multiple frames
foreach (ImageFileDirectoryEntry field in IFDs[0].Fields)
{
Properties.Add(ExifPropertyFactory.Get(field.Tag, field.Type, field.Count, field.Data, BitConverterEx.SystemByteOrder, IFD.Zeroth, Encoding));
}
}
#endregion
#region Instance Methods
///
/// Decreases file size by removing all metadata.
///
public override void Crush()
{
Properties.Clear();
// Remove tags.
foreach (ImageFileDirectory ifd in IFDs)
{
ifd.Fields.RemoveAll((field) =>
{
return (!WhiteList.ContainsKey((ExifTag)field.Tag));
});
}
}
///
/// Saves the to the given stream.
///
/// The data stream used to save the image.
public override void Save(Stream stream)
{
BitConverterEx conv = BitConverterEx.SystemEndian;
// Write TIFF header
uint ifdoffset = 8;
// Byte order
stream.Write((BitConverterEx.SystemByteOrder == BitConverterEx.ByteOrder.LittleEndian ? new byte[] { 0x49, 0x49 } : new byte[] { 0x4D, 0x4D }), 0, 2);
// TIFF ID
stream.Write(conv.GetBytes((ushort)42), 0, 2);
// Offset to 0th IFD, will be corrected below
stream.Write(conv.GetBytes(ifdoffset), 0, 4);
// Write IFD sections
for (int i = 0; i < IFDs.Count; i++)
{
ImageFileDirectory ifd = IFDs[i];
// Save the location of IFD offset
long ifdLocation = stream.Position - 4;
// Write strips first
byte[] stripOffsets = new byte[4 * ifd.Strips.Count];
byte[] stripLengths = new byte[4 * ifd.Strips.Count];
uint stripOffset = ifdoffset;
for (int j = 0; j < ifd.Strips.Count; j++)
{
byte[] stripData = ifd.Strips[j].Data;
byte[] oBytes = BitConverter.GetBytes(stripOffset);
byte[] lBytes = BitConverter.GetBytes((uint)stripData.Length);
Array.Copy(oBytes, 0, stripOffsets, 4 * j, 4);
Array.Copy(lBytes, 0, stripLengths, 4 * j, 4);
stream.Write(stripData, 0, stripData.Length);
stripOffset += (uint)stripData.Length;
}
// Remove old strip tags
for (int j = ifd.Fields.Count - 1; j > 0; j--)
{
ushort tag = ifd.Fields[j].Tag;
if (tag == 273 || tag == 279)
ifd.Fields.RemoveAt(j);
}
// Write new strip tags
ifd.Fields.Add(new ImageFileDirectoryEntry(273, 4, (uint)ifd.Strips.Count, stripOffsets));
ifd.Fields.Add(new ImageFileDirectoryEntry(279, 4, (uint)ifd.Strips.Count, stripLengths));
// Write fields after strips
ifdoffset = stripOffset;
// Correct IFD offset
long currentLocation = stream.Position;
stream.Seek(ifdLocation, SeekOrigin.Begin);
stream.Write(conv.GetBytes(ifdoffset), 0, 4);
stream.Seek(currentLocation, SeekOrigin.Begin);
// Offset to field data
uint dataOffset = ifdoffset + 2 + (uint)ifd.Fields.Count * 12 + 4;
// Field count
stream.Write(conv.GetBytes((ushort)ifd.Fields.Count), 0, 2);
// Fields
foreach (ImageFileDirectoryEntry field in ifd.Fields)
{
// Tag
stream.Write(conv.GetBytes(field.Tag), 0, 2);
// Type
stream.Write(conv.GetBytes(field.Type), 0, 2);
// Count
stream.Write(conv.GetBytes(field.Count), 0, 4);
// Field data
byte[] data = field.Data;
if (data.Length <= 4)
{
stream.Write(data, 0, data.Length);
for (int j = data.Length; j < 4; j++)
stream.WriteByte(0);
}
else
{
stream.Write(conv.GetBytes(dataOffset), 0, 4);
long currentOffset = stream.Position;
stream.Seek(dataOffset, SeekOrigin.Begin);
stream.Write(data, 0, data.Length);
dataOffset += (uint)data.Length;
stream.Seek(currentOffset, SeekOrigin.Begin);
}
}
// Offset to next IFD
ifdoffset = dataOffset;
stream.Write(conv.GetBytes(i == IFDs.Count - 1 ? 0 : ifdoffset), 0, 4);
}
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/TIFFHeader.cs 0000664 0000000 0000000 00000006314 14462226067 0024743 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents a TIFF Header.
///
public struct TIFFHeader
{
///
/// The byte order of the image file.
///
public BitConverterEx.ByteOrder ByteOrder;
///
/// TIFF ID. This value should always be 42.
///
public byte ID;
///
/// The offset to the first IFD section from the
/// start of the TIFF header.
///
public uint IFDOffset;
///
/// The byte order of the TIFF header itself.
///
public BitConverterEx.ByteOrder TIFFHeaderByteOrder;
///
/// Initializes a new instance of the struct.
///
/// The byte order.
/// The TIFF ID. This value should always be 42.
/// The offset to the first IFD section from the
/// start of the TIFF header.
/// The byte order of the TIFF header itself.
public TIFFHeader(BitConverterEx.ByteOrder byteOrder, byte id, uint ifdOffset, BitConverterEx.ByteOrder headerByteOrder)
{
if (id != 42)
throw new NotValidTIFFHeader();
ByteOrder = byteOrder;
ID = id;
IFDOffset = ifdOffset;
TIFFHeaderByteOrder = headerByteOrder;
}
///
/// Returns a initialized from the given byte data.
///
/// The data.
/// The offset into .
/// A initialized from the given byte data.
public static TIFFHeader FromBytes(byte[] data, int offset)
{
TIFFHeader header = new TIFFHeader();
// TIFF header
if (data[offset] == 0x49 && data[offset + 1] == 0x49)
header.ByteOrder = BitConverterEx.ByteOrder.LittleEndian;
else if (data[offset] == 0x4D && data[offset + 1] == 0x4D)
header.ByteOrder = BitConverterEx.ByteOrder.BigEndian;
else
throw new NotValidTIFFHeader();
// TIFF header may have a different byte order
if (BitConverterEx.LittleEndian.ToUInt16(data, offset + 2) == 42)
header.TIFFHeaderByteOrder = BitConverterEx.ByteOrder.LittleEndian;
else if (BitConverterEx.BigEndian.ToUInt16(data, offset + 2) == 42)
header.TIFFHeaderByteOrder = BitConverterEx.ByteOrder.BigEndian;
else
throw new NotValidTIFFHeader();
header.ID = 42;
// IFD offset
header.IFDOffset = BitConverterEx.ToUInt32(data, offset + 4, header.TIFFHeaderByteOrder, BitConverterEx.SystemByteOrder);
return header;
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/TIFFStrip.cs 0000664 0000000 0000000 00000001651 14462226067 0024653 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
namespace ExifLibrary
{
///
/// Represents a strip of compressed image data in a TIFF file.
///
public class TIFFStrip
{
///
/// Compressed image data contained in this strip.
///
public byte[] Data { get; private set; }
///
/// Initializes a new instance of the class.
///
/// The byte array to copy strip from.
/// The offset to the beginning of strip.
/// The length of strip.
public TIFFStrip(byte[] data, uint offset, uint length)
{
Data = new byte[length];
Array.Copy(data, offset, Data, 0, length);
}
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/Utility.cs 0000664 0000000 0000000 00000017013 14462226067 0024543 0 ustar 00root root 0000000 0000000 using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Security.Cryptography;
using System.IO.Compression;
namespace ExifLibrary
{
///
/// Contains utility functions.
///
public class Utility
{
#region File I/O
///
/// Reads the entire stream and returns its contents as a byte array.
///
/// The to read.
/// Contents of the as a byte array.
public static byte[] GetStreamBytes(Stream stream)
{
using (MemoryStream mem = new MemoryStream())
{
stream.Seek(0, SeekOrigin.Begin);
byte[] b = new byte[32768];
int r;
while ((r = stream.Read(b, 0, b.Length)) > 0)
mem.Write(b, 0, r);
return mem.ToArray();
}
}
///
/// Reads the stream into the given byte array.
///
/// The to read.
/// The number of bytes to read.
/// Contents of the as a byte array.
public static byte[] GetStreamBytes(Stream stream, long rem)
{
using (MemoryStream mem = new MemoryStream())
{
byte[] b = new byte[32768];
int r;
while (rem > 0 && (r = stream.Read(b, 0, (int)Math.Min(rem, b.LongLength))) > 0)
{
mem.Write(b, 0, r);
rem = rem - r;
}
return mem.ToArray();
}
}
#endregion
#region Crypto
public static class CRC32
{
// Table of CRCs of all 8-bit messages.
private static ulong[] table = null;
///
/// Make the table for a fast CRC.
///
private static void Initialize()
{
table = new ulong[256];
for (int n = 0; n < 256; n++)
{
ulong c = (ulong)n;
for (int k = 0; k < 8; k++)
{
if ((c & 1) != 0)
c = 0xedb88320L ^ (c >> 1);
else
c = c >> 1;
}
table[n] = c;
}
}
///
/// Updates a running CRC with the given bytes. The CRC
/// should be initialized to all 1's, and the transmitted value
/// is the 1's complement of the final running CRC (see the
/// CRC routine below).
///
/// Initial CRC.
/// The bytes to calculate the CRC of.
/// Checksum as 1's complement of the final running CRC.
private static ulong UpdateCRC(ulong crc, byte[] buffer)
{
ulong c = crc;
if (table == null)
Initialize();
for (int n = 0; n < buffer.Length; n++)
{
c = table[(c ^ buffer[n]) & 0xff] ^ (c >> 8);
}
return c;
}
///
/// Return the CRC of the given bytes.
///
/// The bytes to calculate the CRC of.
/// CRC checksum.
public static ulong CRC(byte[] buffer)
{
return UpdateCRC(0xffffffffL, buffer) ^ 0xffffffffL;
}
///
/// Return the CRC of the given bytes.
///
/// Initial CRC.
/// The bytes to calculate the CRC of.
/// CRC checksum.
public static ulong Hash(ulong crc, byte[] buffer)
{
crc ^= 0xffffffffL;
return UpdateCRC(crc, buffer) ^ 0xffffffffL;
}
}
#endregion
#region Compression
///
/// Compresses the given string.
///
/// Input string.
/// Text encoding.
/// The compressed bytes.
public static byte[] CompressString(String text, Encoding encoding)
{
using (MemoryStream stream = new MemoryStream())
using (DeflateStream zip = new DeflateStream(stream, CompressionMode.Compress))
using (StreamWriter writer = new StreamWriter(zip, encoding))
{
writer.Write(text);
return stream.ToArray();
}
}
///
/// Compresses the given bytes representing a string.
///
/// Input data.
/// Text encoding.
/// The decompressed string.
public static string DecompressString(byte[] input, Encoding encoding)
{
using (MemoryStream stream = new MemoryStream(input))
{
//stream.Seek(2, SeekOrigin.Begin); // Skip zlib flags
int b1 = stream.ReadByte();
int b2 = stream.ReadByte();
using (DeflateStream zip = new DeflateStream(stream, CompressionMode.Decompress))
using (StreamReader reader = new StreamReader(zip, encoding))
{
return reader.ReadToEnd();
}
}
}
#endregion
#region Arrays
///
/// Splits the given byte array at seperators.
///
/// Input array.
/// Separator byte.
/// Sub arrays splitted at the separator.
public static List SplitByteArray(byte[] data, byte seperator)
{
List output = new List();
long lastSepIndex = -1;
long sepIndex = -1;
for (long i = 0; i < data.LongLength; i++)
{
if (data[i] == seperator)
{
sepIndex = i;
byte[] subArray = new byte[sepIndex - (lastSepIndex + 1)];
Array.Copy(data, lastSepIndex + 1, subArray, 0, subArray.LongLength);
lastSepIndex = sepIndex;
output.Add(subArray);
}
}
if (lastSepIndex < data.LongLength - 1)
{
sepIndex = data.LongLength - 1;
byte[] subArray = new byte[sepIndex - (lastSepIndex + 1)];
Array.Copy(data, lastSepIndex + 1, subArray, 0, subArray.LongLength);
lastSepIndex = sepIndex;
output.Add(subArray);
}
return output;
}
#endregion
}
}
quickroute-linux-upstream-2.5/3rdparty/ExifLibrary/app.config 0000664 0000000 0000000 00000000105 14462226067 0024512 0 ustar 00root root 0000000 0000000
quickroute-linux-upstream-2.5/3rdparty/PowerCollections/ 0000775 0000000 0000000 00000000000 14462226067 0023622 5 ustar 00root root 0000000 0000000 quickroute-linux-upstream-2.5/3rdparty/PowerCollections/Algorithms.cs 0000664 0000000 0000000 00001051676 14462226067 0026302 0 ustar 00root root 0000000 0000000 //******************************
// Written by Peter Golde
// Copyright (c) 2004-2007, Wintellect
//
// Use and restribution of this code is subject to the license agreement
// contained in the file "License.txt" accompanying this file.
//******************************
using System;
using System.Collections;
using System.Collections.Generic;
#pragma warning disable 419 // Ambigious cref in XML comment
// Everything should be CLS compliant.
[assembly: CLSCompliant(true)]
namespace Wintellect.PowerCollections
{
///
/// The BinaryPredicate delegate type encapsulates a method that takes two
/// items of the same type, and returns a boolean value representating
/// some relationship between them. For example, checking whether two
/// items are equal or equivalent is one kind of binary predicate.
///
/// The first item.
/// The second item.
/// Whether item1 and item2 satisfy the relationship that the BinaryPredicate defines.
public delegate bool BinaryPredicate(T item1, T item2);
///
/// Algorithms contains a number of static methods that implement
/// algorithms that work on collections. Most of the methods deal with
/// the standard generic collection interfaces such as IEnumerable<T>,
/// ICollection<T> and IList<T>.
///
public static class Algorithms
{
#region Collection wrappers
///
/// The class that is used to implement IList<T> to view a sub-range
/// of a list. The object stores a wrapped list, and a start/count indicating
/// a sub-range of the list. Insertion/deletions through the sub-range view
/// cause the count to change also; insertions and deletions directly on
/// the wrapped list do not.
///
[Serializable]
private class ListRange : ListBase, ICollection
{
private readonly IList wrappedList;
private readonly int start;
private int count;
///
/// Create a sub-range view object on the indicate part
/// of the list.
///
/// List to wrap.
/// The start index of the view in the wrapped list.
/// The number of items in the view.
public ListRange(IList wrappedList, int start, int count)
{
this.wrappedList = wrappedList;
this.start = start;
this.count = count;
}
public override int Count
{
get {
return Math.Min(count, wrappedList.Count - start);
}
}
public override void Clear()
{
if (wrappedList.Count - start < count)
count = wrappedList.Count - start;
while (count > 0) {
wrappedList.RemoveAt(start + count - 1);
--count;
}
}
public override void Insert(int index, T item)
{
if (index < 0 || index > count)
throw new ArgumentOutOfRangeException("index");
wrappedList.Insert(start + index, item);
++count;
}
public override void RemoveAt(int index)
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index");
wrappedList.RemoveAt(start + index);
--count;
}
public override bool Remove(T item)
{
if (wrappedList.IsReadOnly)
throw new NotSupportedException(string.Format(Strings.CannotModifyCollection, "Range"));
else
return base.Remove(item);
}
public override T this[int index]
{
get
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index");
return wrappedList[start + index];
}
set
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index");
wrappedList[start + index] = value;
}
}
bool ICollection.IsReadOnly
{
get
{
return wrappedList.IsReadOnly;
}
}
}
///
/// Returns a view onto a sub-range of a list. Items from are not copied; the
/// returned IList<T> is simply a different view onto the same underlying items. Changes to
/// are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the
/// view, but insertions and deletions in the underlying list do not.
///
/// This method can be used to apply an algorithm to a portion of a list. For example:
/// Algorithms.ReverseInPlace(Algorithms.Range(list, 3, 6))
/// will reverse the 6 items beginning at index 3.
/// The type of the items in the list.
/// The list to view.
/// The starting index of the view.
/// The number of items in the view.
/// A list that is a view onto the given sub-list.
/// is null.
/// or is negative.
/// + is greater than the
/// size of .
public static IList Range(IList list, int start, int count)
{
if (list == null)
throw new ArgumentOutOfRangeException("list");
if (start < 0 || start > list.Count || (start == list.Count && count != 0))
throw new ArgumentOutOfRangeException("start");
if (count < 0 || count > list.Count || count + start > list.Count)
throw new ArgumentOutOfRangeException("count");
return new ListRange(list, start, count);
}
///
/// The class that is used to implement IList<T> to view a sub-range
/// of an array. The object stores a wrapped array, and a start/count indicating
/// a sub-range of the array. Insertion/deletions through the sub-range view
/// cause the count to change up to the size of the underlying array. Elements
/// fall off the end of the underlying array.
///
[Serializable]
private class ArrayRange : ListBase
{
private readonly T[] wrappedArray;
private readonly int start;
private int count;
///
/// Create a sub-range view object on the indicate part
/// of the array.
///
/// Array to wrap.
/// The start index of the view in the wrapped list.
/// The number of items in the view.
public ArrayRange(T[] wrappedArray, int start, int count)
{
this.wrappedArray = wrappedArray;
this.start = start;
this.count = count;
}
public override int Count
{
get
{
return count;
}
}
public override void Clear()
{
Array.Copy(wrappedArray, start + count, wrappedArray, start, wrappedArray.Length - (start + count));
Algorithms.FillRange(wrappedArray, wrappedArray.Length - count, count, default(T));
count = 0;
}
public override void Insert(int index, T item)
{
if (index < 0 || index > count)
throw new ArgumentOutOfRangeException("index");
int i = start + index;
if (i + 1 < wrappedArray.Length)
Array.Copy(wrappedArray, i, wrappedArray, i + 1, wrappedArray.Length - i - 1);
if (i < wrappedArray.Length)
wrappedArray[i] = item;
if (start + count < wrappedArray.Length)
++count;
}
public override void RemoveAt(int index)
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index");
int i = start + index;
if (i < wrappedArray.Length - 1)
Array.Copy(wrappedArray, i + 1, wrappedArray, i, wrappedArray.Length - i - 1);
wrappedArray[wrappedArray.Length - 1] = default(T);
--count;
}
public override T this[int index]
{
get
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index");
return wrappedArray[start + index];
}
set
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index");
wrappedArray[start + index] = value;
}
}
}
///
/// Returns a view onto a sub-range of an array. Items from are not copied; the
/// returned IList<T> is simply a different view onto the same underlying items. Changes to
/// are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the
/// view. After an insertion, the last item in "falls off the end". After a deletion, the
/// last item in array becomes the default value (0 or null).
///
/// This method can be used to apply an algorithm to a portion of a array. For example:
/// Algorithms.ReverseInPlace(Algorithms.Range(array, 3, 6))
/// will reverse the 6 items beginning at index 3.
/// The array to view.
/// The starting index of the view.
/// The number of items in the view.
/// A list that is a view onto the given sub-array.
/// is null.
/// or is negative.
/// + is greater than the
/// size of .
public static IList Range(T[] array, int start, int count)
{
if (array == null)
throw new ArgumentOutOfRangeException("array");
if (start < 0 || start > array.Length || (start == array.Length && count != 0))
throw new ArgumentOutOfRangeException("start");
if (count < 0 || count > array.Length || count + start > array.Length)
throw new ArgumentOutOfRangeException("count");
return new ArrayRange(array, start, count);
}
///
/// The read-only ICollection<T> implementation that is used by the ReadOnly method.
/// Methods that modify the collection throw a NotSupportedException, methods that don't
/// modify are fowarded through to the wrapped collection.
///
[Serializable]
private class ReadOnlyCollection : ICollection
{
private readonly ICollection wrappedCollection; // The collection we are wrapping (never null).
///
/// Create a ReadOnlyCollection wrapped around the given collection.
///
/// Collection to wrap.
public ReadOnlyCollection(ICollection wrappedCollection)
{
this.wrappedCollection = wrappedCollection;
}
///
/// Throws an NotSupportedException stating that this collection cannot be modified.
///
private static void MethodModifiesCollection()
{
throw new NotSupportedException(string.Format(Strings.CannotModifyCollection, "read-only collection"));
}
public IEnumerator GetEnumerator()
{ return wrappedCollection.GetEnumerator(); }
IEnumerator IEnumerable.GetEnumerator()
{ return ((IEnumerable)wrappedCollection).GetEnumerator(); }
public bool Contains(T item)
{ return wrappedCollection.Contains(item); }
public void CopyTo(T[] array, int arrayIndex)
{ wrappedCollection.CopyTo(array, arrayIndex); }
public int Count
{
get { return wrappedCollection.Count; }
}
public bool IsReadOnly
{
get { return true; }
}
public void Add(T item)
{ MethodModifiesCollection(); }
public void Clear()
{ MethodModifiesCollection(); }
public bool Remove(T item)
{ MethodModifiesCollection(); return false; }
}
///
/// Returns a read-only view onto a collection. The returned ICollection<T> interface
/// only allows operations that do not change the collection: GetEnumerator, Contains, CopyTo,
/// Count. The ReadOnly property returns false, indicating that the collection is read-only. All other
/// methods on the interface throw a NotSupportedException.
///
/// The data in the underlying collection is not copied. If the underlying
/// collection is changed, then the read-only view also changes accordingly.
/// The type of items in the collection.
/// The collection to wrap.
/// A read-only view onto . If is null, then null is returned.
public static ICollection ReadOnly(ICollection collection)
{
if (collection == null)
return null;
else
return new ReadOnlyCollection(collection);
}
///
/// The read-only IList<T> implementation that is used by the ReadOnly method.
/// Methods that modify the list throw a NotSupportedException, methods that don't
/// modify are fowarded through to the wrapped list.
///
[Serializable]
private class ReadOnlyList : IList
{
private readonly IList wrappedList; // The list we are wrapping (never null).
///
/// Create a ReadOnlyList wrapped around the given list.
///
/// List to wrap.
public ReadOnlyList(IList wrappedList)
{
this.wrappedList = wrappedList;
}
///
/// Throws an NotSupportedException stating that this collection cannot be modified.
///
private static void MethodModifiesCollection()
{
throw new NotSupportedException(string.Format(Strings.CannotModifyCollection, "read-only list"));
}
public IEnumerator GetEnumerator()
{ return wrappedList.GetEnumerator(); }
IEnumerator IEnumerable.GetEnumerator()
{ return ((IEnumerable)wrappedList).GetEnumerator(); }
public int IndexOf(T item)
{ return wrappedList.IndexOf(item); }
public bool Contains(T item)
{ return wrappedList.Contains(item); }
public void CopyTo(T[] array, int arrayIndex)
{ wrappedList.CopyTo(array, arrayIndex); }
public int Count
{
get { return wrappedList.Count; }
}
public bool IsReadOnly
{
get { return true; }
}
public T this[int index]
{
get { return wrappedList[index]; }
set { MethodModifiesCollection(); }
}
public void Add(T item)
{ MethodModifiesCollection(); }
public void Clear()
{ MethodModifiesCollection(); }
public void Insert(int index, T item)
{ MethodModifiesCollection(); }
public void RemoveAt(int index)
{ MethodModifiesCollection(); }
public bool Remove(T item)
{ MethodModifiesCollection(); return false; }
}
///
/// Returns a read-only view onto a list. The returned IList<T> interface
/// only allows operations that do not change the list: GetEnumerator, Contains, CopyTo,
/// Count, IndexOf, and the get accessor of the indexer.
/// The IsReadOnly property returns true, indicating that the list is read-only. All other
/// methods on the interface throw a NotSupportedException.
///
/// The data in the underlying list is not copied. If the underlying
/// list is changed, then the read-only view also changes accordingly.
/// The type of items in the list.
/// The list to wrap.
/// A read-only view onto . Returns null if is null.
/// If is already read-only, returns .
public static IList ReadOnly(IList list)
{
if (list == null)
return null;
else if (list.IsReadOnly)
return list;
else
return new ReadOnlyList(list);
}
///
/// The private class that implements a read-only wrapped for
/// IDictionary <TKey,TValue>.
///
[Serializable]
private class ReadOnlyDictionary : IDictionary
{
// The dictionary that is wrapped
private readonly IDictionary wrappedDictionary;
///
/// Create a read-only dictionary wrapped around the given dictionary.
///
/// The IDictionary<TKey,TValue> to wrap.
public ReadOnlyDictionary(IDictionary wrappedDictionary)
{
this.wrappedDictionary = wrappedDictionary;
}
///
/// Throws an NotSupportedException stating that this collection cannot be modified.
///
private static void MethodModifiesCollection()
{
throw new NotSupportedException(string.Format(Strings.CannotModifyCollection, "read-only dictionary"));
}
public void Add(TKey key, TValue value)
{ MethodModifiesCollection(); }
public bool ContainsKey(TKey key)
{ return wrappedDictionary.ContainsKey(key); }
public ICollection Keys
{
get { return ReadOnly(wrappedDictionary.Keys); }
}
public ICollection Values
{
get { return ReadOnly(wrappedDictionary.Values); }
}
public bool Remove(TKey key)
{
MethodModifiesCollection();
return false; // never reached
}
public bool TryGetValue(TKey key, out TValue value)
{ return wrappedDictionary.TryGetValue(key, out value); }
public TValue this[TKey key]
{
get { return wrappedDictionary[key];}
set { MethodModifiesCollection(); }
}
public void Add(KeyValuePair item)
{ MethodModifiesCollection(); }
public void Clear()
{ MethodModifiesCollection(); }
public bool Contains(KeyValuePair item)
{ return wrappedDictionary.Contains(item); }
public void CopyTo(KeyValuePair[] array, int arrayIndex)
{ wrappedDictionary.CopyTo(array, arrayIndex); }
public int Count
{
get { return wrappedDictionary.Count; }
}
public bool IsReadOnly
{
get { return true; }
}
public bool Remove(KeyValuePair item)
{
MethodModifiesCollection();
return false; // never reached
}
public IEnumerator> GetEnumerator()
{ return wrappedDictionary.GetEnumerator(); }
IEnumerator IEnumerable.GetEnumerator()
{ return ((IEnumerable)wrappedDictionary).GetEnumerator(); }
}
///
/// Returns a read-only view onto a dictionary. The returned IDictionary<TKey,TValue> interface
/// only allows operations that do not change the dictionary.
/// The IsReadOnly property returns true, indicating that the dictionary is read-only. All other
/// methods on the interface throw a NotSupportedException.
///
/// The data in the underlying dictionary is not copied. If the underlying
/// dictionary is changed, then the read-only view also changes accordingly.
/// The dictionary to wrap.
/// A read-only view onto . Returns null if is null.
/// If is already read-only, returns .
public static IDictionary ReadOnly(IDictionary dictionary)
{
if (dictionary == null)
return null;
else if (dictionary.IsReadOnly)
return dictionary;
else
return new ReadOnlyDictionary(dictionary);
}
///
/// The class that provides a typed IEnumerator<T>
/// view onto an untyped IEnumerator interface.
///
[Serializable]
private class TypedEnumerator : IEnumerator
{
private readonly IEnumerator wrappedEnumerator;
///
/// Create a typed IEnumerator<T>
/// view onto an untyped IEnumerator interface
///
/// IEnumerator to wrap.
public TypedEnumerator(IEnumerator wrappedEnumerator)
{
this.wrappedEnumerator = wrappedEnumerator;
}
T IEnumerator.Current
{
get { return (T) wrappedEnumerator.Current; }
}
void IDisposable.Dispose()
{
if (wrappedEnumerator is IDisposable)
((IDisposable)wrappedEnumerator).Dispose();
}
object IEnumerator.Current
{
get { return wrappedEnumerator.Current; }
}
bool IEnumerator.MoveNext()
{
return wrappedEnumerator.MoveNext();
}
void IEnumerator.Reset()
{
wrappedEnumerator.Reset();
}
}
///
/// The class that provides a typed IEnumerable<T> view
/// onto an untyped IEnumerable interface.
///
[Serializable]
private class TypedEnumerable : IEnumerable
{
private readonly IEnumerable wrappedEnumerable;
///
/// Create a typed IEnumerable<T> view
/// onto an untyped IEnumerable interface.
///
/// IEnumerable interface to wrap.
public TypedEnumerable(IEnumerable wrappedEnumerable)
{
this.wrappedEnumerable = wrappedEnumerable;
}
public IEnumerator GetEnumerator()
{
return new TypedEnumerator(wrappedEnumerable.GetEnumerator());
}
IEnumerator IEnumerable.GetEnumerator()
{
return wrappedEnumerable.GetEnumerator();
}
}
///
/// Given a non-generic IEnumerable interface, wrap a generic IEnumerable<T>
/// interface around it. The generic interface will enumerate the same objects as the
/// underlying non-generic collection, but can be used in places that require a generic interface.
/// The underlying non-generic collection must contain only items that
/// are of type or a type derived from it. This method is useful
/// when interfacing older, non-generic collections to newer code that uses generic interfaces.
///
/// Some collections implement both generic and non-generic interfaces. For efficiency,
/// this method will first attempt to cast to IEnumerable<T>.
/// If that succeeds, it is returned; otherwise, a wrapper object is created.
/// The item type of the wrapper collection.
/// An untyped collection. This collection should only contain
/// items of type or a type derived from it.
/// A generic IEnumerable<T> wrapper around .
/// If is null, then null is returned.
public static IEnumerable TypedAs(IEnumerable untypedCollection)
{
if (untypedCollection == null)
return null;
else if (untypedCollection is IEnumerable)
return (IEnumerable)untypedCollection;
else
return new TypedEnumerable(untypedCollection);
}
///
/// The class that provides a typed ICollection<T> view
/// onto an untyped ICollection interface. The ICollection<T>
/// is read-only.
///
[Serializable]
private class TypedCollection : ICollection
{
private readonly ICollection wrappedCollection;
///
/// Create a typed ICollection<T> view
/// onto an untyped ICollection interface.
///
/// ICollection interface to wrap.
public TypedCollection(ICollection wrappedCollection)
{
this.wrappedCollection = wrappedCollection;
}
///
/// Throws an NotSupportedException stating that this collection cannot be modified.
///
private static void MethodModifiesCollection()
{
throw new NotSupportedException(string.Format(Strings.CannotModifyCollection, "strongly-typed Collection"));
}
public void Add(T item)
{ MethodModifiesCollection(); }
public void Clear()
{ MethodModifiesCollection(); }
public bool Remove(T item)
{ MethodModifiesCollection(); return false; }
public bool Contains(T item)
{
IEqualityComparer equalityComparer = EqualityComparer.Default;
foreach (object obj in wrappedCollection) {
if (obj is T && equalityComparer.Equals(item, (T)obj))
return true;
}
return false;
}
public void CopyTo(T[] array, int arrayIndex)
{ wrappedCollection.CopyTo(array, arrayIndex); }
public int Count
{
get { return wrappedCollection.Count; }
}
public bool IsReadOnly
{
get { return true; }
}
public IEnumerator GetEnumerator()
{ return new TypedEnumerator(wrappedCollection.GetEnumerator()); }
IEnumerator IEnumerable.GetEnumerator()
{ return wrappedCollection.GetEnumerator(); }
}
///
/// Given a non-generic ICollection interface, wrap a generic ICollection<T>
/// interface around it. The generic interface will enumerate the same objects as the
/// underlying non-generic collection, but can be used in places that require a generic interface.
/// The underlying non-generic collection must contain only items that
/// are of type or a type derived from it. This method is useful
/// when interfacing older, non-generic collections to newer code that uses generic interfaces.
///
/// Some collections implement both generic and non-generic interfaces. For efficiency,
/// this method will first attempt to cast to ICollection<T>.
/// If that succeeds, it is returned; otherwise, a wrapper object is created.
/// Unlike the generic interface, the non-generic ICollection interfaces does
/// not contain methods for adding or removing items from the collection. For this reason,
/// the returned ICollection<T> will be read-only.
/// The item type of the wrapper collection.
/// An untyped collection. This collection should only contain
/// items of type or a type derived from it.
/// A generic ICollection<T> wrapper around .
/// If is null, then null is returned.
public static ICollection TypedAs(ICollection untypedCollection)
{
if (untypedCollection == null)
return null;
else if (untypedCollection is ICollection)
return (ICollection) untypedCollection;
else
return new TypedCollection(untypedCollection);
}
///
/// The class used to create a typed IList<T> view onto
/// an untype IList interface.
///
[Serializable]
private class TypedList : IList
{
private readonly IList wrappedList;
///
/// Create a typed IList<T> view onto
/// an untype IList interface.
///
/// The IList to wrap.
public TypedList(IList wrappedList)
{
this.wrappedList = wrappedList;
}
public IEnumerator GetEnumerator()
{ return new TypedEnumerator(wrappedList.GetEnumerator()); }
IEnumerator IEnumerable.GetEnumerator()
{ return wrappedList.GetEnumerator(); }
public int IndexOf(T item)
{ return wrappedList.IndexOf(item); }
public void Insert(int index, T item)
{ wrappedList.Insert(index, item); }
public void RemoveAt(int index)
{ wrappedList.RemoveAt(index); }
public void Add(T item)
{ wrappedList.Add(item); }
public void Clear()
{ wrappedList.Clear(); }
public bool Contains(T item)
{ return wrappedList.Contains(item); }
public void CopyTo(T[] array, int arrayIndex)
{ wrappedList.CopyTo(array, arrayIndex); }
public T this[int index]
{
get { return (T)wrappedList[index]; }
set { wrappedList[index] = value; }
}
public int Count
{
get { return wrappedList.Count ; }
}
public bool IsReadOnly
{
get { return wrappedList.IsReadOnly; }
}
public bool Remove(T item)
{
if (wrappedList.Contains(item)) {
wrappedList.Remove(item);
return true;
}
else {
return false;
}
}
}
///
/// Given a non-generic IList interface, wrap a generic IList<T>
/// interface around it. The generic interface will enumerate the same objects as the
/// underlying non-generic list, but can be used in places that require a generic interface.
/// The underlying non-generic list must contain only items that
/// are of type or a type derived from it. This method is useful
/// when interfacing older, non-generic lists to newer code that uses generic interfaces.
///
/// Some collections implement both generic and non-generic interfaces. For efficiency,
/// this method will first attempt to cast to IList<T>.
/// If that succeeds, it is returned; otherwise, a wrapper object is created.
/// The item type of the wrapper list.
/// An untyped list. This list should only contain
/// items of type or a type derived from it.
/// A generic IList<T> wrapper around .
/// If is null, then null is returned.
public static IList TypedAs(IList untypedList)
{
if (untypedList == null)
return null;
else if (untypedList is IList)
return (IList)untypedList;
else
return new TypedList(untypedList);
}
///
/// The class that is used to provide an untyped ICollection
/// view onto a typed ICollection<T> interface.
///
[Serializable]
private class UntypedCollection : ICollection
{
private readonly ICollection wrappedCollection;
///
/// Create an untyped ICollection
/// view onto a typed ICollection<T> interface.
///
/// The ICollection<T> to wrap.
public UntypedCollection(ICollection wrappedCollection)
{
this.wrappedCollection = wrappedCollection;
}
public void CopyTo(Array array, int index)
{
if (array == null)
throw new ArgumentNullException("array");
int i = 0;
int count = wrappedCollection.Count;
if (index < 0)
throw new ArgumentOutOfRangeException("index", index, Strings.ArgMustNotBeNegative);
if (index >= array.Length || count > array.Length - index)
throw new ArgumentException("index", Strings.ArrayTooSmall);
foreach (T item in wrappedCollection) {
if (i >= count)
break;
array.SetValue(item, index);
++index;
++i;
}
}
public int Count
{
get { return wrappedCollection.Count; }
}
public bool IsSynchronized
{
get { return false; }
}
public object SyncRoot
{
get { return this; }
}
public IEnumerator GetEnumerator()
{
return ((IEnumerable)wrappedCollection).GetEnumerator();
}
}
///
/// Given a generic ICollection<T> interface, wrap a non-generic (untyped)
/// ICollection interface around it. The non-generic interface will contain the same objects as the
/// underlying generic collection, but can be used in places that require a non-generic interface.
/// This method is useful when interfacing generic interfaces with older code that uses non-generic interfaces.
///
/// Many generic collections already implement the non-generic interfaces directly. This
/// method will first attempt to simply cast to ICollection. If that
/// succeeds, it is returned; if it fails, then a wrapper object is created.
/// The item type of the underlying collection.
/// A typed collection to wrap.
/// A non-generic ICollection wrapper around .
/// If is null, then null is returned.
public static ICollection Untyped(ICollection typedCollection)
{
if (typedCollection == null)
return null;
else if (typedCollection is ICollection)
return (ICollection)typedCollection;
else
return new UntypedCollection(typedCollection);
}
///
/// The class that implements a non-generic IList wrapper
/// around a generic IList<T> interface.
///
[Serializable]
private class UntypedList : IList
{
private readonly IList wrappedList;
///
/// Create a non-generic IList wrapper
/// around a generic IList<T> interface.
///
/// The IList<T> interface to wrap.
public UntypedList(IList wrappedList)
{
this.wrappedList = wrappedList;
}
///
/// Convert the given parameter to T. Throw an ArgumentException
/// if it isn't.
///
/// parameter name
/// parameter value
private static T ConvertToItemType(string name, object value)
{
try {
return (T)value;
}
catch (InvalidCastException) {
throw new ArgumentException(string.Format(Strings.WrongType, value, typeof(T)), name);
}
}
public int Add(object value)
{
// We assume that Add always adds to the end. Is this true?
wrappedList.Add(ConvertToItemType("value", value));
return wrappedList.Count - 1;
}
public void Clear()
{ wrappedList.Clear(); }
public bool Contains(object value)
{
if (value is T)
return wrappedList.Contains((T)value);
else
return false;
}
public int IndexOf(object value)
{
if (value is T)
return wrappedList.IndexOf((T)value);
else
return -1;
}
public void Insert(int index, object value)
{ wrappedList.Insert(index, ConvertToItemType("value", value)); }
public bool IsFixedSize
{
get { return false; }
}
public bool IsReadOnly
{
get { return wrappedList.IsReadOnly; }
}
public void Remove(object value)
{
if (value is T)
wrappedList.Remove((T)value);
}
public void RemoveAt(int index)
{ wrappedList.RemoveAt(index);}
public object this[int index]
{
get { return wrappedList[index]; }
set { wrappedList[index] = ConvertToItemType("value", value); }
}
public void CopyTo(Array array, int index)
{
if (array == null)
throw new ArgumentNullException("array");
int i = 0;
int count = wrappedList.Count;
if (index < 0)
throw new ArgumentOutOfRangeException("index", index, Strings.ArgMustNotBeNegative);
if (index >= array.Length || count > array.Length - index)
throw new ArgumentException("index", Strings.ArrayTooSmall);
foreach (T item in wrappedList) {
if (i >= count)
break;
array.SetValue(item, index);
++index;
++i;
}
}
public int Count
{
get { return wrappedList.Count; }
}
public bool IsSynchronized
{
get { return false; }
}
public object SyncRoot
{
get { return this; }
}
public IEnumerator GetEnumerator()
{ return ((IEnumerable)wrappedList).GetEnumerator(); }
}
///
/// Given a generic IList<T> interface, wrap a non-generic (untyped)
/// IList interface around it. The non-generic interface will contain the same objects as the
/// underlying generic list, but can be used in places that require a non-generic interface.
/// This method is useful when interfacing generic interfaces with older code that uses non-generic interfaces.
///
/// Many generic collections already implement the non-generic interfaces directly. This
/// method will first attempt to simply cast to IList. If that
/// succeeds, it is returned; if it fails, then a wrapper object is created.
/// The item type of the underlying list.
/// A typed list to wrap.
/// A non-generic IList wrapper around .
/// If is null, then null is returned.
public static IList Untyped(IList typedList)
{
if (typedList == null)
return null;
else if (typedList is IList)
return (IList)typedList;
else
return new UntypedList(typedList);
}
///
/// The class that is used to implement IList<T> to view an array
/// in a read-write way. Insertions cause the last item in the array
/// to fall off, deletions replace the last item with the default value.
///
[Serializable]
private class ArrayWrapper : ListBase, IList
{
private readonly T[] wrappedArray;
///
/// Create a list wrapper object on an array.
///
/// Array to wrap.
public ArrayWrapper(T[] wrappedArray)
{
this.wrappedArray = wrappedArray;
}
public override int Count
{
get
{
return wrappedArray.Length;
}
}
public override void Clear()
{
int count = wrappedArray.Length;
for (int i = 0; i < count; ++i)
wrappedArray[i] = default(T);
}
public override void Insert(int index, T item)
{
if (index < 0 || index > wrappedArray.Length)
throw new ArgumentOutOfRangeException("index");
if (index + 1 < wrappedArray.Length)
Array.Copy(wrappedArray, index, wrappedArray, index + 1, wrappedArray.Length - index - 1);
if (index < wrappedArray.Length)
wrappedArray[index] = item;
}
public override void RemoveAt(int index)
{
if (index < 0 || index >= wrappedArray.Length)
throw new ArgumentOutOfRangeException("index");
if (index < wrappedArray.Length - 1)
Array.Copy(wrappedArray, index + 1, wrappedArray, index, wrappedArray.Length - index - 1);
wrappedArray[wrappedArray.Length - 1] = default(T);
}
public override T this[int index]
{
get
{
if (index < 0 || index >= wrappedArray.Length)
throw new ArgumentOutOfRangeException("index");
return wrappedArray[index];
}
set
{
if (index < 0 || index >= wrappedArray.Length)
throw new ArgumentOutOfRangeException("index");
wrappedArray[index] = value;
}
}
public override void CopyTo(T[] array, int arrayIndex)
{
if (array == null)
throw new ArgumentNullException("array");
if (array.Length < wrappedArray.Length)
throw new ArgumentException("array is too short", "array");
if (arrayIndex < 0 || arrayIndex >= array.Length)
throw new ArgumentOutOfRangeException("arrayIndex");
if (array.Length + arrayIndex < wrappedArray.Length)
throw new ArgumentOutOfRangeException("arrayIndex");
Array.Copy(wrappedArray, 0, array, arrayIndex, wrappedArray.Length);
}
public override IEnumerator GetEnumerator()
{
return ((IList)wrappedArray).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((IList)wrappedArray).GetEnumerator();
}
///
/// Return true, to indicate that the list is fixed size.
///
bool IList.IsFixedSize
{
get
{
return true;
}
}
}
///
/// Creates a read-write IList<T> wrapper around an array. When an array is
/// implicitely converted to an IList<T>, changes to the items in the array cannot
/// be made through the interface. This method creates a read-write IList<T> wrapper
/// on an array that can be used to make changes to the array.
/// Use this method when you need to pass an array to an algorithms that takes an
/// IList<T> and that tries to modify items in the list. Algorithms in this class generally do not
/// need this method, since they have been design to operate on arrays even when they
/// are passed as an IList<T>.
///
/// Since arrays cannot be resized, inserting an item causes the last item in the array to be automatically
/// removed. Removing an item causes the last item in the array to be replaced with a default value (0 or null). Clearing
/// the list causes all the items to be replaced with a default value.
/// The array to wrap.
/// An IList<T> wrapper onto .
public static IList ReadWriteList(T[] array)
{
if (array == null)
throw new ArgumentNullException("array");
return new ArrayWrapper(array);
}
#endregion Collection wrappers
#region Replacing
///
/// Replace all items in a collection equal to a particular value with another values, yielding another collection.
///
/// The default sense of equality for T is used, as defined by T's
/// implementation of IComparable<T>.Equals or object.Equals.
/// The collection to process.
/// The value to find and replace within .
/// The new value to replace with.
/// An new collection with the items from , in the same order,
/// with the appropriate replacements made.
public static IEnumerable Replace(IEnumerable collection, T itemFind, T replaceWith)
{
return Replace(collection, itemFind, replaceWith, EqualityComparer.Default);
}
///
/// Replace all items in a collection equal to a particular value with another values, yielding another collection. A passed
/// IEqualityComparer is used to determine equality.
///
/// The collection to process.
/// The value to find and replace within .
/// The new value to replace with.
/// The IEqualityComparer<T> used to compare items for equality. Only the Equals method will be called.
/// An new collection with the items from , in the same order,
/// with the appropriate replacements made.
public static IEnumerable Replace(IEnumerable collection, T itemFind, T replaceWith, IEqualityComparer equalityComparer)
{
if (collection == null)
throw new ArgumentNullException("collection");
if (equalityComparer == null)
throw new ArgumentNullException("equalityComparer");
foreach (T item in collection) {
if (equalityComparer.Equals(item, itemFind))
yield return replaceWith;
else
yield return item;
}
}
///
/// Replace all items in a collection that a predicate evalues at true with a value, yielding another collection. .
///
/// The collection to process.
/// The predicate used to evaluate items with the collection. If the predicate returns true for a particular
/// item, the item is replaces with .
/// The new value to replace with.
/// An new collection with the items from , in the same order,
/// with the appropriate replacements made.
public static IEnumerable Replace(IEnumerable collection, Predicate predicate, T replaceWith)
{
if (collection == null)
throw new ArgumentNullException("collection");
if (predicate == null)
throw new ArgumentNullException("predicate");
foreach (T item in collection) {
if (predicate(item))
yield return replaceWith;
else
yield return item;
}
}
///
/// Replace all items in a list or array equal to a particular value with another value. The replacement is done in-place, changing
/// the list.
///
/// The default sense of equality for T is used, as defined by T's
/// implementation of IComparable<T>.Equals or object.Equals.
/// Although arrays cast to IList<T> are normally read-only, this method
/// will work correctly and modify an array passed as .
/// The list or array to process.
/// The value to find and replace within .
/// The new value to replace with.
public static void ReplaceInPlace(IList list, T itemFind, T replaceWith)
{
ReplaceInPlace(list, itemFind, replaceWith, EqualityComparer.Default);
}
///
/// Replace all items in a list or array equal to a particular value with another values.
/// The replacement is done in-place, changing
/// the list. A passed IEqualityComparer is used to determine equality.
///
/// Although arrays cast to IList<T> are normally read-only, this method
/// will work correctly and modify an array passed as .
/// The list or array to process.
/// The value to find and replace within .
/// The new value to replace with.
/// The IEqualityComparer<T> used to compare items for equality. Only the Equals method will be called.
public static void ReplaceInPlace(IList list, T itemFind, T replaceWith, IEqualityComparer equalityComparer)
{
if (list == null)
throw new ArgumentNullException("list");
if (equalityComparer == null)
throw new ArgumentNullException("equalityComparer");
if (list is T[])
list = new ArrayWrapper((T[])list);
if (list.IsReadOnly)
throw new ArgumentException(Strings.ListIsReadOnly, "list");
int listCount = list.Count;
for (int index = 0; index < listCount; ++index) {
if (equalityComparer.Equals(list[index], itemFind))
list[index] = replaceWith;
}
}
///
/// Replace all items in a list or array that a predicate evaluates at true with a value. The replacement is done in-place, changing
/// the list.
///
/// Although arrays cast to IList<T> are normally read-only, this method
/// will work correctly and modify an array passed as .
/// The list or array to process.
/// The predicate used to evaluate items with the collection. If the predicate returns true for a particular
/// item, the item is replaces with .
/// The new value to replace with.
public static void ReplaceInPlace(IList list, Predicate predicate, T replaceWith)
{
if (list == null)
throw new ArgumentNullException("list");
if (predicate == null)
throw new ArgumentNullException("predicate");
if (list is T[])
list = new ArrayWrapper((T[])list);
if (list.IsReadOnly)
throw new ArgumentException(Strings.ListIsReadOnly, "list");
int listCount = list.Count;
for (int index = 0; index < listCount; ++index) {
if (predicate(list[index]))
list[index] = replaceWith;
}
}
#endregion Replacing
#region Consecutive items
///
/// Remove consecutive equal items from a collection, yielding another collection. In each run of consecutive equal items
/// in the collection, all items after the first item in the run are removed.
///
/// The default sense of equality for T is used, as defined by T's
/// implementation of IComparable<T>.Equals or object.Equals.
/// The collection to process.
/// An new collection with the items from , in the same order,
/// with consecutive duplicates removed.
/// is null.
public static IEnumerable RemoveDuplicates(IEnumerable collection)
{
return RemoveDuplicates(collection, EqualityComparer.Default);
}
///
/// Remove consecutive equal items from a collection, yielding another collection. In each run of consecutive equal items
/// in the collection, all items after the first item in the run are removed. A passed
/// IEqualityComparer is used to determine equality.
///
/// The collection to process.
/// The IEqualityComparer<T> used to compare items for equality. Only the Equals method will be called.
/// An new collection with the items from , in the same order,
/// with consecutive duplicates removed.
/// or is null.
public static IEnumerable RemoveDuplicates(IEnumerable collection, IEqualityComparer equalityComparer)
{
if (equalityComparer == null)
throw new ArgumentNullException("equalityComparer");
return RemoveDuplicates(collection, equalityComparer.Equals);
}
///
/// Remove consecutive "equal" items from a collection, yielding another collection. In each run of consecutive equal items
/// in the collection, all items after the first item in the run are removed. The passed
/// BinaryPredicate is used to determine if two items are "equal".
///
/// Since an arbitrary BinaryPredicate is passed to this function, what is being removed need not be true equality.
/// The collection to process.
/// The BinaryPredicate used to compare items for "equality". An item current is removed if predicate(first, current)==true, where
/// first is the first item in the group of "duplicate" items.
/// An new collection with the items from , in the same order,
/// with consecutive "duplicates" removed.
public static IEnumerable RemoveDuplicates(IEnumerable collection, BinaryPredicate predicate)
{
if (collection == null)
throw new ArgumentNullException("collection");
if (predicate == null)
throw new ArgumentNullException("predicate");
T current = default(T);
bool atBeginning = true;
foreach (T item in collection) {
// Is the new item different from the current item?
if (atBeginning || !predicate(current, item)) {
current = item;
yield return item;
}
atBeginning = false;
}
}
///
/// Remove consecutive equal items from a list or array. In each run of consecutive equal items
/// in the list, all items after the first item in the run are removed. The removal is done in-place, changing
/// the list.
///
/// The default sense of equality for T is used, as defined by T's
/// implementation of IComparable<T>.Equals or object.Equals.
/// Although arrays cast to IList<T> are normally read-only, this method
/// will work correctly and modify an array passed as .
/// The list or array to process.
public static void RemoveDuplicatesInPlace(IList list)
{
RemoveDuplicatesInPlace(list, EqualityComparer.Default);
}
///
/// Remove subsequent consecutive equal items from a list or array. In each run of consecutive equal items
/// in the list, all items after the first item in the run are removed.
/// The replacement is done in-place, changing
/// the list. A passed IEqualityComparer is used to determine equality.
///
/// Although arrays cast to IList<T> are normally read-only, this method
/// will work correctly and modify an array passed as .
/// The list or array to process.
/// The IEqualityComparer<T> used to compare items for equality. Only the Equals method will be called.
public static void RemoveDuplicatesInPlace(IList list, IEqualityComparer equalityComparer)
{
if (equalityComparer == null)
throw new ArgumentNullException("equalityComparer");
RemoveDuplicatesInPlace(list, equalityComparer.Equals);
}
///
/// Remove consecutive "equal" items from a list or array. In each run of consecutive equal items
/// in the list, all items after the first item in the run are removed. The replacement is done in-place, changing
/// the list. The passed BinaryPredicate is used to determine if two items are "equal".
///
/// Since an arbitrary BinaryPredicate is passed to this function, what is being tested for need not be true equality.
/// Although arrays cast to IList<T> are normally read-only, this method
/// will work correctly and modify an array passed as .
/// The list or array to process.
/// The BinaryPredicate used to compare items for "equality".
public static void RemoveDuplicatesInPlace(IList list, BinaryPredicate predicate)
{
if (list == null)
throw new ArgumentNullException("list");
if (predicate == null)
throw new ArgumentNullException("predicate");
if (list is T[])
list = new ArrayWrapper((T[])list);
if (list.IsReadOnly)
throw new ArgumentException(Strings.ListIsReadOnly, "list");
T current = default(T);
T item;
int i = -1, j = 0;
int listCount = list.Count;
// Remove duplicates, compressing items to lower in the list.
while (j < listCount) {
item = list[j];
if (i < 0 || !predicate(current, item)) {
current = item;
++i;
if (i != j)
list[i] = current;
}
++j;
}
++i;
if (i < listCount) {
// remove items from the end.
if (list is ArrayWrapper || (list is IList && ((IList)list).IsFixedSize)) {
// An array or similar. Null out the last elements.
while (i < listCount)
list[i++] = default(T);
}
else {
// Normal list.
while (i < listCount) {
list.RemoveAt(listCount - 1);
--listCount;
}
}
}
}
///
/// Finds the first occurence of consecutive equal items in the
/// list.
///
/// The default sense of equality for T is used, as defined by T's
/// implementation of IComparable<T>.Equals or object.Equals.
/// The list to examine.
/// The number of consecutive equal items to look for. The count must be at least 1.
/// The index of the first item in the first run of consecutive equal items, or -1 if no such run exists..
public static int FirstConsecutiveEqual(IList list, int count)
{
return FirstConsecutiveEqual(list, count, EqualityComparer.Default);
}
///
/// Finds the first occurence of consecutive equal items in the
/// list. A passed IEqualityComparer is used to determine equality.
///
/// The list to examine.
/// The number of consecutive equal items to look for. The count must be at least 1.
/// The IEqualityComparer<T> used to compare items for equality. Only the Equals method will be called.
/// The index of the first item in the first run of consecutive equal items, or -1 if no such run exists.
public static int FirstConsecutiveEqual(IList list, int count, IEqualityComparer