public override void Write(System.Byte[] b1, int off, int len)
{
if (len == 0)
{
return;
}
int err;
var b = new byte[b1.Length];
System.Array.Copy(b1, 0, b, 0, b1.Length);
z.next_in = b;
z.next_in_index = off;
z.avail_in = len;
do
{
z.next_out = buf;
z.next_out_index = 0;
z.avail_out = bufsize;
if (compress)
{
err = z.deflate(flush_Renamed_Field);
}
else
{
err = z.inflate(flush_Renamed_Field);
}
if (err != zlibConst.Z_OK && err != zlibConst.Z_STREAM_END)
{
throw new ZStreamException((compress?"de":"in") + "flating: " + z.msg);
}
out_Renamed.Write(buf, 0, bufsize - z.avail_out);
}while (z.avail_in > 0 || z.avail_out == 0);
}
public int read(byte[] b, int off, int len)
{
if (len == 0)
{
return(0);
}
int err;
z.next_out = b;
z.next_out_index = off;
z.avail_out = len;
do
{
if ((z.avail_in == 0) && !nomoreinput)
{
// if buffer is empty and more input is avaiable, refill it
z.next_in_index = 0;
z.avail_in = SupportClass.ReadInput(in_Renamed, buf, 0, bufsize);
//(bufsize<z.avail_out ? bufsize : z.avail_out));
if (z.avail_in == -1)
{
z.avail_in = 0;
nomoreinput = true;
}
}
if (compress)
{
err = z.deflate(flush);
}
else
{
err = z.inflate(flush);
}
if (nomoreinput && (err == zlibConst.Z_BUF_ERROR))
{
return(-1);
}
if (err != zlibConst.Z_OK && err != zlibConst.Z_STREAM_END)
{
throw new ZStreamException((compress ? "de" : "in") + "flating: " + z.msg);
}
if (nomoreinput && (z.avail_out == len))
{
return(-1);
}
} while (z.avail_out == len && err == zlibConst.Z_OK);
//System.err.print("("+(len-z.avail_out)+")");
return(len - z.avail_out);
}
public override void Write(byte[] b1, int off, int len)
{
if (len == 0)
{
return;
}
byte[] array = new byte[b1.Length];
Array.Copy(b1, 0, array, 0, b1.Length);
z.next_in = array;
z.next_in_index = off;
z.avail_in = len;
do
{
z.next_out = buf;
z.next_out_index = 0;
z.avail_out = bufsize;
int num = ((!compress) ? z.inflate(flush_Renamed_Field) : z.deflate(flush_Renamed_Field));
if (num != 0 && num != 1)
{
throw new ZStreamException(((!compress) ? "in" : "de") + "flating: " + z.msg);
}
out_Renamed.Write(buf, 0, bufsize - z.avail_out);
}while (z.avail_in > 0 || z.avail_out == 0);
}
public int read(byte[] b, int off, int len)
{
if (len == 0)
{
return(0);
}
z.next_out = b;
z.next_out_index = off;
z.avail_out = len;
int num;
do
{
if (z.avail_in == 0 && !nomoreinput)
{
z.next_in_index = 0;
z.avail_in = SupportClass.ReadInput(in_Renamed, buf, 0, bufsize);
if (z.avail_in == -1)
{
z.avail_in = 0;
nomoreinput = true;
}
}
num = ((!compress) ? z.inflate(flush) : z.deflate(flush));
if (nomoreinput && num == -5)
{
return(-1);
}
if (num != 0 && num != 1)
{
throw new ZStreamException(((!compress) ? "in" : "de") + "flating: " + z.msg);
}
if (nomoreinput && z.avail_out == len)
{
return(-1);
}
}while (z.avail_out == len && num == 0);
return(len - z.avail_out);
}
private void _Decompress(Stream InStream, Stream OutStream)
{
var ZStream = new ZStream();
//if (ZStream.inflateInit(-15) != zlibConst.Z_OK)
if (ZStream.inflateInit(15) != zlibConst.Z_OK)
{
throw (new InvalidProgramException("Can't initialize inflater"));
}
var Out = new byte[4096];
var In = new byte[4096];
try
{
bool ReadedAll = false;
while (!ReadedAll)
{
int InReaded = InStream.Read(In, 0, In.Length);
ZStream.next_in = In;
ZStream.next_in_index = 0;
ZStream.avail_in = InReaded;
ZStream.next_out = Out;
ZStream.next_out_index = 0;
ZStream.avail_out = Out.Length;
int Status = ZStream.inflate(zlibConst.Z_FULL_FLUSH);
//Console.WriteLine(BitConverter.ToString(Out));
/*
Console.WriteLine(
"{0}, {1}, {2}, {3}",
ZStream.avail_out,
ZStream.next_out,
ZStream.next_out_index,
ZStream.total_out
);
*/
OutStream.Write(Out, 0, (int)ZStream.next_out_index);
switch (Status)
{
case zlibConst.Z_OK:
break;
case zlibConst.Z_STREAM_END:
ReadedAll = true;
break;
default:
Console.Error.WriteLine("" + ZStream.msg);
ReadedAll = true;
//throw (new InvalidDataException("" + ZStream.msg));
break;
}
}
}
finally
{
ZStream.inflateEnd();
}
}
protected override int PerformZlibOperation(ZStream zs, int flush)
{
return zs.inflate(flush);
}
private byte[] DecompressReplay(byte[] replayData, int index, Warcraft3Replay replay)
{
uint numChunks = replay.replayHeader.NumDataBlocks;
ushort compChunkSize = BitConverter.ToUInt16(replayData, index);
ushort decompChunkSize = BitConverter.ToUInt16(replayData, index += 2);
index -= 2; //rewind
byte[] decompressedData = new byte[numChunks * decompChunkSize];
byte[] compChunk;
byte[] decompChunk = new byte[decompChunkSize];
ZStream stream = new ZStream();
stream.avail_in = 0;
stream.next_in_index = 0;
for (int i = 0; i < numChunks; i++)
{
if (stream.inflateInit() != zlibConst.Z_OK)
return null; //error
compChunkSize = BitConverter.ToUInt16(replayData, index);
decompChunkSize = BitConverter.ToUInt16(replayData, index += 2);
index += 6; //skipping checksum
compChunk = new byte[compChunkSize];
for (int j = 0; j < compChunkSize; j++, index++)
compChunk[j] = replayData[index];
stream.avail_in = compChunkSize;
stream.next_in = compChunk;
stream.next_in_index = 0;
stream.avail_out = decompChunkSize;
stream.next_out = decompressedData;
stream.next_out_index = i * decompChunkSize;
stream.inflate(zlibConst.Z_NO_FLUSH);
stream.inflateEnd();
}
return decompressedData;
}
public void Decompress()
{
byte[] numArray = new byte[this.data.Count];
this.data.CopyTo(0, numArray, 0, this.data.Count);
byte[] numArray1 = new byte[800];
ZStream zStream = new ZStream()
{
avail_in = 0
};
zStream.inflateInit();
zStream.next_in = numArray;
zStream.next_in_index = 2;
zStream.avail_in = (int)numArray.Length - 4;
zStream.next_out = numArray1;
zStream.avail_out = 800;
if (zStream.inflate(4) != -3)
{
long totalOut = zStream.total_out;
zStream.inflateEnd();
zStream = null;
this.data.Clear();
this.data.Add(numArray[0]);
this.data.Add(numArray[1]);
for (int i = 0; (long)i < totalOut; i++)
{
this.data.Add(numArray1[i]);
}
this.data.Add(numArray[(int)numArray.Length - 3]);
this.data.Add(numArray[(int)numArray.Length - 2]);
this.data.Add(numArray[(int)numArray.Length - 1]);
}
}
/// <summary>
///
/// </summary>
/// <param name="Block"></param>
/// <returns></returns>
public byte[] ReadBlockDecompressed(uint Block)
{
if (Block >= NumberOfBlocks)
{
return new byte[0];
}
var In = ReadBlockCompressed(Block);
// If block is not compressed, get the contents.
if (!Blocks[Block].IsCompressed)
{
return In;
}
var Out = new byte[this.BlockSize];
In = (byte[])In.Concat(new byte[] { 0x00 });
//return new GZipStream(new MemoryStream(In), CompressionMode.Decompress).ReadAll(FromStart: false);
var ZStream = new ZStream();
if (ZStream.inflateInit(15) != zlibConst.Z_OK)
{
throw (new InvalidProgramException("Can't initialize inflater"));
}
try
{
ZStream.next_in = In;
ZStream.next_in_index = 0;
ZStream.avail_in = In.Length;
ZStream.next_out = Out;
ZStream.next_out_index = 0;
ZStream.avail_out = Out.Length;
int Status = ZStream.inflate(zlibConst.Z_FULL_FLUSH);
if (Status != zlibConst.Z_STREAM_END) throw (new InvalidDataException("" + ZStream.msg));
}
finally
{
ZStream.inflateEnd();
}
return Out;
}
public static PhpBytes GzInflate(PhpBytes data, long length)
{
uint factor=1, maxfactor=16;
long ilength;
ZStream zs = new ZStream();
zs.avail_in = data.Length;
zs.next_in = data.ReadonlyData;
zs.total_out = 0;
// -15 omits the header (undocumented feature of zlib)
int status = zs.inflateInit(-15);
if (status != zlibConst.Z_OK)
{
PhpException.Throw(PhpError.Warning, zError(status));
return null;
}
do
{
ilength = length != 0 ? length : data.Length * (1 << (int)(factor++));
try
{
byte[] newOutput = new byte[ilength];
if (zs.next_out != null)
{
Buffer.BlockCopy(zs.next_out, 0, newOutput, 0, zs.next_out.Length);
}
zs.next_out = newOutput;
}
catch (OutOfMemoryException)
{
zs.inflateEnd();
return null;
}
zs.next_out_index = (int)zs.total_out;
zs.avail_out = unchecked((int)(ilength - zs.total_out));
status = zs.inflate(zlibConst.Z_NO_FLUSH);
}
while ((status == zlibConst.Z_BUF_ERROR || (status == zlibConst.Z_OK && (zs.avail_in != 0 || zs.avail_out == 0))) && length == 0 && factor < maxfactor);
zs.inflateEnd();
if ((length != 0 && status == zlibConst.Z_OK) || factor >= maxfactor)
{
status = zlibConst.Z_MEM_ERROR;
}
if (status == zlibConst.Z_STREAM_END || status == zlibConst.Z_OK)
{
byte[] result = new byte[zs.total_out];
Buffer.BlockCopy(zs.next_out, 0, result, 0, (int)zs.total_out);
return new PhpBytes(result);
}
else
{
PhpException.Throw(PhpError.Warning, zError(status));
return null;
}
}
/// <summary>
/// Reimplements function from zlib (uncompress) that is not present in ZLIB.NET.
/// </summary>
/// <param name="dest">Destination array of bytes. May be trimmed if necessary.</param>
/// <param name="source">Source array of bytes.</param>
/// <returns>Zlib status code.</returns>
private static int ZlibUncompress(ref byte[] dest, byte[] source)
{
ZStream stream = new ZStream();
int err;
stream.next_in = source;
stream.avail_in = source.Length;
stream.next_out = dest;
stream.avail_out = dest.Length;
err = stream.inflateInit();
if (err != zlibConst.Z_OK) return err;
err = stream.inflate(zlibConst.Z_FINISH);
if (err != zlibConst.Z_STREAM_END)
{
stream.inflateEnd();
return err == zlibConst.Z_OK ? zlibConst.Z_BUF_ERROR : err;
}
if (stream.total_out != dest.Length)
{
byte[] output = new byte[stream.total_out];
Buffer.BlockCopy(stream.next_out, 0, output, 0, (int)stream.total_out);
dest = output;
}
return stream.inflateEnd();
}