public override ImageData Read(Stream stream, ImageMetaData info)
{
var header = PngHeader.Clone() as byte[];
using (var data = new StreamRegion (stream, 8, stream.Length - 8, true))
using (var png = new PrefixStream (header, data))
return base.Read (png, info);
}
BitmapSource ReadBitmapSource(IBinaryStream file, GdtMetaData info)
{
using (var bmp = new StreamRegion(file.AsStream, info.BitmapOffset, true))
{
var decoder = new BmpBitmapDecoder(bmp,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
return(decoder.Frames[0]);
}
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (GaxMetaData)info;
using (var enc = new StreamRegion(stream.AsStream, 0x14, true))
using (var crypto = new InputCryptoStream(enc, new GaxTransform(meta.Key)))
using (var input = new BinaryStream(crypto, stream.Name))
return(Png.Read(input, info));
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var header = PngHeader.Clone() as byte[];
using (var data = new StreamRegion(stream.AsStream, 8, true))
using (var pre = new PrefixStream(header, data))
using (var png = new BinaryStream(pre, stream.Name))
return(base.Read(png, info));
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (GgpMetaData)info;
using (var input = new StreamRegion(file.AsStream, meta.Offset, meta.Length, true))
using (var enc = new EncryptedStream(input, meta.Key))
using (var png = new BinaryStream(enc, file.Name))
return(base.Read(png, info));
}
/// <summary>
/// Peeks the value at given offset in the stream without changing stream position.
/// </summary>
/// <typeparam name="T">The type of the value which is peeked from the stream.</typeparam>
/// <param name="offset">The offset which the channel peeks value from.</param>
/// <returns>The value peeked from the channel.</returns>
public T Peek <T>(int offset)
{
lock (readerLock)
{
StreamRegion region = new StreamRegion(this, offset);
object x = readerMarshaler.UnmarshalFrom(new MarshalingDescriptor(typeof(T)), region);
return((T)x);
}
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (KgpMetaData)info;
using (var input = new StreamRegion(stream.AsStream, meta.DataOffset, true))
using (var crypto = new XoredStream(input, meta.Key))
using (var png = new BinaryStream(crypto, stream.Name))
return(Png.Read(png, info));
}
void ReadAlpha()
{
int alpha_stride = (m_width + 3) & ~3;
Stream alpha_stream;
if (m_info.AlphaSize == alpha_stride * m_height)
{
alpha_stream = new StreamRegion(m_input, m_input.Position, true);
}
else
{
alpha_stream = new LzssStream(m_input, LzssMode.Decompress, true);
}
using (alpha_stream)
{
int src_stride = Stride;
int new_stride = m_width * 4;
bool extend_alpha = 3 != m_info.Flags;
var alpha_line = new byte[alpha_stride];
var pixels = new byte[new_stride * m_height];
for (int y = 0; y < m_height; ++y)
{
int src = y * src_stride;
int dst = y * new_stride;
if (alpha_line.Length != alpha_stream.Read(alpha_line, 0, alpha_line.Length))
{
throw new EndOfStreamException();
}
for (int x = 0; x < m_width; ++x)
{
if (8 == m_info.BPP)
{
var color = Palette.Colors[m_output[src++]];
pixels[dst++] = color.B;
pixels[dst++] = color.G;
pixels[dst++] = color.R;
}
else
{
pixels[dst++] = m_output[src++];
pixels[dst++] = m_output[src++];
pixels[dst++] = m_output[src++];
}
int alpha = alpha_line[x];
if (extend_alpha)
{
alpha = alpha >= 0x10 ? 0xFF : alpha * 0x10;
}
pixels[dst++] = (byte)alpha;
}
}
Stride = new_stride;
Palette = null;
m_output = pixels;
}
}
IBinaryStream DeobfuscateStream(IBinaryStream file)
{
var header = file.ReadHeader(4).ToArray();
header[0] = 0x89;
var body = new StreamRegion(file.AsStream, 4, true);
var png = new PrefixStream(header, body);
return(new BinaryStream(png, file.Name));
}
IBinaryStream OpenAsBitmap(IBinaryStream input)
{
var header = new byte[2] {
(byte)'B', (byte)'M'
};
Stream stream = new StreamRegion(input.AsStream, 2, true);
stream = new PrefixStream(header, stream);
return(new BinaryStream(stream, input.Name));
}
/// <summary>
/// Reads a value of the given type T from the stream which uses the underlying marshaler to unmarshal it.
/// </summary>
/// <typeparam name="T">The type of the value to be read.</typeparam>
/// <returns>The value read from the channel.</returns>
public virtual T Read <T>()
{
lock (readerLock)
{
StreamRegion region = new StreamRegion(this, 0);
object value = readerMarshaler.UnmarshalFrom(new MarshalingDescriptor(typeof(T)), region);
AdvanceReadBuffer(region.Offset);
return((T)value);
}
}
public override SoundInput TryOpen(Stream file)
{
var header = new byte[0x30];
if (header.Length != file.Read (header, 0, header.Length))
return null;
if (!Binary.AsciiEqual (header, 0, "AoiOgg") || !Binary.AsciiEqual (header, 0x2C, "OggS"))
return null;
var ogg = new StreamRegion (file, 0x2C);
return new OggInput (ogg);
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
var meta = (MgxMetaData)info;
using (var input = new StreamRegion(file.AsStream, meta.GrxOffset, true))
{
var reader = new Reader(input, meta);
reader.Unpack();
return(ImageData.Create(info, reader.Format, null, reader.Data, reader.Stride));
}
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (SgxMetaData)info;
using (var grx = new StreamRegion(stream.AsStream, meta.GrxOffset, true))
{
var reader = new Reader(grx, (GrxMetaData)meta.GrxInfo);
reader.Unpack();
return(ImageData.Create(info, reader.Format, null, reader.Data, reader.Stride));
}
}
} // 'AoiO'
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0x30);
if (!header.AsciiEqual(0, "AoiOgg") || !header.AsciiEqual(0x2C, "OggS"))
{
return(null);
}
var ogg = new StreamRegion(file.AsStream, 0x2C);
return(new OggInput(ogg));
}
public override ImageData Read(Stream file, ImageMetaData info)
{
var meta = info as GgpMetaData;
if (null == meta)
{
throw new ArgumentException("GgpFormat.Read should be supplied with GgpMetaData", "info");
}
using (var input = new StreamRegion(file, meta.Offset, meta.Length, true))
using (var png = new EncryptedStream(input, meta.Key, true))
return(base.Read(png, info));
}
IBinaryStream OpenAsBitmap(IBinaryStream input)
{
var header = new byte[HeaderSize];
header[0] = (byte)'B';
header[1] = (byte)'M';
LittleEndian.Pack((uint)input.Length, header, 2);
Stream stream = new StreamRegion(input.AsStream, HeaderSize, true);
stream = new PrefixStream(header, stream);
return(new BinaryStream(stream, input.Name));
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (BipMetaData)info;
var header = new byte[0x7c];
var bitmap = new WriteableBitmap((int)meta.Width, (int)meta.Height,
ImageData.DefaultDpiX, ImageData.DefaultDpiY, PixelFormats.Bgra32, null);
foreach (var tile in meta.Tiles)
{
stream.Position = tile.Offset;
if (header.Length != stream.Read(header, 0, header.Length))
{
throw new InvalidFormatException("Invalid tile header");
}
if (!Binary.AsciiEqual(header, "PNGFILE2"))
{
throw new InvalidFormatException("Unknown tile format");
}
int data_size = LittleEndian.ToInt32(header, 0x18) - header.Length;
int alpha = LittleEndian.ToInt32(header, 0x68);
int x = LittleEndian.ToInt32(header, 0x6c);
int y = LittleEndian.ToInt32(header, 0x70);
using (var png = new StreamRegion(stream.AsStream, stream.Position, data_size, true))
{
var decoder = new PngBitmapDecoder(png,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapSource frame = decoder.Frames[0];
PixelFormat format = 0 == alpha ? PixelFormats.Bgr32 : PixelFormats.Bgra32;
var converted = new FormatConvertedBitmap(frame, format, null, 0);
int stride = converted.PixelWidth * 4;
var pixels = new byte[stride * converted.PixelHeight];
converted.CopyPixels(pixels, stride, 0);
for (int p = 0; p < pixels.Length; p += 4)
{
byte r = pixels[p];
pixels[p] = pixels[p + 2];
pixels[p + 2] = r;
int a = 0 == alpha ? 0xff : pixels[p + 3] * 0xff / 0x80;
if (a > 0xff)
{
a = 0xff;
}
pixels[p + 3] = (byte)a;
}
var rect = new Int32Rect(tile.Left + x, tile.Top + y, converted.PixelWidth, converted.PixelHeight);
bitmap.WritePixels(rect, pixels, stride, 0);
}
}
bitmap.Freeze();
return(new ImageData(bitmap, meta));
}
public override ImageMetaData ReadMetaData(Stream stream)
{
var header = new byte[8];
if (8 != stream.Read (header, 0, 8))
return null;
if (!Binary.AsciiEqual (header, "MalieGF"))
return null;
Buffer.BlockCopy (PngHeader, 0, header, 0, 8);
using (var data = new StreamRegion (stream, 8, stream.Length - 8, true))
using (var png = new PrefixStream (header, data))
return base.ReadMetaData (png);
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0x10); // header contains music loop timing
if (!header.AsciiEqual(0xC, "OggS"))
{
return(null);
}
var input = new StreamRegion(file.AsStream, 12);
return(new OggInput(input));
// input is [intentionally] left undisposed in case of exception.
}
internal IBinaryStream DeobfuscateStream(IBinaryStream file)
{
var header = file.ReadHeader(0x20).ToArray();
for (int i = 0; i < 0x20; ++i)
{
header[i] ^= 0xFF;
}
Stream stream = new StreamRegion(file.AsStream, 0x20, true);
stream = new PrefixStream(header, stream);
return(new BinaryStream(stream, file.Name));
}
/// <summary>
/// Writes a value of given type T to the stream which uses the underlying marshaler to marshal it.
/// </summary>
/// <typeparam name="T">The type of the value which is written to the stream.</typeparam>
/// <param name="value">The value which is written to the stream.</param>
public virtual void Write <T>(T value)
{
lock (writerLock)
{
StreamRegion region = new StreamRegion(this, writeBufferFill);
writerMarshaler.MarshalInto(new MarshalingDescriptor(typeof(T)), region, value);
writeBufferFill += region.Offset;
if (writeGrouping == 0)
{
FlushWriteBuffer();
}
}
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0xF);
if (!header.AsciiEqual("OGGPAK"))
{
return(null);
}
uint length = header.ToUInt32(0xB);
var input = new StreamRegion(file.AsStream, 0xF, length);
return(new OggInput(input));
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(0x24);
CrxdMetaData info = null;
if (header.AsciiEqual(0x20, "CRXJ"))
{
stream.Position = 0x28;
uint diff_offset = stream.ReadUInt32();
using (var crx = OpenByOffset(diff_offset))
{
if (null == crx)
{
return(null);
}
info = ReadMetaData(crx) as CrxdMetaData;
if (info != null)
{
info.DiffOffset = diff_offset;
}
}
}
else if (header.AsciiEqual(0x20, "CRXG"))
{
using (var crx_input = new StreamRegion(stream.AsStream, 0x20, true))
using (var crx = new BinaryStream(crx_input, stream.Name))
{
var diff_info = base.ReadMetaData(crx) as CrxMetaData;
if (null == diff_info)
{
return(null);
}
info = new CrxdMetaData
{
Width = diff_info.Width,
Height = diff_info.Height,
OffsetX = diff_info.OffsetX,
OffsetY = diff_info.OffsetY,
BPP = diff_info.BPP,
DiffInfo = diff_info,
DiffOffset = 0,
};
}
}
if (info != null)
{
info.BaseOffset = header.ToUInt32(8);
info.BaseFileName = header.GetCString(0xC, 0x14);
}
return(info);
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var nsa_arc = arc as NsaEncryptedArchive;
if (null == nsa_arc)
{
var input = arc.File.CreateStream(entry.Offset, entry.Size);
return(UnpackEntry(input, entry as NsaEntry));
}
var encrypted = new EncryptedViewStream(arc.File, nsa_arc.Key);
var stream = new StreamRegion(encrypted, entry.Offset, entry.Size);
return(UnpackEntry(stream, entry as NsaEntry));
}
Stream DeobfuscateStream(Stream stream)
{
var png_header = new byte[0x10];
stream.Read(png_header, 5, 11);
System.Buffer.BlockCopy(PngHeader, 0, png_header, 0, 8);
for (int i = 0; i < 8; ++i)
{
png_header[i + 8] ^= (byte)"PGAECODE"[i];
}
var png_body = new StreamRegion(stream, 11, true);
return(new PrefixStream(png_header, png_body));
}
/// <summary>
/// Reads the given number of bytes from the stream.
/// </summary>
/// <param name="count">The number of bytes which is read from the stream.</param>
/// <returns>The byte array which contains the bytes reading from the stream.</returns>
public byte[] ReadBytes(int count)
{
byte[] result = new byte[count];
lock (readerLock)
{
StreamRegion region = new StreamRegion(this, 0);
for (int i = 0; i < count; i++)
{
result[i] = region.ReadByte();
}
AdvanceReadBuffer(region.Offset);
return(result);
}
}
IBinaryStream OpenLzss(IBinaryStream file, int unpacked_size, bool is_compressed)
{
if (is_compressed)
{
var output = new byte[unpacked_size];
file.Position = 0x10;
Decompress(file, output);
return(new BinMemoryStream(output, 12, unpacked_size - 12, file.Name));
}
else
{
var bmp = new StreamRegion(file.AsStream, 0x1C, true);
return(new BinaryStream(bmp, file.Name));
}
}
byte[] UnpackLayer(Frame frame, int length, bool is_alpha = false)
{
using (var packed = new StreamRegion(m_input.AsStream, m_input.Position, length, true))
{
if (0 == m_info.Compression || 2 == m_info.Compression && is_alpha)
{
return(ReadZlib(frame, packed, is_alpha));
}
if (2 == m_info.Compression)
{
return(ReadJpeg(frame, packed));
}
return(ReadBlocks(frame, packed, is_alpha));
}
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
var header = stream.ReadHeader(8).ToArray();
if (!Binary.AsciiEqual(header, "MalieGF"))
{
return(null);
}
Buffer.BlockCopy(HeaderBytes, 0, header, 0, 8);
using (var data = new StreamRegion(stream.AsStream, 8, true))
using (var pre = new PrefixStream(header, data))
using (var png = new BinaryStream(pre, stream.Name))
return(base.ReadMetaData(png));
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0x12);
if (!header.AsciiEqual("\0\0\0\0"))
{
return(null);
}
int riff_length = header.ToInt32(4);
if (file.Length != riff_length + 8)
{
return(null);
}
if (!header.AsciiEqual(8, "\0\0\0\0\0\0\0\0"))
{
return(null);
}
int header_length = header.ToUInt16(0x10);
if (header_length < 0x10 || header_length > riff_length)
{
return(null);
}
header = file.ReadHeader(0x18 + header_length);
if (!header.AsciiEqual(0x14 + header_length, "data"))
{
return(null);
}
var header_bytes = new byte[0x10] {
(byte)'R', (byte)'I', (byte)'F', (byte)'F', header[4], header[5], header[6], header[7],
(byte)'W', (byte)'A', (byte)'V', (byte)'E', (byte)'f', (byte)'m', (byte)'t', (byte)' '
};
Stream riff = new StreamRegion(file.AsStream, 0x10);
riff = new PrefixStream(header_bytes, riff);
var wav = new BinaryStream(riff, file.Name);
try
{
return(Wav.TryOpen(wav));
}
catch
{
wav.Dispose();
throw;
}
}
} // 'AoiO'
public override SoundInput TryOpen(Stream file)
{
var header = new byte[0x30];
if (header.Length != file.Read(header, 0, header.Length))
{
return(null);
}
if (!Binary.AsciiEqual(header, 0, "AoiOgg") || !Binary.AsciiEqual(header, 0x2C, "OggS"))
{
return(null);
}
var ogg = new StreamRegion(file, 0x2C);
return(new OggInput(ogg));
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0x20);
var format = new WaveFormat {
FormatTag = 1,
Channels = header.ToUInt16(4),
SamplesPerSecond = header.ToUInt32(8),
BitsPerSample = header.ToUInt16(6),
};
format.BlockAlign = (ushort)(format.Channels * format.BitsPerSample / 8);
format.SetBPS();
var input = new StreamRegion(file.AsStream, 0x20);
return(new RawPcmInput(input, format));
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = (EencMetaData)info;
meta.Info.FileName = info.FileName;
Stream input = new StreamRegion (stream, 8, true);
try
{
input = new EencStream (input, meta.Key);
if (meta.Compressed)
input = new ZLibStream (input, CompressionMode.Decompress);
return meta.Format.Read (input, meta.Info);
}
finally
{
input.Dispose();
}
}
public override ImageMetaData ReadMetaData(Stream stream)
{
ImageMetaData info;
using (var png = new StreamRegion (stream, 0x10, true))
info = base.ReadMetaData (png);
if (null == info)
return null;
stream.Seek (-14, SeekOrigin.End);
var cntr = new byte[12];
stream.Read (cntr, 0, 12);
if (Binary.AsciiEqual (cntr, "CNTR"))
{
info.OffsetX = LittleEndian.ToInt32 (cntr, 4);
info.OffsetY = LittleEndian.ToInt32 (cntr, 8);
}
return info;
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = (NgpMetaData)info;
using (var input = new StreamRegion (stream, 0x104, meta.PackedSize, true))
using (var z = new ZLibStream (input, CompressionMode.Decompress))
{
var pixels = new byte[meta.UnpackedSize];
if (pixels.Length != z.Read (pixels, 0, pixels.Length))
throw new EndOfStreamException();
PixelFormat format;
if (32 == meta.BPP)
format = PixelFormats.Bgra32;
else if (24 == meta.BPP)
format = PixelFormats.Bgr24;
else if (8 == meta.BPP)
format = PixelFormats.Gray8;
else
throw new System.NotSupportedException ("Not supported NGP image color depth");
return ImageData.Create (info, format, null, pixels);
}
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = info as BipMetaData;
if (null == meta)
throw new ArgumentException ("BipFormat.Read should be supplied with BipMetaData", "info");
var header = new byte[0x7c];
var bitmap = new WriteableBitmap ((int)meta.Width, (int)meta.Height,
ImageData.DefaultDpiX, ImageData.DefaultDpiY, PixelFormats.Bgra32, null);
foreach (var tile in meta.Tiles)
{
stream.Position = tile.Offset;
if (header.Length != stream.Read (header, 0, header.Length))
throw new InvalidFormatException ("Invalid tile header");
if (!Binary.AsciiEqual (header, "PNGFILE2"))
throw new InvalidFormatException ("Unknown tile format");
int data_size = LittleEndian.ToInt32 (header, 0x18) - header.Length;
int alpha = LittleEndian.ToInt32 (header, 0x68);
int x = LittleEndian.ToInt32 (header, 0x6c);
int y = LittleEndian.ToInt32 (header, 0x70);
using (var png = new StreamRegion (stream, stream.Position, data_size, true))
{
var decoder = new PngBitmapDecoder (png,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapSource frame = decoder.Frames[0];
PixelFormat format = 0 == alpha ? PixelFormats.Bgr32 : PixelFormats.Bgra32;
var converted = new FormatConvertedBitmap (frame, format, null, 0);
int stride = converted.PixelWidth * 4;
var pixels = new byte[stride * converted.PixelHeight];
converted.CopyPixels (pixels, stride, 0);
for (int p = 0; p < pixels.Length; p += 4)
{
byte r = pixels[p];
pixels[p] = pixels[p+2];
pixels[p+2] = r;
int a = 0 == alpha ? 0xff : pixels[p+3] * 0xff / 0x80;
if (a > 0xff) a = 0xff;
pixels[p+3] = (byte)a;
}
var rect = new Int32Rect (tile.Left+x, tile.Top+y, converted.PixelWidth, converted.PixelHeight);
bitmap.WritePixels (rect, pixels, stride, 0);
}
}
bitmap.Freeze();
return new ImageData (bitmap, meta);
}
public override ImageMetaData ReadMetaData(Stream stream)
{
var header = new byte[0x40];
if (header.Length != stream.Read (header, 0, header.Length))
return null;
if (!Binary.AsciiEqual (header, 4, "00\0\0"))
return null;
var ykg = new YkgMetaData {
DataOffset = LittleEndian.ToUInt32 (header, 0x28),
DataSize = LittleEndian.ToUInt32 (header, 0x2C)
};
if (0 == ykg.DataOffset)
ykg.DataOffset = LittleEndian.ToUInt32 (header, 8);
if (ykg.DataOffset < 0x30)
return null;
if (0 == ykg.DataSize)
ykg.DataSize = (uint)(stream.Length - ykg.DataOffset);
ImageMetaData info = null;
using (var img = new StreamRegion (stream, ykg.DataOffset, ykg.DataSize, true))
{
if (4 != img.Read (header, 0, 4))
return null;
if (Binary.AsciiEqual (header, "BM"))
{
img.Position = 0;
info = ImageFormat.Bmp.ReadMetaData (img);
ykg.Format = YkgImage.Bmp;
}
else if (Binary.AsciiEqual (header, "\x89PNG"))
{
img.Position = 0;
info = Png.ReadMetaData (img);
ykg.Format = YkgImage.Png;
}
else if (Binary.AsciiEqual (header, "\x89GNP"))
{
using (var body = new StreamRegion (stream, ykg.DataOffset+4, ykg.DataSize-4, true))
using (var png = new PrefixStream (PngPrefix, body))
info = Png.ReadMetaData (png);
ykg.Format = YkgImage.Gnp;
}
}
if (null == info)
return null;
ykg.Width = info.Width;
ykg.Height = info.Height;
ykg.BPP = info.BPP;
ykg.OffsetX = info.OffsetX;
ykg.OffsetY = info.OffsetY;
return ykg;
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = info as YkgMetaData;
if (null == meta)
throw new ArgumentException ("YkgFormat.Read should be supplied with YkgMetaData", "info");
switch (meta.Format)
{
case YkgImage.Bmp:
using (var bmp = new StreamRegion (stream, meta.DataOffset, meta.DataSize, true))
return Bmp.Read (bmp, info);
case YkgImage.Png:
using (var png = new StreamRegion (stream, meta.DataOffset, meta.DataSize, true))
return Png.Read (png, info);
case YkgImage.Gnp:
using (var body = new StreamRegion (stream, meta.DataOffset+4, meta.DataSize-4, true))
using (var png = new PrefixStream (PngPrefix, body))
return Png.Read (png, info);
default:
throw new InvalidFormatException();
}
}
public override ImageMetaData ReadMetaData(Stream stream)
{
var header = new byte[8];
if (8 != stream.Read (header, 0, 8))
return null;
bool compressed = 'Z' == header[3];
uint key = LittleEndian.ToUInt32 (header, 4) ^ EencKey;
Stream input = new StreamRegion (stream, 8, true);
try
{
input = new EencStream (input, key);
if (compressed)
{
input = new ZLibStream (input, CompressionMode.Decompress);
input = new SeekableStream (input);
}
var format = FindFormat (input);
if (null == format)
return null;
return new EencMetaData
{
Width = format.Item2.Width,
Height = format.Item2.Height,
BPP = format.Item2.BPP,
Key = key,
Info = format.Item2,
Format = format.Item1,
Compressed = compressed,
};
}
finally
{
input.Dispose();
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var nsa_arc = arc as NsaEncryptedArchive;
if (null == nsa_arc)
{
var input = arc.File.CreateStream (entry.Offset, entry.Size);
return UnpackEntry (input, entry as NsaEntry);
}
var encrypted = new EncryptedViewStream (arc.File, nsa_arc.Key);
var stream = new StreamRegion (encrypted, entry.Offset, entry.Size);
return UnpackEntry (stream, entry as NsaEntry);
}
public override SoundInput TryOpen(Stream file)
{
var header = new byte[0x24];
if (header.Length != file.Read (header, 0, header.Length))
return null;
if (!Binary.AsciiEqual (header, 4, "WAV"))
return null;
if (LittleEndian.ToInt32 (header, 8) < 2)
return null;
int fmt_offset = LittleEndian.ToInt32 (header, 0x10);
int fmt_size = LittleEndian.ToInt32 (header, 0x14);
int data_offset = LittleEndian.ToInt32 (header, 0x1C);
int data_size = LittleEndian.ToInt32 (header, 0x20);
var wav_header = new byte[8+12+fmt_size+8];
Buffer.BlockCopy (WavHeader, 0, wav_header, 0, WavHeader.Length);
LittleEndian.Pack (wav_header.Length-8+data_size, wav_header, 4);
LittleEndian.Pack (fmt_size, wav_header, 0x10);
file.Position = fmt_offset;
file.Read (wav_header, 0x14, fmt_size);
int d = wav_header.Length-8;
wav_header[d++]= (byte)'d';
wav_header[d++]= (byte)'a';
wav_header[d++]= (byte)'t';
wav_header[d++]= (byte)'a';
LittleEndian.Pack (data_size, wav_header, d);
var wav_data = new StreamRegion (file, data_offset, data_size);
return new WaveInput (new PrefixStream (wav_header, wav_data));
}
public override SoundInput TryOpen(Stream file)
{
if (file.ReadByte() != 0x44)
return null;
file.Position = 4;
if (file.ReadByte() != 0)
return null;
int length = ReadInt32 (file);
if (length != file.Length - 9)
return null;
var format = new WaveFormat
{
FormatTag = 1,
Channels = 2,
SamplesPerSecond = 44100,
BitsPerSample = 16,
BlockAlign = 4,
AverageBytesPerSecond = 44100*4,
};
var pcm = new StreamRegion (file, 9, length);
return new RawPcmInput (pcm, format);
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
using (var png = new StreamRegion (stream, 0x10, true))
return base.Read (png, info);
}
Stream DeobfuscateStream(Stream stream)
{
var png_header = new byte[0x10];
stream.Read (png_header, 5, 11);
System.Buffer.BlockCopy (PngHeader, 0, png_header, 0, 8);
for (int i = 0; i < 8; ++i)
png_header[i+8] ^= (byte)"PGAECODE"[i];
var png_body = new StreamRegion (stream, 11, true);
return new PrefixStream (png_header, png_body);
}
public override SoundInput TryOpen(Stream file)
{
var ogg = new StreamRegion (file, 8);
return new OggInput (ogg);
// in case of exception ogg stream is left undisposed
}
public override ImageMetaData ReadMetaData(Stream stream)
{
byte[] header = new byte[0x18];
if (0x18 != stream.Read (header, 0, 0x18))
return null;
int index_offset = 0xC;
uint first_offset = LittleEndian.ToUInt32 (header, index_offset);
if (0 == first_offset)
{
index_offset += 4;
first_offset = LittleEndian.ToUInt32 (header, index_offset);
if (0 == first_offset)
return null;
}
index_offset += 4;
long first_length;
uint second_offset = LittleEndian.ToUInt32 (header, index_offset);
if (0 == second_offset)
first_length = stream.Length - first_offset;
else if (second_offset < first_offset)
return null;
else
first_length = second_offset - first_offset;
using (var hiz = new StreamRegion (stream, first_offset, first_length, true))
{
var info = base.ReadMetaData (hiz);
(info as HizMetaData).DataOffset += 0x18;
return info;
}
}
