public byte[] Decode(IBinaryStream input) { m_dst = 0; if (1 == Channels) { var adp = new AdpDecoder(); while (input.PeekByte() != -1) { short sample = input.ReadInt16(); PutSample(sample); int quant_idx = input.ReadUInt16() & 0xFF; adp.Reset(sample, quant_idx); for (int j = 0; j < BytesPerChunk - 4; ++j) { byte octet = input.ReadUInt8(); PutSample(adp.DecodeSample(octet)); PutSample(adp.DecodeSample(octet >> 4)); } } } else { var first = new AdpDecoder(); var second = new AdpDecoder(); int samples_per_chunk = (BytesPerChunk - 8) / 8; while (input.PeekByte() != -1) { short sample = input.ReadInt16(); PutSample(sample); int quant_idx = input.ReadUInt16() & 0xFF; first.Reset(sample, quant_idx); sample = input.ReadInt16(); PutSample(sample); quant_idx = input.ReadUInt16() & 0xFF; second.Reset(sample, quant_idx); for (int j = 0; j < samples_per_chunk; ++j) { uint first_code = input.ReadUInt32(); uint second_code = input.ReadUInt32(); for (int i = 0; i < 8; ++i) { PutSample(first.DecodeSample((byte)first_code)); PutSample(second.DecodeSample((byte)second_code)); first_code >>= 4; second_code >>= 4; } } } } return(m_output); }
public override ImageData Read(IBinaryStream file, ImageMetaData info) { file.Position = 4; var palette = ReadPalette(file.AsStream, 0x100, PaletteFormat.Bgr); int stride = (info.iWidth + 3) & ~3; var pixels = new byte[info.iHeight * stride]; int length = info.iHeight * info.iWidth; int dst = 0; while (dst < length) { byte px = file.ReadUInt8(); int next = file.PeekByte(); if (px == next) { file.ReadByte(); int count = file.ReadByte() + 1; while (count-- > 0) { pixels[dst++] = px; } } else { pixels[dst++] = px; } } return(ImageData.CreateFlipped(info, PixelFormats.Indexed8, palette, pixels, stride)); }
bool ConvertToMp3(IBinaryStream input, Stream mp3, ushort schema) { byte[] frame_buffer = null; using (var output = new BinaryWriter(mp3, System.Text.Encoding.Default, true)) { while (input.PeekByte() != -1) { ushort rha_header = Binary.BigEndian(input.ReadUInt16()); uint header; int add_len = 0; byte add_value = 0; if (0 == schema) { header = 0xFFFB0000u | rha_header; } else { if (0 != (rha_header & 0x1000)) // RHAF_LASTZEROADD { add_len = input.ReadUInt16(); add_value = 0; } else if (0 != (rha_header & 0x2000)) // RHAF_LASTFULLADD { add_len = input.ReadUInt16(); add_value = 0xFF; } header = RhaToMp3Header(rha_header); } int frame_length = GetFrameLength(header); if (0 == frame_length || add_len > frame_length) { return(false); } if (null == frame_buffer || frame_length > frame_buffer.Length) { frame_buffer = new byte[frame_length]; } int read_length = frame_length - add_len; if (read_length != input.Read(frame_buffer, 0, read_length)) { break; } for (int i = 0; i < add_len; ++i) { frame_buffer[read_length + i] = add_value; } output.Write(Binary.BigEndian(header)); output.Write(frame_buffer, 0, frame_length); if (0 == (header & (1 << 16))) // CRC bit { output.Write(input.ReadUInt16()); } } } return(mp3.Length > 0); }
public override ImageData Read(IBinaryStream file, ImageMetaData info) { var pixels = new short[info.Width * info.Height]; file.Position = 0x20; int dst = 0; while (dst < pixels.Length && file.PeekByte() != -1) { short px = file.ReadInt16(); if (px < 0) { px &= 0x7FFF; int count = file.ReadUInt8(); for (int i = 0; i < count; ++i) { pixels[dst++] = px; } } else { pixels[dst++] = px; } } return(ImageData.Create(info, PixelFormats.Bgr555, null, pixels)); }
public override ImageMetaData ReadMetaData(IBinaryStream file) { if (0xFF != file.ReadByte() || 0xD8 != file.ReadByte()) { return(null); } while (-1 != file.PeekByte()) { ushort marker = Binary.BigEndian(file.ReadUInt16()); if ((marker & 0xff00) != 0xff00) { break; } int length = Binary.BigEndian(file.ReadUInt16()); if ((marker & 0x00f0) == 0xc0 && marker != 0xffc4) { if (length < 8) { break; } int bits = file.ReadByte(); uint height = Binary.BigEndian(file.ReadUInt16()); uint width = Binary.BigEndian(file.ReadUInt16()); int components = file.ReadByte(); return(new ImageMetaData { Width = width, Height = height, BPP = bits * components, }); } file.Seek(length - 2, SeekOrigin.Current); } return(null); }
List <Entry> ReadIndexV1(IBinaryStream file) { var max_offset = file.Length; file.Position = 8; var key_gen = new KeyGenerator(0xDEADCAFE); var dir = new List <Entry>(); while (file.PeekByte() != -1) { uint name_length = file.ReadUInt32() ^ key_gen.GetNext(); var name_bytes = file.ReadBytes((int)name_length); var name = DecryptName(name_bytes, key_gen); var entry = FormatCatalog.Instance.Create <RgssEntry> (name); entry.Size = file.ReadUInt32() ^ key_gen.GetNext(); entry.Offset = file.Position; entry.Key = key_gen.Current; if (!entry.CheckPlacement(max_offset)) { return(null); } dir.Add(entry); file.Seek(entry.Size, SeekOrigin.Current); } return(dir); }
List <Entry> ReadIndexV3(IBinaryStream file) { var max_offset = file.Length; file.Position = 8; uint key = file.ReadUInt32() * 9 + 3; var dir = new List <Entry>(); while (file.PeekByte() != -1) { uint offset = file.ReadUInt32() ^ key; if (0 == offset) { break; } uint size = file.ReadUInt32() ^ key; uint entry_key = file.ReadUInt32() ^ key; uint name_length = file.ReadUInt32() ^ key; var name_bytes = file.ReadBytes((int)name_length); var name = DecryptName(name_bytes, key); var entry = FormatCatalog.Instance.Create <RgssEntry> (name); entry.Offset = offset; entry.Size = size; entry.Key = entry_key; if (!entry.CheckPlacement(max_offset)) { return(null); } dir.Add(entry); } return(dir); }
bool UnpackSVariant(byte[] output, int dst, int channels, GrpVariant method) { if (GrpVariant.Default == method) { UnpackSv2(output, dst, channels); } else { UnpackSv1(output, dst, channels); } return(m_input.PeekByte() == -1); // rather loose test, but whatever }
void Unpack8BPP(IBinaryStream input, byte[] output) { int dst = 0; while (dst < output.Length && input.PeekByte() != -1) { byte v = input.ReadUInt8(); int count = input.ReadByte(); for (int i = 0; i < count; ++i) { output[dst++] = v; } } }
public override ImageMetaData ReadMetaData(IBinaryStream stream) { int first = stream.PeekByte() ^ 0x21; if (first != 0x78) // doesn't look like zlib stream { return(null); } using (var input = new XoredStream(stream.AsStream, 0x21, true)) using (var zstream = new ZLibStream(input, CompressionMode.Decompress)) using (var bmp = new BinaryStream(zstream, stream.Name)) return(Bmp.ReadMetaData(bmp)); }
void Unpack24BPP(IBinaryStream input, byte[] output) { int dst = 0; while (dst < output.Length && input.PeekByte() != -1) { input.Read(output, dst, 3); int count = input.ReadByte(); if (count > 0) { count *= 3; Binary.CopyOverlapped(output, dst, dst + 3, count - 3); dst += count; } } }
public override ImageData Read(IBinaryStream file, ImageMetaData info) { file.Position = 0xC; var palette = ReadColorMap(file.AsStream, 256, PaletteFormat.Bgr); int stride = (int)info.Width * 3; var pixels = new byte[stride * (int)info.Height]; int dst = 0; while (dst < pixels.Length) { int ctl = file.PeekByte(); if (-1 == ctl) { break; } if (1 == ctl) { file.ReadByte(); int idx = file.ReadByte(); var color = palette[idx]; pixels[dst] = color.B; pixels[dst + 1] = color.G; pixels[dst + 2] = color.R; dst += 3; } else if (2 == ctl) { file.ReadByte(); int idx = file.ReadByte(); int count = file.ReadByte(); var color = palette[idx]; for (int i = 0; i < count; ++i) { pixels[dst] = color.B; pixels[dst + 1] = color.G; pixels[dst + 2] = color.R; dst += 3; } } else { file.Read(pixels, dst, 3); dst += 3; } } return(ImageData.CreateFlipped(info, PixelFormats.Bgr24, null, pixels, stride)); }
void Unpack(IBinaryStream input, Stream output) { var buffer = new byte[16]; int ctl; while ((ctl = input.ReadByte()) != -1) { if (0 == ctl) { input.Read(buffer, 0, 16); output.Write(buffer, 0, 16); } else if (1 == ctl) { for (int i = 0; i < 16; i += 2) { buffer[i] = input.ReadUInt8(); buffer[i + 1] = 0; } output.Write(buffer, 0, 16); } else if (8 == ctl) { for (int i = 0; i < 16; i += 2) { buffer[i] = input.ReadUInt8(); buffer[i + 1] = 0xFF; } output.Write(buffer, 0, 16); } else if (15 == ctl) { int count = input.ReadUInt8(); if (count > buffer.Length) { buffer = new byte[count]; } input.Read(buffer, 0, count); output.Write(buffer, 0, count); } else if (input.PeekByte() != -1) { throw new InvalidFormatException(); } } }
public override ImageData Read(IBinaryStream file, ImageMetaData info) { var meta = (RadMetaData)info; file.Position = 4; int stride = info.iWidth * 3; var pixels = new byte[stride * info.iHeight]; if (meta.IsCompressed) { UnpackRgb(file, pixels); } else { file.Read(pixels, 0, pixels.Length); } if (file.PeekByte() == -1) { return(ImageData.CreateFlipped(info, PixelFormats.Bgr24, null, pixels, stride)); } var alpha = new byte[info.iWidth * info.iHeight]; if (meta.IsCompressed) { UnpackAlpha(file, alpha); } else { file.Read(alpha, 0, alpha.Length); } stride = info.iWidth * 4; var output = new byte[stride * info.iHeight]; int src = 0; int asrc = 0; for (int dst = 0; dst < output.Length; dst += 4) { output[dst] = pixels[src++]; output[dst + 1] = pixels[src++]; output[dst + 2] = pixels[src++]; output[dst + 3] = alpha[asrc++]; } return(ImageData.CreateFlipped(info, PixelFormats.Bgra32, null, output, stride)); }
public override ImageData Read(IBinaryStream file, ImageMetaData info) { ImageData base_img; using (var input = new StreamRegion(file.AsStream, 0x24, true)) using (var bmp = new BinaryStream(input, file.Name)) { var bmp_info = Bmp.ReadMetaData(bmp) as BmpMetaData; if (null == bmp_info) { throw new InvalidFormatException(); } bmp.Position = 0; base_img = Bmp.Read(bmp, bmp_info); file.Position = 0x24 + bmp_info.ImageLength; if (file.PeekByte() == -1) { return(base_img); } } using (var input = new StreamRegion(file.AsStream, file.Position, true)) using (var bmp = new BinaryStream(input, file.Name)) { var bmp_info = Bmp.ReadMetaData(bmp) as BmpMetaData; if (null == bmp_info) { return(base_img); } bmp.Position = 0; var alpha_img = Bmp.Read(bmp, bmp_info); var alpha_bmp = new FormatConvertedBitmap(alpha_img.Bitmap, PixelFormats.Gray8, null, 0); var alpha = new byte[alpha_bmp.PixelWidth * alpha_bmp.PixelHeight]; alpha_bmp.CopyPixels(alpha, alpha_bmp.PixelWidth, 0); var base_bmp = new FormatConvertedBitmap(base_img.Bitmap, PixelFormats.Bgr32, null, 0); int stride = base_bmp.PixelWidth * 4; var pixels = new byte[stride * base_bmp.PixelHeight]; base_bmp.CopyPixels(pixels, stride, 0); int asrc = 0; for (int dst = 3; dst < pixels.Length; dst += 4) { pixels[dst] = alpha[asrc++]; } return(ImageData.Create(info, PixelFormats.Bgra32, null, pixels, stride)); } }
IEnumerator <int> ReadSeq() { var stack = new byte[256]; while (m_input.PeekByte() != -1) { int packed_size = UnpackDict(); int src = 0; int stack_pos = 0; for (;;) { byte s; if (stack_pos > 0) { s = stack[--stack_pos]; } else if (src < packed_size) { s = m_input.ReadUInt8(); src++; } else { break; } if (m_dict[s, 0] == s) { while (m_output_pos == m_output_end) { yield return(m_output_pos); } m_output[m_output_pos++] = s; } else { stack[stack_pos++] = m_dict[s, 1]; stack[stack_pos++] = m_dict[s, 0]; } } } yield return(m_output_pos); }
void UnpackRle(IBinaryStream input, byte[] output) { var header = input.ReadBytes(0x18); byte count_limit = header[5]; int dst = 0; while (dst < output.Length) { int v = input.ReadByte(); if (-1 == v) { break; } int count = 1; while (count < count_limit) { if (input.PeekByte() != v) { break; } ++count; input.ReadByte(); } if (count == count_limit) { byte ctl = input.ReadUInt8(); if (ctl > 0x7F) { byte lo = input.ReadUInt8(); count += lo + ((ctl & 0x7F) << 8) + 128; } else { count += ctl; } } for (int i = 0; i < count; ++i) { output[dst++] = (byte)v; } } }
public override ImageData Read(IBinaryStream file, ImageMetaData info) { file.Position = 4; var pixels = new uint[info.Width * info.Height]; int dst = 0; while (dst < pixels.Length && file.PeekByte() != -1) { uint px = file.ReadUInt32(); if (px != 0) { pixels[dst++] = px; } else { dst += file.ReadUInt8(); } } return(ImageData.Create(info, PixelFormats.Bgra32, null, pixels)); }
bool ConvertToMp3(IBinaryStream input, Stream mp3, ushort schema) { byte[] frame_buffer = null; using (var output = new BinaryWriter(mp3, System.Text.Encoding.Default, true)) { while (input.PeekByte() != -1) { ushort rha_header = Binary.BigEndian(input.ReadUInt16()); uint header; if (0 == schema) { header = 0xFFFB0000u | rha_header; } else { if (0 != (rha_header & 0x3000)) { input.ReadUInt16(); } header = RhaToMp3Header(rha_header); } int frame_length = GetFrameLength(header); if (0 == frame_length) { return(false); } if (null == frame_buffer || frame_length > frame_buffer.Length) { frame_buffer = new byte[frame_length]; } if (frame_length != input.Read(frame_buffer, 0, frame_length)) { break; } output.Write(Binary.BigEndian(header)); output.Write(frame_buffer, 0, frame_length); } } return(mp3.Length > 0); }
void FillBuffer() { if (m_input.PeekByte() == -1) { m_eof = true; return; } int chunk_size = m_input.ReadInt32(); int type = m_input.ReadByte(); if (type != 2) { m_eof = true; return; } if (chunk_size > m_buffer.Length) { m_buffer = new byte[chunk_size]; } m_buffer_size = m_input.Read(m_buffer, 0, chunk_size); m_buffer_pos = 0; }
void UnpackRle(byte[] output) { int dst = 0; while (m_input.PeekByte() != -1 && dst < output.Length) { byte ctl = m_input.ReadUInt8(); if (ctl != 0xF0) { output[dst++] = (byte)ctl; } else { byte count = m_input.ReadUInt8(); if (0 == count) { output[dst++] = (byte)ctl; } else if (1 == count) { output[dst++] = 0xF0; } else if (2 == count) { output[dst++] = 0xF0; output[dst++] = 0xF0; } else { byte v = m_input.ReadUInt8(); while (count-- > 0) { output[dst++] = v; } } } } }
void FillBuffer() { m_buffer_pos = m_buffer_size = 0; if (m_eof) { return; } if (m_input.PeekByte() == -1) { m_eof = true; BigEndian.Pack(0, m_buffer, 0); BigEndian.Pack(0x49454E44, m_buffer, 4); // 'IEND' BigEndian.Pack(0xAE426082, m_buffer, 8); m_buffer_size = 12; return; } int chunk_size = m_input.ReadInt32(); int type = m_input.ReadByte(); if (type != 2) { m_eof = true; return; } if (chunk_size + 12 > m_buffer.Length) { m_buffer = new byte[chunk_size + 12]; } chunk_size = m_input.Read(m_buffer, 8, chunk_size); BigEndian.Pack(chunk_size, m_buffer, 0); BigEndian.Pack(0x49444154, m_buffer, 4); // 'IDAT' uint checksum = Adler32.Compute(m_buffer, 8, chunk_size); BigEndian.Pack(checksum, m_buffer, 8 + chunk_size); m_buffer_size = 12 + chunk_size; return; }
void LL5Decompress(IBinaryStream input, Stream output) { var buffer = new byte[0x100]; while (input.PeekByte() != -1) { int count = input.ReadInt8(); if (count < 0) { count = -count; input.Read(buffer, 0, count); output.Write(buffer, 0, count); } else { byte v = input.ReadUInt8(); for (int i = 0; i < count; ++i) { buffer[i] = v; } output.Write(buffer, 0, count); } } }
public static long FindChunk(IBinaryStream file, string chunk) { try { var buf = new byte[4]; file.Position = 8; while (-1 != file.PeekByte()) { long chunk_offset = file.Position; uint chunk_size = Binary.BigEndian(file.ReadUInt32()); if (4 != file.Read(buf, 0, 4)) { break; } if (Binary.AsciiEqual(buf, chunk)) { return(chunk_offset); } file.Position += chunk_size + 4; } } catch { /* ignore errors */ } return(-1L); }
void QlzUnpack(IBinaryStream input, byte[] output) { int dst = 0; uint bits = 1; int output_last = output.Length - 11; while (dst < output.Length) { if (1 == bits) { bits = input.ReadUInt32(); } if ((bits & 1) == 1) { int ctl = input.PeekByte(); int offset, count = 3; if ((ctl & 3) == 0) { offset = input.ReadUInt8() >> 2; } else if ((ctl & 2) == 0) { offset = input.ReadUInt16() >> 2; } else if ((ctl & 1) == 0) { offset = input.ReadUInt16() >> 6; count += ((ctl >> 2) & 0xF); } else if ((ctl & 0x7F) != 3) { offset = (input.ReadInt24() >> 7) & 0x1FFFF; count += ((ctl >> 2) & 0x1F) - 1; } else { uint v = input.ReadUInt32(); offset = (int)(v >> 15); count += (int)((v >> 7) & 0xFF); } Binary.CopyOverlapped(output, dst - offset, dst, count); dst += count; } else { if (dst > output_last) { break; } output[dst++] = input.ReadUInt8(); } bits >>= 1; } while (dst < output.Length) { if (1 == bits) { input.Seek(4, SeekOrigin.Current); bits = 0x80000000u; } output[dst++] = input.ReadUInt8(); bits >>= 1; } }
public byte[] Unpack(int unpacked_size) { var output = new byte[unpacked_size]; int dst = 0; var table = new byte[2, 256]; while (dst < unpacked_size && m_input.PeekByte() != -1) { for (int i = 0; i < 256; ++i) { table[0, i] = (byte)i; } int count; int t_idx = 0; do { byte ctl = m_input.ReadUInt8(); if (ctl > 127) { t_idx += ctl - 127; ctl = 0; } if (t_idx != 256) { count = ctl + 1; while (count-- > 0) { ctl = (byte)t_idx; table[0, t_idx] = m_input.ReadUInt8(); if (t_idx != table[0, t_idx]) { table[1, t_idx] = m_input.ReadUInt8(); } ++t_idx; } } }while (t_idx != 256); byte hi = m_input.ReadUInt8(); byte lo = m_input.ReadUInt8(); count = hi << 8 | lo; int pos = 0; for (;;) { byte b; if (pos != 0) { b = m_filename[--pos]; } else { if (0 == count--) { break; } b = m_input.ReadUInt8(); } if (b == table[0, b]) { output[dst++] = b; if (dst >= output.Length) { break; } } else { m_filename[pos++] = table[1, b]; m_filename[pos++] = table[0, b]; } } } return(output); }
void UnpackV2() { int dst = 0; byte b = 0, g = 0, r = 0; while (dst < m_output.Length) { if (GetBit() == 0) { if (GetBit() != 0) { if (m_input.PeekByte() != -1) { b = m_input.ReadUInt8(); g = m_input.ReadUInt8(); r = m_input.ReadUInt8(); } } else if (GetBit() != 0) { byte v = (byte)(GetBits(2)); if (3 == v) { b = m_output[dst - m_stride]; g = m_output[dst - m_stride + 1]; r = m_output[dst - m_stride + 2]; } else { b += (byte)(v - 1); v = (byte)GetBits(2); if (3 == v) { if (GetBit() != 0) { b = m_output[dst - m_stride - 3]; g = m_output[dst - m_stride - 2]; r = m_output[dst - m_stride - 1]; } else { b = m_output[dst - m_stride + 3]; g = m_output[dst - m_stride + 4]; r = m_output[dst - m_stride + 5]; } } else { g += (byte)(v - 1); r += (byte)(GetBits(2) - 1); } } } else if (GetBit() != 0) { byte v = (byte)(GetBits(3)); if (7 == v) { b = m_output[dst - m_stride]; g = m_output[dst - m_stride + 1]; r = m_output[dst - m_stride + 2]; b += (byte)(GetBits(3) - 3); g += (byte)(GetBits(3) - 3); r += (byte)(GetBits(3) - 3); } else { b += (byte)(v - 3); g += (byte)(GetBits(3) - 3); r += (byte)(GetBits(3) - 3); } } else if (GetBit() != 0) { b += (byte)(GetBits(4) - 7); g += (byte)(GetBits(4) - 7); r += (byte)(GetBits(4) - 7); } else { b += (byte)(GetBits(5) - 15); g += (byte)(GetBits(5) - 15); r += (byte)(GetBits(5) - 15); } } m_output[dst++] = b; m_output[dst++] = g; m_output[dst++] = r; } }