| public Read ( byte buffer, int offset, int count ) : int | ||
| buffer | byte | /// The buffer to read uncompressed data into /// |
| offset | int | /// The offset indicating where the data should be placed /// |
| count | int | /// The number of uncompressed bytes to be read /// |
| 리턴 | int | |
public byte[] Decompress(byte[] data)
{
using (MemoryStream inputStream = new MemoryStream())
{
inputStream.Write(data, 0, data.Length);
inputStream.Position = 0;
using (Stream decompressStream = new GZipInputStream(inputStream))
{
using (MemoryStream outputStream = new MemoryStream())
{
byte[] buffer = new byte[BUFFER_SIZE];
while (true)
{
int size = decompressStream.Read(buffer, 0, buffer.Length);
if (size > 0)
{
outputStream.Write(buffer, 0, size);
}
else
{
break;
}
}
decompressStream.Close();
return outputStream.ToArray();
}
}
}
}
public static byte[] GetDecompressedBytes(this WWW www)
{
#if UNITY_STANDALONE_WIN || UNITY_WEBGL
string contentEncoding;
if (www.responseHeaders == null ||
!www.responseHeaders.TryGetValue(ContentEncodingHeaderName, out contentEncoding) ||
!contentEncoding.Equals(GzipContentEncodingValue, StringComparison.OrdinalIgnoreCase))
{
return www.bytes;
}
byte[] buffer = new byte[4096];
using (var stream = new MemoryStream(www.bytes))
using (var gzip = new GZipInputStream(stream))
using (var outMs = new MemoryStream(www.bytes.Length))
{
int bytesRead = 0;
while ((bytesRead = gzip.Read(buffer, 0, buffer.Length)) > 0)
{
outMs.Write(buffer,0, bytesRead);
}
return outMs.ToArray();
}
#else
return www.bytes;
#endif
}
public void TestGZip()
{
MemoryStream ms = new MemoryStream();
GZipOutputStream outStream = new GZipOutputStream(ms);
byte[] buf = new byte[100000];
System.Random rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
outStream.Flush();
outStream.Finish();
ms.Seek(0, SeekOrigin.Begin);
GZipInputStream inStream = new GZipInputStream(ms);
byte[] buf2 = new byte[buf.Length];
int currentIndex = 0;
int count = buf2.Length;
while (true) {
int numRead = inStream.Read(buf2, currentIndex, count);
if (numRead <= 0) {
break;
}
currentIndex += numRead;
count -= numRead;
}
Assert.AreEqual(0, count);
for (int i = 0; i < buf.Length; ++i) {
Assert.AreEqual(buf2[i], buf[i]);
}
}
private static byte[] Decompress(byte[] compressed)
{
using (var compressedMemoryStream = new MemoryStream(compressed))
{
var gZipInputStream = new GZipInputStream(compressedMemoryStream);
try
{
using (var unCompressedStream = new MemoryStream())
{
var noOfBytesReadTotal = 0;
const int blockSize = 2048;
var byteBlock = new byte[blockSize];
while (true)
{
var noOfBytesRead = gZipInputStream.Read(byteBlock, 0, byteBlock.Length);
if (noOfBytesRead <= 0)
{
break;
}
noOfBytesReadTotal += noOfBytesRead;
unCompressedStream.Write(byteBlock, 0, noOfBytesRead);
}
var decompressedWithoutTrailingZeros =
unCompressedStream.GetBuffer().Take(noOfBytesReadTotal);
return decompressedWithoutTrailingZeros.ToArray();
}
}
finally
{
gZipInputStream.Close();
}
}
}
public void TestGZip()
{
MemoryStream ms = new MemoryStream();
GZipOutputStream outStream = new GZipOutputStream(ms);
byte[] buf = new byte[100000];
System.Random rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
outStream.Flush();
outStream.Finish();
ms.Seek(0, SeekOrigin.Begin);
GZipInputStream inStream = new GZipInputStream(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 filename)
{
StringBuilder result = null;
try
{
Stream s = new GZipInputStream(File.OpenRead(filename));
result = new StringBuilder(8192);
UTF7Encoding encoding = new UTF7Encoding(true);
int size = 2048;
byte[] writeData = new byte[2048];
while (true)
{
size = s.Read(writeData, 0, size);
if (size > 0)
{
result.Append(encoding.GetString(writeData,0,size));
}
else
{
break;
}
}
s.Close();
} // end try
catch (GZipException)
{
throw new Exception("Error: The file being read contains invalid data.");
}
catch (FileNotFoundException)
{
throw new Exception("Error:The file specified was not found.");
}
catch (ArgumentException)
{
throw new Exception("Error: path is a zero-length string, contains only white space, or contains one or more invalid characters");
}
catch (PathTooLongException)
{
throw new Exception("Error: The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.");
}
catch (DirectoryNotFoundException)
{
throw new Exception("Error: The specified path is invalid, such as being on an unmapped drive.");
}
catch (IOException)
{
throw new Exception("Error: An I/O error occurred while opening the file.");
}
catch (UnauthorizedAccessException)
{
throw new Exception("Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions.");
}
return result.ToString();
}
protected override void CreateReader()
{
_logFileStream = new GZipInputStream(File.Open(_logFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
if (_currentPosition > 0)
{
long seekPosition = 0;
int readBlockSize = 2;//1024*1024;
byte[] temp = new byte[readBlockSize];
while (seekPosition < _currentPosition - readBlockSize)
{
_logFileStream.Read(temp, 0, readBlockSize);
seekPosition += readBlockSize;
}
_logFileStream.Read(temp, 0, (int)(_currentPosition - seekPosition));
}
_logFileStreamReader = new StreamReader(_logFileStream, _logFileEncoding);
}
private static byte[] Unpack(byte[] _bytes)
{
ICSharpCode.SharpZipLib.GZip.GZipInputStream _GZipStream = new ICSharpCode.SharpZipLib.GZip.GZipInputStream(new MemoryStream(_bytes));
byte[] _buffer2 = new byte[99999];
int count = _GZipStream.Read(_buffer2, 0, _buffer2.Length);
return(Substr(_buffer2, count));
}
public ArcFileSystem()
{
data = new byte[90016];
GZipInputStream gzipStream = new GZipInputStream(new FileStream("Assets/SilentHill3/Archives/arc.arc", FileMode.Open, FileAccess.Read));
gzipStream.Read(data, 0, 90016);
ReadAll();
}
public static byte[] DeCompress( byte[] bytesToDeCompress )
{
byte[] rebyte = new byte[ bytesToDeCompress.Length * 20 ];
MemoryStream ms = new MemoryStream( bytesToDeCompress );
MemoryStream outStream = new MemoryStream();
GZipInputStream s = new GZipInputStream( ms );
int read = s.Read( rebyte , 0 , rebyte.Length );
while ( read > 0 )
{
outStream.Write( rebyte, 0 , read );
read = s.Read( rebyte , 0, rebyte.Length );
}
s.Close();
return outStream.ToArray();
}
/// <summary>
/// Decompresses specified DataSet data what is compressed with GZIP.
/// </summary>
/// <param name="source">Stream to decompress.</param>
/// <returns>Returns decompressed DataSet.</returns>
public static DataSet DecompressDataSet(Stream source)
{
source.Position = 0;
GZipInputStream gzip = new GZipInputStream(source);
MemoryStream retVal = new MemoryStream();
byte[] buffer = new byte[8000];
int readedCount = gzip.Read(buffer,0,buffer.Length);
while(readedCount > 0){
// Store current zipped data block
retVal.Write(buffer,0,readedCount);
// Read next data block
readedCount = gzip.Read(buffer,0,buffer.Length);
}
retVal.Position = 0;
DataSet ds = new DataSet();
ds.ReadXml(retVal);
return ds;
/* mono won't support compression
GZipStream gzip = new GZipStream(source,CompressionMode.Decompress);
MemoryStream retVal = new MemoryStream();
byte[] buffer = new byte[8000];
int readedCount = gzip.Read(buffer,0,buffer.Length);
while(readedCount > 0){
// Store current zipped data block
retVal.Write(buffer,0,readedCount);
// Read next data block
readedCount = gzip.Read(buffer,0,buffer.Length);
}
retVal.Position = 0;
DataSet ds = new DataSet();
ds.ReadXml(retVal);
return ds;*/
}
private static string ComputeHashFromGz(string filename)
{
string newHash;
using (GZipInputStream logFileStream = new GZipInputStream(File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
byte[] headBytes = new byte[BytesToRead];
logFileStream.Read(headBytes, 0, BytesToRead);
SHA1 sha1 = SHA1.Create();
newHash = BitConverter.ToString(sha1.ComputeHash(headBytes));
}
return newHash;
}
/// <summary>
/// 解压缩
/// </summary>
public static byte[] Uncompression(byte[] src)
{
if (!IsGZip(src)) return src;
GZipInputStream gis = new GZipInputStream(new MemoryStream(src));
MemoryStream ms = new MemoryStream();
int count = 0;
byte[] tmp = new byte[4096];
while ((count = gis.Read(tmp, 0, tmp.Length)) > 0)
{
ms.Write(tmp, 0, count);
}
gis.Close();
return ms.ToArray();
}
public string unzip(byte[] input)
{
using (MemoryStream memory = new MemoryStream()) {
using (GZipInputStream gzip = new GZipInputStream(new MemoryStream(input))) {
int n = 0;
byte[] temp = new byte[1024];
while ((n = gzip.Read(temp, 0, temp.Length)) != 0)
memory.Write (temp, 0, n);
}//using
return Encoding.UTF8.GetString (memory.ToArray ());
}//using
}
public static string returnUnZippedString(byte[] zippedByteArrayToUnzip)
{
MemoryStream memStream = new MemoryStream(zippedByteArrayToUnzip);
GZipInputStream objGZipInputStream = new GZipInputStream(memStream);
int totalNumberOfBytesRead = 0;
StringWriter unZippedData = new StringWriter();
while (true)
{
byte[] tempUncompressedData = new byte[65536];
int numberOfBytesProcessed = objGZipInputStream.Read(tempUncompressedData,0,65536);
if (0 == numberOfBytesProcessed) break;
unZippedData.Write(Encoding.UTF8.GetChars(tempUncompressedData));
totalNumberOfBytesRead += numberOfBytesProcessed;
}
return unZippedData.ToString();
}
public static byte[] Decompression(byte[] buf)
{
MemoryStream ms = new MemoryStream();
int count = 0;
GZipInputStream zip = new GZipInputStream(new MemoryStream(buf));
byte[] data = new byte[256];
while ((count = zip.Read(data, 0, data.Length)) != 0)
{
ms.Write(data, 0, count);
}
byte[] result = ms.ToArray();
ms.Close();
return result;
}
public string GUnzip(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 GZipInputStream(ms))
{
zipStream.Read(buffer, 0, buffer.Length);
}
return Encoding.UTF8.GetString(buffer);
}
}
public static BlockAccessor decode(BlockAccessor block)
{
byte[] data = new byte[block.Length];
if (block.Read(data,0,(int)block.Length) != block.Length) {
throw new Exception("BlockAccessor partial read");
}
MemoryStream ms = new MemoryStream(data);
BinaryReader reader = new BinaryReader(ms);
UInt32 uncompressed_length = reader.ReadUInt32();
byte[] uncompressed_data = new byte[uncompressed_length];
GZipInputStream uncompressed_stream = new GZipInputStream(ms);
if (uncompressed_stream.Read(uncompressed_data, 0, (int)uncompressed_length)
!= uncompressed_length) {
throw new Exception("GZipInputStream partial read");
}
return new BlockAccessor(uncompressed_data);
}
public static void GzipDecompressFile(string inputFile, string outputFile)
{
using (var fileStreamIn = new FileStream(inputFile, FileMode.Open, FileAccess.Read))
{
using (var fileStreamOut = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
using (var zipInStream = new GZipInputStream(fileStreamIn))
{
int size;
byte[] buffer = new byte[_defaultBufferSize];
do
{
size = zipInStream.Read(buffer, 0, buffer.Length);
fileStreamOut.Write(buffer, 0, size);
} while (size > 0);
}
}
}
}
protected override IEnumerator ReceiveCallback(WWW www, string id)
{
yield return www;
if (www.error == null)
{
string contentEncoding = string.Empty;
foreach (var kvp in www.responseHeaders)
{
if (kvp.Key.Equals(CONTENT_ENCODING, System.StringComparison.OrdinalIgnoreCase) == true)
{
contentEncoding = kvp.Key;
break;
}
}
if (string.IsNullOrEmpty(contentEncoding) == false && www.responseHeaders[contentEncoding].Equals(ENCODING_GZIP, System.StringComparison.OrdinalIgnoreCase) == true)
{
using (MemoryStream inputStream = new MemoryStream())
{
using (GZipInputStream zipStream = new GZipInputStream(new MemoryStream(www.bytes)))
{
byte[] buffer = new byte[4096];
int count = 0;
do
{
count = zipStream.Read(buffer, 0, www.bytes.Length);
inputStream.Write(buffer, 0, count);
} while (count != 0);
}
byte[] receiveData = inputStream.ToArray();
OnReceive(id, receiveData, 0, receiveData.Length);
}
}
else
{
OnReceive(id, www.bytes, 0, www.bytes.Length);
}
}
else
OnError(id, www.error, null);
www.Dispose();
}
/// <summary>
/// 解压字节数组
/// </summary>
/// <param name="inputBytes">Input bytes.</param>
public static byte[] Decompress (byte[] inputBytes)
{
using (var inputStream = new MemoryStream (inputBytes))
{
using (var zipStream = new GZipInputStream (inputStream))
{
using (var outStream = new MemoryStream ())
{
int size = 2048;
var outBytes = new byte[size];
while (size > 0)
{
size = zipStream.Read (outBytes, 0, size);
if (size > 0) outStream.Write (outBytes, 0, size);
}
zipStream.Close ();
return outStream.ToArray ();
}
}
}
}
protected override BlockingStream GetTarStream(IAsset asset)
{
const int chunk = 4096;
BlockingStream blockingStream = new BlockingStream(1000);
asset.GetStreamable().GetStreamAsync()
.ContinueWith(task =>
{
var stream = new ICSharpCode.SharpZipLib.GZip.GZipInputStream(task.GetAwaiter().GetResult());
Task.Factory.StartNew(() =>
{
int read;
var buffer = new byte[chunk];
do
{
read = stream.Read(buffer, 0, chunk);
blockingStream.Write(buffer, 0, read);
} while (read == chunk);
blockingStream.Close();
});
});
return(blockingStream);
}
/// <summary>
/// 解压缩byte数组
/// </summary>
/// <param name="inBytes">需要解压缩的byte数组</param>
/// <returns></returns>
public static byte[] DecompressByte(byte[] inBytes)
{
byte[] writeData = new byte[2048];
MemoryStream inStream = new MemoryStream(inBytes);
Stream zipStream = new GZipInputStream(inStream) as Stream;
MemoryStream outStream = new MemoryStream();
while (true)
{
int size = zipStream.Read(writeData, 0, writeData.Length);
if (size > 0)
{
outStream.Write(writeData, 0, size);
}
else
{
break;
}
}
inStream.Close();
byte[] outData = outStream.ToArray();
outStream.Close();
return outData;
}
/// <summary> Returns an gunzipped copy of the input array, truncated to
/// <code>sizeLimit</code> bytes, if necessary. If the gzipped input
/// has been truncated or corrupted, a best-effort attempt is made to
/// unzip as much as possible. If no data can be extracted
/// <code>null</code> is returned.
/// </summary>
public static byte[] GUnzipBestEffort(System.IO.Stream srcStream, int sizeLimit)
{
try
{
// decompress using GZIPInputStream
System.IO.MemoryStream outStream = new System.IO.MemoryStream(EXPECTED_COMPRESSION_RATIO * (Int32)srcStream.Length);
GZipInputStream inStream = new GZipInputStream(srcStream);
byte[] buf = new byte[BUF_SIZE];
int size = BUF_SIZE;
int written = 0;
while (true)
{
size = inStream.Read(buf, 0, size);
if (size <= 0)
{
break;
}
if ((written + size) > sizeLimit)
{
outStream.Write(buf, 0, sizeLimit - written);
}
outStream.Write(buf, 0, size);
written += size;
}
inStream.Close();
return outStream.ToArray();
}
catch(Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
return null;
}
}
// TODO: Create a class Archive.cs and do all the archiving stuff there!
public static bool UncompressGzipFile(string Filename, string To, Gtk.ProgressBar bar)
{
try{
Console.WriteLine(Filename);
GZipInputStream gzipIn = new GZipInputStream(File.OpenRead(Filename));
FileStream streamWriter = File.Create(To+Path.GetFileNameWithoutExtension(Filename));
long size=0;
byte[] data = new byte[1024];
while (true)
{
size = gzipIn.Read(data, 0, data.Length);
if (size > 0) streamWriter.Write(data, 0, (int) size);
else break;
}
streamWriter.Close();
Console.WriteLine("Deflating the gzip file done!");
return true;
}
catch(Exception e) {
Console.WriteLine("An exception occured while deflating the gzip file: "+e.Message);
return false;
}
}
private byte[] DecompressBytes(byte[] rawBytes)
{
byte[] buffer = new byte[4096];
using (var stream = new MemoryStream(rawBytes))
using (var gzip = new GZipInputStream(stream))
using (var outMs = new MemoryStream(rawBytes.Length))
{
int bytesRead = 0;
while ((bytesRead = gzip.Read(buffer, 0, buffer.Length)) > 0)
{
outMs.Write(buffer, 0, bytesRead);
}
return outMs.ToArray();
}
}
public static byte[] DecodeBase64ToBinary(string input)
{
// Fix for issue #429. See comment up in EncodeBase64() method above for an explanation:
string massagedInput = input.Replace(',','/');
byte[] inputBuffer = Convert.FromBase64String(massagedInput);
using (var inputStream = new MemoryStream(inputBuffer))
{
// mono requires an installed zlib library for GZipStream to work :(
//using (var zipStream = new GZipStream(inputStream, CompressionMode.Decompress))
using (var zipStream = new GZipInputStream(inputStream))
{
using (var decompressedStream = new MemoryStream())
{
var buffer = new byte[4096];
int read;
while ((read = zipStream.Read(buffer, 0, buffer.Length)) > 0)
{
decompressedStream.Write(buffer, 0, read);
}
return decompressedStream.ToArray();
}
}
}
}
public void FromCompressedByteArray(byte[] compressed)
{
byte[] streambuff = new byte[XSize * YSize * ZSize * Voxel.BYTE_SIZE];
using (var ms = new MemoryStream(compressed))
{
using (var gzs = new GZipInputStream(ms))
{
gzs.Read(streambuff, 0, streambuff.Length);
}
}
bool convertAlpha = true;
for (int i = 0; i < (streambuff.Length<50?streambuff.Length:50); i++)
{
if (streambuff[(streambuff.Length - 1) - i] != 0) convertAlpha = false;
}
Voxels = new Voxel[XSize * YSize * ZSize];
int o = 0;
byte[] buffer = new byte[Voxel.BYTE_SIZE];
for (int x = 0; x < XSize; x++)
for (int y = 0; y < YSize; y++)
for (int z = 0; z < ZSize; z++)
{
if (!convertAlpha)
{
for (int i = 0; i < Voxel.BYTE_SIZE; i++) buffer[i] = streambuff[o + i];
Voxels[x + XSize * (y + YSize * z)] = new Voxel(buffer);
o += Voxel.BYTE_SIZE;
}
else
{
for (int i = 0; i < Voxel.BYTE_SIZE - 1; i++) buffer[i] = streambuff[o + i];
buffer[5] = 255;
Voxels[x + XSize * (y + YSize * z)] = new Voxel(buffer);
o += Voxel.BYTE_SIZE - 1;
}
}
}
public void TrailingGarbage()
{
/* ARRANGE */
var ms = new MemoryStream();
var outStream = new GZipOutputStream(ms);
// input buffer to be compressed
byte[] buf = new byte[100000];
var rnd = new Random();
rnd.NextBytes(buf);
// compress input buffer
outStream.Write(buf, 0, buf.Length);
outStream.Flush();
outStream.Finish();
// generate random trailing garbage and add to the compressed stream
byte[] garbage = new byte[4096];
rnd.NextBytes(garbage);
ms.Write(garbage, 0, garbage.Length);
// rewind the concatenated stream
ms.Seek(0, SeekOrigin.Begin);
/* ACT */
// decompress concatenated stream
var inStream = new GZipInputStream(ms);
byte[] buf2 = new byte[buf.Length];
int currentIndex = 0;
int count = buf2.Length;
while (true) {
int numRead = inStream.Read(buf2, currentIndex, count);
if (numRead <= 0) {
break;
}
currentIndex += numRead;
count -= numRead;
}
/* ASSERT */
Assert.AreEqual(0, count);
for (int i = 0; i < buf.Length; ++i) {
Assert.AreEqual(buf2[i], buf[i]);
}
}
public static byte[] Decompress(byte[] data)
{
if (data == null) return null;
byte[] decompressedData = null;
MemoryStream ms = null;
GZipInputStream gzip = null;
try
{
ms = new MemoryStream(data,false);
using (BinaryReader reader = new BinaryReader(ms))
{
bool compressedFlag = reader.ReadBoolean();
if (compressedFlag == false)
{
//Uncompressed
decompressedData = reader.ReadBytes(data.Length - 1);
}
else
{
//Decompress
Int32 size = reader.ReadInt32();
gzip = new GZipInputStream(ms);
decompressedData = new byte[size];
gzip.Read(decompressedData, 0, decompressedData.Length);
gzip.Close();
ms.Close();
}
reader.Close();
}
}
catch
{
return null;
}
finally
{
if (gzip != null) gzip.Dispose();
if (ms != null) ms.Dispose();
}
return decompressedData;
}
private void ExtractFirmwareArchive()
{
string ipod_package = null;
foreach(DirectoryInfo directory in new DirectoryInfo(ResourcesPath).GetDirectories("iPod*.pkg")) {
ipod_package = directory.FullName;
break;
}
string cpio_out = Path.Combine(work_base, "firmware.cpio");
string gzcpio_in = Path.Combine(ipod_package,
"Contents" + Path.DirectorySeparatorChar + "Archive.pax.gz");
// this sucks, it seems necessary to create an extracted CPIO archive
// because GZipInputStream can't do seeking... CPIO needs seeking
FileStream in_stream = new FileStream(gzcpio_in, FileMode.Open, FileAccess.Read);
FileStream out_stream = new FileStream(cpio_out, FileMode.Create);
GZipInputStream gzstream = new GZipInputStream(in_stream);
byte [] block = new byte[4096];
int size = block.Length;
while(true) {
size = gzstream.Read(block, 0, size);
if(size > 0) {
out_stream.Write(block, 0, size);
} else {
break;
}
}
in_stream.Close();
out_stream.Close();
CpioArchive archive = new CpioArchive(cpio_out);
foreach(CpioFileEntry entry in archive) {
string filename = Path.GetFileName(entry.FileName);
if(filename.StartsWith("Firmware-")) {
string image_path = Path.Combine(firmware_export_path, filename);
archive.ExtractEntry(entry, image_path);
images.Add(image_path);
}
}
File.Delete(cpio_out);
}
/// <summary> Returns an gunzipped copy of the input array. </summary>
/// <throws> IOException if the input cannot be properly decompressed </throws>
public static byte[] GUnzip(System.IO.Stream srcStream)
{
// decompress using GZIPInputStream
System.IO.MemoryStream outStream = new System.IO.MemoryStream((Int32)(EXPECTED_COMPRESSION_RATIO * srcStream.Length));
GZipInputStream inStream = new GZipInputStream(srcStream);
byte[] buf = new byte[BUF_SIZE];
int size = BUF_SIZE;
while (true)
{
size = inStream.Read(buf, 0, size);
if (size <= 0)
{
break;
}
outStream.Write(buf, 0, size);
}
outStream.Close();
return outStream.ToArray();
}
