} // 'GRPH'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x1C);
byte key = (byte)(header[4] ^ header[5]);
int data_offset = 0x14;
int x = 0, y = 0;
if (0 != header[0xC])
{
data_offset += header.ToInt32(0x10) / 0x10 * 0x18;
x = header.ToInt32(0x14);
y = header.ToInt32(0x18);
}
using (var input = new StreamRegion(stream.AsStream, data_offset, true))
using (var crypto = new XoredStream(input, key))
using (var png = new BinaryStream(crypto, stream.Name))
{
var info = Png.ReadMetaData(png);
if (null == info)
{
return(null);
}
return(new KgpMetaData
{
Width = info.Width,
Height = info.Height,
OffsetX = x,
OffsetY = y,
BPP = info.BPP,
Key = key,
DataOffset = data_offset,
DataLength = header.ToInt32(8),
});
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(12);
if (!header.AsciiEqual("GaleX200"))
{
return(null);
}
int header_size = LittleEndian.ToInt32(header, 8);
using (var zheader = new StreamRegion(file.AsStream, 12, header_size, true))
using (var xheader = new ZLibStream(zheader, CompressionMode.Decompress))
{
var xml = ReadXml(xheader);
var frames = xml.DocumentElement.SelectSingleNode("/Frames");
var attr = frames.Attributes;
return(new GalXMetaData
{
Width = UInt32.Parse(attr["Width"].Value),
Height = UInt32.Parse(attr["Height"].Value),
BPP = Int32.Parse(attr["Bpp"].Value),
Version = Int32.Parse(attr["Version"].Value),
FrameCount = Int32.Parse(attr["Count"].Value),
Shuffled = attr["Randomized"].Value != "0",
Compression = Int32.Parse(attr["CompType"].Value),
Mask = (uint)Int32.Parse(attr["BGColor"].Value),
BlockWidth = Int32.Parse(attr["BlockWidth"].Value),
BlockHeight = Int32.Parse(attr["BlockHeight"].Value),
DataOffset = header_size + 12,
FrameXml = frames,
});
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
if (!file.Name.HasExtension(".ies"))
{
return(null);
}
var header = file.ReadHeader(0x10);
if (header.ToInt32(12) != 0)
{
return(null);
}
uint width = header.ToUInt32(0);
uint height = header.ToUInt32(4);
int bpp = header.ToInt32(8);
if (width * height * (bpp / 8) != (file.Length - 0x414))
{
return(null);
}
return(new ImageMetaData
{
Width = width,
Height = height,
BPP = bpp,
});
}
} // 'MGOB'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(12);
if (header.ToInt32(4) != 5)
{
return(null);
}
using (var lzss = new PackedStream <LzssDecompressor> (file.AsStream, true))
using (var stream = new SeekableStream(lzss))
using (var mgo = new BinaryStream(stream, file.Name))
{
var name = mgo.ReadCString();
mgo.Position = ((int)(mgo.Position - 1) & ~3) + 4;
int count = mgo.ReadInt32();
mgo.Seek(count * 0x10, SeekOrigin.Current);
int bmp_position = (int)mgo.Position;
var bmp_header = mgo.ReadBytes(0x36);
if (!bmp_header.AsciiEqual("BM"))
{
return(null);
}
return(new MgoMetaData {
Width = bmp_header.ToUInt32(0x12),
Height = bmp_header.ToUInt32(0x16),
BPP = bmp_header.ToInt32(0x1C),
UnpackedSize = header.ToInt32(8),
BmpOffset = bmp_position,
});
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(9);
int packed_size = header.ToInt32(1);
int unpacked_size = header.ToInt32(5);
if (header[0] != 3 || packed_size != file.Length - 9)
{
return(null);
}
var bmp_header = new byte[56];
Unpack(file, bmp_header);
using (var bmp = new BinMemoryStream(bmp_header))
{
var info = Bmp.ReadMetaData(bmp);
if (null == info)
{
return(null);
}
return(new MinkMetaData {
Width = info.Width,
Height = info.Height,
BPP = info.BPP,
UnpackedSize = unpacked_size,
});
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x40);
byte bpp = header[0x23];
switch (bpp)
{
case 1: bpp = 16; break;
case 2: bpp = 24; break;
case 3: bpp = 32; break;
case 5: bpp = 8; break;
default: return(null);
}
return(new Tim2MetaData {
Width = header.ToUInt16(0x24),
Height = header.ToUInt16(0x26),
BPP = bpp,
PaletteSize = header.ToInt32(0x14),
HeaderSize = header.ToUInt16(0x1C),
Colors = header.ToUInt16(0x1E),
});
}
} // '\x89KGD'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x19);
if (header.ToInt32(4) != 0x10 || header[8] != 1)
{
return(null);
}
byte bpp = header[0x11];
byte color_type = header[0x12];
switch (color_type)
{
case 2: bpp *= 3; break;
case 3: bpp = 24; break;
case 4: bpp *= 2; break;
case 6: bpp *= 4; break;
case 0: break;
default: return(null);
}
return(new KgdMetaData {
Width = header.ToUInt32(9),
Height = header.ToUInt32(0xD),
BPP = bpp,
BitsPerPlane = header[0x11],
ColorType = color_type,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x2A);
int x = header.ToInt32(0);
int y = header.ToInt32(4);
if (Math.Abs(x) > 0x2000 || Math.Abs(y) > 0x2000)
{
return(null);
}
uint width = header.ToUInt32(8);
uint height = header.ToUInt32(12);
if (0 == width || 0 == height ||
width != header.ToUInt16(0x24) ||
height != header.ToUInt16(0x26))
{
return(null);
}
stream.Position = 0x18;
var tga_info = base.ReadMetaData(stream);
if (null == tga_info)
{
return(null);
}
tga_info.OffsetX = x;
tga_info.OffsetY = y;
return(tga_info);
}
} // 'CLM'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x40);
if (!header.AsciiEqual(4, "1.00"))
{
return(null);
}
uint data_offset = header.ToUInt32(0x10);
if (data_offset < 0x40)
{
return(null);
}
uint width = header.ToUInt32(0x1C);
uint height = header.ToUInt32(0x20);
int bpp = header.ToInt32(0x24);
int unpacked_size = header.ToInt32(0x28);
return(new ClmMetaData
{
Width = width,
Height = height,
BPP = bpp,
UnpackedSize = unpacked_size,
DataOffset = data_offset,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x29);
if (header.Length != 0x29)
{
return(null);
}
var gps = new GpsMetaData
{
Width = header.ToUInt32(0x19),
Height = header.ToUInt32(0x1D),
Compression = header[0x10],
UnpackedSize = header.ToInt32(0x11),
PackedSize = header.ToInt32(0x15),
};
// read BMP header
using (var stream = OpenGpsStream(file, gps.Compression, 0x54))
using (var input = BinaryStream.FromStream(stream, file.Name))
{
var bmp_info = base.ReadMetaData(input);
if (null == bmp_info)
{
return(null);
}
gps.BPP = bmp_info.BPP;
return(gps);
}
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(12);
int data_size = header.ToInt32(4);
int pack_size = header.ToInt32(8);
if (data_size < 54)
{
return(null);
}
var reader = new CmpReader(stream.AsStream, pack_size, 0x22); // BMP header
reader.Unpack();
var bmp = reader.Data;
if (bmp[0] != 'B' || bmp[1] != 'M')
{
return(null);
}
int width = LittleEndian.ToInt32(bmp, 0x12);
int height = LittleEndian.ToInt32(bmp, 0x16);
int bpp = LittleEndian.ToInt16(bmp, 0x1c);
return(new GcpMetaData
{
Width = (uint)width,
Height = (uint)height,
BPP = bpp,
DataSize = data_size,
PackedSize = pack_size,
});
}
ImageData ReadAlpha(IBinaryStream alp, ImageMetaData info, byte[] image)
{
var header = alp.ReadHeader(0x10);
if (!header.AsciiEqual("ALP1"))
{
throw new InvalidFormatException();
}
int unpacked_size = header.ToInt32(8);
var alpha = new byte[unpacked_size];
int dst = 0;
while (dst < alpha.Length)
{
byte a = alp.ReadUInt8();
int count = alp.ReadUInt8();
for (int i = 0; i < count; ++i)
{
alpha[dst++] = a;
}
}
int dst_stride = (int)info.Width * 4;
var pixels = new byte[dst_stride * (int)info.Height];
int a_src = 0;
int src = 0;
for (dst = 0; dst < pixels.Length; dst += 4)
{
pixels[dst] = image[src++];
pixels[dst + 1] = image[src++];
pixels[dst + 2] = image[src++];
pixels[dst + 3] = alpha[a_src++];
}
return(ImageData.Create(info, PixelFormats.Bgra32, null, pixels, dst_stride));
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
uint width = file.Signature;
if (width <= 0 || width > 0x800)
{
return(null);
}
var header = file.ReadHeader(0x14);
int bits = header.ToInt32(8);
int code_size = header.ToInt32(12);
int data_size = header.ToInt32(16);
if (bits <= 0 || code_size <= bits || data_size <= 0 ||
code_size + data_size > file.Length)
{
return(null);
}
file.Position = 0x14 + code_size + data_size;
if (file.ReadUInt32() != width)
{
return(null);
}
return(new ImageMetaData {
Width = width * 4,
Height = header.ToUInt32(4),
BPP = 24,
});
}
} // '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 override ImageMetaData ReadMetaData(IBinaryStream file)
{
if (!file.Name.HasAnyOfExtensions("mg1", "mg2"))
{
return(null);
}
var header = file.ReadHeader(0x36);
if (!header.AsciiEqual("BM"))
{
return(null);
}
int width = header.ToInt32(0x12);
int tile_count = 5;
if (file.Name.HasExtension("mg2"))
{
tile_count = width / 32;
}
return(new MgMetaData {
Width = (uint)width,
Height = header.ToUInt32(0x16),
BPP = header.ToInt16(0x1C),
ImageOffset = header.ToUInt32(0x0A),
TileCount = tile_count,
});
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(12);
if (!header.AsciiEqual(8, "WAVE"))
{
return(null);
}
file.Position = 0;
SoundInput sound = new WaveInput(file.AsStream);
if (EmbeddedFormats.Contains(sound.Format.FormatTag))
{
var bin = new BinaryStream(sound, file.Name);
try
{
var embedded = AudioFormat.Read(bin);
if (null != embedded)
{
sound = embedded;
}
}
catch
{
sound.Position = 0;
}
}
return(sound);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x10);
if (!header.AsciiEqual(4, "CG01"))
{
return(null);
}
int length = header.ToInt32(8);
foreach (var scheme in KnownSchemes)
{
using (var input = scheme.CreateStream(file.AsStream, 0x10, length))
using (var png = new BinaryStream(input, file.Name))
{
var info = Png.ReadMetaData(png);
if (null == info)
{
continue;
}
return(new Mg2MetaData
{
Width = info.Width,
Height = info.Height,
OffsetX = info.OffsetX,
OffsetY = info.OffsetY,
BPP = info.BPP,
ImageLength = length,
AlphaLength = header.ToInt32(12),
Scheme = scheme,
});
}
}
return(null);
}
} // 'REB2'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x20);
int start_pos = header.ToInt32(0x10);
if (start_pos < 0x36)
{
return(null);
}
int extra_length = header.ToInt32(0x1C);
int width = header.ToInt32(0x14);
int height = header.ToInt32(0x18);
var info = new CfpMetaData {
Width = header.ToUInt32(0x14),
Height = header.ToUInt32(0x18),
BPP = 32,
};
info.DataLength = width * height * 4;
if (0x20 + info.DataLength > file.Length)
{
info.DataOffset = 0x1C;
}
else
{
info.DataOffset = 0x20 + header.ToInt32(0x1C);
}
return(info);
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0x14);
if (header[4] != 'V')
{
return(null);
}
var key = RpgmvDecryptor.LastKey ?? RpgmvDecryptor.FindKeyFor(file.Name);
if (null == key)
{
return(null);
}
for (int i = 0; i < 4; ++i)
{
header[0x10 + i] ^= key[i];
}
if (!header.AsciiEqual(0x10, "OggS"))
{
RpgmvDecryptor.LastKey = null;
return(null);
}
RpgmvDecryptor.LastKey = key;
var ogg = RpgmvDecryptor.DecryptStream(file, key);
return(OggAudio.Instance.TryOpen(ogg));
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x11);
int version = header[2] - '0';
if (!header.AsciiEqual("GR") || version < 1 || version > 3)
{
return(null);
}
var info = new GrpMetaData {
Width = header.ToUInt32(5),
Height = header.ToUInt32(9),
BPP = header.ToUInt16(3),
Version = version
};
if (version > 1)
{
info.UnpackedSize = header.ToInt32(0xD);
}
else
{
info.UnpackedSize = (int)info.Width * (int)info.Height * info.BPP / 8
+ (info.BPP == 8 ? 0x300 : 0);
}
return(info);
}
} // 'MICO'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x10);
if (!header.AsciiEqual(4, "CG01"))
{
return(null);
}
int length = header.ToInt32(8);
using (var input = new Mg2EncryptedStream(file.AsStream, 0x10, length))
using (var png = new BinaryStream(input, file.Name))
{
var info = Png.ReadMetaData(png);
if (null == info)
{
return(null);
}
return(new Mg2MetaData
{
Width = info.Width,
Height = info.Height,
OffsetX = info.OffsetX,
OffsetY = info.OffsetY,
BPP = info.BPP,
ImageLength = length,
AlphaLength = header.ToInt32(12)
});
}
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x80);
int version = header.ToInt32(4);
if (version != 1 && version != 2)
{
return(null);
}
var info = new AgfMetaData
{
Width = header.ToUInt32(0x1C),
Height = header.ToUInt32(0x20),
BPP = 32,
Version = version,
};
if (1 == version)
{
info.DataOffset = header.ToUInt32(0x0C);
}
else
{
info.DataOffset = header.ToUInt32(0x10);
info.Flags = header.ToUInt32(0x54);
info.BaseNameOffset = header.ToUInt32(0x6C);
}
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 override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x28);
int version = header[3] - '0';
var info = new GhpMetaData {
Width = header.ToUInt16(0xC),
Height = header.ToUInt16(0xE),
BPP = 8,
Colors = header.ToUInt16(0x10),
Version = version,
};
if (2 == version)
{
info.PaletteOffset = header.ToUInt32(0x14);
info.ChunkCount = header.ToInt32(0x18);
info.DataOffset = header.ToUInt32(0x1C);
}
else
{
info.PaletteOffset = header.ToUInt32(0x18);
info.DataOffset = header.ToUInt32(0x24);
}
return(info);
}
public override SoundInput TryOpen(IBinaryStream file)
{
if (!file.Name.HasExtension("PWV"))
{
return(null);
}
var header = file.ReadHeader(0x10);
if (!header.AsciiEqual(9, "WAVE"))
{
return(null);
}
var output = new MemoryStream((int)file.Length);
try
{
file.Position = 0;
Unpack(file, output);
output.Position = 0;
var wave = new WaveInput(output);
file.Dispose();
return(wave);
}
catch
{
output.Dispose();
throw;
}
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x28);
if (0xFFFF != header.ToInt32(8))
{
return(null);
}
int packed_size = header.ToInt32(0);
int unpacked_size = header.ToInt32(4);
uint width = header.ToUInt32(0x10);
uint height = header.ToUInt32(0x14);
int bpp = header.ToInt32(0x18);
if (0 == width || 0 == height || width > 0x7fff || height > 0x7fff ||
(bpp != 32 && bpp != 24 && bpp != 8) ||
unpacked_size <= 0 || packed_size < 0)
{
return(null);
}
return(new GrpMetaData
{
Width = width,
Height = height,
BPP = bpp,
PackedSize = packed_size,
UnpackedSize = unpacked_size,
Offset = 0xFFFF,
HeaderSize = 0x28,
AlphaChannel = header.ToInt32(0x24) != 0,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x10);
int packed_size = header.ToInt32(12);
if (packed_size <= 0 || packed_size > stream.Length - 0x10)
{
return(null);
}
uint width = header.ToUInt16(8);
uint height = header.ToUInt16(10);
if (0 == width || 0 == height)
{
return(null);
}
return(new SeraphMetaData
{
OffsetX = header.ToInt16(4),
OffsetY = header.ToInt16(6),
Width = width,
Height = height,
BPP = 24,
PackedSize = packed_size,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x18);
if (header[3] != 0xA5 || header[7] != 0x35)
{
return(null);
}
header[0] ^= 0x5A; // 0xA53CC35A
header[1] ^= 0xC3;
header[2] ^= 0x3C;
header[3] ^= 0xA5;
header[4] ^= 0x05; // 0x35421005
header[5] ^= 0x10;
header[6] ^= 0x42;
header[7] ^= 0x35;
header[0x10] ^= 0x5D; // 0xCF42355D
header[0x11] ^= 0x35;
header[0x12] ^= 0x42;
header[0x13] ^= 0xCF;
var info = UnpackHeader(header);
if (info != null)
{
info.IsEncrypted = true;
}
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x22);
if (!header.AsciiEqual(".TRUE\x8d\x5d\x8c\xcb\x00"))
{
return(null);
}
uint width = header.ToUInt16(0x0e);
uint height = header.ToUInt16(0x10);
uint comp_size = header.ToUInt32(0x1a);
uint extra_size = header.ToUInt32(0x1e);
if (extra_size % 3 != 0 || 0 == extra_size)
{
return(null);
}
return(new EdtMetaData
{
Width = width,
Height = height,
BPP = 24,
CompSize = comp_size,
ExtraSize = extra_size,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(0x11);
if (!header.AsciiEqual(2, "ike") || !header.AsciiEqual(0xF, "BM"))
{
return(null);
}
int unpacked_size = IkeReader.DecodeSize(header[10], header[11], header[12]);
using (var bmp = IkeReader.CreateStream(file, 0x36))
{
var info = Bmp.ReadMetaData(bmp);
if (null == info)
{
return(null);
}
return(new IkeMetaData {
Width = info.Width,
Height = info.Height,
BPP = info.BPP,
UnpackedSize = unpacked_size,
});
}
}
