} // 'AN10'
public override List <Entry> GetFramesList(IBinaryStream file)
{
file.Position = 0x14;
int frame_count = file.ReadInt16();
file.Position = 0x18 + frame_count * 4;
int count = file.ReadInt16();
if (!IsSaneCount(count))
{
return(null);
}
var current_offset = file.Position;
var dir = new List <Entry> (count);
for (int i = 0; i < count; ++i)
{
file.Position = current_offset + 8;
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
uint channels = file.ReadUInt32();
uint image_size = channels * width * height;
var entry = new AnmEntry
{
Offset = current_offset,
Size = 0x14 + image_size,
ImageDataOffset = current_offset + 0x14,
ImageDataSize = image_size,
};
dir.Add(entry);
current_offset += entry.Size;
}
return(dir);
}
} // 'YGP'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 4;
int mask_pos = stream.ReadUInt16(); // 04
byte type = stream.ReadUInt8(); // 06
if (type != 1 && type != 2)
{
return(null);
}
var info = new YgpMetaData {
Type = type, BPP = 32
};
info.Flags = stream.ReadUInt8(); // 07
int header_size = stream.ReadInt32(); // 08
stream.Position = header_size;
info.DataSize = stream.ReadInt32(); // XX+00
info.Width = stream.ReadUInt16(); // XX+04
info.Height = stream.ReadUInt16(); // XX+06
info.DataOffset = header_size + 8;
if (0 != (info.Flags & 4))
{
stream.Position = 0x14;
info.OffsetX = stream.ReadInt16();
info.OffsetY = stream.ReadInt16();
}
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
int c1 = file.ReadByte();
int c2 = file.ReadByte();
if ('B' != c1 || 'M' != c2)
{
return(null);
}
uint size = file.ReadUInt32();
file.ReadUInt32();
uint image_offset = file.ReadUInt32();
uint header_size = file.ReadUInt32();
if (size < 14 + header_size)
{
// some otherwise valid bitmaps have size field set to zero
if (size != 0 && size != 0xE || !file.AsStream.CanSeek)
{
return(null);
}
size = (uint)file.Length;
}
else if (file.AsStream.CanSeek)
{
if (size > file.Length)
{
size = (uint)file.Length;
}
}
uint width, height;
if (0xC == header_size)
{
width = file.ReadUInt16();
height = file.ReadUInt16();
}
else if (header_size < 40 || size - 14 < header_size)
{
return(null);
}
else
{
width = file.ReadUInt32();
height = file.ReadUInt32();
}
file.ReadInt16();
int bpp = file.ReadInt16();
return(new BmpMetaData {
Width = width,
Height = height,
OffsetX = 0,
OffsetY = 0,
BPP = bpp,
ImageLength = size,
ImageOffset = image_offset,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
int width = stream.ReadInt16();
int height = stream.ReadInt16();
if (width <= 0 || height <= 0)
{
return(null);
}
int bpp = stream.ReadInt32();
if (24 != bpp && 32 != bpp && 8 != bpp)
{
return(null);
}
if (0 != stream.ReadInt64())
{
return(null);
}
return(new ImageMetaData
{
Width = (uint)width,
Height = (uint)height,
BPP = bpp,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
if (file.Length <= 0x408)
{
return(null);
}
int x = file.ReadInt16();
int y = file.ReadInt16();
if (x < 0 || y < 0 || x > 0x300 || y > 0x300)
{
return(null);
}
int w = file.ReadInt16();
int h = file.ReadInt16();
if (w <= 0 || w > 0x1000 || h <= 0 || h > 0x1000)
{
return(null);
}
return(new ImageMetaData {
Width = (uint)w,
Height = (uint)h,
BPP = 8,
});
}
public void Unpack()
{
m_input.Position = 0x1A;
int color_data_length = Binary.BigEndian(m_input.ReadInt32());
long next_pos = m_input.Position + color_data_length;
if (0 != color_data_length)
{
if (8 == m_info.BPP)
{
ReadPalette(color_data_length);
}
m_input.Position = next_pos;
}
next_pos += 4 + Binary.BigEndian(m_input.ReadInt32());
m_input.Position = next_pos; // skip Image Resources
next_pos += 4 + Binary.BigEndian(m_input.ReadInt32());
m_input.Position = next_pos; // skip Layer and Mask Information
int compression = Binary.BigEndian(m_input.ReadInt16());
int remaining = checked ((int)(m_input.Length - m_input.Position));
byte[] pixels;
if (0 == compression)
{
pixels = m_input.ReadBytes(remaining);
}
else if (1 == compression)
{
pixels = UnpackRLE();
}
else
{
throw new NotSupportedException("PSD files with ZIP compression not supported");
}
if (1 == m_info.Channels)
{
m_output = pixels;
return;
}
int channels = Math.Min(4, m_info.Channels);
m_output = new byte[channels * m_channel_size];
int src = 0;
for (int ch = 0; ch < channels; ++ch)
{
int dst = ChannelMap[ch];
for (int i = 0; i < m_channel_size; ++i)
{
m_output[dst] = pixels[src++];
dst += channels;
}
}
}
public byte[] Decode(IBinaryStream input)
{
m_dst = 0;
if (1 == Channels)
{
var adp = new AdpDecoder();
while (input.PeekByte() != -1)
{
short sample = input.ReadInt16();
PutSample(sample);
int quant_idx = input.ReadUInt16() & 0xFF;
adp.Reset(sample, quant_idx);
for (int j = 0; j < BytesPerChunk - 4; ++j)
{
byte octet = input.ReadUInt8();
PutSample(adp.DecodeSample(octet));
PutSample(adp.DecodeSample(octet >> 4));
}
}
}
else
{
var first = new AdpDecoder();
var second = new AdpDecoder();
int samples_per_chunk = (BytesPerChunk - 8) / 8;
while (input.PeekByte() != -1)
{
short sample = input.ReadInt16();
PutSample(sample);
int quant_idx = input.ReadUInt16() & 0xFF;
first.Reset(sample, quant_idx);
sample = input.ReadInt16();
PutSample(sample);
quant_idx = input.ReadUInt16() & 0xFF;
second.Reset(sample, quant_idx);
for (int j = 0; j < samples_per_chunk; ++j)
{
uint first_code = input.ReadUInt32();
uint second_code = input.ReadUInt32();
for (int i = 0; i < 8; ++i)
{
PutSample(first.DecodeSample((byte)first_code));
PutSample(second.DecodeSample((byte)second_code));
first_code >>= 4;
second_code >>= 4;
}
}
}
}
return(m_output);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
var meta = new ImageMetaData();
meta.OffsetX = file.ReadInt16();
meta.OffsetY = file.ReadInt16();
meta.Width = file.ReadUInt16();
meta.Height = file.ReadUInt16();
meta.BPP = 32;
return(meta);
}
/// <summary>
/// Setup reader endianness accordingly.
/// </summary>
public void SetupReaders(int format, bool is_little_endian)
{
m_format = format;
if (is_little_endian)
{
ReadUInt16 = () => m_input.ReadUInt16();
ReadUInt32 = () => m_input.ReadUInt32();
ReadInt16 = () => m_input.ReadInt16();
ReadInt32 = () => m_input.ReadInt32();
ReadInt64 = () => m_input.ReadInt64();
}
else
{
ReadUInt16 = () => Binary.BigEndian(m_input.ReadUInt16());
ReadUInt32 = () => Binary.BigEndian(m_input.ReadUInt32());
ReadInt16 = () => Binary.BigEndian(m_input.ReadInt16());
ReadInt32 = () => Binary.BigEndian(m_input.ReadInt32());
ReadInt64 = () => Binary.BigEndian(m_input.ReadInt64());
}
if (m_format >= 14 || m_format == 9)
{
Align = () => {
long pos = m_input.Position;
if (0 != (pos & 3))
{
m_input.Position = (pos + 3) & ~3L;
}
};
}
else
{
Align = () => {};
}
if (m_format >= 14)
{
ReadId = ReadInt64;
}
else
{
ReadId = () => ReadInt32();
}
if (m_format >= 22)
{
ReadOffset = ReadInt64;
}
else
{
ReadOffset = () => ReadUInt32();
}
}
internal static object ReadField(this IBinaryStream input, FieldInfo field)
{
var field_type = field.FieldType;
var type_code = Type.GetTypeCode(field_type);
switch (type_code)
{
case TypeCode.SByte: return(input.ReadInt8());
case TypeCode.Byte: return(input.ReadUInt8());
case TypeCode.Int16: return(input.ReadInt16());
case TypeCode.UInt16: return(input.ReadUInt16());
case TypeCode.Int32: return(input.ReadInt32());
case TypeCode.UInt32: return(input.ReadUInt32());
case TypeCode.Int64: return(input.ReadInt64());
case TypeCode.UInt64: return(input.ReadUInt64());
case TypeCode.Char: return((char)input.ReadInt16());
case TypeCode.String:
var cstring_attr = field.GetCustomAttribute <CStringAttribute>();
if (cstring_attr != null)
{
var encoding = cstring_attr.Encoding ?? Encodings.cp932;
if (cstring_attr.IsLengthDefined)
{
return(input.ReadCString(cstring_attr.Length, encoding));
}
else
{
return(input.ReadCString(encoding));
}
}
throw new FormatException("Serialization method for string field is not defined.");
case TypeCode.Object:
object val = Activator.CreateInstance(field_type);
ReadStruct(input, field_type, ref val); // FIXME check object graph for cycles
return(val);
default:
throw new NotSupportedException("Not supported serialization type.");
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 3;
int bpp = file.ReadByte();
int x = 0;
int y = 0;
int type = bpp;
int header_size = 8;
if (2 == type)
{
bpp = file.ReadByte();
header_size = 13;
}
else if (1 == type)
{
bpp = file.ReadByte();
x = file.ReadInt16();
y = file.ReadInt16();
header_size = 13;
}
else
{
type = 0;
}
if (8 != bpp && 24 != bpp && 32 != bpp)
{
return(null);
}
uint w = file.ReadUInt16();
uint h = file.ReadUInt16();
if (2 == type)
{
x = file.ReadInt16();
y = file.ReadInt16();
}
return(new ElgMetaData
{
Width = w,
Height = h,
OffsetX = x,
OffsetY = y,
BPP = bpp,
Type = type,
HeaderSize = header_size,
});
}
bool UnpackAlpha(int length)
{
bool has_alpha = false;
int dst = 3;
while (length > 0)
{
int count = m_input.ReadInt16();
length -= 2;
if (count < 0)
{
count = (count & 0x7FFF) + 1;
byte a = m_input.ReadUInt8();
has_alpha = has_alpha || a != 0;
length--;
for (int i = 0; i < count; ++i)
{
m_output[dst] = a;
dst += 4;
}
}
else
{
for (int i = 0; i < count; ++i)
{
byte a = m_input.ReadUInt8();
has_alpha = has_alpha || a != 0;
m_output[dst] = a;
dst += 4;
}
length -= count;
}
}
return(has_alpha);
}
} // 'amp_'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 4;
int version = stream.ReadInt16();
if (version != 1)
{
return(null);
}
int unpacked_size = stream.ReadInt32();
int data_offset = stream.ReadInt32();
if (unpacked_size < 0x36 || data_offset < stream.Position)
{
return(null);
}
var header = new byte[0x20];
stream.Position = data_offset;
Unpack(stream.AsStream, header);
Decrypt(header);
if ('B' != header[0] || 'M' != header[1])
{
return(null);
}
return(new ZbmMetaData
{
Width = LittleEndian.ToUInt32(header, 0x12),
Height = LittleEndian.ToUInt32(header, 0x16),
BPP = LittleEndian.ToInt16(header, 0x1C),
UnpackedSize = unpacked_size,
DataOffset = data_offset,
});
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var pixels = new short[info.Width * info.Height];
file.Position = 0x20;
int dst = 0;
while (dst < pixels.Length && file.PeekByte() != -1)
{
short px = file.ReadInt16();
if (px < 0)
{
px &= 0x7FFF;
int count = file.ReadUInt8();
for (int i = 0; i < count; ++i)
{
pixels[dst++] = px;
}
}
else
{
pixels[dst++] = px;
}
}
return(ImageData.Create(info, PixelFormats.Bgr555, null, pixels));
}
public override uint Signature { get { return 0; } } // 'RIFF'
public override ImageMetaData ReadMetaData (IBinaryStream file)
{
// 'RIFF' isn't included into signature to avoid auto-detection of the WAV files as IPH images.
if (0x46464952 != file.Signature) // 'RIFF'
return null;
var header = file.ReadHeader (0x10);
if (0x38 != header.ToInt32 (4))
return null;
var signature = header.ToInt32 (8);
if (signature != 0x20485049 && signature != 0x00485049) // 'IPH'
return null;
if (0x20746D66 != header.ToInt32 (12)) // 'fmt '
return null;
file.Position = 0x38;
if (0x20706D62 != file.ReadInt32()) // 'bmp '
return null;
var info = new IphMetaData();
info.PackedSize = file.ReadInt32();
info.Width = file.ReadUInt16();
info.Height = file.ReadUInt16();
file.Position = 0x50;
info.BPP = file.ReadUInt16();
info.IsCompressed = 0 != file.ReadInt16();
// XXX int16@[0x54] is a transparency color or 0xFFFF if image is not transparent
return info;
}
internal ApsMetaData ReadCompressionMetaData(IBinaryStream reader, Rectangle rect)
{
int compression = reader.ReadInt16();
var info = new ApsMetaData
{
Width = (uint)rect.Width,
Height = (uint)rect.Height,
BPP = 32,
IsPacked = 0 != compression,
};
if (0 == compression)
{
info.UnpackedSize = reader.ReadUInt32();
}
else if (1 == compression)
{
info.PackedSize = reader.ReadUInt32();
info.UnpackedSize = reader.ReadUInt32();
}
else
{
return(null);
}
info.DataOffset = (uint)reader.Position;
return(info);
}
bool SkipFrameTable(IBinaryStream file)
{
file.Position = 4;
int table_count = file.ReadInt16();
file.Position = 8;
for (int i = 0; i < table_count; ++i)
{
switch (file.ReadByte())
{
case 0: break;
case 1: file.Seek(8, SeekOrigin.Current); break;
case 2:
case 3:
case 4:
case 5: file.Seek(4, SeekOrigin.Current); break;
default: return(false);
}
}
int count = file.ReadUInt16();
file.Seek(count * 8, SeekOrigin.Current);
return(true);
}
void UnpackAlpha(int length)
{
int dst = 3;
while (length > 0)
{
int count = m_input.ReadInt16();
length -= 2;
if (count < 0)
{
count = (count & 0x7FFF) + 1;
byte a = (byte)~m_input.ReadUInt8();
length--;
for (int i = 0; i < count; ++i)
{
m_output[dst] = a;
dst += 4;
}
}
else
{
for (int i = 0; i < count; ++i)
{
m_output[dst] = (byte)~m_input.ReadUInt8();
dst += 4;
}
length -= count;
}
}
}
} // 'AN20'
public override List <Entry> GetFramesList(IBinaryStream file)
{
if (!SkipFrameTable(file))
{
return(null);
}
int count = file.ReadInt16();
if (!IsSaneCount(count))
{
return(null);
}
long current_offset = file.Position + 0x10;
var dir = new List <Entry> (count);
for (int i = 0; i < count; ++i)
{
file.Position = current_offset + 8;
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
uint depth = file.ReadUInt32();
uint image_size = depth * width * height;
var entry = new AnmEntry
{
Offset = current_offset,
Size = 0x14 + image_size,
ImageDataOffset = current_offset + 0x14,
ImageDataSize = image_size,
};
dir.Add(entry);
current_offset += entry.Size;
}
return(dir);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x10);
var info = new CzMetaData {
Width = header.ToUInt16(8),
Height = header.ToUInt16(10),
BPP = header.ToUInt16(12),
HeaderLength = header.ToUInt32(4),
Version = header[2] - '0',
};
if (info.HeaderLength > 0x18)
{
info.OffsetX = file.ReadInt16();
info.OffsetY = file.ReadInt16();
}
return(info);
}
private void Decode3Alt(IBinaryStream input, Stream output, int step)
{
int output_size = input.ReadInt32();
int count = input.ReadInt32();
using (var buffer = new BinaryWriter(output, Encoding.ASCII, true))
{
short sample = input.ReadInt16();
buffer.Write(sample);
int output_count = 1;
for (int i = 0; i < count; ++i)
{
short v = input.ReadInt16();
int repeat = SizeTableAlt[v & 7];
output_count += repeat;
short end = (short)(v & 0xFFF8);
short inc = (short)((end - sample) / repeat);
for (int j = 0; j < repeat; ++j)
{
sample += inc;
buffer.Write(sample);
if (step != 0)
{
buffer.BaseStream.Seek(step, SeekOrigin.Current);
}
}
sample = end;
}
if (step != 0)
{
output_size /= step;
}
while (output_count++ < output_size)
{
sample = input.ReadInt16();
buffer.Write(sample);
if (step != 0)
{
buffer.BaseStream.Seek(step, SeekOrigin.Current);
}
}
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
if (!file.Name.HasExtension(".ggs"))
{
return(null);
}
int x = file.ReadInt16();
int y = file.ReadInt16();
uint w = file.ReadUInt16();
uint h = file.ReadUInt16();
if (0 == w || 0 == h || w > 0x4000 || h > 0x4000 || x < 0 || y < 0)
{
return(null);
}
return(new ImageMetaData {
Width = w, Height = h, OffsetX = x, OffsetY = y, BPP = 24
});
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
int name_count = stream.ReadInt16();
if (name_count <= 0 || name_count > 1000)
{
return(null);
}
for (int i = 0; i < name_count; ++i)
{
int name_length = stream.ReadInt32();
if (name_length <= 0 || name_length > 260)
{
return(null);
}
stream.Seek(name_length, SeekOrigin.Current);
}
int tile_count = stream.ReadInt16();
if (tile_count <= 0 || tile_count > 1000)
{
return(null);
}
var rect = new Rectangle(0, 0, 0, 0);
for (int i = 0; i < tile_count; ++i)
{
int name_length = stream.ReadInt32();
if (name_length <= 0 || name_length > 260)
{
return(null);
}
stream.Seek(name_length + 0xC, SeekOrigin.Current);
int x = stream.ReadInt32();
int y = stream.ReadInt32();
int w = stream.ReadInt32() - x;
int h = stream.ReadInt32() - y;
var part_rect = new Rectangle(x, y, w, h);
rect = Rectangle.Union(rect, part_rect);
stream.Seek(0x28, SeekOrigin.Current);
}
return(ReadCompressionMetaData(stream, rect));
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
int count = stream.ReadInt16();
if (count <= 0 || count >= 0x100)
{
return(null);
}
int offset;
if (count > 1)
{
offset = stream.ReadInt32();
if (offset != 2 + count * 4)
{
return(null);
}
}
else
{
offset = 2;
}
stream.Position = offset;
int unpacked_size = stream.ReadInt32();
int packed_size = stream.ReadInt32();
offset += 8;
if (offset + packed_size > stream.Length)
{
return(null);
}
byte[] header = new byte[0x36];
if (0x36 != MgrOpener.Decompress(stream.AsStream, header) ||
header[0] != 'B' || header[1] != 'M')
{
return(null);
}
using (var bmp = new BinMemoryStream(header, stream.Name))
{
var info = Bmp.ReadMetaData(bmp);
if (null == info)
{
return(null);
}
return(new MgrMetaData
{
Width = info.Width,
Height = info.Height,
BPP = info.BPP,
Offset = offset,
PackedSize = packed_size,
UnpackedSize = unpacked_size,
});
}
}
} // 'HG-2'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 8;
var info = new Hg2MetaData();
int version = stream.ReadInt32();
if (0x25 == version)
{
info.HeaderSize = 0x58;
}
else if (0x20 == version)
{
info.HeaderSize = 0x50;
}
else if (0x10 == version)
{
info.HeaderSize = 0x30;
}
else
{
return(null);
}
info.Version = version;
info.Width = stream.ReadUInt32();
info.Height = stream.ReadUInt32();
info.BPP = stream.ReadInt16();
info.Depth = stream.ReadInt16();
stream.Seek(8, SeekOrigin.Current);
info.DataPacked = stream.ReadInt32();
info.DataUnpacked = stream.ReadInt32();
info.CtlPacked = stream.ReadInt32();
info.CtlUnpacked = stream.ReadInt32();
if (info.HeaderSize > 0x30)
{
stream.Seek(8, SeekOrigin.Current);
info.CanvasWidth = stream.ReadUInt32();
info.CanvasHeight = stream.ReadUInt32();
info.OffsetX = stream.ReadInt32();
info.OffsetY = stream.ReadInt32();
}
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream input)
{
int x = input.ReadInt16();
int y = input.ReadInt16();
int w = input.ReadInt16();
int h = input.ReadInt16();
if (w <= 0 || w > 0x1000 || h <= 0 || h > 0x1000 ||
x < 0 || x > 0x800 || y < 0 || y > 0x800)
{
return(null);
}
return(new ImageMetaData {
Width = (uint)w,
Height = (uint)h,
OffsetX = x,
OffsetY = y,
BPP = 8,
});
}
private void Decode3(IBinaryStream input, Stream output, int step)
{
input.ReadInt32(); // unpacked_size
int count = input.ReadInt32();
using (var buffer = new BinaryWriter(output, Encoding.ASCII, true))
{
short sample = input.ReadInt16();
buffer.Write(sample);
for (int i = 0; i < count; ++i)
{
if (count - 300 == i)
{
sample = 0;
}
ushort v = input.ReadUInt8();
if (0 != (v & 1))
{
ushort v14 = (ushort)((v >> 1) & 0x7F);
if (0 != (v14 & 0x40))
{
sample = (short)(v14 << 10);
}
else
{
sample += (short)SampleTable2[v14];
}
buffer.Write(sample);
if (step != 0)
{
buffer.BaseStream.Seek(step, SeekOrigin.Current);
}
}
else
{
v |= (ushort)(input.ReadUInt8() << 8);
int repeat = SizeTable[(v >> 1) & 7];
short end = (short)(v & 0xFFF0);
double inc = (end - sample) / (double)repeat;
double v8 = sample;
for (int j = 0; j < repeat; ++j)
{
v8 += inc;
buffer.Write((short)v8);
if (step != 0)
{
buffer.BaseStream.Seek(step, SeekOrigin.Current);
}
}
sample = end;
}
}
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
if (!file.Name.HasExtension(".gga"))
{
return(null);
}
int x = file.ReadInt16();
int y = file.ReadInt16();
uint w = file.ReadUInt16();
uint h = file.ReadUInt16();
int unpacked_size = file.ReadInt32();
if (0 == w || 0 == h || w > 0x7FFF || h > 0x7FFF || x < 0 || y < 0 ||
3 * w * h != unpacked_size)
{
return(null);
}
return(new GgaMetaData {
Width = w, Height = h, OffsetX = x, OffsetY = y, BPP = 24,
UnpackedSize = unpacked_size,
});
}
internal override ImageMetaData GetBaseInfo(IBinaryStream input)
{
SkipFrameTable(input);
input.ReadInt16();
return(new ImageMetaData
{
OffsetX = input.ReadInt32(),
OffsetY = input.ReadInt32(),
Width = input.ReadUInt32(),
Height = input.ReadUInt32(),
BPP = 32,
});
}
internal bool ReadBmpInfo(IBinaryStream file, IpfMetaData info)
{
if (0x20706D62 != file.ReadInt32()) // 'bmp '
{
return(false);
}
int bmp_size = file.ReadInt32();
if (bmp_size <= 0x20)
{
return(false);
}
info.BmpOffset = file.Position + 0x18;
info.Width = file.ReadUInt16();
info.Height = file.ReadUInt16();
file.ReadUInt32();
info.OffsetX = file.ReadInt16();
info.OffsetY = file.ReadInt16();
file.Seek(6, SeekOrigin.Current);
info.IsCompressed = 0 != (file.ReadByte() & 1);
return(true);
}