public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 3;
byte id = file.ReadUInt8();
uint data_size = file.ReadUInt32();
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
uint stride = file.ReadUInt32();
if (stride < width)
{
throw new NotSupportedException();
}
if (stride * height != data_size)
{
return(null);
}
return(new MfgMetaData
{
Width = width,
Height = height,
BPP = (int)(stride * 8 / width),
Type = id,
Stride = (int)stride,
});
}
public override SoundInput TryOpen(IBinaryStream file)
{
var header = file.ReadHeader(0x24);
if (!header.AsciiEqual(0, "RIFF") || !header.AsciiEqual(8, "PCMWFMT "))
{
return(null);
}
uint data_pos = header.ToUInt32(0x10) + 0x14;
file.Position = data_pos;
if (file.ReadUInt32() != 0x61746164) // 'data'
{
return(null);
}
uint data_size = file.ReadUInt32();
var format = new WaveFormat {
FormatTag = header.ToUInt16(0x14),
Channels = header.ToUInt16(0x16),
SamplesPerSecond = header.ToUInt32(0x18),
AverageBytesPerSecond = header.ToUInt32(0x1C),
BlockAlign = header.ToUInt16(0x20),
BitsPerSample = header.ToUInt16(0x22),
};
var pcm = new StreamRegion(file.AsStream, data_pos + 8, data_size);
return(new RawPcmInput(pcm, format));
}
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);
}
public void Unpack()
{
long next_pos = m_info.DataOffset;
for (;;)
{
m_input.Position = next_pos;
uint id = m_input.ReadUInt32();
next_pos += 8 + m_input.ReadUInt32();
if (0x6C646664 == id) // 'dfdl'
{
int unpacked_size = m_input.ReadInt32();
if (unpacked_size <= 0)
{
continue;
}
m_mask = new byte[unpacked_size];
using (var input = new ZLibStream(m_input.AsStream, CompressionMode.Decompress, true))
input.Read(m_mask, 0, unpacked_size);
}
else if (0x64676364 == id) // 'dcgd'
{
break;
}
}
long qnt_pos = m_input.Position;
if (m_input.ReadUInt32() != Qnt.Signature)
{
throw new InvalidFormatException();
}
using (var reg = new StreamRegion(m_input.AsStream, qnt_pos, true))
using (var qnt = new BinaryStream(reg, m_input.Name))
{
var qnt_info = Qnt.ReadMetaData(qnt) as QntMetaData;
if (null == qnt_info)
{
throw new InvalidFormatException();
}
var overlay = new QntFormat.Reader(reg, qnt_info);
overlay.Unpack();
m_overlay_bpp = overlay.BPP;
if (m_mask != null)
{
ReadBaseImage();
}
if (m_base != null)
{
m_output = ApplyOverlay(overlay.Data);
SetFormat((int)m_info.Width, m_overlay_bpp);
}
else
{
m_output = overlay.Data;
SetFormat((int)qnt_info.Width, m_overlay_bpp);
}
}
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var info = new AkbMetaData();
bool is_incremental = '+' == (file.ReadUInt32() >> 24);
info.Width = file.ReadUInt16();
info.Height = file.ReadUInt16();
info.Flags = file.ReadUInt32();
info.BPP = 0 == (info.Flags & 0x40000000) ? 32 : 24;
info.Background = file.ReadBytes(4);
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
info.InnerWidth = file.ReadInt32() - info.OffsetX;
info.InnerHeight = file.ReadInt32() - info.OffsetY;
if (info.InnerWidth > info.Width || info.InnerHeight > info.Height)
{
return(null);
}
if (is_incremental)
{
info.BaseFileName = file.ReadCString(0x20);
}
info.DataOffset = (uint)file.Position;
return(info);
}
public string LoadRioTypeCore(out uint signature)
{
signature = m_input.ReadUInt32();
if (!CoreSignatures.Contains(signature))
{
throw new InvalidFormatException("[RIO] invalid signature");
}
int version = ReadUInt16();
if (version >= 0x10 && version <= 0x3FFF)
{
Schema = version;
if (version >= 0x11)
{
m_field_4C &= 0xFFFF;
m_field_4C |= ReadUInt16() << 16;
}
}
else
{
m_input.Seek(-2, SeekOrigin.Current);
}
if (EncryptedSignature == signature)
{
m_field_4C |= 0xC;
}
return(ReadClass());
}
public void Parse(IBinaryStream index)
{
index.Position = 16;
int segment_count = Binary.BigEndian(index.ReadInt32());
m_segments = new List <BundleSegment> (segment_count);
long packed_offset = m_data_offset;
long unpacked_offset = 0;
for (int i = 0; i < segment_count; ++i)
{
var segment = new BundleSegment();
segment.Offset = packed_offset;
segment.UnpackedOffset = unpacked_offset;
segment.UnpackedSize = Binary.BigEndian(index.ReadUInt32());
segment.PackedSize = Binary.BigEndian(index.ReadUInt32());
segment.Compression = Binary.BigEndian(index.ReadUInt16());
m_segments.Add(segment);
packed_offset += segment.PackedSize;
unpacked_offset += segment.UnpackedSize;
}
int count = Binary.BigEndian(index.ReadInt32());
m_bundles = new List <BundleEntry> (count);
for (int i = 0; i < count; ++i)
{
var entry = new BundleEntry();
entry.Offset = Binary.BigEndian(index.ReadInt64());
entry.Size = (uint)Binary.BigEndian(index.ReadInt64());
entry.Flags = Binary.BigEndian(index.ReadUInt32());
entry.Name = index.ReadCString(Encoding.UTF8);
m_bundles.Add(entry);
}
}
int PrepareBmpHeader(IBinaryStream input, byte[] output)
{
input.ReadInt32();
uint h1 = ~input.ReadUInt32();
uint h2 = ~input.ReadUInt32();
uint h3 = ~input.ReadUInt32();
uint width = Binary.BigEndian((ushort)h1);
uint height = Binary.BigEndian((ushort)(h1 >> 16));
output[0] = (byte)'B';
output[1] = (byte)'M';
LittleEndian.Pack(output.Length, output, 2);
output[10] = 54; // offset to the body
output[14] = 40; // header size
LittleEndian.Pack(width, output, 18);
LittleEndian.Pack(height, output, 22);
output[26] = 1; // planes
output[28] = Binary.RotByteL((byte)h2, 4); // bpp
LittleEndian.Pack(Binary.RotL(h3, 16), output, 34);
LittleEndian.Pack(0xB12, output, 38);
LittleEndian.Pack(0xB12, output, 42);
LittleEndian.Pack((uint)Binary.RotByteL((byte)(h2 >> 16), 4), output, 46);
LittleEndian.Pack((uint)Binary.RotByteL((byte)(h2 >> 24), 4), output, 50);
return(54);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
uint size = file.ReadUInt32();
if (size != file.Length)
{
return(null);
}
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
int compressed = file.ReadInt32();
if (compressed > 1 || 0 == compressed && (width * height + 0x410) != size)
{
return(null);
}
return(new CmMetaData {
Width = width,
Height = height,
BPP = 8,
IsCompressed = 1 == compressed,
DataOffset = 0x10,
DataLength = size,
});
}
} // 'dcf '
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Seek(4, SeekOrigin.Current);
uint header_size = stream.ReadUInt32();
long data_pos = stream.Position + header_size;
if (stream.ReadInt32() != 1)
{
return(null);
}
uint width = stream.ReadUInt32();
uint height = stream.ReadUInt32();
int bpp = stream.ReadInt32();
int name_length = stream.ReadInt32();
if (name_length <= 0)
{
return(null);
}
int shift = (name_length % 7) + 1;
var name_bits = stream.ReadBytes(name_length);
for (int i = 0; i < name_length; ++i)
{
name_bits[i] = Binary.RotByteL(name_bits[i], shift);
}
return(new DcfMetaData
{
Width = width,
Height = height,
BPP = bpp,
BaseName = Encodings.cp932.GetString(name_bits),
DataOffset = data_pos,
});
}
} // 'TYP1'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 4;
int bpp = stream.ReadByte();
bool has_palette = stream.ReadByte() != 0;
var info = new Typ1MetaData {
BPP = bpp
};
info.Width = stream.ReadUInt16();
info.Height = stream.ReadUInt16();
uint packed_size = stream.ReadUInt32();
uint palette_size = 8 == bpp ? 0x400u : 0u;
if (packed_size + palette_size + 0xE == stream.Length)
{
info.SeparateChannels = false;
info.HasPalette = palette_size > 0;
info.PackedSize = packed_size;
}
else
{
info.SeparateChannels = true;
info.HasPalette = has_palette;
info.Channel[0] = stream.ReadUInt32();
info.Channel[1] = stream.ReadUInt32();
info.Channel[2] = stream.ReadUInt32();
info.Channel[3] = stream.ReadUInt32();
}
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream input)
{
input.Position = 4;
uint width = Binary.BigEndian(input.ReadUInt32());
uint height = Binary.BigEndian(input.ReadUInt32());
if (0 == width || 0 == height)
{
return(null);
}
int bpp = input.ReadByte();
int color_type = input.ReadByte();
switch (color_type)
{
case 2: bpp *= 3; break;
case 4: bpp *= 2; break;
case 6: bpp *= 4; break;
case 3:
case 0: break;
default: return(null);
}
return(new ImageMetaData
{
Width = width,
Height = height,
BPP = bpp,
});
}
internal ApsMetaData ReadCompressionMetaData(IBinaryStream reader, Rectangle rect)
{
int compression = reader.ReadInt16();
var info = new ApsMetaData
{
Width = (uint)rect.Width,
Height = (uint)rect.Height,
BPP = 32,
IsPacked = 0 != compression,
};
if (0 == compression)
{
info.UnpackedSize = reader.ReadUInt32();
}
else if (1 == compression)
{
info.PackedSize = reader.ReadUInt32();
info.UnpackedSize = reader.ReadUInt32();
}
else
{
return(null);
}
info.DataOffset = (uint)reader.Position;
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
var info = new EpaMetaData();
info.Mode = file.ReadInt32() >> 24;
info.ColorType = file.ReadInt32() & 0xff;
switch (info.ColorType)
{
case 0: info.BPP = 8; break;
case 1: info.BPP = 24; break;
case 2: info.BPP = 32; break;
case 3: info.BPP = 15; break;
case 4: info.BPP = 8; break;
default: return(null);
}
info.Width = file.ReadUInt32();
info.Height = file.ReadUInt32();
if (2 == info.Mode)
{
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
}
return(info);
}
} // 'hiz'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
int n = file.ReadInt32();
if (100 != n)
{
return(null);
}
uint right = file.ReadUInt32() ^ 0xAA5A5A5A;
uint bottom = file.ReadUInt32() ^ 0xAC9326AF;
int unknown1 = file.ReadInt32(); // @0x10
if (unknown1 == 0x375A8436)
{
return(null);
}
uint unpacked_size = file.ReadUInt32() ^ 0x19739D6A; // @0x14
if (unpacked_size != right * bottom * 4)
{
return(null);
}
return(new HizMetaData
{
Width = right,
Height = bottom,
BPP = 32,
IsPacked = true,
DataOffset = 0x4c,
UnpackedSize = unpacked_size,
});
}
public string LoadRioTypeCore(out uint signature)
{
signature = m_input.ReadUInt32();
if (!CoreSignatures.Contains(signature))
{
throw new InvalidFormatException("[RIO] invalid signature");
}
int version = ReadUInt16();
if (version < 0x10 || version > 0x3FFF)
{
throw new InvalidFormatException("[RIO] invalid version");
}
if (version >= 0x11)
{
m_field_4C &= 0xFFFF;
m_field_4C |= ReadUInt16() << 16;
}
if (EncryptedSignature == signature)
{
m_field_4C |= 0xC;
}
return(ReadClass());
}
public List <Entry> Read(IBinaryStream input, int count)
{
m_dir.Clear();
if (m_dir.Capacity < count)
{
m_dir.Capacity = count;
}
try
{
for (int i = 0; i < count; ++i)
{
uint offset = input.ReadUInt32();
uint size = input.ReadUInt32();
var name = input.ReadCString(0x18);
var entry = FormatCatalog.Instance.Create <Entry> (name);
entry.Offset = offset;
entry.Size = size;
if (!entry.CheckPlacement(m_arc_length))
{
return(null);
}
m_dir.Add(entry);
}
return(m_dir);
}
catch
{
return(null);
}
}
public override List <Entry> GetFramesList(IBinaryStream file)
{
file.Position = 4;
int count = file.ReadInt16();
if (!IsSaneCount(count))
{
return(null);
}
file.Position = 0x16;
var current_offset = file.Position;
var dir = new List <Entry> (count);
for (int i = 0; i < count; ++i)
{
file.Position = current_offset + 8;
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
uint depth = file.ReadUInt32();
uint image_size = depth * width * height;
var entry = new AnmEntry
{
Offset = current_offset,
Size = 0x14 + image_size,
ImageDataOffset = current_offset + 0x14,
ImageDataSize = image_size,
};
dir.Add(entry);
current_offset += entry.Size;
}
return(dir);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
int frames = file.ReadUInt16();
int bpp = file.ReadUInt16();
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
int x = file.ReadInt32();
int y = file.ReadInt32();
file.ReadInt32(); // 0
uint frame_size = file.ReadUInt32();
if (24 != bpp && 8 != bpp)
{
Trace.WriteLine("unsupported bpp", "WipFormat");
return(null);
}
return(new WipMetaData
{
Width = width,
Height = height,
OffsetX = x,
OffsetY = y,
BPP = bpp,
FrameCount = frames,
FrameSize = frame_size,
});
}
public WadyInput(IBinaryStream input) : base(new MemoryStream())
{
input.Seek(5, SeekOrigin.Begin);
MulValue = input.ReadUInt8();
input.Seek(6, SeekOrigin.Current);
int src_size = input.ReadInt32();
input.Seek(16, SeekOrigin.Current);
var format = new WaveFormat();
format.FormatTag = input.ReadUInt16();
format.Channels = input.ReadUInt16();
format.SamplesPerSecond = input.ReadUInt32();
format.AverageBytesPerSecond = input.ReadUInt32();
format.BlockAlign = input.ReadUInt16();
format.BitsPerSample = input.ReadUInt16();
format.ExtraSize = 0;
this.Format = format;
int remaining = (int)(input.Length - input.Position);
if (remaining == src_size)
{
(Source as MemoryStream).Capacity = src_size * 2;
Decode(input, src_size, Source);
}
else
{
Decode2(input, Source);
}
Source.Position = 0;
this.PcmSize = Source.Length;
input.Dispose();
}
} // 'CHD'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
int count = file.ReadInt32();
if (count < 0 || count > 0xFFFFF)
{
return(null);
}
file.ReadInt32();
uint first_offset = 0;
for (int i = 0; i < count && 0 == first_offset; ++i)
{
first_offset = file.ReadUInt32();
}
if (0 == first_offset)
{
return(null);
}
file.Position = first_offset;
var info = new ChdMetaData();
info.Width = file.ReadUInt32();
info.Height = file.ReadUInt32();
info.OffsetX = file.ReadInt32();
info.OffsetY = file.ReadInt32();
info.FirstOffset = first_offset + 0x10;
info.BPP = 32;
return(info);
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
int type = file.ReadInt32();
if (type < 0 || type > 3)
{
return(null);
}
if (-1 != file.ReadInt32())
{
return(null);
}
int x = file.ReadInt32();
int y = file.ReadInt32();
uint width = file.ReadUInt32();
uint height = file.ReadUInt32();
int comp_size = file.ReadInt32();
int uncomp_size = file.ReadInt32();
if (uncomp_size != width * height * 3u)
{
return(null);
}
return(new Pt1MetaData {
Width = width,
Height = height,
OffsetX = x,
OffsetY = y,
BPP = 3 == type ? 32 : 24,
Type = type,
PackedSize = comp_size,
UnpackedSize = uncomp_size
});
}
} // 'HG-2'
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 8;
var info = new Hg2MetaData();
int type = stream.ReadInt32();
if (0x25 == type)
{
info.HeaderSize = 0x58;
}
else if (0x20 == type)
{
info.HeaderSize = 0x50;
}
else
{
return(null);
}
info.Width = stream.ReadUInt32();
info.Height = stream.ReadUInt32();
info.BPP = stream.ReadInt32();
stream.Seek(8, SeekOrigin.Current);
info.DataPacked = stream.ReadInt32();
info.DataUnpacked = stream.ReadInt32();
info.CtlPacked = stream.ReadInt32();
info.CtlUnpacked = stream.ReadInt32();
stream.Seek(8, SeekOrigin.Current);
info.CanvasWidth = stream.ReadUInt32();
info.CanvasHeight = stream.ReadUInt32();
info.OffsetX = stream.ReadInt32();
info.OffsetY = stream.ReadInt32();
return(info);
}
List <Entry> ReadIndex(IBinaryStream index, long max_offset, int align)
{
var index_length = index.Length;
int index_pos = 0;
var dir = new List <Entry>();
while (index_pos < index_length)
{
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 += ((align + 1 + name_length) & -align) + 8;
// index_pos += ((9 + name_length) & ~7) + 8;
// index_pos += ((5 + name_length) & ~3) + 8;
var entry = FormatCatalog.Instance.Create <Entry> (name);
entry.Offset = offset;
entry.Size = size;
if (!entry.CheckPlacement(max_offset))
{
return(null);
}
dir.Add(entry);
}
return(dir);
}
public void Unpack()
{
m_input.Position = m_info.DataOffset;
uint name_length = m_input.ReadUInt32();
m_input.Seek(name_length, SeekOrigin.Current);
uint mask = m_input.ReadUInt32();
m_input.Seek(9, SeekOrigin.Current);
int layer_count = m_input.ReadInt32();
if (layer_count < 1)
{
throw new InvalidFormatException();
}
// XXX only first frame is interpreted.
var frame = new Frame(layer_count);
frame.Width = m_input.ReadInt32();
frame.Height = m_input.ReadInt32();
frame.BPP = m_input.ReadInt32();
if (frame.BPP <= 0)
{
throw new InvalidFormatException();
}
if (frame.BPP <= 8)
{
frame.Palette = ImageFormat.ReadColorMap(m_input.AsStream, 1 << frame.BPP);
}
frame.SetStride();
m_frames.Add(frame);
for (int i = 0; i < layer_count; ++i)
{
m_input.ReadInt32(); // left
m_input.ReadInt32(); // top
m_input.ReadByte(); // visibility
m_input.ReadInt32(); // (-1) TransColor
m_input.ReadInt32(); // (0xFF) alpha
m_input.ReadByte(); // AlphaOn
name_length = m_input.ReadUInt32();
m_input.Seek(name_length, SeekOrigin.Current);
if (m_info.Version >= 107)
{
m_input.ReadByte(); // lock
}
var layer = new Layer();
int layer_size = m_input.ReadInt32();
layer.Pixels = UnpackLayer(frame, layer_size);
int alpha_size = m_input.ReadInt32();
if (alpha_size != 0)
{
layer.Alpha = UnpackLayer(frame, alpha_size, true);
}
frame.Layers.Add(layer);
}
Flatten(0);
}
public override ImageMetaData ReadMetaData(IBinaryStream stream)
{
stream.Position = 4;
int id = stream.ReadByte();
if (0x54 != id)
{
return(null);
}
int encryption = stream.ReadByte();
if (encryption != 0x43 && encryption != 0x53)
{
return(null);
}
bool is_encrypted = 0x53 == encryption;
int version = stream.ReadByte();
if (0x30 != version)
{
return(null);
}
version = stream.ReadByte() - 0x30;
if (version != 0 && version != 1)
{
return(null);
}
uint width = stream.ReadUInt32();
uint height = stream.ReadUInt32();
int data_size = stream.ReadInt32();
int additional_size = 0;
if (1 == version)
{
additional_size = stream.ReadUInt16();
}
if (width > 0x8000 || height > 0x8000)
{
return(null);
}
return(new RctMetaData
{
Width = width,
Height = height,
OffsetX = 0,
OffsetY = 0,
BPP = 24,
Version = version,
IsEncrypted = is_encrypted,
DataOffset = (uint)stream.Position,
DataSize = data_size,
BaseNameLength = additional_size,
});
}
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 4;
return(new ImageMetaData
{
Width = file.ReadUInt32(),
Height = file.ReadUInt32(),
BPP = 32,
});
}
public DscDecoder(IBinaryStream input) : base(input.AsStream)
{
m_magic = (uint)input.ReadUInt16() << 16;
input.Position = 0x10;
m_key = input.ReadUInt32();
int output_size = input.ReadInt32();
m_dec_count = input.ReadUInt32();
m_output = new byte[output_size];
}
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);
}
