/// <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> 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()); }
static void uncompress(ref byte[] dest, byte[] src) { ZStream stream = new ZStream(); stream.next_in = src; stream.avail_in = src.Length; stream.next_out = dest; stream.avail_out = dest.Length; stream.inflateInit(); int err = stream.inflate(zlibConst.Z_FINISH); if (err != zlibConst.Z_STREAM_END) { stream.inflateEnd(); throw new ApplicationException(); } Array.Resize <byte>(ref dest, (int)stream.total_out); err = stream.inflateEnd(); if (err != zlibConst.Z_OK) { throw new ApplicationException(); } }
/// <summary> /// Uncompress a source byte array to a destination (old version) /// </summary> public static int UncompressOld(byte[] dest, ref ulong destLen, byte[] source, ref ulong sourceLen) { var stream = new ZStream { next_in = source, avail_in = (int)sourceLen, next_out = dest, avail_out = (int)destLen, }; destLen = 0; sourceLen = 0; // make second parameter negative to disable checksum verification int err = stream.inflateInit(-Constants.MAX_WBITS); if (err != zlibConst.Z_OK) { return(err); } while (stream.avail_in > 1) { err = stream.inflate(Constants.Z_BLOCK); if (err != zlibConst.Z_OK) { stream.inflateEnd(); return(err); } } destLen = (ulong)stream.total_out; sourceLen = (ulong)stream.total_in; return(stream.inflateEnd()); }
private void ZIPCleanup() { base.TIFFPredictorCleanup(); if ((m_state & ZSTATE_INIT_ENCODE) != 0) { m_stream.deflateEnd(); m_state = 0; } else if ((m_state & ZSTATE_INIT_DECODE) != 0) { m_stream.inflateEnd(); m_state = 0; } }
public static byte[] Uncompress(byte[] buff, int offset = 0) { //using (MemoryStream md = new MemoryStream()) //{ // Stream d = new ZOutputStream(md); // d.Write(buff, offset, buff.Length - offset); // d.Close(); // return md.ToArray(); //} ZStream zs = new ZStream(); zs.next_in = buff; zs.avail_in = buff.Length; zs.next_out = _buffer; zs.avail_out = _buffer.Length; if (zlibConst.Z_OK != zs.inflateInit()) { return(null); } if (zlibConst.Z_STREAM_END != zs.inflate(zlibConst.Z_FINISH)) { return(null); } zs.inflateEnd(); byte[] result = new byte[zs.total_out]; System.Array.Copy(_buffer, result, zs.total_out); return(result); }
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]); } }
public static byte[] Uncompress(byte[] compressed, int start, int size, int maxUncompressedSize) { ZStream stream = new ZStream(); stream.next_in = compressed; stream.next_in_index = start; stream.avail_in = compressed.Length; byte[] uncompressed = new byte[maxUncompressedSize]; stream.next_out = uncompressed; stream.next_out_index = 0; stream.avail_out = maxUncompressedSize; int err = stream.inflateInit(); if (err != zlibConst.Z_OK) { return(null); } err = stream.inflate(zlibConst.Z_FINISH); if (err != zlibConst.Z_STREAM_END) { stream.inflateEnd(); return(null); } int realSize = (int)stream.total_out; err = stream.inflateEnd(); if (err != zlibConst.Z_OK) { return(null); } if (realSize < maxUncompressedSize) { byte[] temp = new byte[realSize]; Array.Copy(uncompressed, temp, realSize); return(temp); } else { return(uncompressed); } }
/// <summary> /// Extract all files contained in the package in the folder pointed by the destination path. /// </summary> public void ExtractAll(String Destination) { Destination = Destination.Replace('/', '\\'); if (!Destination.EndsWith("\\")) { Destination += "\\"; } using (FileStream Input = new FileStream(TpdFile.GetFilename(), FileMode.Open, FileAccess.Read, FileShare.Read)) { Byte[] Buffer = new Byte[Kernel.MAX_BUFFER_SIZE]; Byte[] Tmp = new Byte[Kernel.MAX_BUFFER_SIZE]; foreach (Entry Entry in Entries.Values) { String DestPath = Destination + Entry.Path.Replace("/", "\\"); if (!Directory.Exists(Path.GetDirectoryName(DestPath))) { Directory.CreateDirectory(Path.GetDirectoryName(DestPath)); } Input.Seek(Entry.Offset, SeekOrigin.Begin); using (FileStream Output = new FileStream(DestPath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read)) { ZStream Stream = new ZStream(); Stream.inflateInit(); Int32 Result = 0; Int32 Length = 0; do { Stream.avail_in = Input.Read(Buffer, 0, Kernel.MAX_BUFFER_SIZE); Stream.next_in = Buffer; Stream.next_in_index = 0; if (Stream.avail_in == 0) { break; } do { Stream.avail_out = Kernel.MAX_BUFFER_SIZE; Stream.next_out = Tmp; Stream.next_out_index = 0; Result = Stream.inflate(zlibConst.Z_NO_FLUSH); Length = Kernel.MAX_BUFFER_SIZE - Stream.avail_out; Output.Write(Tmp, 0, Length); }while (Stream.avail_out == 0); }while (Result != zlibConst.Z_STREAM_END); Stream.inflateEnd(); } } } }
private static (byte[] bytes, int res) DecompressZ(byte[] inbuf, int index = 0) { var z = new ZStream(); var ms = new MemoryStream(); var outbuf = new byte[1024]; if (z.inflateInit() != zlibConst.Z_OK) { throw new InvalidOperationException("zlib.inflateInit Error"); } z.next_in = inbuf; z.avail_in = inbuf.Length; z.next_in_index = index; z.next_out = outbuf; z.avail_out = outbuf.Length; z.next_out_index = 0; while (true) { int status = z.inflate(zlibConst.Z_NO_FLUSH); /* 展開 */ if (status == zlibConst.Z_STREAM_END) { break; } if (status != zlibConst.Z_OK) { throw new InvalidOperationException("zlib.inflate Error"); } if (z.avail_out == 0) { ms.Write(outbuf, 0, outbuf.Length); z.next_out = outbuf; z.avail_out = outbuf.Length; z.next_out_index = 0; } } if ((outbuf.Length - z.avail_out) != 0) { ms.Write(outbuf, 0, outbuf.Length - z.avail_out); } if (z.inflateEnd() != zlibConst.Z_OK) { throw new InvalidOperationException("zlib.inflateEnd Error"); } int count = z.next_in_index - index; z.free(); return(ms.ToArray(), count); }
public static PhpString gzdecode(byte[] data, int length = 0) { if (length < 0) { PhpException.Throw(PhpError.Warning, "length ({0}) must be greater or equal zero", length.ToString()); return(default(PhpString)); } if (data.Length == 0) { return(default(PhpString)); } if (data.Length < 10 || data[0] != GZIP_HEADER[0] || data[1] != GZIP_HEADER[1]) { PhpException.Throw(PhpError.Warning, "incorrect gzip header"); return(default(PhpString)); } var zs = new ZStream(); zs.next_in = data; zs.next_in_index = GZIP_HEADER_LENGTH; zs.avail_in = data.Length - GZIP_HEADER_LENGTH; zs.total_out = 0; // negative number omits the zlib header (undocumented feature of zlib) int status = zs.inflateInit(-MAX_WBITS); if (status == zlibConst.Z_OK) { status = zlib_inflate_rounds(zs, length, out byte[] output); if (status == zlibConst.Z_STREAM_END) { zs.inflateEnd(); return(new PhpString(output)); } } PhpException.Throw(PhpError.Warning, zError(status) ?? zs.msg); zs.inflateEnd(); return(default(PhpString)); }
public virtual void end() { if (compress) { z.deflateEnd(); } else { z.inflateEnd(); } z.free(); z = null; }
/// <summary> /// Closes any open connections between the Tibia client and game server, and stops listening for any /// new incoming HTTP or TCP connection requests. /// </summary> internal void Stop() { if (!_isStarted) { return; } try { _zStream.deflateEnd(); _zStream.inflateEnd(); _httpListener.Close(); if (_tcpListener != null) { _tcpListener.Stop(); } if (_clientSocket != null) { _clientSocket.Close(); } if (_serverSocket != null) { _serverSocket.Close(); } } catch (Exception ex) { _client.Logger.Error(ex.ToString()); } _isStarted = false; _xteaKey = null; ConnectionState = ConnectionState.Disconnected; }
/// <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> /// <param name="msg">Eventual message from zstream.</param> /// <returns>Zlib status code.</returns> static int ZlibUncompress(ref byte[] dest, byte[] source, out string msg) { var zs = new ZStream(); int err; zs.next_in = source; zs.avail_in = source.Length; zs.next_out = dest; zs.avail_out = dest.Length; err = zs.inflateInit(); if (err != zlibConst.Z_OK) { msg = zs.msg; return(err); } err = zs.inflate(zlibConst.Z_FINISH); if (err != zlibConst.Z_STREAM_END) { zs.inflateEnd(); msg = zs.msg; return(err == zlibConst.Z_OK ? zlibConst.Z_BUF_ERROR : err); } if (zs.total_out != dest.Length) { byte[] output = new byte[zs.total_out]; Buffer.BlockCopy(zs.next_out, 0, output, 0, (int)zs.total_out); dest = output; } msg = zs.msg; return(zs.inflateEnd()); }
/// <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.Header.BlockSize]; In = In.Concat(new byte[] { 0x00 }); 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); }
internal void Decompress(int type) { if (this is NetworkClient) { throw new Exception("Trying to decompress data on Client connection!"); } zStream_Length = 0; zStream.avail_in = inMaxIndex - inIndex; zStream.next_in = inData; zStream.next_in_index = inIndex; zStream.next_out = zStream_Out; zStream.next_out_index = 0; zStream.avail_out = zStream_Out.Length; switch (zStream.inflate(type)) { case zlibConst.Z_OK: inIndex = zStream.next_in_index; zStream_Length = (int)zStream.total_out; zStream.total_out = 0; break; case zlibConst.Z_STREAM_END: inIndex = zStream.next_in_index; zStream_Length = (int)zStream.total_out; zStream.inflateEnd(); zStream.free(); zStream = null; break; default: //case zlibConst.Z_STREAM_ERROR: throw new Exception("Error while decompressing: " + (zStream.msg ?? "unknown error") + "!"); } }
public static PhpString gzinflate(byte[] data, long length = 0) { uint factor = 1, maxfactor = 16; long ilength; var zs = new ZStream(); zs.avail_in = data.Length; zs.next_in = data; 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(default(PhpString)); } 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(default(PhpString)); } 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 PhpString(result)); } else { PhpException.Throw(PhpError.Warning, zError(status) ?? zs.msg); return(default(PhpString)); } }
public static void main(String[] arg) { int err; int comprLen = 40000; int uncomprLen = comprLen; byte[] uncompr = new byte[uncomprLen]; byte[] compr = new byte[comprLen]; long dictId; ZStream c_stream = new ZStream(); err = c_stream.deflateInit(JZlib.Z_BEST_COMPRESSION); CHECK_ERR(c_stream, err, "deflateInit"); err = c_stream.deflateSetDictionary(dictionary, dictionary.Length); CHECK_ERR(c_stream, err, "deflateSetDictionary"); dictId = c_stream.adler; c_stream.next_out = compr; c_stream.next_out_index = 0; c_stream.avail_out = comprLen; c_stream.next_in = hello; c_stream.next_in_index = 0; c_stream.avail_in = hello.Length; err = c_stream.deflate(JZlib.Z_FINISH); if (err != JZlib.Z_STREAM_END) { java.lang.SystemJ.outJ.println("deflate should report Z_STREAM_END"); java.lang.SystemJ.exit(1); } err = c_stream.deflateEnd(); CHECK_ERR(c_stream, err, "deflateEnd"); ZStream d_stream = new ZStream(); d_stream.next_in = compr; d_stream.next_in_index = 0; d_stream.avail_in = comprLen; err = d_stream.inflateInit(); CHECK_ERR(d_stream, err, "inflateInit"); d_stream.next_out = uncompr; d_stream.next_out_index = 0; d_stream.avail_out = uncomprLen; while (true) { err = d_stream.inflate(JZlib.Z_NO_FLUSH); if (err == JZlib.Z_STREAM_END) { break; } if (err == JZlib.Z_NEED_DICT) { if ((int)d_stream.adler != (int)dictId) { java.lang.SystemJ.outJ.println("unexpected dictionary"); java.lang.SystemJ.exit(1); } err = d_stream.inflateSetDictionary(dictionary, dictionary.Length); } CHECK_ERR(d_stream, err, "inflate with dict"); } err = d_stream.inflateEnd(); CHECK_ERR(d_stream, err, "inflateEnd"); int j = 0; for (; j < uncompr.Length; j++) { if (uncompr[j] == 0) { break; } } java.lang.SystemJ.outJ.println("after inflateSync(): hel" + new java.lang.StringJ(uncompr, 0, j)); }
/// <summary> /// Get the data of the entry linked by the specified path. /// All the data will be allocated in memory. It may fail. /// /// Return false if the entry does not exist. /// </summary> public Boolean GetEntryData(String Path, out Byte[] Data) { Data = null; if (Path.StartsWith("/") || Path.StartsWith("\\")) { return(false); } Entry Entry; lock (Entries) { if (!Entries.TryGetValue(Path.ToLowerInvariant().Replace('\\', '/'), out Entry)) { return(false); } } Data = new Byte[(Int32)Entry.UncompressedSize]; using (var Input = new FileStream(TpdFile.GetFilename(), FileMode.Open, FileAccess.Read, FileShare.Read)) { var Buffer = new Byte[Kernel.MAX_BUFFER_SIZE]; var Tmp = new Byte[Kernel.MAX_BUFFER_SIZE]; var Pos = 0; Input.Seek(Entry.Offset, SeekOrigin.Begin); { var Stream = new ZStream(); Stream.inflateInit(); var Result = 0; var Length = 0; do { Stream.avail_in = Input.Read(Buffer, 0, Kernel.MAX_BUFFER_SIZE); Stream.next_in = Buffer; Stream.next_in_index = 0; if (Stream.avail_in == 0) { break; } do { Stream.avail_out = Kernel.MAX_BUFFER_SIZE; Stream.next_out = Tmp; Stream.next_out_index = 0; Result = Stream.inflate(zlibConst.Z_NO_FLUSH); Length = Kernel.MAX_BUFFER_SIZE - Stream.avail_out; Array.Copy(Buffer, 0, Data, Pos, Length); Pos += Length; }while (Stream.avail_out == 0); }while (Result != zlibConst.Z_STREAM_END); Stream.inflateEnd(); } } return(true); }
protected override int EndZlibOperation(ZStream zs) { return(zs.inflateEnd()); }
internal static byte[] Decompress(byte[] input, int wbits = MAX_WBITS, int bufsize = DEFAULTALLOC) { byte[] outputBuffer = new byte[bufsize]; byte[] output = new byte[bufsize]; int outputOffset = 0; ZStream zst = new ZStream(); zst.next_in = input; zst.avail_in = input.Length; zst.next_out = outputBuffer; zst.avail_out = outputBuffer.Length; int err = zst.inflateInit(wbits); if (err != Z_OK) { zst.inflateEnd(); throw zlib_error(zst, err, "while preparing to decompress data"); } do { err = zst.inflate(FlushStrategy.Z_FINISH); if (err != Z_STREAM_END) { if (err == Z_BUF_ERROR && zst.avail_out > 0) { zst.inflateEnd(); throw zlib_error(zst, err, "while decompressing data"); } else if (err == Z_OK || (err == Z_BUF_ERROR && zst.avail_out == 0)) { // copy to the output and reset the buffer if (outputOffset + outputBuffer.Length > output.Length) { Array.Resize(ref output, output.Length * 2); } Array.Copy(outputBuffer, 0, output, outputOffset, outputBuffer.Length); outputOffset += outputBuffer.Length; zst.next_out = outputBuffer; zst.avail_out = outputBuffer.Length; zst.next_out_index = 0; } else { zst.inflateEnd(); throw zlib_error(zst, err, "while decompressing data"); } } } while(err != Z_STREAM_END); err = zst.inflateEnd(); if (err != Z_OK) { throw zlib_error(zst, err, "while finishing data decompression"); } if (outputOffset + outputBuffer.Length - zst.avail_out > output.Length) { Array.Resize(ref output, output.Length * 2); } Array.Copy(outputBuffer, 0, output, outputOffset, outputBuffer.Length - zst.avail_out); outputOffset += outputBuffer.Length - zst.avail_out; return(output.Take(outputOffset).ToArray()); }
/// <summary> /// Get the data of the entry linked by the specified path. /// All the data will be allocated in memory. It may fail. /// /// Return false if the entry does not exist. /// </summary> public Boolean GetEntryData(String Path, Byte **pData, Int32 *pLength) { *pData = null; if (Path.StartsWith("/") || Path.StartsWith("\\")) { return(false); } Entry Entry; lock (Entries) { if (!Entries.TryGetValue(Path.ToLowerInvariant().Replace('\\', '/'), out Entry)) { return(false); } } *pData = (Byte *)Kernel.malloc((Int32)Entry.UncompressedSize); *pLength = (Int32)Entry.UncompressedSize; using (FileStream Input = new FileStream(TpdFile.GetFilename(), FileMode.Open, FileAccess.Read, FileShare.Read)) { Byte[] Buffer = new Byte[Kernel.MAX_BUFFER_SIZE]; Byte[] Tmp = new Byte[Kernel.MAX_BUFFER_SIZE]; Int32 Pos = 0; Input.Seek(Entry.Offset, SeekOrigin.Begin); { ZStream Stream = new ZStream(); Stream.inflateInit(); Int32 Result = 0; Int32 Length = 0; do { Stream.avail_in = Input.Read(Buffer, 0, Kernel.MAX_BUFFER_SIZE); Stream.next_in = Buffer; Stream.next_in_index = 0; if (Stream.avail_in == 0) { break; } do { Stream.avail_out = Kernel.MAX_BUFFER_SIZE; Stream.next_out = Tmp; Stream.next_out_index = 0; Result = Stream.inflate(zlibConst.Z_NO_FLUSH); Length = Kernel.MAX_BUFFER_SIZE - Stream.avail_out; Kernel.memcpy((*pData) + Pos, Tmp, Length); Pos += Length; }while (Stream.avail_out == 0); }while (Result != zlibConst.Z_STREAM_END); Stream.inflateEnd(); } } return(true); }
/// <summary> /// Returns the spectrum-data (m/z and intensity) of the given scan number. The boundries /// for the scan number can be retrieved with <see cref="GetFirstSpectrumNumber"/> and /// <see cref="GetLastSpectrumNumber"/>. This method will throw an exception when the given /// scan number is outside these boundries. The spectrum data is returned as a 2-dimensional /// list of size (2, nrspectra) in emulation of the thermo RAW access DLL. /// </summary> /// <param name="scannumber">The scan number.</param> /// <returns>The scan-data.</returns> public double[,] GetMassListFromScanNum(int scannumber) { if (scannumber < minScanNumber || scannumber > maxScanNumber) { throw new Exception("Undefined scan number: " + scannumber + " outside (" + minScanNumber + "," + maxScanNumber + ")"); } int compressedLength = 0; string compressionType = null; int precision = -1; string byteOrder = null; string contentType = null; string data = null; string peakData = GetScanPeakData(scannumber); XmlTextReader xmlReader = new XmlTextReader(new StringReader(peakData)); while (xmlReader.Read()) { xmlReader.MoveToElement(); if (!xmlReader.IsStartElement("peaks")) { continue; } precision = Parser.Int(xmlReader.GetAttribute("precision")); byteOrder = xmlReader.GetAttribute("byteOrder"); contentType = xmlReader.GetAttribute("contentType"); if (string.IsNullOrEmpty(contentType)) { contentType = xmlReader.GetAttribute("pairOrder"); } compressionType = xmlReader.GetAttribute("compressionType"); string sCompressedLen = xmlReader.GetAttribute("compressedLen"); compressedLength = string.IsNullOrEmpty(sCompressedLen) ? -1 : Parser.Int(sCompressedLen); data = xmlReader.ReadElementContentAsString(); } if (byteOrder == null || contentType == null || data == null) { throw new Exception("Malformed mz-xml File."); } if (!contentType.Equals("m/z-int") && !contentType.Equals("mz-int")) { throw new Exception("Non-supported content type: ' " + contentType + "'."); } // convert from base64 encoding byte[] bytes = Convert.FromBase64String(data); // decompress if (compressionType != null && compressionType.Equals("zlib")) { if (compressedLength != bytes.Length) { throw new Exception("Attribute 'compressedLen' has a different value from the reconstructed data array."); } ZStream z = new ZStream(); const int bufferLen = 1024; z.next_in = bytes; z.next_in_index = 0; z.avail_in = bytes.Length; z.inflateInit(); int totalLength = 0; List <byte[]> pieces = new List <byte[]>(); while (true) { z.next_out = new byte[bufferLen]; z.next_out_index = 0; z.avail_out = bufferLen; pieces.Add(z.next_out); int err = z.inflate(zlibConst.Z_NO_FLUSH); totalLength += bufferLen - z.avail_out; if (err == zlibConst.Z_STREAM_END) { break; } if (err != zlibConst.Z_OK) { throw new ZStreamException(z.msg); } } z.inflateEnd(); bytes = new byte[totalLength]; int pos = 0; foreach (byte[] piece in pieces) { Buffer.BlockCopy(piece, 0, bytes, pos, totalLength - pos > 1024 ? bufferLen : totalLength - pos); pos += piece.Length; } } // convert from byte encoding double[] massintensities = ByteArray.ToDoubleArray(bytes, byteOrder.Equals("network") ? ByteArray.endianBig : ByteArray.endianLittle, precision); double[,] masslist = new double[2, massintensities.Length / 2]; for (int i = 0; i < massintensities.Length; i += 2) { masslist[0, i / 2] = massintensities[i]; masslist[1, i / 2] = massintensities[i + 1]; } return(masslist); }
public static string decompress([BytesConversion] IList <byte> data, [DefaultParameterValue(MAX_WBITS)] int wbits, [DefaultParameterValue(DEFAULTALLOC)] int bufsize) { byte[] input = data.ToArray(); byte[] outputBuffer = new byte[bufsize]; byte[] output = new byte[bufsize]; int outputOffset = 0; ZStream zst = new ZStream(); zst.next_in = input; zst.avail_in = input.Length; zst.next_out = outputBuffer; zst.avail_out = outputBuffer.Length; int err = zst.inflateInit(wbits); if (err != Z_OK) { zst.inflateEnd(); throw zlib_error(zst, err, "while preparing to decompress data"); } do { err = zst.inflate(FlushStrategy.Z_FINISH); if (err != Z_STREAM_END) { if (err == Z_BUF_ERROR && zst.avail_out > 0) { zst.inflateEnd(); throw zlib_error(zst, err, "while decompressing data"); } else if (err == Z_OK || (err == Z_BUF_ERROR && zst.avail_out == 0)) { // copy to the output and reset the buffer if (outputOffset + outputBuffer.Length > output.Length) { Array.Resize(ref output, output.Length * 2); } Array.Copy(outputBuffer, 0, output, outputOffset, outputBuffer.Length); outputOffset += outputBuffer.Length; zst.next_out = outputBuffer; zst.avail_out = outputBuffer.Length; zst.next_out_index = 0; } else { zst.inflateEnd(); throw zlib_error(zst, err, "while decompressing data"); } } } while(err != Z_STREAM_END); err = zst.inflateEnd(); if (err != Z_OK) { throw zlib_error(zst, err, "while finishing data decompression"); } if (outputOffset + outputBuffer.Length - zst.avail_out > output.Length) { Array.Resize(ref output, output.Length * 2); } Array.Copy(outputBuffer, 0, output, outputOffset, outputBuffer.Length - zst.avail_out); outputOffset += outputBuffer.Length - zst.avail_out; return(PythonAsciiEncoding.Instance.GetString(output, 0, outputOffset)); }
public static BufLen BCGZipDecompressNew(BufLen buf) { var reader = new BufRefLen(buf); // Skip gzip header var gzheader = reader.ReadBufLen(10); var flag = gzheader.Peek8(3); if ((flag & 0x04) != 0) { reader.Seek(reader.Read16()); // "Extra" } if ((flag & 0x08) != 0) { while (reader.Read8() != 0) { ; // "Name" } } if ((flag & 0x10) != 0) { while (reader.Read8() != 0) { ; // "Comment" } } if ((flag & 0x02) != 0) { reader.Read16(); // "CRC16" } var z = new ZStream(); z.inflateInit(true); var dest = new byte[buf.Length * 2]; var destix = 0; z.next_in_index = reader.BaseArrayOffset; z.next_in = reader.BaseArray; z.avail_in = reader.Length - 8; bigger_dest: z.next_out = dest; z.next_out_index = destix; z.avail_out = dest.Length - destix; var err = z.inflate(JZlib.Z_FINISH); if (err != JZlib.Z_BUF_ERROR && err != JZlib.Z_OK && err != JZlib.Z_STREAM_END) { throw new IOException("inflating: " + z.msg); } if (z.avail_out == 0) { var newdest = new byte[dest.Length * 2]; Array.Copy(dest, newdest, dest.Length); destix = dest.Length; dest = newdest; goto bigger_dest; } var result = new BufLen(dest, 0, dest.Length - z.avail_out); z.inflateEnd(); return(result); }
public static void main(String[] arg) { int err; int comprLen = 40000; int uncomprLen = comprLen; byte[] compr = new byte[comprLen]; byte[] uncompr = new byte[uncomprLen]; int len = hello.Length; ZStream c_stream = new ZStream(); err = c_stream.deflateInit(JZlib.Z_DEFAULT_COMPRESSION); CHECK_ERR(c_stream, err, "deflate"); c_stream.next_in = hello; c_stream.next_in_index = 0; c_stream.next_out = compr; c_stream.next_out_index = 0; c_stream.avail_in = 3; c_stream.avail_out = comprLen; err = c_stream.deflate(JZlib.Z_FULL_FLUSH); CHECK_ERR(c_stream, err, "deflate"); compr[3]++; // force an error in first compressed block c_stream.avail_in = len - 3; err = c_stream.deflate(JZlib.Z_FINISH); if (err != JZlib.Z_STREAM_END) { CHECK_ERR(c_stream, err, "deflate"); } err = c_stream.deflateEnd(); CHECK_ERR(c_stream, err, "deflateEnd"); comprLen = (int)(c_stream.total_out); ZStream d_stream = new ZStream(); d_stream.next_in = compr; d_stream.next_in_index = 0; d_stream.avail_in = 2; err = d_stream.inflateInit(); CHECK_ERR(d_stream, err, "inflateInit"); d_stream.next_out = uncompr; d_stream.next_out_index = 0; d_stream.avail_out = uncomprLen; err = d_stream.inflate(JZlib.Z_NO_FLUSH); CHECK_ERR(d_stream, err, "inflate"); d_stream.avail_in = comprLen - 2; err = d_stream.inflateSync(); CHECK_ERR(d_stream, err, "inflateSync"); err = d_stream.inflate(JZlib.Z_FINISH); if (err != JZlib.Z_DATA_ERROR) { java.lang.SystemJ.outJ.println("inflate should report DATA_ERROR"); /* Because of incorrect adler32 */ java.lang.SystemJ.exit(1); } err = d_stream.inflateEnd(); CHECK_ERR(d_stream, err, "inflateEnd"); int j = 0; for (; j < uncompr.Length; j++) { if (uncompr[j] == 0) { break; } } java.lang.SystemJ.outJ.println("after inflateSync(): hel" + new java.lang.StringJ(uncompr, 0, j)); }
/// <summary> /// Reads NBT data from the specified (compressed) stream. /// </summary> public static NBTNamedTag <INBTData> ReadChunk(Stream fs, Point <int> Pos) { // Read the chunk from the file. byte[] buf = new byte[5]; long seekOffset = 0; int sectorNumber = 0; int offset = 0; // Read the chunk offset. Point <int> chunkOffsetInRegion; chunkOffsetInRegion.X = Pos.X % 32; if (chunkOffsetInRegion.X < 0) { chunkOffsetInRegion.X += 32; } chunkOffsetInRegion.Y = Pos.Y % 32; if (chunkOffsetInRegion.Y < 0) { chunkOffsetInRegion.Y += 32; } seekOffset = 4 * (chunkOffsetInRegion.X + chunkOffsetInRegion.Y * 32); fs.Position = seekOffset; fs.Read(buf, 0, 4); sectorNumber = (int)buf[3]; offset = (int)buf[0] << 16 | (int)buf[1] << 8 | (int)buf[2]; if (offset == 0) { throw new ArithmeticException(); } // Get the chunk length and version. int chunkLength = 0; fs.Position = offset * 4096; fs.Read(buf, 0, 5); chunkLength = (int)buf[0] << 24 | (int)buf[1] << 14 | (int)buf[2] << 8 | (int)buf[3]; if (chunkLength > sectorNumber * 4096 || chunkLength > CHUNK_DEFLATE_MAX) { throw new ArithmeticException(); } if (buf[4] != 2) { throw new ArithmeticException(); } // Read compressed chunk data. byte[] inChunk = new byte[CHUNK_DEFLATE_MAX]; byte[] outChunk = new byte[CHUNK_INFLATE_MAX]; fs.Read(inChunk, 0, chunkLength - 1); fs.Close(); // Decompress it. ZStream z = new ZStream(); z.next_out = outChunk; z.avail_out = CHUNK_INFLATE_MAX; z.next_in = inChunk; z.avail_in = chunkLength - 1; z.inflateInit(); z.inflate(zlibConst.Z_NO_FLUSH); z.inflateEnd(); System.IO.MemoryStream msUncompressed = new System.IO.MemoryStream(outChunk); return(NBT.ReadUncompressed(msUncompressed)); }
public static void main(String[] arg) { int err; int comprLen = 40000; int uncomprLen = comprLen; byte[] compr = new byte[comprLen]; byte[] uncompr = new byte[uncomprLen]; ZStream c_stream = new ZStream(); err = c_stream.deflateInit(JZlib.Z_BEST_SPEED); CHECK_ERR(c_stream, err, "deflateInit"); c_stream.next_out = compr; c_stream.next_out_index = 0; c_stream.avail_out = comprLen; // At this point, uncompr is still mostly zeroes, so it should compress // very well: c_stream.next_in = uncompr; c_stream.avail_in = uncomprLen; err = c_stream.deflate(JZlib.Z_NO_FLUSH); CHECK_ERR(c_stream, err, "deflate"); if (c_stream.avail_in != 0) { java.lang.SystemJ.outJ.println("deflate not greedy"); java.lang.SystemJ.exit(1); } // Feed in already compressed data and switch to no compression: c_stream.deflateParams(JZlib.Z_NO_COMPRESSION, JZlib.Z_DEFAULT_STRATEGY); c_stream.next_in = compr; c_stream.next_in_index = 0; c_stream.avail_in = comprLen / 2; err = c_stream.deflate(JZlib.Z_NO_FLUSH); CHECK_ERR(c_stream, err, "deflate"); // Switch back to compressing mode: c_stream.deflateParams(JZlib.Z_BEST_COMPRESSION, JZlib.Z_FILTERED); c_stream.next_in = uncompr; c_stream.next_in_index = 0; c_stream.avail_in = uncomprLen; err = c_stream.deflate(JZlib.Z_NO_FLUSH); CHECK_ERR(c_stream, err, "deflate"); err = c_stream.deflate(JZlib.Z_FINISH); if (err != JZlib.Z_STREAM_END) { java.lang.SystemJ.outJ.println("deflate should report Z_STREAM_END"); java.lang.SystemJ.exit(1); } err = c_stream.deflateEnd(); CHECK_ERR(c_stream, err, "deflateEnd"); ZStream d_stream = new ZStream(); d_stream.next_in = compr; d_stream.next_in_index = 0; d_stream.avail_in = comprLen; err = d_stream.inflateInit(); CHECK_ERR(d_stream, err, "inflateInit"); while (true) { d_stream.next_out = uncompr; d_stream.next_out_index = 0; d_stream.avail_out = uncomprLen; err = d_stream.inflate(JZlib.Z_NO_FLUSH); if (err == JZlib.Z_STREAM_END) { break; } CHECK_ERR(d_stream, err, "inflate large"); } err = d_stream.inflateEnd(); CHECK_ERR(d_stream, err, "inflateEnd"); if (d_stream.total_out != 2 * uncomprLen + comprLen / 2) { java.lang.SystemJ.outJ.println("bad large inflate: " + d_stream.total_out); java.lang.SystemJ.exit(1); } else { java.lang.SystemJ.outJ.println("large_inflate(): OK"); } }
public static void main(String[] arg) { int err; int comprLen = 40000; int uncomprLen = comprLen; byte[] compr = new byte[comprLen]; byte[] uncompr = new byte[uncomprLen]; ZStream c_stream = new ZStream(); err = c_stream.deflateInit(JZlib.Z_DEFAULT_COMPRESSION); CHECK_ERR(c_stream, err, "deflateInit"); c_stream.next_in = hello; c_stream.next_in_index = 0; c_stream.next_out = compr; c_stream.next_out_index = 0; while (c_stream.total_in != hello.Length && c_stream.total_out < comprLen) { c_stream.avail_in = c_stream.avail_out = 1; // force small buffers err = c_stream.deflate(JZlib.Z_NO_FLUSH); CHECK_ERR(c_stream, err, "deflate"); } while (true) { c_stream.avail_out = 1; err = c_stream.deflate(JZlib.Z_FINISH); if (err == JZlib.Z_STREAM_END) { break; } CHECK_ERR(c_stream, err, "deflate"); } err = c_stream.deflateEnd(); CHECK_ERR(c_stream, err, "deflateEnd"); ZStream d_stream = new ZStream(); d_stream.next_in = compr; d_stream.next_in_index = 0; d_stream.next_out = uncompr; d_stream.next_out_index = 0; err = d_stream.inflateInit(); CHECK_ERR(d_stream, err, "inflateInit"); while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) { d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ err = d_stream.inflate(JZlib.Z_NO_FLUSH); if (err == JZlib.Z_STREAM_END) { break; } CHECK_ERR(d_stream, err, "inflate"); } err = d_stream.inflateEnd(); CHECK_ERR(d_stream, err, "inflateEnd"); int i = 0; for (; i < hello.Length; i++) { if (hello[i] == 0) { break; } } int j = 0; for (; j < uncompr.Length; j++) { if (uncompr[j] == 0) { break; } } if (i == j) { for (i = 0; i < j; i++) { if (hello[i] != uncompr[i]) { break; } } if (i == j) { java.lang.SystemJ.outJ.println("inflate(): " + new java.lang.StringJ(uncompr, 0, j).ToString()); return; } } else { java.lang.SystemJ.outJ.println("bad inflate"); } }