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(); }