/// <summary>
/// Closes the stream.
/// </summary>
protected override void Dispose(bool disposing)
{
if (_mode == CompressionMode.Decompress)
{
// Can only check Adler checksum on seekable streams. Since DeflateStream
// aggresively caches input, it normally has already consumed the footer.
if (_stream.CanSeek)
{
_stream.Seek(-4, SeekOrigin.End);
byte[] footerBuffer = StreamUtilities.ReadExact(_stream, 4);
if (EndianUtilities.ToInt32BigEndian(footerBuffer, 0) != _adler32.Value)
{
throw new InvalidDataException("Corrupt decompressed data detected");
}
}
_deflateStream.Dispose();
}
else
{
_deflateStream.Dispose();
byte[] footerBuffer = new byte[4];
EndianUtilities.WriteBytesBigEndian(_adler32.Value, footerBuffer, 0);
_stream.Write(footerBuffer, 0, 4);
}
base.Dispose(disposing);
}
[Category("StaticLinkedAotNotWorking")] // Native MPH loading issues
public void DisposeTest()
{
MemoryStream backing = new MemoryStream(compressed_data);
DeflateStream decompress = new DeflateStream(backing, CompressionMode.Decompress);
decompress.Dispose();
decompress.Dispose();
}
public void DoubleDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Dispose();
ds.Dispose();
}
public void CanDisposeDeflateStream()
{
var ms = new MemoryStream();
var zip = new DeflateStream(ms, CompressionMode.Compress);
zip.Dispose();
// Base Stream should be null after dispose
Assert.Null(zip.BaseStream);
zip.Dispose(); // Should be a no-op
}
internal override void Dispose(bool disposing)
{
if (!_isDisposed)
{
if (disposing)
{
_connectCancelToken?.Dispose();
(WebSocketClient as IDisposable)?.Dispose();
_decompressor?.Dispose();
_compressed?.Dispose();
}
_isDisposed = true;
}
}
public override byte[] EndCompress()
{
m_Deflate.Dispose();
m_Deflate = null;
try
{
return(m_Memory.ToArray());
}
finally
{
m_Memory.Position = 0;
m_Memory.SetLength(0);
}
}
public byte[] ReadAt(int pos, int cnt)
{
EnsureReadMode();
int end = pos + cnt - 1;
if (pos < 0 || end > OriginalSize)
{
throw new ArgumentOutOfRangeException();
}
int startIdx = pos / ExtraField.ChunkSize;
int offset = pos % ExtraField.ChunkSize;
int endIdx = end / ExtraField.ChunkSize;
if (startIdx != _lastStart || endIdx != _lastEnd || _buf == null)
{
_lastStart = startIdx;
_lastEnd = endIdx;
_buf = new byte[(endIdx - startIdx + 1) * ExtraField.ChunkSize];
//read chunks
for (int i = startIdx; i <= endIdx; ++i)
{
FileStream.Position = _dataBegin + ExtraField.Indices[i];
DeflateStream.Dispose();
DeflateStream = new DeflateStream(FileStream, CompressionMode.Decompress, true);
//If I keep using the same deflatestream the data will become corrupted
//when crossing chunks, I don't no why :(
Read(_buf, (i - startIdx) * ExtraField.ChunkSize, ExtraField.ChunkSize);
}
}
byte[] res = new byte[cnt];
Buffer.BlockCopy(_buf, offset, res, 0, cnt);
return(res);
}
public virtual void Close()
{
if (!initdone)
{
doInit(); // can happen if never called write
}
if (closed)
{
return;
}
closed = true;
if (deflateStream != null)
{
deflateStream.Dispose();
}
if (crcread == null) // eat trailing 4 bytes
{
crcread = new byte[4];
for (int i = 0; i < 4; i++)
{
crcread[i] = (byte)rawStream.ReadByte();
}
}
if (!leaveOpen)
{
rawStream.Dispose();
}
}
void HandleLevelFinalise()
{
game.SetNewScreen(null);
game.activeScreen = prevScreen;
if (prevScreen != null)
{
game.CursorVisible = prevCursorVisible;
}
prevScreen = null;
int mapWidth = reader.ReadInt16();
int mapHeight = reader.ReadInt16();
int mapLength = reader.ReadInt16();
double loadingMs = (DateTime.UtcNow - receiveStart).TotalMilliseconds;
Utils.LogDebug("map loading took:" + loadingMs);
game.Map.SetData(map, mapWidth, mapHeight, mapLength);
game.MapEvents.RaiseOnNewMapLoaded();
map = null;
gzipStream.Dispose();
if (sendWomId && !sentWomId)
{
SendChat("/womid WoMClient-2.0.7", false);
sentWomId = true;
}
gzipStream = null;
ServerName = null;
ServerMotd = null;
GC.Collect();
}
protected override void Dispose(bool disposing)
{
if (!initdone)
{
doInit();
}
if (!closed)
{
closed = true;
if (deflateStream != null)
{
deflateStream.Dispose();
}
else
{
rawStream.WriteByte(3);
rawStream.WriteByte(0);
}
uint value = adler32.GetValue();
rawStream.WriteByte((byte)((value >> 24) & 0xFF));
rawStream.WriteByte((byte)((value >> 16) & 0xFF));
rawStream.WriteByte((byte)((value >> 8) & 0xFF));
rawStream.WriteByte((byte)(value & 0xFF));
if (!leaveOpen)
{
rawStream.Dispose();
}
}
}
protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
try
{
if (disposing)
{
var output = m_stream.BaseStream;
m_stream.Dispose();
if (m_writing)
{
WriteCheckSum(output);
m_adler.Dispose();
}
if (m_should_dispose_base)
{
output.Dispose();
}
}
m_disposed = true;
}
finally
{
base.Dispose(disposing);
}
}
}
protected override void Dispose(bool disposing)
{
if (isDisposed)
{
return;
}
if (disposing)
{
if (deflateStream != null)
{
deflateStream.Dispose();
deflateStream = null;
}
else
{
rawStream.WriteByte(3);
rawStream.WriteByte(0);
}
uint crc = (uint)adler32.Value;
rawStream.WriteByte((byte)((crc >> 24) & 0xFF));
rawStream.WriteByte((byte)((crc >> 16) & 0xFF));
rawStream.WriteByte((byte)((crc >> 8) & 0xFF));
rawStream.WriteByte((byte)((crc) & 0xFF));
}
base.Dispose(disposing);
isDisposed = true;
}
void HandleLevelFinalise()
{
net.task.Interval = 1.0 / 20;
game.Gui.SetNewScreen(null);
game.Gui.activeScreen = prevScreen;
if (prevScreen != null && prevCursorVisible != game.CursorVisible)
{
game.CursorVisible = prevCursorVisible;
}
prevScreen = null;
int mapWidth = reader.ReadUInt16();
int mapHeight = reader.ReadUInt16();
int mapLength = reader.ReadUInt16();
double loadingMs = (DateTime.UtcNow - mapReceiveStart).TotalMilliseconds;
Utils.LogDebug("map loading took: " + loadingMs);
#if USE16_BIT
game.World.SetNewMap(Utils.UInt8sToUInt16s(map), mapWidth, mapHeight, mapLength);
#else
game.World.SetNewMap(map, mapWidth, mapHeight, mapLength);
#endif
game.WorldEvents.RaiseOnNewMapLoaded();
map = null;
gzipStream.Dispose();
net.wom.CheckSendWomID();
gzipStream = null;
GC.Collect();
}
protected override void Dispose(bool disposing)
{
if (isDisposed)
{
return;
}
if (disposing)
{
if (deflateStream != null)
{
deflateStream.Dispose();
deflateStream = null;
if (crcread == null)
{
crcread = new byte[4];
for (int i = 0; i < 4; i++)
{
crcread[i] = (byte)rawStream.ReadByte();
}
}
}
}
base.Dispose(disposing);
isDisposed = true;
}
/// <summary>
/// Decompresses the data.
/// </summary>
/// <param name="data">The data.</param>
/// <returns>
/// The <see cref="T:byte[]"/>.
/// </returns>
private byte[] Decompress(byte[] data)
{
if (data == null || data.Length == 0)
{
return(null);
}
DeflateStream deflateStream = null;
try
{
MemoryStream input = new MemoryStream(data);
using (MemoryStream output = new MemoryStream())
{
deflateStream = new DeflateStream(input, CompressionMode.Decompress);
deflateStream.CopyTo(output);
byte[] result = output.ToArray();
return(result);
}
}
finally
{
deflateStream?.Dispose();
}
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Stream compressedStream = null;
switch (_encondingType)
{
case "gzip":
compressedStream = new GZipStream(stream, CompressionMode.Compress, true);
break;
case "deflate":
compressedStream = new DeflateStream(stream, CompressionMode.Compress, true);
break;
default:
break;
}
return(_originalContent.CopyToAsync(compressedStream).ContinueWith(tsk =>
{
if (compressedStream != null)
{
compressedStream.Dispose();
}
}));
}
/// <summary>
/// Closes and disposes of any open streams.
/// </summary>
internal void Close()
{
_deflateCompressStream?.Dispose();
_deflateDecompressStream?.Dispose();
_multipleMessagesStream?.Dispose();
_zstdDecompressStream?.Dispose();
}
public void DeflateStreamVsNoCompression()
{
byte[] bytesToCompress = Encoding.Default.GetBytes(Text.LoremIpsum);
Console.WriteLine("Enum.ToObject vs DynamicMethod");
MemoryStream targetStream = new MemoryStream();
DeflateStream deflateStream = new DeflateStream(targetStream, CompressionMode.Compress, true);
int iterations = 1000;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < iterations; i++)
{
deflateStream.Write(bytesToCompress, 0, bytesToCompress.Length);
targetStream.WriteByte(0);
}
stopwatch.Stop();
deflateStream.Close();
deflateStream.Dispose();
long compressDuration = stopwatch.ElapsedMilliseconds;
stopwatch.Reset();
stopwatch.Start();
for (int i = 0; i < iterations; i++)
{
targetStream.Write(bytesToCompress, 0, bytesToCompress.Length);
}
stopwatch.Stop();
long noCompressDuration = stopwatch.ElapsedMilliseconds;
Console.WriteLine("Using compression: {0}", compressDuration);
Console.WriteLine("Using no compression: {0}", noCompressDuration);
Console.WriteLine("Performance gain: {0:0.00}%", this.CalculatePerformanceGain(compressDuration, compressDuration));
}
/// <summary> </summary>
public static byte[] Decompress(byte[] datas, int len)
{
MemoryStream stream = new MemoryStream(datas);
DeflateStream zlib = new DeflateStream(stream, CompressionMode.Decompress);
int unk_byte = stream.ReadByte();
int zCMF = stream.ReadByte();
int zFLG = stream.ReadByte();
if ((zCMF & 0xF) != Z_DEFLATE)
{
throw new InvalidDataException("Not 'Deflate' method.");
}
if (zCMF != 0x78)
{
throw new InvalidDataException("Invalid CMF.");
}
if ((zFLG & 0x20) != 0)
{
throw new InvalidDataException("FLG 'Directory preset' is true.");
}
byte[] rtn = new byte[len];
zlib.Read(rtn, 0, len);
zlib.Dispose();
stream.Dispose();
return(rtn);
}
public override void Dispose()
{
if (!IsCreating)
{
base.Dispose();
}
else
{
if (_chOffset > 0)
{
ChunkDone();
}
DeflateStream.Dispose();
_temp.Dispose();
ExtraField.Finish();
FileStream.Seek(0, SeekOrigin.End);
WriteNameComment();
using (FileStream temp = File.OpenRead(_tempName))
{
temp.CopyTo(FileStream);
}
WriteFooter();
FileStream.Dispose();
File.Delete(_tempName);
}
}
protected override void Dispose(bool disposing)
{
if (!initdone)
{
doInit();
}
if (closed)
{
return;
}
closed = true;
if (deflateStream != null)
{
deflateStream.Dispose();
}
if (crcread == null)
{
crcread = new byte[4];
for (int i = 0; i < 4; i++)
{
crcread[i] = (byte)rawStream.ReadByte();
}
}
if (!leaveOpen)
{
rawStream.Dispose();
}
}
protected override void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (!initdone)
{
doInit(); // can happen if never called write
}
if (closed)
{
return;
}
closed = true;
if (deflateStream != null)
{
deflateStream.Dispose();
}
if (crcread == null)
{ // eat trailing 4 bytes
crcread = new byte[4];
for (int i = 0; i < 4; i++)
{
crcread[i] = (byte)rawStream.ReadByte();
}
}
if (!leaveOpen)
{
rawStream.Dispose();
}
base.Dispose(disposing);
}
/// <summary>
/// Compresses the input stream to the output stream.
/// </summary>
/// <param name="inputStream">The input stream to compress.</param>
/// <param name="inputStream">The output stream to write to.</param>
/// <param name="compressionType">Type of the compression.</param>
/// <returns></returns>
public void Compress(Stream inputStream, Stream outputStream, CompressionType compressionType)
{
long intialPosition = inputStream.Position;
Stream compressionStream = null;
try
{
switch (compressionType)
{
case CompressionType.Gzip:
compressionStream = new GZipStream(outputStream, CompressionMode.Compress, leaveOpen: true);
break;
case CompressionType.Deflate:
compressionStream = new DeflateStream(outputStream, CompressionMode.Compress, leaveOpen: true);
break;
default:
throw new ArgumentOutOfRangeException(nameof(compressionType), compressionType, null);
}
inputStream.CopyTo(compressionStream);
}
finally
{
compressionStream?.Dispose();
inputStream.Position = intialPosition;
}
}
public virtual void Close()
{
if (!initdone)
{
doInit(); // can happen if never called write
}
if (closed)
{
return;
}
closed = true;
// sigh ... no only must I close the parent stream to force a flush, but I must save a reference
// raw stream because (apparently) Close() sets it to null (shame on you, MS developers)
if (deflateStream != null)
{
deflateStream.Dispose();
}
else // second hack: empty input?
{
rawStream.WriteByte(3);
rawStream.WriteByte(0);
}
// add crc
uint crcv = adler32.GetValue();
rawStream.WriteByte((byte)((crcv >> 24) & 0xFF));
rawStream.WriteByte((byte)((crcv >> 16) & 0xFF));
rawStream.WriteByte((byte)((crcv >> 8) & 0xFF));
rawStream.WriteByte((byte)((crcv) & 0xFF));
if (!leaveOpen)
{
rawStream.Dispose();
}
}
byte[] DecompressEntry(BinaryReader reader, ushort compressionMethod, int compressedSize, int uncompressedSize)
{
if (compressionMethod == 0) // Store/Raw
{
return(reader.ReadBytes(uncompressedSize));
}
else if (compressionMethod == 8) // Deflate
{
byte[] data = new byte[uncompressedSize];
byte[] compressedData = reader.ReadBytes(compressedSize);
MemoryStream stream = new MemoryStream(compressedData);
int index = 0, read = 0;
DeflateStream inflater = new DeflateStream(stream, CompressionMode.Decompress);
while (index < uncompressedSize &&
(read = inflater.Read(data, index, data.Length - index)) > 0)
{
index += read;
}
inflater.Dispose();
return(data);
}
else
{
Utils.LogDebug("Unsupported .zip entry compression method: " + compressionMethod);
reader.ReadBytes(compressedSize);
return(null);
}
}
internal void Read()
{
try
{
using (FileStream fileStream = File.OpenRead(this.Name))
{
using (DeflateStream deflateStream = new DeflateStream(fileStream, CompressionMode.Decompress))
{
using (BinaryReader binaryReader = new BinaryReader(deflateStream))
{
int num = (int)binaryReader.ReadByte();
for (int i = 0; i < num; i++)
{
this.AddFile(binaryReader.ReadString(), binaryReader.ReadBytes(binaryReader.ReadInt32()));
}
}
deflateStream.Dispose();
}
}
}
catch
{
this.InvalidFile = true;
}
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Stream compressedStream;
switch (_compressionMethod)
{
case CompressionMethod.GZip:
compressedStream = new GZipStream(stream, CompressionMode.Compress, true);
break;
case CompressionMethod.Deflate:
compressedStream = new DeflateStream(stream, CompressionMode.Compress, true);
break;
case CompressionMethod.None:
default:
throw new ArgumentOutOfRangeException();
}
return(_originalContent.CopyToAsync(compressedStream, context)
.ContinueWith(_ => compressedStream?.Dispose(),
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default));
}
public override void NetSend(BinaryWriter trueWriter, bool lightSend)
{
/* Recreate a BinaryWriter writer */
MemoryStream buffer = new MemoryStream(65536);
DeflateStream compressor = new DeflateStream(buffer, CompressionMode.Compress, true);
BufferedStream writerBuffer = new BufferedStream(compressor, 65536);
BinaryWriter writer = new BinaryWriter(writerBuffer);
/* Original code */
base.NetSend(writer, lightSend);
if (netQueue.Count > Capacity / 2 || !lightSend)
{
netQueue.Clear();
netQueue.Enqueue(UnitOperation.FullSync.Create());
}
writer.Write((ushort)netQueue.Count);
while (netQueue.Count > 0)
{
netQueue.Dequeue().Send(writer, this);
}
/* Forces data to be flushed into the compressed buffer */
writerBuffer.Flush(); compressor.Close();
/* Sends the buffer through the network */
trueWriter.Write((ushort)buffer.Length);
trueWriter.Write(buffer.ToArray());
/* Dispose all objects */
writer.Dispose(); writerBuffer.Dispose(); compressor.Dispose(); buffer.Dispose();
}
public void Dispose()
{
ZipStream.Flush();
ZipStream.Close();
ZipStream.Dispose();
FileStream.Dispose();
}
private MemoryStream CompressCache()
{
// small arrays almost never yeild a benefit from compressing
if (cache.Length < 50)
{
return(null);
}
byte[] cacheBytes = cache.GetBuffer();
MemoryStream compressedBuffer = new MemoryStream();
compressedBuffer.WriteByte(0x78);
compressedBuffer.WriteByte(0x9c);
var outCompStream = new DeflateStream(compressedBuffer, CompressionMode.Compress, true);
outCompStream.Write(cacheBytes, 0, (int)cache.Length);
outCompStream.Dispose();
int adler = IPAddress.HostToNetworkOrder(Adler32(cacheBytes, 0, (int)cache.Length));
compressedBuffer.Write(BitConverter.GetBytes(adler), 0, sizeof(uint));
// if the compression hasn't helped, then just return null
if (compressedBuffer.Length >= cache.Length)
{
return(null);
}
return(compressedBuffer);
}
public void CompressCanWrite()
{
var ms = new MemoryStream();
var zip = new DeflateStream(ms, CompressionMode.Compress);
Assert.True(zip.CanWrite);
zip.Dispose();
Assert.False(zip.CanWrite);
}
public void DecompressCanRead()
{
var ms = new MemoryStream();
var zip = new DeflateStream(ms, CompressionMode.Decompress);
Assert.True(zip.CanRead);
zip.Dispose();
Assert.False(zip.CanRead);
}
public async Task CanReadBaseStreamAfterDispose()
{
var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
var newMs = StripHeaderAndFooter.Strip(ms);
var zip = new DeflateStream(newMs, CompressionMode.Decompress, true);
var baseStream = zip.BaseStream;
zip.Dispose();
int size = 1024;
byte[] bytes = new byte[size];
baseStream.Read(bytes, 0, size); // This will throw if the underlying stream is not writable as expected
baseStream.Position = 0;
await baseStream.ReadAsync(bytes, 0, size);
}
public void CanDisposeDeflateStream()
{
var ms = new MemoryStream();
var zip = new DeflateStream(ms, CompressionMode.Compress);
zip.Dispose();
// Base Stream should be null after dispose
Assert.Null(zip.BaseStream);
zip.Dispose(); // Should be a no-op
}
public void CopyToAsyncArgumentValidation()
{
using (DeflateStream ds = new DeflateStream(new MemoryStream(), CompressionMode.Decompress))
{
Assert.Throws<ArgumentNullException>("destination", () => { ds.CopyToAsync(null); });
Assert.Throws<ArgumentOutOfRangeException>("bufferSize", () => { ds.CopyToAsync(new MemoryStream(), 0); });
Assert.Throws<NotSupportedException>(() => { ds.CopyToAsync(new MemoryStream(new byte[1], writable: false)); });
ds.Dispose();
Assert.Throws<ObjectDisposedException>(() => { ds.CopyToAsync(new MemoryStream()); });
}
using (DeflateStream ds = new DeflateStream(new MemoryStream(), CompressionMode.Compress))
{
Assert.Throws<NotSupportedException>(() => { ds.CopyToAsync(new MemoryStream()); });
}
}
public async Task FlushAsyncFailsAfterDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Dispose();
await Assert.ThrowsAsync<ObjectDisposedException>(async () =>
{
await ds.FlushAsync();
});
}
public void FlushFailsAfterDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Dispose();
Assert.Throws<ObjectDisposedException>(() => { ds.Flush(); });
}
public void FlushThenDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Flush();
ds.Dispose();
}
public void DoubleDispose()
{
var ms = new MemoryStream();
var ds = new DeflateStream(ms, CompressionMode.Compress);
ds.Dispose();
ds.Dispose();
}
public async Task DecompressFailsWithRealGzStream()
{
string[] files = { gzTestFile("GZTestDocument.doc.gz"), gzTestFile("GZTestDocument.txt.gz") };
foreach (string fileName in files)
{
var baseStream = await LocalMemoryStream.readAppFileAsync(fileName);
var zip = new DeflateStream(baseStream, CompressionMode.Decompress);
int _bufferSize = 2048;
var bytes = new byte[_bufferSize];
Assert.Throws<InvalidDataException>(() => { zip.Read(bytes, 0, _bufferSize); });
zip.Dispose();
}
}
public override void FromXML(XmlNode node)
{
if (node != null && node.Name == "layer")
{
XmlAttributeCollection attrs = node.Attributes;
m_name = attrs["name"].Value;
m_layerDimensions.first = Convert.ToInt32(attrs["width"].Value);
m_layerDimensions.second = Convert.ToInt32(attrs["height"].Value);
foreach(XmlNode child in node.ChildNodes)
{
if (child.Name == "properties")
{
foreach (XmlNode propertyNode in child)
{
if (propertyNode.Name != "property")
continue;
XmlAttributeCollection propertyAtts = propertyNode.Attributes;
m_properties[propertyAtts["name"].Value] = propertyAtts["value"].Value;
}
}
else if (child.Name == "data")
{
m_data = new TileData();
attrs = child.Attributes;
if (attrs["encoding"]!= null)
{
string[] encodings = { "", "csv", "base64" };
string encodingValue = attrs["encoding"].Value;
int encodingIdx = Array.IndexOf(encodings, encodingValue);
if (encodingIdx >= 0)
{
m_data.m_encoding = (TileEncodingType)encodingIdx;
}
string[] compressions = { "", "gzip", "zlib" };
string compression = attrs["compression"].Value;
int compressionIdx = Array.IndexOf(compressions, compression);
if (compressionIdx >= 0)
{
m_data.m_compression = (TileCompressionType)compressionIdx;
}
switch(m_data.m_encoding)
{
case TileEncodingType.kCSV:
{
string text = child.InnerText;
string[] values = text.Split(',');
foreach (string v in values)
{
uint value = Convert.ToUInt32(v);
TileInfo info = new TileInfo();
info.m_horizontalFlip = (value & FLIPPED_HORIZONTALLY_FLAG) != 0;
info.m_verticalFlip = (value & FLIPPED_VERTICALLY_FLAG) != 0;
info.m_diagonalFlip = (value & FLIPPED_DIAGONALLY_FLAG) != 0;
value = value & ~(FLIPPED_DIAGONALLY_FLAG | FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG);
info.m_gid = value;
m_data.m_tiles.Add(info);
}
break;
}
case TileEncodingType.kBase64:
{
byte[] bytes = null;
switch(m_data.m_compression)
{
case TileCompressionType.kNone:
{
bytes = Convert.FromBase64String(child.InnerText);
break;
}
case TileCompressionType.kGzip:
{
//Transform string into byte[]
string str = child.InnerText;
byte[] byteArray = new byte[str.Length];
int indexBA = 0;
foreach (char item in str.ToCharArray())
{
byteArray[indexBA++] = (byte)item;
}
MemoryStream ms = new MemoryStream(byteArray);
GZipStream gzip = new GZipStream(ms, CompressionMode.Decompress);
byteArray = new byte[byteArray.Length];
int rBytes = gzip.Read(byteArray, 0, byteArray.Length);
StringBuilder sb = new StringBuilder(rBytes);
for (int i = 0; i < rBytes; ++i)
{
sb.Append((char)byteArray[i]);
}
gzip.Close();
ms.Close();
gzip.Dispose();
ms.Dispose();
bytes = Convert.FromBase64String(sb.ToString());
break;
}
case TileCompressionType.kZlib:
{
//Transform string into byte[]
string str = child.InnerText;
byte[] byteArray = new byte[str.Length];
int indexBA = 0;
foreach (char item in str.ToCharArray())
{
byteArray[indexBA++] = (byte)item;
}
MemoryStream ms = new MemoryStream(byteArray);
DeflateStream zlib = new DeflateStream(ms, CompressionMode.Decompress);
byteArray = new byte[byteArray.Length];
int rBytes = zlib.Read(byteArray, 0, byteArray.Length);
StringBuilder sb = new StringBuilder(rBytes);
for (int i = 0; i < rBytes; ++i)
{
sb.Append((char)byteArray[i]);
}
zlib.Close();
ms.Close();
zlib.Dispose();
ms.Dispose();
bytes = Convert.FromBase64String(sb.ToString());
break;
}
}
for (int i = 0; i < bytes.Length; i += 4)
{
uint value = (uint)bytes[i] | ((uint)bytes[i + 1] << 8) | ((uint)bytes[i + 2] << 16) | ((uint)bytes[i + 3] << 24);
TileInfo info = new TileInfo();
info.m_horizontalFlip = (value & FLIPPED_HORIZONTALLY_FLAG) != 0;
info.m_verticalFlip = (value & FLIPPED_VERTICALLY_FLAG) != 0;
info.m_diagonalFlip = (value & FLIPPED_DIAGONALLY_FLAG) != 0;
value = value & ~(FLIPPED_DIAGONALLY_FLAG | FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG);
info.m_gid = value;
m_data.m_tiles.Add(info);
}
break;
}
default:
{
break;
}
}
}
else
{
m_data.m_encoding = TileEncodingType.kNone;
m_data.m_compression = TileCompressionType.kNone;
m_data.m_tiles.Clear();
foreach(XmlNode tileNode in child.ChildNodes)
{
if (tileNode.Name != "tile")
{
continue;
}
TileInfo info = new TileInfo();
uint value = Convert.ToUInt32(tileNode.Attributes["gid"].Value);
info.m_horizontalFlip = (value & FLIPPED_HORIZONTALLY_FLAG) != 0;
info.m_verticalFlip = (value & FLIPPED_VERTICALLY_FLAG) != 0;
info.m_diagonalFlip = (value & FLIPPED_DIAGONALLY_FLAG) != 0;
value = value & ~(FLIPPED_DIAGONALLY_FLAG | FLIPPED_HORIZONTALLY_FLAG |FLIPPED_VERTICALLY_FLAG);
info.m_gid = value;
m_data.m_tiles.Add(info);
}
}
}
}
}
}
