public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var pent = entry as PackedEntry;
IBinaryStream input = arc.File.CreateStream(entry.Offset, entry.Size, entry.Name);
if (null != pent && pent.IsPacked)
{
IBinaryStream unpacked;
using (input)
{
var data = new byte[pent.UnpackedSize];
UnpackEntry(input.AsStream, data);
unpacked = new BinMemoryStream(data, entry.Name);
}
input = unpacked;
}
if (input.Length > 4 && input.Length < 0x10000)
{
int unpacked_size = input.ReadUInt16();
int packed_size = input.ReadUInt16();
if (packed_size == input.Length - 4)
{
using (input)
{
var data = new byte[unpacked_size];
UnpackLz77(input.AsStream, data);
return(new BinMemoryStream(data, entry.Name));
}
}
input.Position = 0;
}
return(input.AsStream);
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var bmp_data = Decompress(file);
using (var bmp = new BinMemoryStream(bmp_data))
return(Bmp.Read(bmp, info));
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var actarc = arc as ActressArchive;
if (null == actarc || null == actarc.Key)
{
return(base.OpenEntry(arc, entry));
}
var header = ReadEntryHeader(actarc, entry);
Stream input;
if (entry.Size <= 0x20)
{
input = new BinMemoryStream(header, entry.Name);
}
else
{
input = new PrefixStream(header, arc.File.CreateStream(entry.Offset + 0x20, entry.Size - 0x20));
}
if (header.AsciiEqual("BM"))
{
return(input);
}
input.Position = 4;
return(new LzssStream(input));
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var bmp_header = Decompress(file, 0x36);
using (var bmp = new BinMemoryStream(bmp_header))
return(Bmp.ReadMetaData(bmp));
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
uint length = file.ReadUInt32() ^ DefaultHeaderKey;
if (length <= 0)
{
return(null);
}
var header = new byte[0x36];
Unpack(file, header);
if (!header.AsciiEqual("BM"))
{
return(null);
}
using (var bmp = new BinMemoryStream(header))
{
var info = Bmp.ReadMetaData(bmp) as BmpMetaData;
if (info != null)
{
info.ImageLength = length;
}
return(info);
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var header = file.ReadHeader(8);
if (!header.AsciiEqual("YP"))
{
return(null);
}
int unpacked_size = header.ToInt24(2);
int packed_size = header.ToInt24(5);
var data = LzUnpack(file, 0x36);
using (var bmp = new BinMemoryStream(data, file.Name))
{
var info = Bmp.ReadMetaData(bmp);
if (null == info)
{
return(info);
}
return(new YpMetaData {
Width = info.Width,
Height = info.Height,
BPP = info.BPP,
UnpackedSize = unpacked_size,
});
}
}
ImageData Unpack()
{
BitmapSource image;
using (var jpeg = new BinMemoryStream(m_input, 6, m_jpeg_length))
{
var decoder = new JpegBitmapDecoder(jpeg, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
image = decoder.Frames[0];
}
Info = new ImageMetaData {
Width = (uint)image.PixelWidth,
Height = (uint)image.PixelHeight,
BPP = image.Format.BitsPerPixel,
};
byte[] alpha = new byte[image.PixelWidth * image.PixelHeight];
using (var input = new BinMemoryStream(m_input, 6 + m_jpeg_length, m_input.Length - (6 + m_jpeg_length)))
using (var alpha_data = new ZLibStream(input, CompressionMode.Decompress))
{
alpha_data.Read(alpha, 0, alpha.Length);
}
if (image.Format.BitsPerPixel != 32)
{
image = new FormatConvertedBitmap(image, PixelFormats.Bgr32, null, 0);
}
int stride = image.PixelWidth * 4;
var pixels = new byte[stride * image.PixelHeight];
image.CopyPixels(pixels, stride, 0);
ApplyAlpha(pixels, alpha);
return(ImageData.Create(Info, PixelFormats.Bgra32, null, pixels, stride));
}
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 ImageData Read(IBinaryStream stream, ImageMetaData info)
{
if (stream.Length > int.MaxValue)
{
throw new FileSizeException();
}
var header = stream.ReadHeader(14);
int data_length = header.ToInt32(10);
int input_length = (int)(stream.Length - stream.Position);
using (var lz = new LzssReader(stream.AsStream, input_length, data_length))
{
lz.FrameSize = 0x1000;
lz.FrameFill = 0x20;
lz.FrameInitPos = 0x1000 - 0x10;
lz.Unpack();
var data = lz.Data;
int count = Math.Min(100, data.Length);
for (int i = 0; i < count; ++i)
{
data[i] ^= 0xff;
}
using (var bmp = new BinMemoryStream(data, stream.Name))
return(base.Read(bmp, info));
}
}
public override IImageDecoder OpenImage(ArcFile arc, Entry entry)
{
// XXX compression method identical to Maika.Mk2Opener
var id_str = arc.File.View.ReadString(entry.Offset, 2);
if (id_str != "B1" && id_str != "D1" && id_str != "E1")
{
return(base.OpenImage(arc, entry));
}
uint packed_size = arc.File.View.ReadUInt32(entry.Offset + 2);
if (packed_size != entry.Size - 10)
{
return(base.OpenImage(arc, entry));
}
uint unpacked_size = arc.File.View.ReadUInt32(entry.Offset + 6);
using (var input = arc.File.CreateStream(entry.Offset + 10, packed_size))
using (var lzss = new LzssReader(input, (int)packed_size, (int)unpacked_size))
{
lzss.Unpack();
var bmp = new BinMemoryStream(lzss.Data, entry.Name);
return(new ImageFormatDecoder(bmp));
}
}
public override Stream EntryReadFilter(Xp3Entry entry, Stream input)
{
if (entry.UnpackedSize <= 15 || "audio" == entry.Type)
return input;
var header = new byte[15];
input.Read (header, 0, 15);
if (CzMagic == header.ToUInt32 (0))
{
var type = new char[3] {
(char)(header[4] ^ 0x11),
(char)(header[5] ^ 0x7F),
(char)(header[6] ^ 0x9A)
};
byte key = (byte)type[0];
int unpacked_size = CzDecryptInt (header, 7, key);
int packed_size = CzDecryptInt (header, 11, key);
if (packed_size < entry.UnpackedSize && 0 == ((packed_size-5) & 0xF))
{
var data = new byte[packed_size];
input.Read (data, 0, packed_size);
input.Dispose();
data = CzDecryptData (data);
input = new BinMemoryStream (data);
if ('C' == type[0])
input = new ZLibStream (input, CompressionMode.Decompress);
return input;
}
}
if (!input.CanSeek)
return new PrefixStream (header, input);
input.Position = 0;
return input;
}
/// <summary>
// Try to parse file containing game meta-information.
/// </summary>
internal string TryParseMeta(string meta_arc_name)
{
if (!VFS.FileExists(meta_arc_name))
{
return(null);
}
using (var unpacker = new TocUnpacker(meta_arc_name))
{
if (unpacker.Length > 0x1000)
{
return(null);
}
var data = unpacker.Unpack(8);
if (null == data)
{
return(null);
}
using (var content = new BinMemoryStream(data))
{
int title_length = content.ReadInt32();
if (title_length <= 0 || title_length > content.Length)
{
return(null);
}
var title = content.ReadBytes(title_length);
if (title.Length != title_length)
{
return(null);
}
return(Encodings.cp932.GetString(title));
}
}
}
public static byte[] GetKeyDataFromExe(string filename)
{
using (var exe = new ExeFile.ResourceAccessor(filename))
{
var tform = exe.GetResource("TFORM1", "#10");
if (null == tform || !tform.AsciiEqual(0, "TPF0"))
{
return(null);
}
using (var input = new BinMemoryStream(tform))
{
var deserializer = new DelphiDeserializer(input);
var form = deserializer.Deserialize();
var image = form.Contents.FirstOrDefault(n => n.Name == "IconKeyImage");
if (null == image)
{
return(null);
}
var icon = image.Props["Picture.Data"] as byte[];
if (null == icon || icon.Length < 0x106 || !icon.AsciiEqual(0, "\x05TIcon"))
{
return(null);
}
return(new CowArray <byte> (icon, 6, 0x100).ToArray());
}
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var rent = entry as RepiEntry;
if (null == rent || !rent.HasEncryptionKey)
{
return(arc.File.CreateStream(entry.Offset, entry.Size));
}
var key = rent.CreateKey();
uint enc_length = Math.Min((uint)key.Length, entry.Size);
byte[] encrypted = arc.File.View.ReadBytes(entry.Offset, enc_length);
DecryptEntry(encrypted, key);
Stream input;
if (enc_length == entry.Size)
{
input = new BinMemoryStream(encrypted, entry.Name);
}
else
{
input = arc.File.CreateStream(entry.Offset + enc_length, entry.Size - enc_length);
input = new PrefixStream(encrypted, input);
}
if (rent.IsPacked)
{
input = new LzssStream(input);
}
return(input);
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (MgrMetaData)info;
stream.Position = meta.Offset;
var data = new byte[meta.UnpackedSize];
if (data.Length != MgrOpener.Decompress(stream.AsStream, data))
{
throw new InvalidFormatException();
}
if (meta.BPP != 32)
{
using (var bmp = new BinMemoryStream(data, stream.Name))
return(Bmp.Read(bmp, info));
}
// special case for 32bpp bitmaps with alpha-channel
int stride = (int)meta.Width * 4;
var pixels = new byte[stride * (int)meta.Height];
int src = LittleEndian.ToInt32(data, 0xA);
for (int dst = stride * ((int)meta.Height - 1); dst >= 0; dst -= stride)
{
Buffer.BlockCopy(data, src, pixels, dst, stride);
src += stride;
}
return(ImageData.Create(info, PixelFormats.Bgra32, null, pixels));
}
public override IImageDecoder OpenImage(ArcFile arc, Entry entry)
{
var g00arc = (G00Archive)arc;
var g00ent = (G00Entry)entry;
var input = new BinMemoryStream(g00arc.Bitmap);
return(new G00TileDecoder(input, g00arc.ImageInfo, g00ent));
}
SoundInput RebuildVorbis(Sample sample)
{
if (!sample.MetaData.ContainsKey(ChunkType.VorbisData))
{
throw new InvalidFormatException("No VORBISDATA chunk in FSB5 Vorbis stream.");
}
var vorbis_data = sample.MetaData[ChunkType.VorbisData] as VorbisData;
var setup_data = GetVorbisHeader(vorbis_data.Crc32);
var state = new OggStreamState(1);
var id_packet = RebuildIdPacket(sample, 0x100, 0x800);
var comment_packet = RebuildCommentPacket();
var setup_packet = RebuildSetupPacket(setup_data);
var info = CreateVorbisInfo(sample, setup_packet);
var output = new MemoryStream();
state.PacketIn(id_packet);
state.Write(output);
state.PacketIn(comment_packet);
state.Write(output);
state.PacketIn(setup_packet);
state.Write(output);
state.Flush(output);
long packet_no = setup_packet.PacketNo + 1;
long granule_pos = 0;
int prev_block_size = 0;
using (var input = new BinMemoryStream(sample.Data))
{
var packet = new OggPacket();
int packet_size = ReadPacketSize(input);
while (packet_size > 0)
{
packet.SetPacket(packet_no++, input.ReadBytes(packet_size));
packet_size = ReadPacketSize(input);
packet.EoS = 0 == packet_size;
int block_size = info.PacketBlockSize(packet);
if (prev_block_size != 0)
{
granule_pos += (block_size + prev_block_size) / 4;
}
else
{
granule_pos = 0;
}
packet.GranulePos = granule_pos;
prev_block_size = block_size;
state.PacketIn(packet);
state.Write(output);
}
}
output.Position = 0;
return(new OggInput(output));
}
public byte[] Unpack()
{
using (var packed = new BinMemoryStream(m_src, m_input_pos, m_remaining))
using (var hstr = new HuffmanStream(packed))
{
hstr.Read(m_dst, 0, m_dst.Length);
return(m_dst);
}
}
public List <Entry> Read()
{
byte[] packed;
using (var input = m_file.CreateStream(12, m_data_offset - 12))
using (var bits = new MsbBitStream(input))
{
bits.GetNextBit();
m_dict = ReadBytes(bits);
if (null == m_dict)
{
return(null);
}
int packed_size = ReadInt32(bits);
int unpacked_size = ReadInt32(bits);
packed = new byte[packed_size];
for (int i = 0; i < packed_size; ++i)
{
packed[i] = (byte)bits.GetBits(8);
}
}
using (var bstr = new BinMemoryStream(packed))
using (var zstr = new ZLibStream(bstr, CompressionMode.Decompress))
using (var index = new MsbBitStream(zstr))
{
index.GetNextBit();
int count = ReadInt32(index);
if (!ArchiveFormat.IsSaneCount(count))
{
return(null);
}
var dir = new List <Entry> (count);
for (int i = 0; i < count; ++i)
{
if (index.GetBits(2) == -1)
{
break;
}
var name_buf = ReadEncryptedChars(index);
if (null == name_buf)
{
return(null);
}
var name = DecryptString(name_buf, name_buf.Length);
var entry = FormatCatalog.Instance.Create <Entry> (name);
ReadInt32(index);
ReadInt32(index);
entry.Offset = (uint)ReadInt32(index) + m_data_offset;
entry.Size = (uint)ReadInt32(index);
if (!entry.CheckPlacement(m_file.MaxOffset))
{
return(null);
}
dir.Add(entry);
}
return(dir);
}
}
IarImage CombineImage(IarImage overlay, IarArchive iarc)
{
using (var input = new BinMemoryStream(overlay.Data))
{
var dir = (List <Entry>)iarc.Dir;
int base_index = input.ReadInt32();
if (base_index >= dir.Count)
{
throw new InvalidFormatException("Invalid base image index");
}
int diff_y = input.ReadInt32();
int diff_count = input.ReadInt32();
var overlay_info = overlay.Info;
int pixel_size = overlay_info.BPP / 8;
var base_image = new IarImage(iarc, dir[base_index]);
byte[] output = base_image.Data;
if (overlay_info.Height != base_image.Info.Height || overlay_info.Stride != base_image.Info.Stride)
{
int src_height = (int)Math.Min(overlay_info.Height, base_image.Info.Height);
int src_stride = Math.Min(overlay_info.Stride, base_image.Info.Stride);
byte[] src = base_image.Data;
output = new byte[overlay_info.Height * overlay_info.Stride];
int dst_pos = 0;
if (base_image.Info.OffsetY < overlay_info.OffsetY)
{
dst_pos += (-base_image.Info.OffsetY + overlay_info.OffsetY) * overlay_info.Stride;
}
if (base_image.Info.OffsetX < overlay_info.OffsetX)
{
dst_pos += (-base_image.Info.OffsetX + overlay_info.OffsetX) * pixel_size;
}
for (int y = 0; y < src_height; ++y)
{
Buffer.BlockCopy(src, y * base_image.Info.Stride, output, dst_pos, src_stride);
dst_pos += overlay_info.Stride;
}
}
int dst = diff_y * overlay_info.Stride;
for (int i = 0; i < diff_count; ++i)
{
int chunk_count = input.ReadUInt16();
int x = 0;
for (int j = 0; j < chunk_count; ++j)
{
int skip_count = pixel_size * input.ReadUInt16();
int copy_count = pixel_size * input.ReadUInt16();
x += skip_count;
input.Read(output, dst + x, copy_count);
x += copy_count;
}
dst += overlay_info.Stride;
}
return(new IarImage(overlay_info, output, overlay.Palette));
}
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
int unpacked_size = (int)file.Signature;
file.Position = 4;
var unpacked = Decompress(file, unpacked_size);
using (var bmp = new BinMemoryStream(unpacked, file.Name))
return(Bmp.Read(bmp, info));
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (YpMetaData)info;
file.Position = 8;
var data = LzUnpack(file, meta.UnpackedSize);
using (var bmp = new BinMemoryStream(data, file.Name))
return(Bmp.Read(bmp, info));
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (BmpMetaData)info;
var data = new byte[meta.ImageLength];
file.Position = 8;
Unpack(file, data);
using (var bmp = new BinMemoryStream(data))
return(Bmp.Read(bmp, info));
}
public void UnpackAlpha(int offset)
{
using (var input = new BinMemoryStream(this.Input, offset, Input.Length - offset))
{
if (1 != input.ReadInt32())
{
return;
}
int dst = 3;
int ctl = 1 << 1;
while (dst < Output.Length)
{
ctl >>= 1;
if (1 == ctl)
{
ctl = input.ReadUInt8() | 0x100;
}
if (0 != (ctl & 1))
{
int v = input.ReadUInt16();
int x = v & 0x3F;
if (x > 0x1F)
{
x |= -0x40;
}
int y = (v >> 6) & 7;
if (y != 0)
{
y |= -8;
}
int count = ((v >> 9) & 0x7F) + 3;
int src = dst + (x + y * Width) * 4;
if (src < 0 || src >= dst)
{
return;
}
for (int i = 0; i < count; ++i)
{
Output[dst] = Output[src];
src += 4;
dst += 4;
}
}
else
{
Output[dst] = input.ReadUInt8();
dst += 4;
}
}
HasAlpha = true;
}
}
public override ArcFile TryOpen(ArcView file)
{
if ((file.View.ReadInt32(0) | file.View.ReadInt32(4) | file.View.ReadInt32(8)) != 0)
{
return(null);
}
int key = file.View.ReadInt32(0x10);
int count = file.View.ReadInt32(0x14);
if (!IsSaneCount(count))
{
return(null);
}
uint index_offset = 0x18;
var index = new Dictionary <int, Entry> (count);
for (int i = 0; i < count; ++i)
{
int id = file.View.ReadInt32(index_offset);
var entry = new Entry {
Offset = file.View.ReadUInt32(index_offset + 4),
Size = file.View.ReadUInt32(index_offset + 8),
};
if (!entry.CheckPlacement(file.MaxOffset))
{
return(null);
}
index[id] = entry;
index_offset += 12;
}
var names_entry = index[0];
var names = file.View.ReadBytes(names_entry.Offset, names_entry.Size);
if (key != 0)
{
DecryptData(names, key);
}
using (var input = new BinMemoryStream(names))
{
while (input.PeekByte() != -1)
{
int id = input.ReadInt32();
var name = input.ReadCString();
if (!string.IsNullOrEmpty(name))
{
var entry = index[id];
entry.Name = name;
entry.Type = FormatCatalog.Instance.GetTypeFromName(name);
}
}
}
var dir = index.Values.Where(e => !string.IsNullOrEmpty(e.Name)).ToList();
return(new YkArchive(file, this, dir, key));
}
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 override ArcFile TryOpen(ArcView file)
{
uint index_size = file.View.ReadUInt32(4);
if (index_size < 0x10 || index_size >= file.MaxOffset)
{
return(null);
}
IBinaryStream index;
bool is_encrypted = file.View.ReadByte(3) == '2';
if (is_encrypted)
{
var index_bytes = new byte[(index_size + 3) & ~3u];
file.View.Read(8, index_bytes, 0, index_size);
DecryptIndex(index_bytes, (int)index_size);
index = new BinMemoryStream(index_bytes, 0, (int)index_size, file.Name);
}
else
{
index = file.CreateStream(8, index_size);
}
using (index)
{
uint index_pos = 0;
var dir = new List <Entry>();
while (index_pos < index_size)
{
index.Position = index_pos;
uint offset = index.ReadUInt32();
if (0 == offset)
{
break;
}
uint size = index.ReadUInt32();
byte name_length = index.ReadUInt8();
var name = index.ReadCString(name_length);
index_pos += ((5u + name_length) & ~3u) + 8u;
var entry = FormatCatalog.Instance.Create <Entry> (name);
entry.Offset = offset;
entry.Size = size;
if (!entry.CheckPlacement(file.MaxOffset))
{
return(null);
}
dir.Add(entry);
}
if (0 == dir.Count)
{
return(null);
}
return(new ArcFile(file, this, dir));
}
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (EgnMetaData)info;
stream.Position = meta.DataOffset;
var reader = new Reader(stream, meta.UnpackedSize, meta.Mode, meta.Flag);
reader.Unpack();
using (var bmp = new BinMemoryStream(reader.Data, stream.Name))
return(Bmp.Read(bmp, info));
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (MinkMetaData)info;
file.Position = 9;
var pixels = new byte[meta.UnpackedSize];
Unpack(file, pixels);
using (var bmp = new BinMemoryStream(pixels, file.Name))
return(Bmp.Read(bmp, info));
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (ExpMetaData)info;
file.Position = 0x28;
var reader = new ExpReader(file, meta.BitmapFileName);
var bmp_data = reader.Unpack(meta.BitmapSize);
using (var mem_bmp = new BinMemoryStream(bmp_data, file.Name))
return(Bmp.Read(mem_bmp, info));
}
