public Stream GetStream()
{
byte[] data = new byte[Data.Size];
long offset = Packfile.DataOffset + Data.Start;
Packfile.DataStream.Seek(offset, SeekOrigin.Begin);
if (Data.Flags.HasFlag(PackfileEntryFlags.Compressed))
{
byte[] compressedData = new byte[Data.CompressedSize];
Packfile.DataStream.Read(compressedData, 0, (int)Data.CompressedSize);
using (MemoryStream tempStream = new MemoryStream(compressedData))
{
using (Stream s = new ZlibStream(tempStream, CompressionMode.Decompress, true))
{
s.Read(data, 0, (int)Data.Size);
}
}
}
else
{
Packfile.DataStream.Read(data, 0, (int)Data.Size);
}
MemoryStream ms = new MemoryStream(data);
return ms;
}
/// <summary>
/// 지정된 데이타를 압축한다.
/// </summary>
/// <param name="input">압축할 Data</param>
/// <returns>압축된 Data</returns>
public override byte[] Compress(byte[] input) {
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.CompressStartMsg);
// check input data
if(input.IsZeroLength()) {
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.InvalidInputDataMsg);
return CompressorTool.EmptyBytes;
}
byte[] output;
using(var outStream = new MemoryStream(input.Length)) {
using(var zlib = new ZlibStream(outStream, CompressionMode.Compress)) {
zlib.Write(input, 0, input.Length);
}
output = outStream.ToArray();
}
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.CompressResultMsg, input.Length, output.Length, output.Length / (double)input.Length);
return output;
}
public static byte[] Comp(byte[] input)
{
using (var sourceStream = new MemoryStream(input))
{
using (var compressed = new MemoryStream())
{
using (var zipSteam = new ZlibStream(compressed, CompressionMode.Compress, CompressionLevel.Level9, true))
{
zipSteam.FlushMode = FlushType.Full;
//var buffer = new byte[1024];
//int len = sourceStream.Read(buffer, 0, buffer.Length);
//while (len > 0)
//{
// zipSteam.Write(buffer, 0, len);
// len = sourceStream.Read(buffer, 0, buffer.Length);
//}
sourceStream.CopyTo(zipSteam);
zipSteam.Flush();
return compressed.ToArray();
}
}
}
}
protected byte[] CompressMap()
{
int uncompressedSize = DynaBuffer.GetBytesUsed();
MemoryStream ms = new MemoryStream();
Ionic.Zlib.ZlibStream ws = new Ionic.Zlib.ZlibStream(ms, Ionic.Zlib.CompressionMode.Compress, Ionic.Zlib.CompressionLevel.BestCompression, true);
ws.Write(DynaBuffer.GetRawBuffer(), 0, uncompressedSize);
ws.Flush();
ws.Close();
int len = (int)ms.Length;
byte[] compressedData = ms.GetBuffer();
// ms.Length();
Array.Resize(ref compressedData, (int)ms.Length);
DynamicOutputBuffer header = DynamicOutputBuffer.GetTempBuffer(64);
header.WriteUInt16(Constants.WorldCodeHeaderSize);
header.WriteUInt16(Constants.WorldCodeHeader);
header.WriteUInt16(1);
header.WriteUInt32(uncompressedSize);
header.WriteUInt32(compressedData.Length);
header.WriteBytes(compressedData);
header.WriteUInt16(Constants.WorldCodeEndSize);
header.WriteUInt16(Constants.WorldCodeEnd);
return(header.GetFinalBuffer());
}
public static McaChunk ReadChunk(byte[] buffer, int dx, int dz)
{
//from mca file header
int i = 4 * (dx + dz * 32);
int offset = (buffer [i] << 16) | (buffer [i + 1] << 8) | (buffer [i + 2]);
int sectors = buffer [i + 3];
if (offset == 0 && sectors == 0)
return null;
Console.WriteLine("Read Chunk " + dx + "," + dz + " @ " + offset + ":" + sectors);
if (offset == 0 || sectors == 0)
throw new InvalidDataException("zero offset/sector");
offset = offset << 12; //4096 = 2**12
int length = EndianBitConverter.Big.ToInt32(buffer, offset); //byte length
if (((length + 5 - 1) >> 12) + 1 != sectors)
throw new InvalidDataException("Body length is larger than the sectors, " + length + " > " + (sectors * 4096));
if (buffer [offset + 4] != 2)
throw new NotImplementedException("Only support zlib compression");
McaChunk mc = new McaChunk(dx, dz);
MemoryStream ms = new MemoryStream(buffer, offset + 5, length);
using (ZlibStream compressed = new ZlibStream(ms, CompressionMode.Decompress))
{
EndianBinaryReader r = new EndianBinaryReader(EndianBitConverter.Big, compressed);
mc.Tag = Tag.ReadTag(r);
}
return mc;
}
public Packfile(Stream stream, bool isStr2)
{
IsStr2 = isStr2;
stream.Seek(0, SeekOrigin.Begin);
FileData = stream.ReadStruct<PackfileFileData>();
m_Files = new List<IPackfileEntry>();
uint runningPosition = 0;
List<PackfileEntryFileData> entryFileData = new List<PackfileEntryFileData>();
for (int i = 0; i < FileData.NumFiles; i++)
{
PackfileEntryFileData data = stream.ReadStruct<PackfileEntryFileData>();
if (IsCondensed && IsCompressed)
{
data.Flags = 0;
data.Start = runningPosition;
runningPosition += data.Size;
}
else if (IsCondensed)
{
data.Start = runningPosition;
runningPosition += data.Size.Align(16);
}
entryFileData.Add(data);
}
for (int i = 0; i < FileData.NumFiles; i++)
{
stream.Align(2);
string filename = stream.ReadAsciiNullTerminatedString();
stream.Seek(1, SeekOrigin.Current);
m_Files.Add(new PackfileEntry(this, entryFileData[i], filename));
stream.Align(2);
}
if (IsCondensed && IsCompressed)
{
DataOffset = 0;
byte[] compressedData = new byte[FileData.CompressedDataSize];
stream.Read(compressedData, 0, (int)FileData.CompressedDataSize);
using (MemoryStream tempStream = new MemoryStream(compressedData))
{
using (Stream s = new ZlibStream(tempStream, CompressionMode.Decompress, true))
{
byte[] uncompressedData = new byte[FileData.DataSize];
s.Read(uncompressedData, 0, (int)FileData.DataSize);
DataStream = new MemoryStream(uncompressedData);
}
}
}
else
{
DataStream = stream;
DataOffset = stream.Position;
}
}
public void uncompress(Stream inStream, Stream outStream)
{
ZlibStream compressionStream = new ZlibStream(inStream, CompressionMode.Decompress, true);
compressionStream.CopyTo(outStream);
}
/// <summary>
/// Decompress a byte array into another byte array of the specified size
/// </summary>
/// <param name="to_decompress">Data to decompress</param>
/// <param name="size_uncompressed">Size of the data once decompressed</param>
/// <returns>Decompressed data as a byte array</returns>
public static byte[] Decompress(byte[] to_decompress, int size_uncompressed)
{
ZlibStream stream = new ZlibStream(new System.IO.MemoryStream(to_decompress, false), CompressionMode.Decompress);
byte[] packetData_decompressed = new byte[size_uncompressed];
stream.Read(packetData_decompressed, 0, size_uncompressed);
stream.Close();
return packetData_decompressed;
}
public byte[] Decompress(Stream inputStream)
{
using (var zlibStream = new ZlibStream(inputStream, CompressionMode.Decompress))
using (var outputStream = new MemoryStream())
{
zlibStream.WriteTo(outputStream);
return outputStream.ToArray();
}
}
public static byte[] Compress(byte[] input)
{
using (MemoryStream ms = new MemoryStream()) {
using (ZlibStream zls = new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestSpeed)) {
zls.Write(input, 0, input.Length);
}
return ms.ToArray();
}
}
public static byte[] ZlibDecompress(byte[] data)
{
MemoryStream src = new MemoryStream(data);
var fr = new Ionic.Zlib.ZlibStream(src, Ionic.Zlib.CompressionMode.Decompress);
MemoryStream fw = new MemoryStream();
IOTool.CopyStream(fr, fw);
return(fw.ToArray());
}
private void load(BinaryReader binReader)
{
if (binReader != null && binReader.BaseStream != null && binReader.BaseStream.Length > 0 && binReader.BaseStream.CanSeek == true)
{
try
{
binReader.BaseStream.Seek(0, SeekOrigin.Begin);
if (binReader.BaseStream.Length - binReader.BaseStream.Position >= 13)
{
string magic = System.Text.Encoding.UTF8.GetString(binReader.ReadBytes(3));
int version = (int)binReader.ReadInt16();
// usually version == 40
if (magic == "C3D" && version >= 40 && version < 50)
{
int totalLength = (int)binReader.ReadUInt32();
// useless
int totalResLength = (int)binReader.ReadUInt32();
int len = (int)(binReader.BaseStream.Length - binReader.BaseStream.Position);
var rawData = binReader.ReadBytes(len);
// create a seekable memory stream of the file bytes
using (MemoryStream filestream = new MemoryStream())
{
// create a BinaryReader used to read the uf3d file
using (Ionic.Zlib.ZlibStream gzipStream = new Ionic.Zlib.ZlibStream(filestream, Ionic.Zlib.CompressionMode.Decompress, Ionic.Zlib.CompressionLevel.Default, true))
{
gzipStream.Write(rawData, 0, rawData.Length);
gzipStream.Flush();
if (filestream != null && filestream.Length > 0 && filestream.CanSeek == true)
{
// create a BinaryReader used to read the uf3d file
using (binReader = new BinaryReader(filestream))
{
this.loadDataChunk(binReader);
}
ParticleSystemAssembler.Assemble(this);
}
}
}
}
}
}
catch (Exception ex)
{
// clear all
this.ClearAll();
throw ex;
}
}
else
{
this.ClearAll();
throw new Exception(@"Error loading file, could not read file from disk.");
}
}
public void compress(Stream inStream, Stream outStream)
{
ZlibStream compressionStream = new ZlibStream(outStream, CompressionMode.Compress, true);
inStream.CopyTo(compressionStream);
compressionStream.Close();
}
/// <summary>
/// Compress to CompressedData
/// </summary>
public static MemoryStream Compress(byte[] buffer)
{
var output = new MemoryStream();
using (ZlibStream zout = new ZlibStream(output, CompressionMode.Compress))
{
zout.Write(buffer, 0, buffer.Length);
zout.Flush();
}
return output;
}
public static byte[] ZlibDecompress(byte[] input, int length)
{
using (var ms = new System.IO.MemoryStream()) {
using (var compressor = new Ionic.Zlib.ZlibStream(ms, CompressionMode.Decompress, CompressionLevel.BestCompression)) {
compressor.Write(input, 0, length);
}
return(ms.ToArray());
}
}
public static byte[] ZlibCompress(byte[] data)
{
MemoryStream res = new MemoryStream();
var fw = new Ionic.Zlib.ZlibStream(res, Ionic.Zlib.CompressionMode.Compress);
fw.Write(data, 0, data.Length);
fw.Close();
res.Flush();
return(res.ToArray());
}
public static byte[] Decompress(byte[] compressed, int uncompressedSize)
{
using (MemoryStream input = new MemoryStream(compressed))
using (ZlibStream zin = new ZlibStream(input, CompressionMode.Decompress))
{
byte[] uncompressed = new byte[uncompressedSize];
ReadBuffer(zin, uncompressed);
return uncompressed;
}
}
/// <summary>
/// compress a stream<see cref="Stream"/>
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static Stream CompressStream(Stream stream)
{
var result = new MemoryStream();
using (var zlibStream = new ZlibStream(result, CompressionMode.Compress, Ionic.Zlib.CompressionLevel.BestSpeed, true))
{
CopyStream(stream, zlibStream);
}
return result;
}
public static UnmanagedMemory ZibCompress(byte[] input)
{
using (var ms = new TraderMemoryStream(500 * 1024))
{
using (var zs = new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
zs.Write(input, 0, input.Length);
}
return ms.Buffer;
}
}
public void DecompressResponse()
{
if (string.IsNullOrEmpty(this.ZNO))
{
return;
}
MemoryStream compressMetadataCollection = null;
MemoryStream decompressedMetadataCollection = null;
ZlibStream decompressStream = null;
try
{
byte[] compressedMetadataCollectionBytes = Convert.FromBase64String(this.ZNO);
compressMetadataCollection = new MemoryStream(compressedMetadataCollectionBytes);
byte[] buffer = new byte[1024];
int numBytesRead = 0;
bool start = true;
decompressedMetadataCollection = new MemoryStream();
using (decompressStream = new ZlibStream(compressMetadataCollection, CompressionMode.Decompress))
{
while (start || numBytesRead > 0)
{
numBytesRead = decompressStream.Read(buffer, 0, buffer.Length);
if (numBytesRead > 0)
{
decompressedMetadataCollection.Write(buffer, 0, numBytesRead);
}
start = false;
}
}
decompressedMetadataCollection.Position = 0;
DataContractSerializer deserializer = new DataContractSerializer(typeof(CompressedResponseTuple));
CompressedResponseTuple responseTuple = deserializer.ReadObject(decompressedMetadataCollection) as CompressedResponseTuple;
Nodes = responseTuple.Nodes;
Relationships = responseTuple.Relationships;
}
finally
{
if (decompressedMetadataCollection != null)
{
decompressedMetadataCollection.Dispose();
decompressedMetadataCollection = null;
}
}
}
public static Firmware ProcessFirmware(string path)
{
// JavaScriptSerializer serializer = new JavaScriptSerializer();
Console.WriteLine("Read File " + path);
// read the file
StreamReader f = new StreamReader(File.OpenRead(path));
//fw = serializer.Deserialize<Firmware>(f.ReadToEnd());
fw = JSON.Instance.ToObject<Firmware>(f.ReadToEnd());
f.Close();
byte[] data = Convert.FromBase64String(fw.image);
MemoryStream imagems = new MemoryStream(data, true);
ZlibStream decompressionStream = new ZlibStream(imagems, CompressionMode.Decompress);
int size = fw.image_size + (fw.image_size % 4);
fw.imagebyte = new byte[size];
for (int a = 0; a < fw.imagebyte.Length; a++)
{
fw.imagebyte[a] = 0xff;
}
try
{
decompressionStream.Read(fw.imagebyte, 0, fw.image_size);
}
catch { Console.WriteLine("Possible bad file - usualy safe to ignore"); }
Console.WriteLine("image_size {0} size {1}",fw.image_size,size);
BinaryWriter sw = new BinaryWriter(File.Open("px4fw.bin", FileMode.Create));
foreach (byte by in fw.imagebyte)
{
sw.Write(by);
// Console.Write("{0:x2}", by);
}
sw.Close();
// pad image to 4-byte length
//while ((fw.imagebyte.Length % 4) != 0) {
//fw.imagebyte. += b'\x00'
return fw;
}
public static byte ReadCompressedID(byte[] compressed)
{
using (MemoryStream input = new MemoryStream(compressed))
using (ZlibStream zin = new ZlibStream(input, CompressionMode.Decompress))
{
int val = zin.ReadByte();
if (val < 0)
throw new InvalidDataException();
return (byte)val;
}
}
internal static byte[] Compress(byte[] buffer)
{
using (var output = new MemoryStream())
{
using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression))
{
compressor.Write(buffer, 0, buffer.Length);
}
return output.ToArray();
}
}
/// <summary>
/// extract a stream
/// </summary>
/// <param name="decompressed"></param>
/// <returns></returns>
public static Stream ExtractStream(Stream decompressed)
{
decompressed.Seek(0, SeekOrigin.Begin);
var result = new MemoryStream();
using (var zlibStream = new ZlibStream(result, CompressionMode.Decompress, true))
{
CopyStream(decompressed, zlibStream);
return result;
}
}
public static byte[] ZibCompress(byte[] input)
{
using (var ms = new System.IO.MemoryStream())
{
using (var zs = new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
zs.Write(input, 0, input.Length);
}
return ms.ToArray();
}
}
public static byte[] CompressZlib(byte[] bytes)
{
using (var ms = new MemoryStream())
{
using (var zip = new ZlibStream(ms, CompressionMode.Compress, true))
{
zip.Write(bytes, 0, bytes.Length);
}
return ms.ToArray();
}
}
static byte[] ZlibDecompress(byte[] input, int length)
{
using (var ms = new System.IO.MemoryStream())
{
using (var compressor = new Ionic.Zlib.ZlibStream(ms, CompressionMode.Decompress, CompressionLevel.BestCompression))
{
compressor.Write(input, 0, length);
}
return ms.ToArray();
}
}
public static byte[] CompressBuffer(byte[] buffer)
{
byte[] compressed;
using (var input = new MemoryStream(buffer))
using (var compressStream = new MemoryStream())
using (var compressor = new ZlibStream(compressStream, CompressionMode.Compress, CompressionLevel.Default, true))
{
input.CopyTo(compressor);
compressor.Close();
compressed = compressStream.ToArray();
}
return compressed;
}
public static byte[] CompressAndEncode(object input)
{
//https://github.com/fuzeman/rencode-sharp/issues/6
var inputString = Rencode.Encode(input);
byte[] inputBytes = inputString.Select(Convert.ToByte).ToArray();
using (
ZlibStream zStream = new ZlibStream(new MemoryStream(inputBytes), Ionic.Zlib.CompressionMode.Compress,
CompressionLevel.Default))
{
var compressedBytes = zStream.ReadFully();
return compressedBytes;
}
}
protected OffsettableStream Decompress(Stream stream, long offset, int allocsize)
{
stream.Seek(offset, SeekOrigin.Begin);
using (ZlibStream zstream = new ZlibStream(stream, CompressionMode.Decompress, true))
{
OffsettableMemoryStream outstrm = new OffsettableMemoryStream(allocsize);
zstream.CopyTo(outstrm);
outstrm.Position = 0;
TotalSize = (int)zstream.TotalOut;
CompressedSize = (int)zstream.TotalIn;
this.DataLength = TotalSize;
return outstrm;
}
}
/// <summary>
/// Compress a byte array into another bytes array using Zlib compression
/// </summary>
/// <param name="to_compress">Data to compress</param>
/// <returns>Compressed data as a byte array</returns>
public static byte[] Compress(byte[] to_compress)
{
ZlibStream stream = new ZlibStream(new System.IO.MemoryStream(to_compress, false), CompressionMode.Compress);
List<byte> temp_compression_list = new List<byte>();
byte[] b = new byte[1];
while (true)
{
int read = stream.Read(b, 0, 1);
if (read > 0) { temp_compression_list.Add(b[0]); }
else break;
}
stream.Close();
return temp_compression_list.ToArray();
}
public static byte[] DecompressDeflate(byte[] InData)
{
using (MemoryStream ms = new MemoryStream(InData))
{
using (ZlibStream zs = new ZlibStream(ms, CompressionMode.Decompress))
{
using (MemoryStream output = new MemoryStream())
{
zs.CopyTo(output);
return output.ToArray();
}
}
}
}
public static void Decomp(byte[] input, Stream outputStream)
{
using (var zipStream = new ZlibStream(outputStream, CompressionMode.Decompress))
{
using (var inputStream = new MemoryStream(input))
{
byte[] buffer = input.Length > 4096 ? new byte[4096] : new byte[input.Length];
int size;
while ((size = inputStream.Read(buffer, 0, buffer.Length)) != 0)
zipStream.Write(buffer, 0, size);
}
}
}
private byte[] Compress(byte[] a)
{
using (var ms = new System.IO.MemoryStream())
{
using (var compressor =
new Ionic.Zlib.ZlibStream(ms,
CompressionMode.Compress,
CompressionLevel.Level9))
{
compressor.Write(a, 0, a.Length);
}
return(ms.ToArray());
}
}
public static OSD ZDecompressBytesToOsd(byte[] input)
{
OSD osd = null;
using (MemoryStream msSinkUnCompressed = new MemoryStream())
{
using (Ionic.Zlib.ZlibStream zOut = new Ionic.Zlib.ZlibStream(msSinkUnCompressed, CompressionMode.Decompress, true))
{
zOut.Write(input, 0, input.Length);
}
msSinkUnCompressed.Seek(0L, SeekOrigin.Begin);
osd = OSDParser.DeserializeLLSDBinary(msSinkUnCompressed.ToArray());
}
return(osd);
}
public byte[] CompressChunk()
{
//File and body headers ar emanaged outside
//All we do here is to write the compressed tag
using (MemoryStream ms = new MemoryStream())
{
using (ZlibStream compressed = new ZlibStream(ms, CompressionMode.Compress, true))
{
var w = new EndianBinaryWriter(EndianBitConverter.Big, compressed);
Tag.Write(w);
compressed.Flush();
}
return ms.ToArray();
}
}
public static void CopyDecompressed(string inputPath, string outputPath)
{
if (inputPath.ToLowerInvariant() == outputPath.ToLowerInvariant())
{
throw new Exception("The input and output files must be different.");
}
using (var swfStream = new FileStream(inputPath, FileMode.Open, FileAccess.Read))
{
const int headerSize = 8;
var read = 0;
var header = new byte[headerSize];
do
{
read = swfStream.Read(header, read, headerSize - read);
} while (read < headerSize);
switch (header[0])
{
case 0x46:
// already uncompressed - just copy the file
using (var outStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
{
outStream.Write(header, 0, headerSize);
swfStream.CopyTo(outStream);
}
break;
case 0x43:
using (var outStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
{
header[0] = 0x46;
outStream.Write(header, 0, headerSize);
using (var decompressed = new ZlibStream(swfStream, CompressionMode.Decompress))
{
decompressed.CopyTo(outStream);
}
}
break;
case 0x5A:
throw new Exception("LZMA compression is not supported (yet).");
default:
throw new Exception(string.Format("Unexpected compression type: 0x{0:x2}", header[0]));
}
}
}
public static OSD ZCompressOSD(OSD inOsd, bool useHeader)
{
OSD osd = null;
using (MemoryStream msSinkCompressed = new MemoryStream())
{
using (Ionic.Zlib.ZlibStream zOut = new Ionic.Zlib.ZlibStream(msSinkCompressed,
Ionic.Zlib.CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
CopyStream(new MemoryStream(OSDParser.SerializeLLSDBinary(inOsd, useHeader)), zOut);
zOut.Close();
}
msSinkCompressed.Seek(0L, SeekOrigin.Begin);
osd = OSD.FromBinary(msSinkCompressed.ToArray());
}
return(osd);
}
public static OSD ZCompressOSD(OSD inOsd, bool useHeader)
{
OSD osd = null;
byte[] data = OSDParser.SerializeLLSDBinary(inOsd, useHeader);
using (MemoryStream msSinkCompressed = new MemoryStream())
{
using (Ionic.Zlib.ZlibStream zOut = new Ionic.Zlib.ZlibStream(msSinkCompressed,
Ionic.Zlib.CompressionMode.Compress, CompressionLevel.BestCompression, true))
{
zOut.Write(data, 0, data.Length);
}
msSinkCompressed.Seek(0L, SeekOrigin.Begin);
osd = OSD.FromBinary(msSinkCompressed.ToArray());
}
return(osd);
}
/// <summary>
/// Uncompress a byte array into a byte array.
/// </summary>
/// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
/// <seealso cref="ZlibStream.UncompressString(byte[])"/>
/// <param name="compressed">
/// A buffer containing ZLIB-compressed data.
/// </param>
public static byte[] UncompressBuffer(byte[] compressed)
{
// workitem 8460
byte[] working = new byte[1024];
using (var output = new MemoryStream())
{
using (var input = new MemoryStream(compressed))
{
using (Stream decompressor = new ZlibStream(input, CompressionMode.Decompress))
{
int n;
while ((n = decompressor.Read(working, 0, working.Length)) != 0)
{
output.Write(working, 0, n);
}
}
return(output.ToArray());
}
}
}
public static byte[] UncompressBuffer(byte[] compressed)
{
byte[] buffer2;
byte[] buffer = new byte[0x400];
using (MemoryStream stream = new MemoryStream())
{
using (MemoryStream stream2 = new MemoryStream(compressed))
{
using (Stream stream3 = new ZlibStream(stream2, CompressionMode.Decompress))
{
int num;
while ((num = stream3.Read(buffer, 0, buffer.Length)) != 0)
{
stream.Write(buffer, 0, num);
}
}
buffer2 = stream.ToArray();
}
}
return(buffer2);
}
