public override ImageMetaData ReadMetaData(Stream stream)
{
using (var reader = new LzssReader(stream, (int)stream.Length, 0x26)) // BMP header
{
reader.Unpack();
var bmp = reader.Data;
if (bmp[0] != 'B' || bmp[1] != 'M')
{
return(null);
}
int file_size = LittleEndian.ToInt32(bmp, 2);
int width = LittleEndian.ToInt32(bmp, 0x12);
int height = LittleEndian.ToInt32(bmp, 0x16);
int bpp = LittleEndian.ToInt16(bmp, 0x1c);
int image_size = LittleEndian.ToInt32(bmp, 0x22);
if (0 == image_size)
{
image_size = width * height * (bpp / 8);
}
return(new GrMetaData
{
Width = (uint)width,
Height = (uint)height,
BPP = bpp,
UnpackedSize = 24 == bpp ? file_size : (image_size + 0x36),
});
}
}
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 ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (GraMetaData)info;
stream.Position = meta.DataOffset;
using (var reader = new LzssReader(stream.AsStream, meta.PackedSize, meta.UnpackedSize))
{
reader.Unpack();
int stride = ((int)info.Width * info.BPP / 8 + 3) & ~3;
PixelFormat format;
if (32 == info.BPP)
{
format = PixelFormats.Bgra32;
}
else if (24 == info.BPP)
{
format = PixelFormats.Bgr24;
}
else
{
format = PixelFormats.Gray8;
}
return(ImageData.CreateFlipped(info, format, null, reader.Data, stride));
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var input = arc.File.CreateStream(entry.Offset, entry.Size);
if (entry.Size <= 8)
{
return(input);
}
if (!entry.Name.EndsWith(".so4", StringComparison.InvariantCultureIgnoreCase) &&
!entry.Name.EndsWith(".so5", StringComparison.InvariantCultureIgnoreCase))
{
return(input);
}
using (var header = new ArcView.Reader(input))
{
int packed = header.ReadInt32();
int unpacked = header.ReadInt32();
if (packed + 8 != entry.Size || packed <= 0 || unpacked <= 0)
{
return(input);
}
using (input)
using (var reader = new LzssReader(input, packed, unpacked))
{
reader.Unpack();
return(new MemoryStream(reader.Data));
}
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var input = arc.File.CreateStream(entry.Offset, entry.Size);
var pac = arc as PacArchive;
var pent = entry as PackedEntry;
if (null == pac || null == pent || !pent.IsPacked)
{
return(input);
}
switch (pac.PackType)
{
case Compression.Lzss:
using (input)
using (var reader = new LzssReader(input, (int)pent.Size, (int)pent.UnpackedSize))
{
reader.Unpack();
return(new MemoryStream(reader.Data, false));
}
case Compression.Huffman:
using (input)
{
var packed = new byte[entry.Size];
input.Read(packed, 0, packed.Length);
var unpacked = HuffmanDecode(packed, (int)pent.UnpackedSize);
return(new MemoryStream(unpacked, 0, (int)pent.UnpackedSize, false));
}
case Compression.Deflate:
default:
return(new ZLibStream(input, CompressionMode.Decompress));
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var input = arc.File.CreateStream(entry.Offset, entry.Size);
if (entry.Size <= 8)
{
return(input);
}
if (!entry.Name.HasAnyOfExtensions("so4", "so5"))
{
return(input);
}
int packed = input.ReadInt32();
int unpacked = input.ReadInt32();
if (packed + 8 != entry.Size || packed <= 0 || unpacked <= 0)
{
input.Position = 0;
return(input);
}
using (input)
using (var reader = new LzssReader(input, packed, unpacked))
{
reader.Unpack();
return(new BinMemoryStream(reader.Data, entry.Name));
}
}
public override ImageData Read(Stream file, ImageMetaData info)
{
var meta = (GgdMetaData)info;
file.Position = meta.HeaderSize + 4;
var palette_data = new byte[0x400];
if (palette_data.Length != file.Read(palette_data, 0, palette_data.Length))
{
throw new InvalidFormatException();
}
var colors = new Color[256];
for (int i = 0; i < 256; ++i)
{
colors[i] = Color.FromRgb(palette_data[i * 4 + 2], palette_data[i * 4 + 1], palette_data[i * 4]);
}
file.Seek(4, SeekOrigin.Current);
int input_size = (int)(file.Length - file.Position);
using (var reader = new LzssReader(file, input_size, (int)meta.BitmapSize))
{
reader.Unpack();
var palette = new BitmapPalette(colors);
int stride = ((int)meta.Width + 3) & ~3;
return(ImageData.Create(info, PixelFormats.Indexed8, palette, reader.Data, stride));
}
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
if (stream.Length > int.MaxValue)
{
throw new FileSizeException();
}
var header = new byte[14];
if (header.Length != stream.Read(header, 0, header.Length))
{
throw new InvalidFormatException();
}
int data_length = LittleEndian.ToInt32(header, 10);
int input_length = (int)(stream.Length - stream.Position);
using (var lz = new LzssReader(stream, 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 MemoryStream(data))
return(base.Read(bmp, info));
}
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
if (stream.Length > int.MaxValue)
{
throw new FileSizeException();
}
var header = new byte[14];
if (header.Length != stream.Read(header, 0, header.Length))
{
throw new InvalidFormatException();
}
int data_length = LittleEndian.ToInt32(header, 10);
int input_length = (int)(stream.Length - stream.Position);
using (var lz = new LzssReader(stream, input_length, data_length))
{
lz.FrameSize = 0x1000;
lz.FrameFill = 0x20;
lz.FrameInitPos = 0x1000 - 0x10;
lz.Unpack();
using (var cwd = new MemoryStream(lz.Data))
return(base.Read(cwd, info));
}
}
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));
}
}
internal static byte[] UnpackBitmap(Stream stream, int pack_type, int packed_size, int unpacked_size)
{
if (2 == pack_type)
{
using (var reader = new RleReader(stream, packed_size, unpacked_size))
{
reader.Unpack();
return(reader.Data);
}
}
else if (0 == pack_type)
{
using (var reader = new LzssReader(stream, packed_size, unpacked_size))
{
reader.Unpack();
return(reader.Data);
}
}
else if (1 == pack_type)
{
var bitmap = new byte[unpacked_size];
if (bitmap.Length != stream.Read(bitmap, 0, bitmap.Length))
{
throw new InvalidFormatException("Unexpected end of file");
}
return(bitmap);
}
else
{
throw new InvalidFormatException();
}
}
public override ArcFile TryOpen(ArcView file)
{
if (!file.View.AsciiEqual(0, "GsSYMBOL5BINDATA"))
{
return(null);
}
uint header_size = file.View.ReadUInt32(0xa4);
if (header_size < 0xd0)
{
return(null);
}
int count = file.View.ReadInt32(0xa8);
uint index_offset = file.View.ReadUInt32(0xb8);
uint index_size = file.View.ReadUInt32(0xbc);
uint crypt_key = file.View.ReadUInt32(0xc0);
uint unpacked_index_size = file.View.ReadUInt32(0xc4);
if (count * 0x18 != unpacked_index_size)
{
return(null);
}
uint data_offset = file.View.ReadUInt32(0xc8);
byte[] packed_index = new byte[index_size];
if (index_size != file.View.Read(index_offset, packed_index, 0, index_size))
{
return(null);
}
if (0 != crypt_key)
{
for (int i = 0; i != packed_index.Length; ++i)
{
packed_index[i] ^= (byte)(i & crypt_key);
}
}
using (var stream = new MemoryStream(packed_index))
using (var reader = new LzssReader(stream, packed_index.Length, (int)unpacked_index_size))
{
reader.Unpack();
var index = reader.Data;
index_offset = 0;
var dir = new List <Entry> (count);
for (int i = 0; i < count; ++i)
{
var entry = new PackedEntry
{
Name = i.ToString("D5"),
Offset = data_offset + LittleEndian.ToUInt32(index, (int)index_offset),
Size = LittleEndian.ToUInt32(index, (int)index_offset + 4),
UnpackedSize = LittleEndian.ToUInt32(index, (int)index_offset + 8),
};
dir.Add(entry);
index_offset += 0x18;
}
return(new ArcFile(file, this, dir));
}
}
public override ArcFile TryOpen(ArcView file)
{
if (!(file.View.AsciiEqual(0, "DataPack5") ||
file.View.AsciiEqual(0, "GsPack5") ||
file.View.AsciiEqual(0, "GsPack4")))
{
return(null);
}
int version_minor = file.View.ReadUInt16(0x30);
int version_major = file.View.ReadUInt16(0x32);
uint index_size = file.View.ReadUInt32(0x34);
int count = file.View.ReadInt32(0x3c);
if (!IsSaneCount(count) || index_size > 0xffffff)
{
return(null);
}
uint crypt_key = file.View.ReadUInt32(0x38);
long data_offset = file.View.ReadUInt32(0x40);
int index_offset = file.View.ReadInt32(0x44);
int entry_size = version_major < 5 ? 0x48 : 0x68;
int unpacked_size = count * entry_size;
byte[] packed_index = file.View.ReadBytes(index_offset, index_size);
if (index_size != packed_index.Length)
{
return(null);
}
if (0 != crypt_key)
{
for (int i = 0; i != packed_index.Length; ++i)
{
packed_index[i] ^= (byte)(i & crypt_key);
}
}
using (var stream = new MemoryStream(packed_index))
using (var reader = new LzssReader(stream, packed_index.Length, unpacked_size))
{
reader.Unpack();
var index = reader.Data;
index_offset = 0;
var dir = new List <Entry> (count);
for (int i = 0; i < count; ++i)
{
string name = Binary.GetCString(index, index_offset, 0x40);
if (0 != name.Length)
{
long offset = data_offset + LittleEndian.ToUInt32(index, index_offset + 0x40);
var entry = AutoEntry.Create(file, offset, name);
entry.Size = LittleEndian.ToUInt32(index, index_offset + 0x44);
dir.Add(entry);
}
index_offset += entry_size;
}
return(new ArcFile(file, this, dir));
}
}
public byte[] UnpackBytes()
{
using (var mem = new MemoryStream(m_input))
using (var lzss = new LzssReader(mem, m_input.Length, m_unpacked_size))
{
lzss.FrameFill = 0x20;
lzss.Unpack();
return(lzss.Data);
}
}
void LzssUnpack(int offset)
{
int out_length = m_width * m_height * 3;
using (var input = new MemoryStream(m_input, offset, m_input.Length - offset))
using (var lzss = new LzssReader(input, (int)input.Length, out_length))
{
lzss.Unpack();
m_output = lzss.Data;
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
if (0 == entry.Size)
{
return(Stream.Null);
}
var larc = arc as LuciArchive;
var lent = entry as LuciEntry;
Stream input = arc.File.CreateStream(entry.Offset, entry.Size);
if (null == larc || null == lent)
{
return(input);
}
byte[] data;
using (input)
{
if (lent.IsPacked)
{
using (var reader = new LzssReader(input, (int)lent.Size, (int)lent.UnpackedSize))
{
reader.Unpack();
data = reader.Data;
}
}
else
{
data = new byte[lent.Size];
input.Read(data, 0, data.Length);
}
}
if (larc.Info.WholeCrypt)
{
DecryptContent(data, larc.Scheme.ContentXor);
}
if (larc.Info.IsEncrypted)
{
int count = Math.Min(data.Length, 0x100);
if (count != 0)
{
DecryptEntry(data, count, larc.Info.Key, larc.Scheme.RotatePattern);
}
}
input = new MemoryStream(data);
if (null != larc.Info.Prefix)
{
return(new PrefixStream(larc.Info.Prefix, input));
}
else
{
return(input);
}
}
} // 'SZDD'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 0x0e;
using (var lz = new LzssReader(stream.AsStream, 100, 0x38)) // extract CWD header
{
lz.FrameSize = 0x1000;
lz.FrameFill = 0x20;
lz.FrameInitPos = 0x1000 - 0x10;
lz.Unpack();
using (var cwd = new BinMemoryStream(lz.Data, stream.Name))
return(base.ReadMetaData(cwd));
}
}
public override SoundInput TryOpen(Stream file)
{
int packed = ReadInt32(file);
if (packed < 0)
{
return(null);
}
byte[] input;
if (packed > 12)
{
if ((packed + 8) != file.Length)
{
return(null);
}
int unpacked = ReadInt32(file);
if (unpacked <= 0)
{
return(null);
}
using (var reader = new LzssReader(file, packed, unpacked))
{
reader.Unpack();
if (Binary.AsciiEqual(reader.Data, 0, "RIFF"))
{
var sound = new WaveInput(new MemoryStream(reader.Data));
file.Dispose();
return(sound);
}
input = reader.Data;
}
}
else
{
if (0x46464952 != ReadInt32(file)) // 'RIFF'
{
return(null);
}
file.Position = 0;
input = new byte[file.Length];
file.Read(input, 0, input.Length);
}
var wa1 = new Wa1Reader(input);
wa1.Unpack();
var wav = new WaveInput(new MemoryStream(wa1.Data));
file.Dispose();
return(wav);
}
public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
var meta = (BmdMetaData)info;
stream.Position = 0x14;
int image_size = (int)(meta.Width * meta.Height * 4);
using (var reader = new LzssReader(stream.AsStream, (int)meta.PackedSize, image_size))
{
PixelFormat format = meta.Flag != 0 ? PixelFormats.Bgra32 : PixelFormats.Bgr32;
reader.Unpack();
return(ImageData.Create(meta, format, null, reader.Data, (int)meta.Width * 4));
}
}
// DOUBLE
private ImageData ReadV2()
{
if (0 != m_info.PackedSize)
{
using (var reader = new LzssReader(m_input, m_info.PackedSize, m_info.UnpackedSize))
{
reader.Unpack();
m_image_data = reader.Data;
}
}
else
{
m_image_data = new byte[m_info.UnpackedSize];
if (m_image_data.Length != m_input.Read(m_image_data, 0, m_image_data.Length))
{
throw new InvalidFormatException("Unexpected end of file");
}
}
int pixels_offset = 0;
if (8 == m_info.BPP)
{
SetPalette(m_image_data);
pixels_offset += 0x400;
}
if (0 == pixels_offset)
{
return(ImageData.Create(m_info, Format, Palette, m_image_data));
}
if (pixels_offset + m_stride * (int)m_info.Height > m_image_data.Length)
{
throw new InvalidFormatException();
}
unsafe
{
fixed(byte *pixels = &m_image_data[pixels_offset])
{
var bitmap = BitmapSource.Create((int)m_info.Width, (int)m_info.Height,
ImageData.DefaultDpiX, ImageData.DefaultDpiY, Format, Palette,
(IntPtr)pixels, m_image_data.Length - pixels_offset, m_stride);
bitmap.Freeze();
return(new ImageData(bitmap, m_info));
}
}
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = info as IgfMetaData;
if (null == meta)
{
throw new ArgumentException("IgfFormat.Read should be supplied with IgfMetaData", "info");
}
int stride = (int)info.Width * info.BPP / 8;
stream.Position = 0x14;
byte[] pixels;
if (meta.IsPacked)
{
int in_size = (int)(stream.Length - 0x14);
using (var lzss = new LzssReader(stream, in_size, meta.UnpackedSize))
{
lzss.FrameFill = 0x20;
lzss.Unpack();
pixels = lzss.Data;
}
}
else
{
pixels = new byte[info.Height * stride];
if (pixels.Length != stream.Read(pixels, 0, pixels.Length))
{
throw new InvalidFormatException("Unexpected end of file");
}
}
PixelFormat format;
if (24 == info.BPP)
{
format = PixelFormats.Bgr24;
}
else if (32 == info.BPP)
{
format = PixelFormats.Bgra32;
}
else
{
format = PixelFormats.Gray8;
}
return(ImageData.CreateFlipped(info, format, null, pixels, stride));
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
if (entry.Size <= 8 ||
!entry.Name.EndsWith(".snc", StringComparison.InvariantCultureIgnoreCase) ||
!arc.File.View.AsciiEqual(entry.Offset, "CMP_"))
{
return(arc.File.CreateStream(entry.Offset, entry.Size));
}
int unpacked_size = arc.File.View.ReadInt32(entry.Offset + 4);
using (var input = arc.File.CreateStream(entry.Offset + 8, entry.Size - 8))
using (var lzss = new LzssReader(input, (int)(entry.Size - 8), unpacked_size))
{
lzss.FrameFill = 0x20;
lzss.Unpack();
return(new MemoryStream(lzss.Data));
}
}
} // 'SZDD'
public override ImageMetaData ReadMetaData(Stream stream)
{
stream.Position = 0x0e;
using (var lz = new LzssReader(stream, 100, 54)) // extract BMP header
{
lz.FrameSize = 0x1000;
lz.FrameFill = 0x20;
lz.FrameInitPos = 0x1000 - 0x10;
lz.Unpack();
var header = lz.Data;
for (int i = 0; i < 54; ++i)
{
header[i] ^= 0xff;
}
using (var bmp = new MemoryStream(header))
return(base.ReadMetaData(bmp));
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
if (entry.Size <= 8 ||
!entry.Name.HasExtension(".snc") ||
!arc.File.View.AsciiEqual(entry.Offset, "CMP_"))
{
return(arc.File.CreateStream(entry.Offset, entry.Size));
}
int unpacked_size = arc.File.View.ReadInt32(entry.Offset + 4);
using (var input = arc.File.CreateStream(entry.Offset + 8, entry.Size - 8))
using (var lzss = new LzssReader(input, (int)(entry.Size - 8), unpacked_size))
{
lzss.FrameFill = 0x20;
lzss.Unpack();
return(new BinMemoryStream(lzss.Data, entry.Name));
}
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = info as BmdMetaData;
if (null == meta)
{
throw new ArgumentException("BmdFormat.Read should be supplied with BmdMetaData", "info");
}
stream.Position = 0x14;
int image_size = (int)(meta.Width * meta.Height * 4);
using (var reader = new LzssReader(stream, (int)meta.PackedSize, image_size))
{
PixelFormat format = meta.Flag != 0 ? PixelFormats.Bgra32 : PixelFormats.Bgr32;
reader.Unpack();
return(ImageData.Create(meta, format, null, reader.Data, (int)meta.Width * 4));
}
}
public override ImageData Read(IBinaryStream file, ImageMetaData info)
{
if (file.Length > int.MaxValue)
{
throw new FileSizeException();
}
var header = file.ReadHeader(14);
int data_length = header.ToInt32(10);
int input_length = (int)(file.Length - file.Position);
using (var lz = new LzssReader(file.AsStream, input_length, data_length))
{
lz.FrameSize = 0x1000;
lz.FrameFill = 0x20;
lz.FrameInitPos = 0x1000 - 0x10;
lz.Unpack();
using (var cwd = new BinMemoryStream(lz.Data, file.Name))
return(base.Read(cwd, info));
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var pent = entry as PackedEntry;
if (null == pent || !(arc is AstArchive))
{
return(arc.File.CreateStream(entry.Offset, entry.Size));
}
if (pent.Size == pent.UnpackedSize)
{
arc.File.View.Reserve(entry.Offset, entry.Size);
var sig = arc.File.View.ReadUInt32(entry.Offset);
if (0xB8B1AF76 == sig) // PNG signature ^ FF
{
var data = arc.File.View.ReadBytes(entry.Offset, entry.Size);
for (int i = 0; i < data.Length; ++i)
{
data[i] ^= 0xff;
}
return(new MemoryStream(data));
}
return(arc.File.CreateStream(entry.Offset, entry.Size));
}
using (var input = arc.File.CreateStream(entry.Offset, entry.Size))
using (var reader = new LzssReader(input, (int)pent.Size, (int)pent.UnpackedSize))
{
reader.Unpack();
var data = reader.Data;
if (!Binary.AsciiEqual(data, 0, "RIFF") &&
!Binary.AsciiEqual(data, 0, "OggS"))
{
for (int i = 0; i < data.Length; ++i)
{
data[i] ^= 0xff;
}
}
return(new MemoryStream(data));
}
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var pent = (PackedEntry)entry;
if (!pent.IsPacked)
{
if (entry.Size <= 12 ||
entry.Name.HasExtension(".grd") || // let GrdFormat unpack images
!arc.File.View.AsciiEqual(entry.Offset, "CMP_"))
{
return(arc.File.CreateStream(entry.Offset, entry.Size));
}
pent.IsPacked = true;
pent.UnpackedSize = arc.File.View.ReadUInt32(entry.Offset + 4);
}
using (var input = arc.File.CreateStream(entry.Offset + 12, entry.Size - 12))
using (var lzss = new LzssReader(input, (int)input.Length, (int)pent.UnpackedSize))
{
lzss.FrameFill = 0x20;
lzss.Unpack();
return(new BinMemoryStream(lzss.Data, entry.Name));
}
}
private ImageData ReadV1()
{
if (8 == m_info.BPP)
{
var palette_data = new byte[0x400];
if (palette_data.Length != m_input.Read(palette_data, 0, palette_data.Length))
{
throw new InvalidFormatException("Unexpected end of file");
}
SetPalette(palette_data);
}
var packed = new byte[m_info.PackedSize];
if (packed.Length != m_input.Read(packed, 0, packed.Length))
{
throw new InvalidFormatException("Unexpected end of file");
}
for (int i = 0; i < packed.Length; ++i)
{
packed[i] ^= (byte)i;
}
using (var input = new MemoryStream(packed))
using (var reader = new LzssReader(input, packed.Length, m_info.UnpackedSize))
{
reader.Unpack();
m_image_data = new byte[m_info.UnpackedSize];
// flip pixels vertically
int dst = 0;
for (int src = m_stride * ((int)m_info.Height - 1); src >= 0; src -= m_stride)
{
Buffer.BlockCopy(reader.Data, src, m_image_data, dst, m_stride);
dst += m_stride;
}
}
return(ImageData.Create(m_info, Format, Palette, m_image_data));
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = (GrMetaData)info;
using (var reader = new LzssReader(stream, (int)stream.Length, meta.UnpackedSize + 2))
{
reader.Unpack();
if (32 != info.BPP)
{
using (var bmp = new MemoryStream(reader.Data))
return(base.Read(bmp, info));
}
int stride = (int)info.Width * 4;
var pixels = new byte[stride * info.Height];
int dst = 0;
int offset = 0x36;
for (int src = stride * ((int)info.Height - 1); src >= 0; src -= stride)
{
Buffer.BlockCopy(reader.Data, offset + src, pixels, dst, stride);
dst += stride;
}
return(ImageData.Create(info, PixelFormats.Bgra32, null, pixels));
}
}
