lifegpc/GARbro-crskycode
1
0
Fork 0
mirror of https://github.com/crskycode/GARbro.git synced 2026-07-08 01:30:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

LzssStream and related classes moved to separate namespace.

Browse Source
This commit is contained in:
morkt
2015-07-25 04:20:20 +04:00
parent ca42a0cfa4
commit 230ba532f0
25 changed files with 330 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

264
ArcFormats/ArcCommon.cs
View File

@@ -291,270 +291,6 @@ namespace GameRes.Formats
}
}
public enum LzssMode
{
Decompress,
Compress,
};
public class LzssSettings
{
public int FrameSize { get; set; }
public byte FrameFill { get; set; }
public int FrameInitPos { get; set; }
}
internal sealed class LzssCoroutine : LzssSettings
{
byte[] m_buffer;
int m_offset;
int m_length;
Stream m_input;
IEnumerator<int> m_unpack;
public bool Eof { get; private set; }
public LzssCoroutine (Stream input)
{
m_input = input;
FrameSize = 0x1000;
FrameFill = 0;
FrameInitPos = 0xfee;
}
public int Continue (byte[] buffer, int offset, int count)
{
m_buffer = buffer;
m_offset = offset;
m_length = count;
if (null == m_unpack)
m_unpack = Unpack();
Eof = !m_unpack.MoveNext();
return m_offset - offset;
}
private IEnumerator<int> Unpack ()
{
byte[] frame = new byte[FrameSize];
int frame_pos = FrameInitPos;
int frame_mask = FrameSize-1;
for (;;)
{
int ctl = m_input.ReadByte();
if (-1 == ctl)
yield break;
for (int bit = 1; bit != 0x100; bit <<= 1)
{
if (0 != (ctl & bit))
{
int b = m_input.ReadByte();
if (-1 == b)
yield break;
frame[frame_pos++] = (byte)b;
frame_pos &= frame_mask;
m_buffer[m_offset++] = (byte)b;
if (0 == --m_length)
yield return m_offset;
}
else
{
int lo = m_input.ReadByte();
if (-1 == lo)
yield break;
int hi = m_input.ReadByte();
if (-1 == hi)
yield break;
int offset = (hi & 0xf0) << 4 | lo;
for (int count = 3 + (hi & 0xF); count != 0; --count)
{
byte v = frame[offset++];
offset &= frame_mask;
frame[frame_pos++] = v;
frame_pos &= frame_mask;
m_buffer[m_offset++] = v;
if (0 == --m_length)
yield return m_offset;
}
}
}
}
}
}
public class LzssStream : Stream
{
Stream m_input;
LzssCoroutine m_reader;
bool m_should_dispose;
public LzssStream (Stream input, LzssMode mode = LzssMode.Decompress, bool leave_open = false)
{
if (mode != LzssMode.Decompress)
throw new NotImplementedException ("LzssStream compression not implemented");
m_input = input;
m_reader = new LzssCoroutine (input);
m_should_dispose = !leave_open;
}
public LzssSettings Config { get { return m_reader; } }
public override bool CanRead { get { return m_input.CanRead; } }
public override bool CanSeek { get { return false; } }
public override bool CanWrite { get { return false; } }
public override long Length
{
get { throw new NotSupportedException ("LzssStream.Length property is not supported"); }
}
public override long Position
{
get { throw new NotSupportedException ("LzssStream.Position property is not supported"); }
set { throw new NotSupportedException ("LzssStream.Position property is not supported"); }
}
public override int Read (byte[] buffer, int offset, int count)
{
if (!m_reader.Eof && count > 0)
return m_reader.Continue (buffer, offset, count);
return 0;
}
public override void Flush()
{
}
public override long Seek (long offset, SeekOrigin origin)
{
throw new NotSupportedException ("LzssStream.Seek method is not supported");
}
public override void SetLength (long length)
{
throw new NotSupportedException ("LzssStream.SetLength method is not supported");
}
public override void Write (byte[] buffer, int offset, int count)
{
throw new NotSupportedException ("LzssStream.Write method is not supported");
}
public override void WriteByte (byte value)
{
throw new NotSupportedException ("LzssStream.WriteByte method is not supported");
}
#region IDisposable Members
bool m_disposed = false;
protected override void Dispose (bool disposing)
{
if (!m_disposed)
{
if (m_should_dispose && disposing)
m_input.Dispose();
m_disposed = true;
base.Dispose (disposing);
}
}
#endregion
}
public class LzssReader : IDisposable
{
BinaryReader m_input;
byte[] m_output;
int m_size;
public BinaryReader Input { get { return m_input; } }
public byte[] Data { get { return m_output; } }
public int FrameSize { get; set; }
public byte FrameFill { get; set; }
public int FrameInitPos { get; set; }
public LzssReader (Stream input, int input_length, int output_length)
{
m_input = new BinaryReader (input, Encoding.ASCII, true);
m_output = new byte[output_length];
m_size = input_length;
FrameSize = 0x1000;
FrameFill = 0;
FrameInitPos = 0xfee;
}
public void Unpack ()
{
int dst = 0;
var frame = new byte[FrameSize];
if (FrameFill != 0)
for (int i = 0; i < frame.Length; ++i)
frame[i] = FrameFill;
int frame_pos = FrameInitPos;
int frame_mask = FrameSize-1;
int remaining = (int)m_size;
while (remaining > 0)
{
int ctl = m_input.ReadByte();
--remaining;
for (int bit = 1; remaining > 0 && bit != 0x100; bit <<= 1)
{
if (dst >= m_output.Length)
return;
if (0 != (ctl & bit))
{
byte b = m_input.ReadByte();
--remaining;
frame[frame_pos++] = b;
frame_pos &= frame_mask;
m_output[dst++] = b;
}
else
{
if (remaining < 2)
return;
int lo = m_input.ReadByte();
int hi = m_input.ReadByte();
remaining -= 2;
int offset = (hi & 0xf0) << 4 | lo;
for (int count = 3 + (hi & 0xF); count != 0; --count)
{
if (dst >= m_output.Length)
break;
byte v = frame[offset++];
offset &= frame_mask;
frame[frame_pos++] = v;
frame_pos &= frame_mask;
m_output[dst++] = v;
}
}
}
}
}
#region IDisposable Members
bool disposed = false;
public void Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
}
protected virtual void Dispose (bool disposing)
{
if (!disposed)
{
if (disposing)
{
m_input.Dispose();
}
disposed = true;
}
}
#endregion
}
public class HuffmanDecoder
{
byte[] m_src;