public TiffEntry(ref FileMap f, UInt32 offset, UInt32 up_offset)
{
parent_offset = up_offset;
own_data = null;
empty_data = 0;
file = f;
type = TiffDataType.TIFF_UNDEFINED; // We set type to undefined to avoid debug assertion errors.
byte[] temp_data = f.getData(offset, 8);
tag = (TiffTag)Common.get4LEget2LE(temp_data, 0);
type = (TiffDataType)Common.get4LEget2LE(temp_data, 2);
count = Common.get4LE(temp_data, 4);
bytesize = (UInt64)count << (int)Data.datashifts[(int)type];
if (bytesize > UInt32.MaxValue)
{
TiffParserException.ThrowTPE("TIFF entry is supposedly " + bytesize + " bytes");
}
if (bytesize == 0) // Better return empty than null-dereference later
{
data = (byte8 *)&empty_data;
}
else if (bytesize <= 4)
{
data = fgetDataWrt(offset + 8, bytesize);
}
else
{ // offset
data_offset = get4LE(f.getData(offset + 8, 4), 0);
fetchData();
}
}
public Tag(TagType id, TiffDataType type, uint count)
{
TagId = id;
dataType = type;
dataCount = count;
data = new Object[dataCount];
}
public static int GetTypeSize(this TiffDataType id)
{
switch (id)
{
case TiffDataType.BYTE:
case TiffDataType.ASCII:
case TiffDataType.SBYTE:
case TiffDataType.UNDEFINED:
return(1);
case TiffDataType.SHORT:
case TiffDataType.SSHORT:
return(2);
case TiffDataType.LONG:
case TiffDataType.SLONG:
case TiffDataType.FLOAT:
case TiffDataType.OFFSET:
return(4);
case TiffDataType.RATIONAL:
case TiffDataType.DOUBLE:
case TiffDataType.SRATIONAL:
return(8);
case TiffDataType.NOTYPE:
default:
return(0);
}
}
public Tag()
{
data = new object[1];
dataCount = 1;
dataType = TiffDataType.UNDEFINED;
displayName = "";
}
public int getTypeSize(TiffDataType id)
{
int size = 0;
switch (id)
{
case TiffDataType.BYTE:
case TiffDataType.ASCII:
case TiffDataType.SBYTE:
case TiffDataType.UNDEFINED:
case TiffDataType.OFFSET:
size = 1;
break;
case TiffDataType.SHORT:
case TiffDataType.SSHORT:
size = 2;
break;
case TiffDataType.LONG:
case TiffDataType.SLONG:
case TiffDataType.FLOAT:
size = 4;
break;
case TiffDataType.RATIONAL:
case TiffDataType.DOUBLE:
case TiffDataType.SRATIONAL:
size = 8;
break;
}
return(size);
}
internal static Type Typeof(TiffDataType type)
{
try {
return(TiffDataTypeHelper.TypeDictionary[type]);
} catch (KeyNotFoundException) {
return(typeof(object));
}
}
internal static int Sizeof(TiffDataType type)
{
try {
return(TiffDataTypeHelper.SizeDictionary[type]);
} catch (KeyNotFoundException) {
return(0);
}
}
public TiffEntry(TiffTag _tag, TiffDataType _type, UInt32 _count, byte[] _data)
{
file = null;
parent_offset = 0;
tag = _tag;
type = _type;
count = _count;
data_offset = 0; // Set nonsense value in case someone tries to use it
bytesize = (ulong)_count << (int)Data.datashifts[(int)_type];
if (null == _data)
{
own_data = new byte[bytesize];
memset(own_data, 0, bytesize);
data = own_data;
}
else
{
data = _data;
own_data = null;
}
}
public Tag(ImageBinaryReader fileStream, int baseOffset)
{
parent_offset = baseOffset;
TagId = (TagType)fileStream.ReadUInt16();
dataType = (TiffDataType)fileStream.ReadUInt16();
if (TagId == TagType.FUJI_RAW_IFD)
{
if (dataType == TiffDataType.OFFSET) // FUJI - correct type
{
dataType = TiffDataType.LONG;
}
}
dataCount = fileStream.ReadUInt32();
dataOffset = 0;
if (((dataCount * dataType.GetTypeSize() > 4)))
{
dataOffset = fileStream.ReadUInt32();
}
else
{
GetData(fileStream);
int k = (int)dataCount * dataType.GetTypeSize();
if (k < 4)
{
fileStream.ReadBytes(4 - k);
}
}
/* if (dataOffset < fileStream.BaseStream.Length && dataOffset > 1)
* {
* long firstPosition = fileStream.Position;
* fileStream.Position = dataOffset + parent_offset;
* GetData(fileStream);
* fileStream.BaseStream.Position = firstPosition;
* ¨*/
}
TiffEntryBE(TiffTag tag, TiffDataType type, UInt32 count, byte[] data) : base(tag, type, count, data)
{
}
public ImageBinaryReaderBigEndian(object[] data, TiffDataType dataType) : base(StreamFromArray(data, dataType))
{
}
public HeaderTiff(string path)
{
Path = path;
using (Tiff Image = Tiff.Open(path, "r"))
{
{
FieldValue[] value = Image.GetField(TiffTag.IMAGEWIDTH);
Dimensions.X = value[0].ToInt();
}
{
FieldValue[] value = Image.GetField(TiffTag.IMAGELENGTH);
Dimensions.Y = value[0].ToInt();
}
{
Dimensions.Z = Image.NumberOfDirectories();
}
{
FieldValue[] value = Image.GetField(TiffTag.SAMPLEFORMAT);
SampleFormat Format = SampleFormat.UINT;// (SampleFormat)value[0].ToInt();
int BitsPerPixel = 8;// Image.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
if (Format == SampleFormat.UINT)
{
if (BitsPerPixel == 8)
Mode = TiffDataType.Byte;
else if (BitsPerPixel == 16)
Mode = TiffDataType.Ushort;
else if (BitsPerPixel == 32)
Mode = TiffDataType.Uint;
else if (BitsPerPixel == 64)
Mode = TiffDataType.Ulong;
else
throw new FormatException("Unexpected bits per pixel.");
}
else if (Format == SampleFormat.INT)
{
if (BitsPerPixel == 16)
Mode = TiffDataType.Short;
else if (BitsPerPixel == 32)
Mode = TiffDataType.Int;
else if (BitsPerPixel == 64)
Mode = TiffDataType.Long;
else
throw new FormatException("Unexpected bits per pixel.");
}
else if (Format == SampleFormat.IEEEFP)
{
if (BitsPerPixel == 32)
Mode = TiffDataType.Float;
else if (BitsPerPixel == 64)
Mode = TiffDataType.Double;
else
throw new FormatException("Unexpected bits per pixel.");
}
}
}
}
public static Stream streamFromArray(object[] array, TiffDataType type)
{
byte[] temp;
//get type of array
switch (type)
{
case TiffDataType.BYTE: /* 8-bit unsigned integer */
case TiffDataType.ASCII: /* 8-bit bytes w/ last byte null */
case TiffDataType.UNDEFINED: /* !8-bit untyped data */
case TiffDataType.SBYTE: /* !8-bit signed integer */
temp = new byte[array.Length];
for (int i = 0; i < array.Length; i++)
{
temp[i] = (byte)array[i];
}
break;
case TiffDataType.SHORT: /* 16-bit unsigned integer */
case TiffDataType.SSHORT: /* !16-bit signed integer */
temp = new byte[array.Length * 2];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (byte)((int)array[i] >> 8);
temp[i + 1] = (byte)((int)array[i]);
}
break;
case TiffDataType.LONG: /* 32-bit unsigned integer */
case TiffDataType.OFFSET: /* 32-bit unsigned offset used in ORF at least */
case TiffDataType.FLOAT: /* !32-bit IEEE floating point */
case TiffDataType.SLONG: /* !32-bit signed integer */
temp = new byte[array.Length * 4];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (byte)((int)array[i] >> 24);
temp[i + 1] = (byte)((int)array[i] >> 16);
temp[i + 2] = (byte)((int)array[i] >> 8);
temp[i + 3] = (byte)((int)array[i]);
}
break;
case TiffDataType.SRATIONAL: /* !64-bit signed fraction */
case TiffDataType.DOUBLE: /* !64-bit IEEE floating point */
case TiffDataType.RATIONAL: /* 64-bit unsigned fraction */
temp = new byte[array.Length * 8];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (byte)((int)array[i] >> 56);
temp[i + 1] = (byte)((int)array[i] >> 48);
temp[i + 2] = (byte)((int)array[i] >> 40);
temp[i + 3] = (byte)((int)array[i] >> 32);
temp[i + 4] = (byte)((int)array[i] >> 24);
temp[i + 5] = (byte)((int)array[i] >> 16);
temp[i + 6] = (byte)((int)array[i] >> 8);
temp[i + 7] = (byte)((int)array[i]);
}
break;
default:
throw new Exception();
}
Stream stream = new MemoryStream(temp)
{
Position = 0
};
return(stream);
}
public ImageBinaryReader(object[] data, TiffDataType dataType, uint offset) : this(StreamFromArray(data, dataType), offset)
{
}
public ImageBinaryReader(object[] data, TiffDataType dataType) : this(StreamFromArray(data, dataType))
{
}
public HeaderTiff(string path)
{
Path = path;
using (Tiff Image = Tiff.Open(path, "r"))
{
{
FieldValue[] value = Image.GetField(TiffTag.IMAGEWIDTH);
Dimensions.X = value[0].ToInt();
}
{
FieldValue[] value = Image.GetField(TiffTag.IMAGELENGTH);
Dimensions.Y = value[0].ToInt();
}
{
Dimensions.Z = Image.NumberOfDirectories();
}
{
FieldValue[] value = Image.GetField(TiffTag.SAMPLEFORMAT);
SampleFormat Format = SampleFormat.UINT; // (SampleFormat)value[0].ToInt();
int BitsPerPixel = 8; // Image.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
if (Format == SampleFormat.UINT)
{
if (BitsPerPixel == 8)
{
Mode = TiffDataType.Byte;
}
else if (BitsPerPixel == 16)
{
Mode = TiffDataType.Ushort;
}
else if (BitsPerPixel == 32)
{
Mode = TiffDataType.Uint;
}
else if (BitsPerPixel == 64)
{
Mode = TiffDataType.Ulong;
}
else
{
throw new FormatException("Unexpected bits per pixel.");
}
}
else if (Format == SampleFormat.INT)
{
if (BitsPerPixel == 16)
{
Mode = TiffDataType.Short;
}
else if (BitsPerPixel == 32)
{
Mode = TiffDataType.Int;
}
else if (BitsPerPixel == 64)
{
Mode = TiffDataType.Long;
}
else
{
throw new FormatException("Unexpected bits per pixel.");
}
}
else if (Format == SampleFormat.IEEEFP)
{
if (BitsPerPixel == 32)
{
Mode = TiffDataType.Float;
}
else if (BitsPerPixel == 64)
{
Mode = TiffDataType.Double;
}
else
{
throw new FormatException("Unexpected bits per pixel.");
}
}
}
}
}
public HeaderTiff(string path, Stream stream = null)
{
Path = path;
if (stream == null)
{
stream = File.OpenRead(path);
}
Tiff Image = Tiff.ClientOpen("inmemory", "r", stream, new TiffStream());
{
{
FieldValue[] value = Image.GetField(TiffTag.IMAGEWIDTH);
Dimensions.X = value[0].ToInt();
}
{
FieldValue[] value = Image.GetField(TiffTag.IMAGELENGTH);
Dimensions.Y = value[0].ToInt();
}
{
Dimensions.Z = Image.NumberOfDirectories();
}
{
FieldValue[] value = Image.GetField(TiffTag.SAMPLEFORMAT);
SampleFormat Format = SampleFormat.UINT;
if (value != null)
{
Format = (SampleFormat)value[0].ToInt();
}
int BitsPerPixel = Image.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
if (Format == SampleFormat.UINT)
{
if (BitsPerPixel == 8)
{
Mode = TiffDataType.Byte;
}
else if (BitsPerPixel == 16)
{
Mode = TiffDataType.Ushort;
}
else if (BitsPerPixel == 32)
{
Mode = TiffDataType.Uint;
}
else if (BitsPerPixel == 64)
{
Mode = TiffDataType.Ulong;
}
else
{
throw new FormatException("Unexpected bits per pixel.");
}
}
else if (Format == SampleFormat.INT)
{
if (BitsPerPixel == 16)
{
Mode = TiffDataType.Short;
}
else if (BitsPerPixel == 32)
{
Mode = TiffDataType.Int;
}
else if (BitsPerPixel == 64)
{
Mode = TiffDataType.Long;
}
else
{
throw new FormatException("Unexpected bits per pixel.");
}
}
else if (Format == SampleFormat.IEEEFP)
{
if (BitsPerPixel == 32)
{
Mode = TiffDataType.Float;
}
else if (BitsPerPixel == 64)
{
Mode = TiffDataType.Double;
}
else
{
throw new FormatException("Unexpected bits per pixel.");
}
}
else
{
throw new FormatException("Unexpected format.");
}
}
}
if (stream.GetType() != typeof(MemoryStream))
{
stream.Close();
}
}
protected static Stream StreamFromArray(object[] array, TiffDataType type)
{
if (array == null || array.Length == 0)
{
throw new ArgumentNullException();
}
byte[] temp = new byte[array.Length * type.GetTypeSize()];
//get type of array
switch (type)
{
case TiffDataType.BYTE: // 8-bit unsigned integer
case TiffDataType.ASCII: // 8-bit bytes w/ last byte null
case TiffDataType.UNDEFINED: // !8-bit untyped data
case TiffDataType.SBYTE: // !8-bit signed integer
for (int i = 0; i < array.Length; i++)
{
temp[i] = (byte)array[i];
}
break;
case TiffDataType.SHORT: // 16-bit unsigned integer
case TiffDataType.SSHORT: // !16-bit signed integer
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (byte)((int)array[i] >> 8);
temp[i + 1] = (byte)((int)array[i]);
}
break;
case TiffDataType.LONG: // 32-bit unsigned integer
case TiffDataType.OFFSET: // 32-bit unsigned offset used in ORF at least
case TiffDataType.FLOAT: // !32-bit IEEE floating point
case TiffDataType.SLONG: // !32-bit signed integer
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (byte)((int)array[i] >> 24);
temp[i + 1] = (byte)((int)array[i] >> 16);
temp[i + 2] = (byte)((int)array[i] >> 8);
temp[i + 3] = (byte)((int)array[i]);
}
break;
case TiffDataType.SRATIONAL: // !64-bit signed fraction
case TiffDataType.DOUBLE: //* !64-bit IEEE floating point
case TiffDataType.RATIONAL: //* 64-bit unsigned fraction
for (int i = 0; i < temp.Length; i++)
{
temp[i] = (byte)((int)array[i] >> 56);
temp[i + 1] = (byte)((int)array[i] >> 48);
temp[i + 2] = (byte)((int)array[i] >> 40);
temp[i + 3] = (byte)((int)array[i] >> 32);
temp[i + 4] = (byte)((int)array[i] >> 24);
temp[i + 5] = (byte)((int)array[i] >> 16);
temp[i + 6] = (byte)((int)array[i] >> 8);
temp[i + 7] = (byte)((int)array[i]);
}
break;
default:
throw new IOException();
}
return(new MemoryStream(temp)
{
Position = 0
});
}
