private static string ExtractJsonResponse(WebResponse response) { GetRateLimits(response); var responseStream = response.GetResponseStream(); if (responseStream == null) { throw new StackExchangeException("Response stream is empty, unable to continue"); } string json; using (var outStream = new MemoryStream()) { using (var zipStream = new GZipStream(responseStream, CompressionMode.Decompress)) { zipStream.CopyTo(outStream); outStream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(outStream, Encoding.UTF8)) { json = reader.ReadToEnd(); } } } return json; }
public static string GzipDecompress(string fileFullName) { var retName = string.Empty; if (!File.Exists(fileFullName)) return retName; var fi = new FileInfo(fileFullName); using (var fs = fi.OpenRead()) { var dName = fi.DirectoryName; if (string.IsNullOrWhiteSpace(dName)) { dName = TempDirectories.Root; } var cName = fi.FullName; var nName = Path.GetFileNameWithoutExtension(cName); var nFName = Path.Combine(dName, nName); using (var dFs = File.Create(nFName)) { using (var gzipStream = new GZipStream(fs, CompressionMode.Decompress)) { gzipStream.CopyTo(dFs); } } retName = nFName; } return retName; }
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) { var name = new AssemblyName(args.Name).Name.Replace('-', '.'); if (name.StartsWith(m_rootNamespace)) return null; for (int i = 0; i < m_resourceName.Length; ++i) { if (m_resourceName[i].Contains(name)) { byte[] buff; using (var comp = new MemoryStream((byte[])m_resourceMethod[i].GetValue(null, null))) using (var gzip = new GZipStream(comp, CompressionMode.Decompress)) using (var uncomp = new MemoryStream(4096)) { gzip.CopyTo(uncomp); buff = uncomp.ToArray(); } return Assembly.Load(buff); } } return null; }
/// <summary> /// /// </summary> public static void Decompress(this FileInfo fileInfo) { // Get the stream of the source file. using (FileStream inFile = fileInfo.OpenRead()) { // Get original file extension, for example // "doc" from report.doc.gz. string curFile = fileInfo.FullName; string origName = curFile.Remove(curFile.Length - fileInfo.Extension.Length); //Create the decompressed file. using (FileStream outFile = File.Create(origName)) { using (GZipStream Decompress = new GZipStream(inFile, CompressionMode.Decompress)) { // Copy the decompression stream // into the output file. Decompress.CopyTo(outFile); Console.WriteLine("Decompressed: {0}", fileInfo.Name); } } } }
private static int Main(string[] args) { // Get embedded compressed resource stream and decompress data Stream byteStream = new MemoryStream(); using (Stream resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("PackedStarter.NetRevisionTool.exe.gz")) using (GZipStream zip = new GZipStream(resourceStream, CompressionMode.Decompress, true)) { zip.CopyTo(byteStream); } // Copy decompressed stream to an array byte[] bytes = new byte[byteStream.Length]; byteStream.Seek(0, SeekOrigin.Begin); byteStream.Read(bytes, 0, bytes.Length); // Load embedded assembly Assembly assembly = Assembly.Load(bytes); // Find and invoke Program.Main method Type programType = assembly.GetType("NetRevisionTool.Program"); MethodInfo mainMethod = programType.GetMethod("Main"); object returnValue = mainMethod.Invoke(null, new object[] { args }); // Pass on return code if (returnValue is int) { return (int) returnValue; } return 0; }
public static ISavegame Deserialize(Stream stream) { if (stream == null) throw new ArgumentNullException(nameof(stream)); if (stream.Position != 0) stream.Seek(0, SeekOrigin.Begin); var checkBuffer = new byte[2]; stream.Read(checkBuffer, 0, 2); stream.Seek(0, SeekOrigin.Begin); if (checkBuffer.SequenceEqual(new byte[] {0x1f, 0x8b})) { using (var gZipStream = new GZipStream(stream, CompressionMode.Decompress)) { using (var memoryStream = new MemoryStream()) { gZipStream.CopyTo(memoryStream); return Deserialize(Encoding.UTF8.GetString(memoryStream.ToArray())); } } } if (stream is MemoryStream) { var memoryStream = (MemoryStream) stream; return Deserialize(Encoding.UTF8.GetString(memoryStream.ToArray())); } using (var memoryStream = new MemoryStream()) { stream.CopyTo(memoryStream); return Deserialize(Encoding.UTF8.GetString(memoryStream.ToArray())); } }
public ImageDataResult TryGetImageData(out byte[] result) { result = null; if(Compression != CompressionType.None && Compression != CompressionType.Gzip) { return ImageDataResult.UnsupportedCompressionFormat; } if(CRC != UImageReader.GzipCrc32(image)) { return ImageDataResult.BadChecksum; } result = new byte[image.Length]; Array.Copy(image, result, result.Length); if(Compression == CompressionType.Gzip) { using(var stream = new GZipStream(new MemoryStream(result), CompressionMode.Decompress)) { using(var decompressed = new MemoryStream()) { stream.CopyTo(decompressed); result = decompressed.ToArray(); } } } return ImageDataResult.OK; }
public void CompressedTheContentIfGzipIsProvidedOnTheHeader() { GZippedContent gzippedContent = new GZippedContent(new JsonContent(new { test = "test" })); HttpConnectRequest request = CreatePostRequest(content: gzippedContent); HttpRequestMessage httpRequestMessage = _middleware.BuildRequestMessageTester(request); var content = httpRequestMessage.Content; var contentHeader = content.Headers.SingleOrDefault(h => h.Key == "Content-Encoding"); contentHeader.Should().NotBeNull(); contentHeader.Value.SingleOrDefault(v => v == "gzip").Should().NotBeNull(); content.Should().NotBeNull(); var stream = content.ReadAsStreamAsync().Result; var serializer = new JsonSerializer(); string jsonString = ""; using (System.IO.MemoryStream output = new System.IO.MemoryStream()) { using (System.IO.Compression.GZipStream sr = new System.IO.Compression.GZipStream(stream, System.IO.Compression.CompressionMode.Decompress)) { sr.CopyTo(output); } jsonString = Encoding.UTF8.GetString(output.GetBuffer(), 0, (int)output.Length); } JObject json = JObject.Parse(jsonString); json["test"].ToString().Should().Be("test"); }
public static PssgFile Open(Stream stream) { PssgFileType fileType = PssgFile.GetPssgType(stream); if (fileType == PssgFileType.Pssg) { return PssgFile.ReadPssg(stream, fileType); } else if (fileType == PssgFileType.Xml) { return PssgFile.ReadXml(stream); } else // CompressedPssg { using (stream) { MemoryStream mStream = new MemoryStream(); using (GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress)) { gZipStream.CopyTo(mStream); } mStream.Seek(0, SeekOrigin.Begin); return PssgFile.ReadPssg(mStream, fileType); } } }
/// <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; var zipInputStream = new ZipInputStream(dataStream); if (zipInputStream.CanDecompressEntry) { MemoryStream zipoutStream = new MemoryStream(); zipInputStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } else { try { dataStream.Seek(0, SeekOrigin.Begin); #if !WINDOWS_PHONE var gzipInputStream = new GZipInputStream(dataStream, CompressionMode.Decompress); #else var gzipInputStream = new GZipInputStream(dataStream); #endif MemoryStream zipoutStream = new MemoryStream(); gzipInputStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } } return(outputBytes); }
/// <summary> /// Metodo que descomprime un fichero /// </summary> /// <param name="fi">Informacion del fichero descomprimido</param> public static void Decompress(FileInfo fi) { // Get the stream of the source file. using (var inFile = fi.Open(FileMode.Open, FileAccess.ReadWrite)) { // Get original file extension, for example // "doc" from report.doc.gz. var curFile = fi.FullName; var origName = curFile.Remove(curFile.Length - fi.Extension.Length); //Create the decompressed file. using (var outFile = File.Create(origName)) { using (var decompress = new GZipStream(inFile, CompressionMode.Decompress)) { // Copy the decompression stream // into the output file. decompress.CopyTo(outFile); decompress.Close(); } outFile.Close(); } inFile.Close(); } }
public static void Uncompress(Stream input, Stream output) { using (var zinput = new GZipStream(input, CompressionMode.Decompress, true)) { zinput.CopyTo(output); } }
private static void ExtractAssembly(bool is64bit) { var p = Path.Combine(OutputPath, is64bit ? "x64" : "x86", "xxhash.dll"); if(!Directory.Exists(Path.GetDirectoryName(p))) { Directory.CreateDirectory(Path.GetDirectoryName(p)); } if (!File.Exists(p)) { string resourceName = string.Format("XXHashSharp.{0}.xxhash.dll.gz", is64bit ? "x64" : "x86"); using (var s = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName)) { using (var gz = new GZipStream(s, CompressionMode.Decompress)) { using (var fs = new FileStream(p, FileMode.Create, FileAccess.Write)) { gz.CopyTo(fs); fs.Flush(true); } } } } LoadLibrary(p); }
/// <summary> /// <para> --- </para> /// <para> Initializes FFmpeg.exe; Ensuring that there is a copy</para> /// <para> in the clients temp folder & isn't in use by another process.</para> /// </summary> public Engine() { string ffmpegDirectory = "" + Path.GetDirectoryName(FFmpegFilePath); if (!Directory.Exists(ffmpegDirectory)) Directory.CreateDirectory(ffmpegDirectory); if (File.Exists(FFmpegFilePath)) { if (!Document.IsFileLocked(new FileInfo(FFmpegFilePath))) return; Process[] ffmpegProcesses = Process.GetProcessesByName("ffmpeg"); if (ffmpegProcesses.Length > 0) foreach (Process process in ffmpegProcesses) { // pew pew pew... process.Kill(); // let it die... Thread.Sleep(200); } } else { Stream ffmpegStream = Assembly.GetExecutingAssembly() .GetManifestResourceStream("MediaToolkit.Resources.FFmpeg.exe.gz"); if (ffmpegStream == null) throw new Exception("FFMpeg GZip stream is null"); using (var tempFileStream = new FileStream(FFmpegFilePath, FileMode.Create)) using (var gZipStream = new GZipStream(ffmpegStream, CompressionMode.Decompress)) { gZipStream.CopyTo(tempFileStream); } } }
public ManagedBitmap(string fileName) { try { byte[] buffer = new byte[1024]; using (var fd = new MemoryStream()) using (Stream csStream = new GZipStream(File.OpenRead(fileName), CompressionMode.Decompress)) { csStream.CopyTo(fd); 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; } }
public static void Decompress(Stream inputStream, Stream outputStream) { using (GZipStream zip = new GZipStream(inputStream, CompressionMode.Decompress)) { zip.CopyTo(outputStream); } }
private static System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) { var asm = args.RequestingAssembly ?? Assembly.GetExecutingAssembly(); string asmname = asm.GetName().Name.Split('.').FirstOrDefault(); var tgt = new AssemblyName(args.Name); var tgtname = asmname + "." + tgt.Name + ".dll"; var resname = asm.GetManifestResourceNames().FirstOrDefault(n => string.Compare(n, tgtname, true) == 0); if (!string.IsNullOrWhiteSpace(resname)) { using (var strm = asm.GetManifestResourceStream(resname)) { byte[] data = new byte[strm.Length]; strm.Read(data, 0, (int)strm.Length); return Assembly.Load(data); } } resname = asm.GetManifestResourceNames().FirstOrDefault(n => string.Compare(n, tgtname + ".gz", true) == 0); if (!string.IsNullOrWhiteSpace(resname)) { using (var strm = asm.GetManifestResourceStream(resname)) using (var decom = new GZipStream(strm, CompressionMode.Decompress, true)) { byte[] data = null; using (var ms = new MemoryStream()) { decom.CopyTo(ms); data = ms.ToArray(); } return Assembly.Load(data); } } return null; }
/// <summary> Loads a TrigradCompressed image from a stream. </summary> public TrigradCompressed(Stream s) { using (GZipStream dezipper = new GZipStream(s, CompressionMode.Decompress)) using (BinaryReader reader = new BinaryReader(new MemoryStream())) { dezipper.CopyTo(reader.BaseStream); reader.BaseStream.Position = 0; Width = reader.ReadUInt16(); Height = reader.ReadUInt16(); List<Color> colorIndex = new List<Color>(); Dictionary<Point, ushort> pointIndex = new Dictionary<Point, ushort>(); ushort colors = reader.ReadUInt16(); for (int i = 0; i < colors; i++) { colorIndex.Add(Color.FromArgb(reader.ReadByte(), reader.ReadByte(), reader.ReadByte())); } uint points = reader.ReadUInt32(); for (int i = 0; i < points; i++) { Point p = new Point(reader.ReadUInt16(), reader.ReadUInt16()); ushort index = reader.ReadUInt16(); pointIndex.Add(p, index); } foreach (var pair in pointIndex) { SampleTable.Add(pair.Key, colorIndex[pair.Value]); } } }
static void Decompress_gz(string gz_file) { FileStream OriginalFileStream = File.OpenRead(gz_file); // This Returns a file stream to read. string extension = Path.GetExtension(gz_file); // This Gets the Extension of the File. string final_filename = gz_file.Substring(0, gz_file.Length - extension.Length); // Getting the File Name without the File Extension. final_filename = final_filename + ".txt"; FileStream decompressedFileStream = File.Create(final_filename); // Creating a File to Store the Decompressed File GZipStream decompressionStream = new GZipStream(OriginalFileStream, CompressionMode.Decompress); // This sets the Decompression of the Original Compressed FileStream. decompressionStream.CopyTo(decompressedFileStream); // Copies the Decompressed File Stream to the desired file. // Closing all the File Handles decompressionStream.Close(); decompressedFileStream.Close(); OriginalFileStream.Close(); // Parsing the Decompressed File. Parse_File(final_filename); Console.WriteLine("Decompressed File Name is " + final_filename); return; }
/// <summary> /// Decompresses stream using GZip. Returns decompressed Stream. /// Returns null if stream isn't compressed. /// </summary> /// <param name="compressedStream">Stream compressed with GZip.</param> public static MemoryStream DecompressStream(Stream compressedStream) { MemoryStream newStream = new MemoryStream(); compressedStream.Seek(0, SeekOrigin.Begin); GZipStream Decompressor = null; try { Decompressor = new GZipStream(compressedStream, CompressionMode.Decompress, true); Decompressor.CopyTo(newStream); } catch (InvalidDataException invdata) { return null; } catch(Exception e) { throw; } finally { if (Decompressor != null) Decompressor.Dispose(); } return newStream; }
/// <inheritdoc /> public byte[] Decompress(byte[] data) { var output = new MemoryStream(); using (var stream = new GZipStream(new MemoryStream(data), CompressionMode.Decompress)) stream.CopyTo(output); return output.ToArray(); }
static void Assemble(List<string> files, string destinationDirectory) { if (destinationDirectory.LastIndexOf('\\') != destinationDirectory.Length - 1) { destinationDirectory += "\\"; } foreach (string filePath in files) { string fileName = filePath.Substring(filePath.LastIndexOf('\\')+1); string fileExt = fileName.Replace(".gz",""); fileExt = fileExt.Substring(fileExt.LastIndexOf('.')); using (FileStream destination = new FileStream(destinationDirectory + fileName.Remove(fileName.IndexOf("-part")) + fileExt, FileMode.Append, FileAccess.Write), source = new FileStream(filePath, FileMode.Open, FileAccess.Read)) { using (GZipStream decompressionStream = new GZipStream(source,CompressionMode.Decompress)) { decompressionStream.CopyTo(destination); } } } Console.WriteLine("The file is assembled successfully."); }
private static void DecompressFile(string file) { byte[] buffer; using (var fileStream = File.OpenRead(file)) { using (var compressedStream = new GZipStream(fileStream, CompressionMode.Decompress)) { using (var memoryStream = new MemoryStream()) { try { compressedStream.CopyTo(memoryStream); memoryStream.Seek(0, SeekOrigin.Begin); buffer = new byte[memoryStream.Length]; memoryStream.Read(buffer, 0, (int)memoryStream.Length); } catch (Exception e) { throw; } } } } File.Create(file).Close(); File.WriteAllBytes(file, buffer); }
public bool DecompressDataFile(FileInfo dfi) { bool result; try { // Get the stream of the source file. using (FileStream inFile = dfi.OpenRead()) { // Get original file extension, by removing ".gz" from Data.sqlite.gz string curFile = dfi.FullName; string origName = curFile.Remove(curFile.Length - dfi.Extension.Length); //Create the decompressed file. using (FileStream outFile = File.Create(origName)) { using (System.IO.Compression.GZipStream Decompress = new System.IO.Compression.GZipStream(inFile, System.IO.Compression.CompressionMode.Decompress)) { byte[] tmp = new byte[4]; inFile.Read(tmp, 0, 4); inFile.Seek(0, SeekOrigin.Begin); // Copy the decompression stream into the output file. Decompress.CopyTo(outFile); result = true; Console.WriteLine("Decompressed: {0}", dfi.Name); } } } } catch (Exception e) { Console.WriteLine(String.Format("Exception: {0}\n{1}", e.Message, e.StackTrace)); result = false; } return(result); }
public void TestUnzip() { var fs = File.OpenRead(@".\TestFiles\example.svgz"); var stream = new System.IO.Compression.GZipStream(fs, CompressionMode.Decompress); var destination = File.OpenWrite(@".\TestFiles\example.svg"); stream.CopyTo(destination); }
/// <summary> /// Decompresses the content of a stream. The data stream will be closed /// </summary> /// <param name="data">Data to decompress</param> /// <param name="decompressedData">Stream with the decompressed data</param> public static void Decompress(ref Stream data, out Stream decompressedData) { decompressedData = new MemoryStream(); var decompress = new GZipStream(data, CompressionMode.Decompress); decompress.CopyTo(decompressedData); decompress.Close(); data.Close(); }
public static byte[] Decompress(byte[] buffer, int index, int count) { using (var zipStream = new GZipStream(new MemoryStream(buffer, index, count), CompressionMode.Decompress)) using (var resultStream = new MemoryStream()) { zipStream.CopyTo(resultStream); return resultStream.ToArray(); } }
public static string Decompress(this string value) { using (var msi = new MemoryStream(Convert.FromBase64String(value))) using (var mso = new MemoryStream()) { using (var gs = new GZipStream(msi, CompressionMode.Decompress)) gs.CopyTo(mso); return Encoding.GetString(mso.ToArray()); } }
public static void UnGZipFileToFile(string compressedfile, string destinationFilename) { using (Stream fd = File.Create(destinationFilename)) using (Stream fs = File.OpenRead(compressedfile)) using (Stream csStream = new GZipStream(fs, CompressionMode.Decompress)) { csStream.CopyTo(fd); } }
public byte[] DecompressWithGzip(byte[] data) { using (var compressedStream = new MemoryStream(data)) using (var zipStream = new GZipStream(compressedStream, CompressionMode.Decompress)) using (var resultStream = new MemoryStream()) { zipStream.CopyTo(resultStream); return resultStream.ToArray(); } }
public static byte[] Decompress(byte[] data) { using (var inStream = new MemoryStream(data)) using (var zipStream = new GZipStream(inStream, CompressionMode.Decompress)) using (var outStream = new MemoryStream()) { zipStream.CopyTo(outStream); return outStream.ToArray(); } }
static public byte[] DecompressGzip(byte[] compressed) { using var decompressStream = new System.IO.Compression.GZipStream( new System.IO.MemoryStream(compressed), System.IO.Compression.CompressionMode.Decompress); var decompressedStream = new System.IO.MemoryStream(); decompressStream.CopyTo(decompressedStream); return(decompressedStream.ToArray()); }
public static byte[] GZipDecompress(byte[] data) { using (var msIn = new MemoryStream(data)) using (var unzipper = new GZipStream(msIn, CompressionMode.Decompress)) using (var msOut = new MemoryStream()) { unzipper.CopyTo(msOut); return msOut.ToArray(); } }
public byte[] Decompress(byte[] input) { using (var inputStream = new MemoryStream(input)) using (var decompressionStream = new GZipStream(inputStream, CompressionMode.Decompress)) using (var outputStream = new MemoryStream()) { decompressionStream.CopyTo(outputStream); return outputStream.ToArray(); } }
public static Stream UnzipStream(Stream input) { var ms = new MemoryStream(); using (var gzip = new GZipStream(input, CompressionMode.Decompress, true)) gzip.CopyTo(ms); ms.Position = 0; return ms; }
/// <summary> /// Decompress data using GZip /// </summary> /// <param name="dataToDecompress">The stream that hold the data</param> /// <returns>Bytes array of decompressed data</returns> public static byte[] Decompress(Stream dataToDecompress) { MemoryStream target = new MemoryStream(); using (System.IO.Compression.GZipStream decompressionStream = new System.IO.Compression.GZipStream(dataToDecompress, System.IO.Compression.CompressionMode.Decompress)) { decompressionStream.CopyTo(target); } return(target.GetBuffer()); }
/// <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, CompressionFormat format) { byte[] outputBytes = null; switch (format) { case CompressionFormat.Zlib: try { try { using (var deflateStream = new ZlibStream(dataStream, MonoGame.Utilities.CompressionMode.Decompress)) { using (MemoryStream zipoutStream = new MemoryStream()) { deflateStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } } } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } break; case CompressionFormat.Gzip: try { #if !WINDOWS_PHONE var gzipInputStream = new GZipInputStream(dataStream, System.IO.Compression.CompressionMode.Decompress); #else var gzipInputStream = new GZipInputStream(dataStream); #endif MemoryStream zipoutStream = new MemoryStream(); gzipInputStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } break; } return(outputBytes); }
private static byte[] Decompress(byte[] compressedBytes) { using (MemoryStream input = new MemoryStream(compressedBytes)) using (MemoryStream output = new MemoryStream()) { using (System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(input, System.IO.Compression.CompressionMode.Decompress)) { zip.CopyTo(output); } return(output.ToArray()); } }
public static string DecompressFileToString(string filename) { using (MemoryStream ms = new MemoryStream()) using (var fs = File.Open(filename, FileMode.Open)) using (var gz = new System.IO.Compression.GZipStream(fs, System.IO.Compression.CompressionMode.Decompress)) { gz.CopyTo(ms); ms.Position = 0; using (StreamReader sr = new StreamReader(ms)) { return(sr.ReadToEnd()); } } }
/// <summary> /// Unzips a zipped stream to the specified stream /// </summary> /// <param name="zipStream">The zipped stream to un-zip.</param> /// <param name="unZipStream">The stream where the unzipped data will be written to.</param> /// <param name="zipStreamPosition">Set the zip stream position.</param> public static void Decompress(MemoryStream zipStream, MemoryStream unZipStream, long zipStreamPosition = 0) { // Set the position. zipStream.Position = zipStreamPosition; // Create all the streams using (System.IO.Compression.GZipStream stream = new System.IO.Compression.GZipStream(zipStream, CompressionMode.Decompress, true)) { // Decompress the data. stream.CopyTo(unZipStream); // Cleanup the resources. stream.Close(); } }
public void TestGZipStream() { compressor = new System.IO.Compression.GZipStream(compressed, System.IO.Compression.CompressionMode.Compress, true); StartCompression(); compressor.Write(input.GetBuffer(), 0, inputSize); compressor.Close(); EndCompression(); var decompressor = new System.IO.Compression.GZipStream(compressed, System.IO.Compression.CompressionMode.Decompress, true); decompressor.CopyTo(decompressed); AfterDecompression(); }
/// <summary> /// Unzips a zipped file to the specified location /// </summary> /// <param name="zipFilename">The zipped file to un-zip.</param> /// <param name="unZipFilename">The file name where the unzipped file will be written to.</param> public static void Decompress(string zipFilename, string unZipFilename) { // Create all the streams using (Stream zipStream = File.OpenRead(zipFilename)) using (Stream unzipStream = File.Create(unZipFilename)) using (System.IO.Compression.GZipStream stream = new System.IO.Compression.GZipStream(zipStream, CompressionMode.Decompress)) { // Decompress the data. stream.CopyTo(unzipStream); // Cleanup the resources. stream.Close(); zipStream.Close(); unzipStream.Close(); } }
public T ToObject <T>(byte[] bytes, Type[] types = null) { using (MemoryStream stream = new MemoryStream(bytes)) { using (MemoryStream str = new MemoryStream()) { using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(stream, System.IO.Compression.CompressionMode.Decompress)) { gzip.CopyTo(str); } return(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(System.Text.Encoding.UTF8.GetString(str.GetBuffer()), new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All })); } } }
public static byte[] Decompress(byte[] file) { using (EndianBinaryReader r = new EndianBinaryReader(new MemoryStream(file), Endianness.Little)) { uint splitSize = r.ReadUInt32(); uint entryCount = r.ReadUInt32(); uint uncompSize = r.ReadUInt32(); uint[] splits = r.ReadUInt32s((int)entryCount); byte[] output = new byte[uncompSize]; r.SeekBegin((r.Position + 0x7F) & ~0x7F); // Align using (EndianBinaryWriter w = new EndianBinaryWriter(new MemoryStream(output), Endianness.Little)) { for (int i = 0; i < entryCount; i++) { uint cur_comp = r.ReadUInt32(); if (i == entryCount - 1) { if (cur_comp != splits[i] - 4) { w.Write(splits[i]); } else { using (System.IO.Compression.GZipStream deflate = new System.IO.Compression.GZipStream(new MemoryStream(r.ReadBytes((int)cur_comp)), System.IO.Compression.CompressionMode.Decompress)) deflate.CopyTo(w.BaseStream); } } else { if (cur_comp == splits[i] - 4) { using (System.IO.Compression.GZipStream deflate = new System.IO.Compression.GZipStream(new MemoryStream(r.ReadBytes((int)cur_comp)), System.IO.Compression.CompressionMode.Decompress)) deflate.CopyTo(w.BaseStream); } } r.SeekBegin(r.Position + 0x7F & ~0x7F); // Align } } return(output); } }
private void ReadConfig() { MemoryStream ms = new MemoryStream(); byte[] SerializeByte = ms.ToArray(); FileStream fs = new FileStream(@".\config.bin", FileMode.OpenOrCreate, FileAccess.Read, FileShare.None); GZipStream compressedStream = new System.IO.Compression.GZipStream(fs, CompressionMode.Decompress, true); compressedStream.CopyTo(ms); ms.Position = 0; BinaryFormatter binFormat = new BinaryFormatter(); if (ms.Length != 0) { config = (Config)binFormat.Deserialize(ms); } fs.Close(); ms.Close(); compressedStream.Close(); }
/// <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)) { using (MemoryStream zipoutStream = new MemoryStream()) { deflateStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } } } catch { try { dataStream.Seek(0, SeekOrigin.Begin); #if !WINDOWS_PHONE var gzipInputStream = new GZipInputStream(dataStream, System.IO.Compression.CompressionMode.Decompress); #else var gzipInputStream = new GZipInputStream(dataStream); #endif MemoryStream zipoutStream = new MemoryStream(); gzipInputStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } } return(outputBytes); }
public static System.IO.Stream UnzipStream(System.IO.Stream input, bool zippedStream = true, String contentEncoding = null, String fileName = null) { System.IO.Stream tempStream = null; if (contentEncoding == null) { contentEncoding = WebOperationContext.Current.IncomingRequest.Headers[HttpRequestHeader.ContentEncoding]; } if (String.IsNullOrEmpty(contentEncoding) || !zippedStream) { if (!String.IsNullOrEmpty(fileName)) { return(System.IO.File.OpenRead(fileName)); } else { return(input); } } else { switch (contentEncoding.ToLower()) { case "gzip": if (!String.IsNullOrEmpty(fileName)) { tempStream = System.IO.File.OpenRead(fileName); } System.IO.MemoryStream ms = new System.IO.MemoryStream(); using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(tempStream != null ? tempStream : input, System.IO.Compression.CompressionMode.Decompress, true)) { gzip.CopyTo(ms); } ms.Position = 0; return(ms); case "deflate": String tempFileName = null; if (String.IsNullOrEmpty(fileName)) { tempFileName = Path.Combine(System.IO.Path.GetTempPath(), System.Guid.NewGuid().ToString()); using (FileStream fs = System.IO.File.OpenWrite(tempFileName)) { input.CopyTo(fs); fs.Flush(); } } try { using (ZipArchive a = ZipFile.OpenRead(String.IsNullOrEmpty(fileName) ? tempFileName : fileName)) { ZipArchiveEntry entry = a.Entries[0]; return(entry.Open()); } } finally { if (!String.IsNullOrEmpty(tempFileName)) { System.IO.File.Delete(tempFileName); } } default: throw new Exception("Unsupported content type"); } } }
/// <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, CompressionFormat format) { byte[] outputBytes = null; switch (format) { case CompressionFormat.Zlib: try { var zipInputStream = new ZipInputStream(dataStream); if (zipInputStream.CanDecompressEntry) { MemoryStream zipoutStream = new MemoryStream(); zipInputStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } else { dataStream.Seek(0, SeekOrigin.Begin); var inZInputStream = new ZInputStream(dataStream); var outMemoryStream = new MemoryStream(); outputBytes = new byte[inZInputStream.BaseStream.Length]; while (true) { int bytesRead = inZInputStream.Read(outputBytes, 0, outputBytes.Length); if (bytesRead == 0) { break; } outMemoryStream.Write(outputBytes, 0, bytesRead); } } } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } break; case CompressionFormat.Gzip: try { #if !WINDOWS_PHONE var gzipInputStream = new GZipInputStream(dataStream, CompressionMode.Decompress); #else var gzipInputStream = new GZipInputStream(dataStream); #endif MemoryStream zipoutStream = new MemoryStream(); gzipInputStream.CopyTo(zipoutStream); outputBytes = zipoutStream.ToArray(); } catch (Exception exc) { CCLog.Log("Error decompressing image data: " + exc.Message); } break; } return(outputBytes); }
public void UploadDataInternal(Common.Solution solution, Stream messageBody, bool checkExisting, bool zippedStream = true, String contentEncoding = null, String fileName = null, Action <int> progressCallback = null, int progressStep = 0) { System.IO.Stream tempStream = null; if (contentEncoding == null && zippedStream) { contentEncoding = WebOperationContext.Current.IncomingRequest.Headers[HttpRequestHeader.ContentEncoding]; } if (String.IsNullOrEmpty(contentEncoding) || !zippedStream) { if (!String.IsNullOrEmpty(fileName)) { tempStream = System.IO.File.OpenRead(fileName); } new DataUploader2(progressCallback, progressStep).UploadData(solution, tempStream != null ? tempStream : messageBody, checkExisting); } else { switch (contentEncoding.ToLower()) { case "gzip": if (!String.IsNullOrEmpty(fileName)) { tempStream = System.IO.File.OpenRead(fileName); } System.IO.MemoryStream ms = new System.IO.MemoryStream(); using (System.IO.Compression.GZipStream gzip = new System.IO.Compression.GZipStream(tempStream != null ? tempStream : messageBody, System.IO.Compression.CompressionMode.Decompress, true)) { gzip.CopyTo(ms); } ms.Position = 0; new DataUploader2(progressCallback, progressStep).UploadData(solution, ms, checkExisting); break; case "deflate": String tempFileName = null; if (String.IsNullOrEmpty(fileName)) { tempFileName = Path.Combine(System.IO.Path.GetTempPath(), System.Guid.NewGuid().ToString()); using (FileStream fs = System.IO.File.OpenWrite(tempFileName)) { messageBody.CopyTo(fs); fs.Flush(); } } try { using (ZipArchive a = ZipFile.OpenRead(String.IsNullOrEmpty(fileName) ? tempFileName : fileName)) { ZipArchiveEntry entry = a.Entries[0]; using (System.IO.Stream s = entry.Open()) { new DataUploader2(progressCallback, progressStep).UploadData(solution, s, checkExisting); } } } finally { if (!String.IsNullOrEmpty(tempFileName)) { System.IO.File.Delete(tempFileName); } } break; default: throw new Exception("Unsupported content type"); } } if (tempStream != null) { tempStream.Dispose(); } }