public Read ( byte buffer, int offset, int count ) : int | ||
buffer | byte | /// The array to read and decompress data into /// |
offset | int | /// The offset indicating where the data should be placed /// |
count | int | /// The number of bytes to decompress /// |
Résultat | int |
/// <summary> /// Decompresses an array of bytes. /// </summary> /// <param name="_pBytes">An array of bytes to be decompressed.</param> /// <returns>Decompressed bytes</returns> public static byte[] DeCompress(byte[] _pBytes) { InflaterInputStream inputStream = new InflaterInputStream(new MemoryStream(_pBytes)); MemoryStream ms = new MemoryStream(); Int32 mSize; byte[] mWriteData = new byte[4096]; while (true) { mSize = inputStream.Read(mWriteData, 0, mWriteData.Length); if (mSize > 0) { ms.Write(mWriteData, 0, mSize); } else { break; } } inputStream.Close(); return ms.ToArray(); }
public static byte[] DecompressGzipBytes(byte[] Bytes) { ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream stream = new ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream(new MemoryStream(Bytes)); MemoryStream memory = new MemoryStream(); byte[] writeData = new byte[4096]; int size; while (true) { size = stream.Read(writeData, 0, writeData.Length); if (size > 0) { memory.Write(writeData, 0, size); } else { break; } } stream.Close(); return(memory.ToArray()); }
public void TestInflateDeflate() { MemoryStream ms = new MemoryStream(); Deflater deflater = new Deflater(6); DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater); byte[] buf = new byte[1000000]; System.Random rnd = new Random(); rnd.NextBytes(buf); outStream.Write(buf, 0, buf.Length); outStream.Flush(); outStream.Finish(); ms.Seek(0, SeekOrigin.Begin); InflaterInputStream inStream = new InflaterInputStream(ms); byte[] buf2 = new byte[buf.Length]; int pos = 0; while (true) { int numRead = inStream.Read(buf2, pos, 4096); if (numRead <= 0) { break; } pos += numRead; } for (int i = 0; i < buf.Length; ++i) { Assertion.AssertEquals(buf2[i], buf[i]); } }
public string Decompress(string compressedString) { var uncompressedString = string.Empty; var totalLength = 0; var inputAsBytes = Convert.FromBase64String(compressedString);; var writeData = new byte[4096]; var inputStream = new InflaterInputStream(new MemoryStream(inputAsBytes)); for(;;) { var size = inputStream.Read(writeData, 0, writeData.Length); if (size > 0) { totalLength += size; uncompressedString += Encoding.UTF8.GetString(writeData, 0, size); } else { break; } } inputStream.Close(); return uncompressedString; }
void Inflate(MemoryStream ms, byte[] original, int level, bool zlib) { ms.Seek(0, SeekOrigin.Begin); Inflater inflater = new Inflater(!zlib); InflaterInputStream inStream = new InflaterInputStream(ms, inflater); byte[] buf2 = new byte[original.Length]; int currentIndex = 0; int count = buf2.Length; try { while (true) { int numRead = inStream.Read(buf2, currentIndex, count); if (numRead <= 0) { break; } currentIndex += numRead; count -= numRead; } } catch(Exception ex) { Console.WriteLine("Unexpected exception - '{0}'", ex.Message); throw; } if ( currentIndex != original.Length ) { Console.WriteLine("Original {0}, new {1}", original.Length, currentIndex); Assert.Fail("Lengths different"); } for (int i = 0; i < original.Length; ++i) { if ( buf2[i] != original[i] ) { string description = string.Format("Difference at {0} level {1} zlib {2} ", i, level, zlib); if ( original.Length < 2048 ) { StringBuilder builder = new StringBuilder(description); for (int d = 0; d < original.Length; ++d) { builder.AppendFormat("{0} ", original[d]); } Assert.Fail(builder.ToString()); } else { Assert.Fail(description); } } } }
public void Decompress(ArraySegment<byte> input, ArraySegment<byte> output) { using (var gz = new InflaterInputStream(new MemoryStream(input.Array, input.Offset, input.Count))) { int read = gz.Read(output.Array, output.Offset, output.Count); if (read != output.Count) throw new Exception("Short read!"); } }
public static byte[] Decompress(byte[] data, int final_size) { byte[] r = null; using (Stream s = new InflaterInputStream(new MemoryStream(data))) s.Read(r, 0, final_size); return r; }
public static byte[] UncompressStream(Stream stream, int filesize, int memsize) { BinaryReader r = new BinaryReader(stream); long end = stream.Position + filesize; byte[] header = r.ReadBytes(2); if (checking) if (header.Length != 2) throw new InvalidDataException("Hit unexpected end of file at " + stream.Position); bool useDEFLATE = true; byte[] uncompressedData = null; if (header[0] == 0x78) { useDEFLATE = true; } else if (header[1] == 0xFB) { useDEFLATE = false; } else { throw new InvalidDataException("Unrecognized compression format"); } if (useDEFLATE) { byte[] data = new byte[filesize]; stream.Position -= 2; // go back to header stream.Read(data, 0, filesize); using (MemoryStream source = new MemoryStream(data)) { using (InflaterInputStream decomp = new InflaterInputStream(source)) { uncompressedData = new byte[memsize]; decomp.Read(uncompressedData, 0, memsize); } } } else { uncompressedData = OldDecompress(stream, header[0]); } long realsize = uncompressedData.Length; if (checking) if (realsize != memsize) throw new InvalidDataException(String.Format( "Resource data indicates size does not match index at 0x{0}. Read 0x{1}. Expected 0x{2}.", stream.Position.ToString("X8"), realsize.ToString("X8"), memsize.ToString("X8"))); return uncompressedData; }
public byte[] Decode(byte[] input, int decompressedSize) { InflaterInputStream stream = new InflaterInputStream(new MemoryStream(input)); byte[] data = new byte[4096]; MemoryStream outStream = new MemoryStream(); int size; while ((size = stream.Read(data, 0, data.Length)) > 0) { outStream.Write(data, 0, size); } outStream.Capacity = (int)outStream.Length; return outStream.GetBuffer(); }
public static byte[] Decompress(byte[] data) { byte[] r = null; using (Stream s = new InflaterInputStream(new MemoryStream(data))) { byte[] b = new byte[8192]; int count = s.Read(b, 0, b.Length); r = b.Take(count).ToArray(); } return r; }
// Length = decompressed length public static byte[] Decompress(int Length, byte[] Data) { byte[] Output = new byte[Length]; Stream s = new InflaterInputStream(new MemoryStream(Data)); int Offset = 0; while(true) { int size = s.Read(Output, Offset, Length); if (size == Length) break; Offset += size; Length -= size; } return Output; }
public static byte[] Decompress(string data) { byte[] array = null; if (data.StartsWith("ZipStream:")) { MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(data.Substring(10))); InflaterInputStream inflaterInputStream = new InflaterInputStream(memoryStream); BinaryReader binaryReader = new BinaryReader(memoryStream); int num = binaryReader.ReadInt32(); array = new byte[num]; inflaterInputStream.Read(array, 0, num); inflaterInputStream.Close(); memoryStream.Close(); } return array; }
public static void Decompress(ref GenericReader gr) { int uncompressedLength = gr.ReadInt32(); byte[] output = new byte[gr.ReadInt32()]; byte[] temp = gr.ReadBytes((int)gr.Remaining); gr.Close(); Stream s = new InflaterInputStream(new MemoryStream(temp)); int offset = 0; while (true) { int size = s.Read(output, offset, uncompressedLength); if (size == uncompressedLength) break; offset += size; uncompressedLength -= size; } gr = new GenericReader(new MemoryStream(output)); //gr.BaseStream.Position = 0; }
public static GenericReader Decompress(GenericReader gr) { int uncompressedLength = gr.ReadInt32(); byte[] input = gr.ReadBytes((int)gr.Remaining); byte[] output = new byte[uncompressedLength]; gr.Close(); InflaterInputStream istream = new InflaterInputStream(new MemoryStream(input)); int offset = 0; while (true) { int size = istream.Read(output, offset, uncompressedLength); if (size == uncompressedLength) break; offset += size; uncompressedLength -= size; } return new GenericReader(new MemoryStream(output)); }
public string Inflate(byte[] gzBuffer) { using (var ms = new MemoryStream()) { var msgLength = BitConverter.ToInt32(gzBuffer, 0); ms.Write(gzBuffer, 4, gzBuffer.Length - 4); var buffer = new byte[msgLength]; ms.Position = 0; using (var zipStream = new InflaterInputStream(ms, new Inflater())) { zipStream.Read(buffer, 0, buffer.Length); } return Encoding.UTF8.GetString(buffer); } }
public byte[] Decompress( byte[] bytes ) { Stream stream = new InflaterInputStream( new MemoryStream( bytes ) ); MemoryStream memory = new MemoryStream(); int totalLength = 0; byte[] writeData = new byte[4096]; while ( true ) { int size = stream.Read( writeData, 0, writeData.Length ); if ( size > 0 ) { totalLength += size; memory.Write( writeData, 0, size ); } else break; } stream.Close(); return memory.ToArray(); }
public static byte[] Decompress(byte[] bytes) { InflaterInputStream stream = new InflaterInputStream(new MemoryStream(bytes)); MemoryStream memory = new MemoryStream(); Byte[] writeData = new byte[4096]; int size; while (true) { size = stream.Read(writeData, 0, writeData.Length); if (size > 0) { memory.Write(writeData, 0, size); } else { break; } } stream.Close(); return memory.ToArray(); }
public static MemoryStream ProcessData(byte[] data) { if (data == null) { return null; } MemoryStream baseInputStream = null; MemoryStream stream2; InflaterInputStream stream3 = null; try { baseInputStream = new MemoryStream(data); stream2 = new MemoryStream(); stream3 = new InflaterInputStream(baseInputStream); byte[] buffer = new byte[data.Length]; while (true) { int count = stream3.Read(buffer, 0, buffer.Length); if (count <= 0) { break; } stream2.Write(buffer, 0, count); } stream2.Flush(); stream2.Seek(0L, SeekOrigin.Begin); } finally { if (baseInputStream != null) { baseInputStream.Close(); } if (stream3 != null) { stream3.Close(); } } return stream2; }
public static byte[] DeCompress( byte []b ) { Stream s2 = new InflaterInputStream( new MemoryStream( b ) ); try { byte []dest = null; int size = s2.Read( writeData, 0, writeData.Length); if (size > 0) { dest = new byte[ size ]; Buffer.BlockCopy( writeData , 0, dest, 0, size ); } s2.Flush(); s2.Close(); return dest; } catch(Exception e) { Console.WriteLine( e.Message ); return null; } }
public string Decompress(byte[] baseBytes) { string resultStr = string.Empty; using (MemoryStream memoryStream = new MemoryStream(baseBytes)) { using (InflaterInputStream inf = new InflaterInputStream(memoryStream)) { using (MemoryStream buffer = new MemoryStream()) { byte[] result = new byte[1024]; int resLen; while ((resLen = inf.Read(result, 0, result.Length)) > 0) { buffer.Write(result, 0, resLen); } resultStr = Encoding.Default.GetString(result); } } } return resultStr; }
private byte[] UncompressedImage() { using (MemoryStream stream = new MemoryStream(_payload)) { using (BinaryReader br = new BinaryReader(stream)) { br.BaseStream.Position += 3; ushort compressed = br.ReadUInt16(); ushort uncompressed = br.ReadUInt16(); ushort width = br.ReadUInt16(); ushort height = br.ReadUInt16(); byte[] compressedImage = br.ReadBytes((int)compressed); using (MemoryStream str = new MemoryStream(compressedImage)) { using (InflaterInputStream zlip = new InflaterInputStream(str)) { byte[] buffer = new byte[51200]; zlip.Read(buffer, 0, uncompressed); return UncompressedImg(width, height, buffer); } } } } }
/* Private methods */ private void readCMV(string inFilename) { byte[] source, decompressed; ExtensionType extension; InflaterInputStream zipInStream; Stream stream; FileStream fileStream; MemoryStream memoryStream; extension = checkExtension(inFilename); if (extension == ExtensionType.CCMV) { source = File.ReadAllBytes(inFilename); decompressed = new byte[0]; memoryStream = new MemoryStream(source); zipInStream = new InflaterInputStream(memoryStream); zipInStream.Read(decompressed, 0, decompressed.Length); stream = new MemoryStream(decompressed); } else { fileStream = File.OpenRead(inFilename); stream = fileStream; } byte[] intBytes = new byte[4]; stream.Read(intBytes, 0, 4); version = BitConverter.ToUInt32(intBytes, 0); stream.Read(intBytes, 0, 4); cols = BitConverter.ToUInt32(intBytes, 0); stream.Read(intBytes, 0, 4); rows = BitConverter.ToUInt32(intBytes, 0); stream.Read(intBytes, 0, 4); delayRate = BitConverter.ToUInt32(intBytes, 0); // Sounds if (version == 10001) { stream.Read(intBytes, 0, 4); numSounds = BitConverter.ToInt32(intBytes, 0); soundNames = new byte[50 * numSounds]; stream.Read(soundNames, 0, 50 * numSounds); soundTimings = new byte[200 * NUM_SOUNDCHANNELS]; // 0x3200 stream.Read(soundTimings, 0, 200 * NUM_SOUNDCHANNELS); } int frameSize = (int)(cols * rows); frameSize += frameSize; byte[] previousFrame = new byte[frameSize]; for (int frameByte = 0; frameByte < frameSize; frameByte++) { previousFrame[frameByte] = 0; } byte[] curFrame = new byte[frameSize]; int framesDone = 0; int frameSizeLeft = frameSize; int frameSizeDone = 0; while (stream.Position < stream.Length) { if (stream.Read(intBytes, 0, 4) == 4) { int compressedChunkSize = BitConverter.ToInt32(intBytes, 0); byte[] buffer = new byte[compressedChunkSize]; stream.Read(buffer, 0, compressedChunkSize); memoryStream = new MemoryStream(buffer); zipInStream = new InflaterInputStream(memoryStream); int bytesRead = 0; do { bytesRead = zipInStream.Read(curFrame, frameSizeDone, frameSizeLeft); if (bytesRead == frameSizeLeft) { /* * Valid variables at this point: * frameSize * byte[frameSize] previousFrame * byte[frameSize] curFrame */ framesDone++; frames.Add(new CMVFrame(curFrame, cols, rows)); Array.Copy(curFrame, previousFrame, frameSize); frameSizeLeft = frameSize; frameSizeDone = 0; } else { frameSizeDone += bytesRead; frameSizeLeft -= bytesRead; } } while (bytesRead == frameSize); } else { break; } } stream.Close(); stream.Dispose(); }
public static byte[] DecompressZlib(byte[] input, int size) { byte[] result = new byte[size]; InflaterInputStream zipStream = new InflaterInputStream(new MemoryStream(input)); zipStream.Read(result, 0, size); zipStream.Flush(); return result; }
public Packet[] Uncompress() { System.IO.Stream msStream = new System.IO.MemoryStream(bCompressedData); InflaterInputStream iisUnpack = new InflaterInputStream(msStream, new Inflater(true)); byte[] bOutput = new byte[0]; try { byte[] bWorkout = new byte[4096]; int iSize = iisUnpack.Read(bWorkout, 0, bWorkout.Length); while (iSize > 0) { byte[] bOldOutput = new byte[bOutput.Length]; bOutput.CopyTo(bOldOutput, 0); bOutput = new byte[bOutput.Length + iSize]; bOldOutput.CopyTo(bOutput, 0); Array.Copy(bWorkout, 0, bOutput, bOldOutput.Length, iSize); iSize = iisUnpack.Read(bWorkout, 0, bWorkout.Length); } iisUnpack.Close(); } catch (Exception e) { // TODO - Throw the exception in the main application // System.Windows.Forms.MessageBox.Show(e.ToString()); throw new System.Exception("Error uncompressing the message: " + e.Message); } return Packet.ParsePackets(bOutput); }
private List<byte> Decompress(FileStream data, long offset, long length) { var t = new List<byte>(); var inflator = new Inflater(); Stream stream = CopyStream(data, offset, (int) length); var in1 = new InflaterInputStream(stream, inflator, 1024*8); var buffer = new byte[1024*8]; int len; while ((len = in1.Read(buffer, 0, 1024*8)) > 0) { for (int i = 0; i < len; i++) { t.Add(buffer[i]); } } return t; }
private void Decompress() { byte[] data = new byte[Length - 8]; var iis = new InflaterInputStream(mBitStream.BaseStream); int i = 0, j; do { j = iis.Read(data, i, data.Length - i); if (j <= 0) throw new EndOfStreamException(); i += j; } while(i < data.Length); mBitStream = new BitStream(new MemoryStream(data)); }
Tuple<PackObjectType, byte[]> readLooseObject(FileInfo objectFi) { ObjectId objId = ObjectId.Parse(objectFi.Directory.Name + objectFi.Name); var sha = SHA1.Create(); string tag; byte[] objectContents; using (var fs = objectFi.OpenRead()) { //TODO: apply some not-invented-here syndrom by reimplmenting inflate using (var inflater = new InflaterInputStream(fs)) { int? spaceNdx = null; int headerBytesRead = 0; byte[] headerBytes = new byte[30]; //should be enough for a 64-bit size while (true) { int b = inflater.ReadByte(); if (b == -1) throw new Exception("Unexpected EOF"); headerBytes[headerBytesRead] = (byte)b; if (b == ' ') spaceNdx = headerBytesRead; headerBytesRead++; if (b == 0) break; if (headerBytesRead == headerBytes.Length) throw new Exception("Header too big."); } if (!spaceNdx.HasValue) throw new Exception("Did not find space."); //split the string along the space to get the object type and size and size tag = Encoding.ASCII.GetString(headerBytes, 0, spaceNdx.Value); string sizeStr = Encoding.ASCII.GetString(headerBytes, spaceNdx.Value + 1, headerBytesRead - spaceNdx.Value - 2); int objectSize = int.Parse(sizeStr, NumberStyles.None, CultureInfo.InvariantCulture); objectContents = new byte[objectSize]; if (inflater.Read(objectContents, 0, objectSize) != objectSize) throw new Exception("Short read."); sha.TransformBlock(headerBytes, 0, headerBytesRead, null, 0); } } sha.TransformFinalBlock(objectContents, 0, objectContents.Length); if (!objId.Equals(new ObjectId(sha.Hash))) throw new Exception("Hash is not right!"); PackObjectType objType; switch (tag) { case "blob": objType = PackObjectType.Blob; break; case "commit": objType = PackObjectType.Commit; break; case "tree": objType = PackObjectType.Tree; break; case "tag": objType = PackObjectType.Tag; break; default: throw new Exception("Unrecognized object type: " + tag); } return new Tuple<PackObjectType, byte[]>(objType, objectContents); }
private Object GetObjectLoose(string aId) { var path = Path.Combine(iFolderObjects.FullName, aId.Substring(0, 2), aId.Substring(2, 38)); try { var file = File.OpenRead(path); using (var inflater = new InflaterInputStream(file)) { int offset = 0; byte[] header = new byte[100]; while (true) { int b = inflater.ReadByte(); if (b == 0) { break; } if (offset >= 100) { throw (new GitException("Illegal object header " + aId)); } header[offset++] = (byte)b; } string[] parts = ASCIIEncoding.ASCII.GetString(header, 0, offset).Split(new char[] { ' ' }); if (parts.Length != 2) { throw (new GitException("Illegal object header " + aId)); } int length; if (!int.TryParse(parts[1], out length)) { throw (new GitException("Illegal object length " + aId)); } byte[] bytes = new byte[length]; inflater.Read(bytes, 0, length); switch (parts[0]) { case "commit": return (new Object(EObjectType.Commit, bytes)); case "tag": return (new Object(EObjectType.Tag, bytes)); case "tree": return (new Object(EObjectType.Tree, bytes)); case "blob": return (new Object(EObjectType.Blob, bytes)); default: throw (new GitException("Unrecognised object type " + aId)); } } } catch (FileNotFoundException) { return (null); } }
/// <summary> /// Decompresses the provided data, returning the inflated result. /// </summary> /// <param name="data">the deflated picture data.</param> /// <returns>the inflated picture data.</returns> private static byte[] InflatePictureData(byte[] data) { using (MemoryStream in1 = new MemoryStream(data)) { using (MemoryStream out1 = new MemoryStream()) { InflaterInputStream zIn = null; try { Inflater inflater = new Inflater(false); zIn = new InflaterInputStream(in1, inflater); byte[] buf = new byte[4096]; int ReadBytes; while ((ReadBytes = zIn.Read(buf, 0, buf.Length)) > 0) { out1.Write(buf, 0, ReadBytes); } return out1.ToArray(); } catch (IOException e) { log.Log(POILogger.WARN, "Possibly corrupt compression or non-compressed data", e); return data; } } } }
/// <summary> /// Decompresses the provided data, returning the inflated result. /// </summary> /// <param name="data">the deflated picture data.</param> /// <returns>the inflated picture data.</returns> private static byte[] InflatePictureData(byte[] data) { try { InflaterInputStream in1 = new InflaterInputStream( new MemoryStream(data)); MemoryStream out1 = new MemoryStream(); byte[] buf = new byte[4096]; int ReadBytes; while ((ReadBytes = in1.Read(buf,0,buf.Length)) > 0) { out1.Write(buf, 0, ReadBytes); } return out1.ToArray(); } catch (IOException e) { log.Log(POILogger.INFO, "Possibly corrupt compression or non-compressed data", e); return data; } }
/// <summary> /// The decompression routine. /// </summary> /// <param name="bytes">The bytes to decompress.</param> /// <returns>A decompressed array of bytes.</returns> private static byte[] Decompress(byte[] bytes) { using (var byteStream = new MemoryStream(bytes)) { using (Stream stream = new InflaterInputStream(byteStream)) { using (var memory = new MemoryStream(Buffersize)) { var buffer = new byte[Buffersize]; while (true) { var size = stream.Read(buffer, 0, Buffersize); if (size <= 0) { break; } memory.Write(buffer, 0, size); } return memory.ToArray(); } } } }