} // '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);
}
void UpdateRepeatCount(Dictionary <uint, int> rows_count)
{
m_input.Position = 4;
int count = m_input.ReadInt32();
var frames = new List <uint> (count);
for (int i = 0; i < count; ++i)
{
var offset = m_input.ReadUInt32();
if (0 != offset)
{
frames.Add(offset);
}
}
foreach (var offset in frames)
{
if (offset + 0x14 == m_origin)
{
continue;
}
m_input.Position = offset + 4;
int height = m_input.ReadInt32();
m_input.Position = offset + 0x14;
for (int i = 0; i < height; ++i)
{
var row_offset = m_input.ReadUInt32();
if (rows_count.ContainsKey(row_offset))
{
++rows_count[row_offset];
}
}
}
}
void UnpackRle(int dst, int pixel_size)
{
int remaining = m_input.ReadInt32();
while (remaining > 0)
{
int count = m_input.ReadInt8();
--remaining;
if (count >= 0)
{
for (int i = 0; i <= count; ++i)
{
m_output[dst] = m_input.ReadUInt8();
--remaining;
dst += pixel_size;
}
}
else
{
count = 1 - count;
byte repeat = m_input.ReadUInt8();
--remaining;
for (int i = 0; i < count; ++i)
{
m_output[dst] = repeat;
dst += pixel_size;
}
}
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(16);
var info = new EpaMetaData {
Width = header.ToUInt32(8),
Height = header.ToUInt32(12),
Mode = header[3],
ColorType = header[4],
};
switch (info.ColorType)
{
case 0: info.BPP = 8; break;
case 1: info.BPP = 24; break;
case 2: info.BPP = 32; break;
case 3: info.BPP = 16; break;
case 4: info.BPP = 8; break;
default: return(null);
}
if (2 == info.Mode)
{
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
}
return(info);
}
} // '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,
});
}
void ParseEncryptedIndex(int count)
{
int header_length = m_index.ReadUInt8();
if (0 != header_length)
{
m_info.Prefix = m_index.ReadBytes(header_length);
}
m_wide_offset = m_index.ReadByte() != 0;
int name_tree_length = m_index.ReadInt32();
var entry_table_offset = m_index.Position + name_tree_length;
m_name_buf = new byte[0x110];
TraverseIndex(m_index.Position, 0);
if (m_dir.Count != count)
{
throw new InvalidFormatException();
}
foreach (EpkEntry entry in m_dir)
{
m_index.Position = entry_table_offset + entry.DirIndex * 12;
ReadEntry(entry);
}
}
} // 'METAL'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x2C);
if (!header.AsciiEqual("METAL") || header.ToInt32(0x10) != 0x28 || header[0x15] == 0)
{
return(null);
}
int name_length = header.ToInt32(0x28);
if (name_length <= 0)
{
return(null);
}
var name = file.ReadCString(name_length);
if (file.ReadInt32() != 0xC)
{
return(null);
}
int frame_count = file.ReadInt32();
if (!ArchiveFormat.IsSaneCount(frame_count))
{
return(null);
}
var data_pos = file.Position + frame_count * 0x18;
return(new MtlMetaData {
Width = header.ToUInt32(0x20),
Height = header.ToUInt32(0x24),
BPP = 32,
DataOffset = data_pos,
});
}
public void Parse(IBinaryStream index)
{
index.Position = 16;
int segment_count = Binary.BigEndian(index.ReadInt32());
m_segments = new List <BundleSegment> (segment_count);
long packed_offset = m_data_offset;
long unpacked_offset = 0;
for (int i = 0; i < segment_count; ++i)
{
var segment = new BundleSegment();
segment.Offset = packed_offset;
segment.UnpackedOffset = unpacked_offset;
segment.UnpackedSize = Binary.BigEndian(index.ReadUInt32());
segment.PackedSize = Binary.BigEndian(index.ReadUInt32());
segment.Compression = Binary.BigEndian(index.ReadUInt16());
m_segments.Add(segment);
packed_offset += segment.PackedSize;
unpacked_offset += segment.UnpackedSize;
}
int count = Binary.BigEndian(index.ReadInt32());
m_bundles = new List <BundleEntry> (count);
for (int i = 0; i < count; ++i)
{
var entry = new BundleEntry();
entry.Offset = Binary.BigEndian(index.ReadInt64());
entry.Size = (uint)Binary.BigEndian(index.ReadInt64());
entry.Flags = Binary.BigEndian(index.ReadUInt32());
entry.Name = index.ReadCString(Encoding.UTF8);
m_bundles.Add(entry);
}
}
} // 'hiz'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
int n = file.ReadInt32();
if (100 != n)
{
return(null);
}
uint right = file.ReadUInt32() ^ 0xAA5A5A5A;
uint bottom = file.ReadUInt32() ^ 0xAC9326AF;
int unknown1 = file.ReadInt32(); // @0x10
if (unknown1 == 0x375A8436)
{
return(null);
}
uint unpacked_size = file.ReadUInt32() ^ 0x19739D6A; // @0x14
if (unpacked_size != right * bottom * 4)
{
return(null);
}
return(new HizMetaData
{
Width = right,
Height = bottom,
BPP = 32,
IsPacked = true,
DataOffset = 0x4c,
UnpackedSize = unpacked_size,
});
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (FcbMetaData)info;
byte[] input;
if (1 == meta.Method)
{
stream.Position = 0x14;
int unpacked_size = Binary.BigEndian(stream.ReadInt32());
stream.ReadInt32(); // packed_size
input = new byte[unpacked_size];
using (var z = new ZLibStream(stream.AsStream, CompressionMode.Decompress, true))
if (unpacked_size != z.Read(input, 0, unpacked_size))
{
throw new EndOfStreamException();
}
}
else if (0 == meta.Method)
{
stream.Position = 0x10;
using (var tz = new TzCompression(stream.AsStream))
input = tz.Unpack();
}
else
{
throw new InvalidFormatException();
}
var pixels = Unpack(input, info);
return(ImageData.Create(info, PixelFormats.Bgra32, null, pixels));
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var info = new AkbMetaData();
bool is_incremental = '+' == (file.ReadUInt32() >> 24);
info.Width = file.ReadUInt16();
info.Height = file.ReadUInt16();
info.Flags = file.ReadUInt32();
info.BPP = 0 == (info.Flags & 0x40000000) ? 32 : 24;
info.Background = file.ReadBytes(4);
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
info.InnerWidth = file.ReadInt32() - info.OffsetX;
info.InnerHeight = file.ReadInt32() - info.OffsetY;
if (info.InnerWidth > info.Width || info.InnerHeight > info.Height)
{
return(null);
}
if (is_incremental)
{
info.BaseFileName = file.ReadCString(0x20);
}
info.DataOffset = (uint)file.Position;
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x14);
int version = header.ToUInt16(4);
if (version != 101 && version != 102)
{
return(null);
}
var info = new PrtMetaData {
Width = header.ToUInt16(0xC),
Height = header.ToUInt16(0xE),
BPP = header.ToUInt16(6),
Version = version,
PaletteOffset = header.ToUInt16(8),
DataOffset = header.ToUInt16(0xA),
HasAlpha = header.ToInt32(0x10) != 0,
};
if (102 == version)
{
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
}
return(info);
}
public void Unpack()
{
m_input.Position = 0x11;
int ctl_length = (m_input.ReadInt32() + 7) / 8;
var ctl_bytes = m_input.ReadBytes(ctl_length);
m_input.ReadInt32();
using (var ctl_mem = new MemoryStream(ctl_bytes))
using (var bits = new LsbBitStream(ctl_mem))
{
int dst = 0;
while (dst < m_output.Length)
{
int bit = bits.GetNextBit();
if (-1 == bit)
{
break;
}
if (0 == bit)
{
m_output[dst++] = m_input.ReadUInt8();
}
else
{
int offset = m_input.ReadUInt16();
int count = (offset & 7) + 1;
offset = (offset >> 3) + 1;
Binary.CopyOverlapped(m_output, dst - offset, dst, count);
dst += count;
}
}
}
}
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 static CgdMetaData FromStream(IBinaryStream file, uint offset)
{
file.Position = offset;
int unpacked_size = file.ReadInt32();
file.ReadInt32();
byte compression = (byte)file.ReadUInt16();
uint header_size = file.ReadUInt16();
uint id = file.ReadUInt32();
if (header_size < 0x10 || (id != 0x973768 && id != 0xB29EA4))
{
return(null);
}
ushort width = file.ReadUInt16();
ushort height = file.ReadUInt16();
ushort bpp = file.ReadUInt16();
return(new CgdMetaData {
Width = width,
Height = height,
BPP = bpp,
DataOffset = offset + 0x10 + header_size,
UnpackedSize = unpacked_size,
Compression = compression,
});
}
} // 'CHD'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
int count = file.ReadInt32();
if (count < 0 || count > 0xFFFFF)
{
return(null);
}
file.ReadInt32();
uint first_offset = 0;
for (int i = 0; i < count && 0 == first_offset; ++i)
{
first_offset = file.ReadUInt32();
}
if (0 == first_offset)
{
return(null);
}
file.Position = first_offset;
var info = new ChdMetaData();
info.Width = file.ReadUInt32();
info.Height = file.ReadUInt32();
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
info.FirstOffset = first_offset + 0x10;
info.BPP = 32;
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var info = new EpaMetaData();
info.Mode = file.ReadInt32() >> 24;
info.ColorType = file.ReadInt32() & 0xff;
switch (info.ColorType)
{
case 0: info.BPP = 8; break;
case 1: info.BPP = 24; break;
case 2: info.BPP = 32; break;
case 3: info.BPP = 15; break;
case 4: info.BPP = 8; break;
default: return(null);
}
info.Width = file.ReadUInt32();
info.Height = file.ReadUInt32();
if (2 == info.Mode)
{
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
}
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
int frames = file.ReadUInt16();
int bpp = file.ReadUInt16();
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
int x = file.ReadInt32();
int y = file.ReadInt32();
file.ReadInt32(); // 0
uint frame_size = file.ReadUInt32();
if (24 != bpp && 8 != bpp)
{
Trace.WriteLine("unsupported bpp", "WipFormat");
return(null);
}
return(new WipMetaData
{
Width = width,
Height = height,
OffsetX = x,
OffsetY = y,
BPP = bpp,
FrameCount = frames,
FrameSize = frame_size,
});
}
} // 'dcf '
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Seek(4, SeekOrigin.Current);
uint header_size = stream.ReadUInt32();
long data_pos = stream.Position + header_size;
if (stream.ReadInt32() != 1)
{
return(null);
}
uint width = stream.ReadUInt32();
uint height = stream.ReadUInt32();
int bpp = stream.ReadInt32();
int name_length = stream.ReadInt32();
if (name_length <= 0)
{
return(null);
}
int shift = (name_length % 7) + 1;
var name_bits = stream.ReadBytes(name_length);
for (int i = 0; i < name_length; ++i)
{
name_bits[i] = Binary.RotByteL(name_bits[i], shift);
}
return(new DcfMetaData
{
Width = width,
Height = height,
BPP = bpp,
BaseName = Encodings.cp932.GetString(name_bits),
DataOffset = data_pos,
});
}
byte[] UnpackCfp0(IBinaryStream input)
{
input.Position = 8;
int unpacked_size = input.ReadInt32();
var output = new byte[unpacked_size];
int dst = 0;
while (dst < output.Length)
{
int cmd = input.ReadByte();
int count = 0;
switch (cmd)
{
case 0:
count = input.ReadUInt8();
input.Read(output, dst, count);
break;
case 1:
count = input.ReadInt32();
input.Read(output, dst, count);
break;
case 2:
{
count = input.ReadUInt8();
byte v = input.ReadUInt8();
for (int i = 0; i < count; ++i)
{
output[dst + i] = v;
}
break;
}
case 3:
{
count = input.ReadInt32();
byte v = input.ReadUInt8();
for (int i = 0; i < count; ++i)
{
output[dst + i] = v;
}
break;
}
case 6:
int offset = input.ReadUInt16();
count = input.ReadUInt16();
Binary.CopyOverlapped(output, dst - offset, dst, count);
break;
case 15:
case -1:
return(output);
}
dst += count;
}
return(output);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.ReadUInt32();
if (file.ReadUInt32() != 0x0a1a0a0d)
{
return(null);
}
uint chunk_size = Binary.BigEndian(file.ReadUInt32());
byte[] chunk_type = file.ReadBytes(4);
if (!Binary.AsciiEqual(chunk_type, "IHDR"))
{
return(null);
}
var meta = new ImageMetaData();
meta.Width = Binary.BigEndian(file.ReadUInt32());
meta.Height = Binary.BigEndian(file.ReadUInt32());
int bpp = file.ReadByte();
int color_type = file.ReadByte();
switch (color_type)
{
case 2: meta.BPP = bpp * 3; break;
case 3: meta.BPP = 24; break;
case 4: meta.BPP = bpp * 2; break;
case 6: meta.BPP = bpp * 4; break;
default: meta.BPP = bpp; break;
}
SkipBytes(file, 7);
for (;;)
{
chunk_size = Binary.BigEndian(file.ReadUInt32());
file.Read(chunk_type, 0, 4);
if (Binary.AsciiEqual(chunk_type, "IDAT") || Binary.AsciiEqual(chunk_type, "IEND"))
{
break;
}
if (Binary.AsciiEqual(chunk_type, "oFFs"))
{
int x = Binary.BigEndian(file.ReadInt32());
int y = Binary.BigEndian(file.ReadInt32());
if (0 == file.ReadByte())
{
meta.OffsetX = x;
meta.OffsetY = y;
}
break;
}
SkipBytes(file, chunk_size + 4);
}
return(meta);
}
public void Unpack()
{
m_input.Position = m_info.DataOffset;
uint name_length = m_input.ReadUInt32();
m_input.Seek(name_length, SeekOrigin.Current);
uint mask = m_input.ReadUInt32();
m_input.Seek(9, SeekOrigin.Current);
int layer_count = m_input.ReadInt32();
if (layer_count < 1)
{
throw new InvalidFormatException();
}
// XXX only first frame is interpreted.
var frame = new Frame(layer_count);
frame.Width = m_input.ReadInt32();
frame.Height = m_input.ReadInt32();
frame.BPP = m_input.ReadInt32();
if (frame.BPP <= 0)
{
throw new InvalidFormatException();
}
if (frame.BPP <= 8)
{
frame.Palette = ImageFormat.ReadColorMap(m_input.AsStream, 1 << frame.BPP);
}
frame.SetStride();
m_frames.Add(frame);
for (int i = 0; i < layer_count; ++i)
{
m_input.ReadInt32(); // left
m_input.ReadInt32(); // top
m_input.ReadByte(); // visibility
m_input.ReadInt32(); // (-1) TransColor
m_input.ReadInt32(); // (0xFF) alpha
m_input.ReadByte(); // AlphaOn
name_length = m_input.ReadUInt32();
m_input.Seek(name_length, SeekOrigin.Current);
if (m_info.Version >= 107)
{
m_input.ReadByte(); // lock
}
var layer = new Layer();
int layer_size = m_input.ReadInt32();
layer.Pixels = UnpackLayer(frame, layer_size);
int alpha_size = m_input.ReadInt32();
if (alpha_size != 0)
{
layer.Alpha = UnpackLayer(frame, alpha_size, true);
}
frame.Layers.Add(layer);
}
Flatten(0);
}
public PgdReader(IBinaryStream input, int position)
{
m_input = input;
m_input.Position = position;
int unpacked_size = m_input.ReadInt32();
m_input.ReadInt32(); // packed_size
m_output = new byte[unpacked_size];
}
public void Unpack()
{
int alpha_size = m_input.ReadInt32();
UnpackAlpha(alpha_size);
int rgb_size = m_input.ReadInt32();
UnpackColor(rgb_size);
}
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;
}
}
}
bool TestAlign(IBinaryStream index, int align)
{
int first_offset = index.ReadInt32();
int size = index.ReadInt32();
int second_offset = (first_offset + size + 7) & -8;
int name_length = index.ReadUInt8();
index.Position = ((align + 1 + name_length) & -align) + 8;
return(second_offset == index.ReadInt32());
}
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,
});
}
}
public BmrDecoder(IBinaryStream input)
{
input.Position = 3;
m_step = input.ReadUInt8();
m_final_size = input.ReadInt32();
m_key = input.ReadInt32();
int unpacked_size = input.ReadInt32();
m_output = new byte[unpacked_size];
m_input = new MsbBitStream(input.AsStream, true);
}
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;
}
}
}
}
internal virtual ImageMetaData GetBaseInfo(IBinaryStream input)
{
input.Position = 4;
return(new ImageMetaData
{
OffsetX = input.ReadInt32(),
OffsetY = input.ReadInt32(),
Width = input.ReadUInt32(),
Height = input.ReadUInt32(),
BPP = 32,
});
}