/// <summary>
/// 拷贝流
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
private static void CopyStream(MemoryStream input, ZOutputStream output)
{
byte[] buffer = new byte[2000];
int len;
while ((len = input.Read(buffer, 0, 2000)) > 0)
{
output.Write(buffer, 0, len);
}
output.Flush();
}
/// <summary>
/// Compresses the given <paramref name="input" />
/// </summary>
/// <param name="input">The data to compress</param>
/// <returns></returns>
public static byte[] Compress(byte[] input)
{
var sourceStream = new MemoryStream();
var stream = new ZOutputStream(sourceStream, -1);
// write zlib header
stream.Write(input);
stream.Finish();
return(sourceStream.GetBuffer());
}
public static void DecompressData(byte[] inData, out byte[] outData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
outData = outMemoryStream.ToArray();
}
}
internal CmsCompressedOutputStream(
ZOutputStream outStream,
BerSequenceGenerator sGen,
BerSequenceGenerator cGen,
BerSequenceGenerator eiGen)
{
_out = outStream;
_sGen = sGen;
_cGen = cGen;
_eiGen = eiGen;
}
public byte[] DecompressData(byte[] inData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
{
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
{
outZStream.Write(inData, 0, inData.Length);
return(outMemoryStream.ToArray());
}
}
}
public static byte[] Decompress(byte[] zippedData)
{
using (var outMemoryStream = new MemoryStream())
using (var outZStream = new ZOutputStream(outMemoryStream))
using (var inMemoryStream = new MemoryStream(zippedData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
public static byte[] Compress(byte[] rawData)
{
using (var outMemoryStream = new MemoryStream())
using (var outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
using (var inMemoryStream = new MemoryStream(rawData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
public byte[] Compress(byte[] datas)
{
using (var outMemoryStream = new MemoryStream())
using (var outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
using (Stream inMemoryStream = new MemoryStream(datas))
{
CopyTo(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
public byte[] Decompress(byte[] datas)
{
using (var outMemoryStream = new MemoryStream())
using (var outZStream = new ZOutputStream(outMemoryStream))
using (Stream inMemoryStream = new MemoryStream(datas))
{
CopyTo(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
public static void CompressData(byte[] inData, out byte[] outData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
outData = outMemoryStream.ToArray();
}
}
private static byte[] Decompress(byte[] inData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
/// <summary>
/// Deflate a string using zlib.net library since IronRuby's Deflate module is buggy, f**k
/// </summary>
/// <param name="data">The string to compress</param>
/// <returns>The decompressed string as a Ruby string</returns>
public static MutableString ZlibDeflate(string data)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_BEST_COMPRESSION))
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
outZStream.Write(bytes, 0, bytes.Length);
outZStream.finish();
return(MutableString.CreateBinary(outMemoryStream.ToArray()));
}
}
private static byte[] Compress(byte[] inData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
private void StoreLayerDataBase64(List <int> tileIndices, XmlWriter xmlWriter, string dataCompression)
{
byte[] tileBytes = ConvertTileIndicesToBytes(tileIndices);
if (dataCompression == "none")
{
string base64Data = Convert.ToBase64String(tileBytes);
xmlWriter.WriteString(base64Data);
}
else if (dataCompression == "gzip")
{
MemoryStream inMemoryStream = new MemoryStream(tileBytes);
MemoryStream outMemoryStream = new MemoryStream();
GZipStream outGZipStream = new GZipStream(outMemoryStream, CompressionMode.Compress);
byte[] buffer = new byte[1024];
while (true)
{
int bytesRead = inMemoryStream.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
break;
}
outGZipStream.Write(buffer, 0, bytesRead);
}
outGZipStream.Close();
byte[] compressedBytes = outMemoryStream.ToArray();
string base64Data = Convert.ToBase64String(compressedBytes);
xmlWriter.WriteString(base64Data);
}
else if (dataCompression == "zlib")
{
MemoryStream inMemoryStream = new MemoryStream(tileBytes);
MemoryStream outMemoryStream = new MemoryStream();
ZOutputStream zOutputStream = new ZOutputStream(outMemoryStream, 9);
byte[] buffer = new byte[1024];
while (true)
{
int bytesRead = inMemoryStream.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
break;
}
zOutputStream.Write(buffer, 0, bytesRead);
}
zOutputStream.Close();
byte[] compressedBytes = outMemoryStream.ToArray();
string base64Data = Convert.ToBase64String(compressedBytes);
xmlWriter.WriteString(base64Data);
}
}
public static byte[] Uncompress(byte[] datas)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
using (Stream inMemoryStream = new MemoryStream(datas))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
return(outMemoryStream.ToArray());
}
}
public void CopyStream(Stream input, ZOutputStream output)
{
// Read compressed data and send it to the decompressor
var buffer = new byte[2000];
int len;
while ((len = input.Read(buffer, 0, 2000)) > 0)
{
output.Write(buffer, 0, len);
}
output.Flush();
}
public Stream Decompress(Stream sourceStream)
{
outputStream.SetLength(0);
//解压
ZOutputStream zStream = new ZOutputStream(outputStream);
CopyStream(sourceStream, zStream);
sourceStream.SetLength(0);
outputStream.Position = 0;
CopyStream(outputStream, sourceStream);
return(sourceStream);
}
/// <summary>
/// Compresses the data array.
/// </summary>
/// <param name="data">The data to compress.</param>
/// <returns>The compressed data.</returns>
private static byte[] CompressData(byte[] data)
{
using (var compressedStream = new MemoryStream())
{
using (var outputStream = new ZOutputStream(compressedStream, zlibConst.Z_DEFAULT_COMPRESSION))
{
outputStream.Write(data, 0, data.Length);
}
return(compressedStream.ToArray());
}
}
public static byte[] Decompress(byte[] data, int size)
{
byte[] output = new byte[size];
ZOutputStream zos = new ZOutputStream(new MemoryStream(output));
try
{
CopyStream(new MemoryStream(data), zos, size);
}
catch { throw new Exception("Invalid zlib data"); }
return(output);
}
internal static void CompressData(Stream inData, Stream outData, int CompressLevel = 9)
{
MemoryStream tmp = new MemoryStream();
ZOutputStream outZStream = new ZOutputStream(tmp, CompressLevel);
CopyStream(inData, outZStream);
outZStream.Finish();
tmp.Position = 0;
CopyStream(tmp, outData);
outZStream.Close();
tmp.Close();
}
public static byte[] DecompressBytes(byte[] inData)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream))
using (Stream inMemoryStream = new MemoryStream(inData))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
outMemoryStream.Seek(0, SeekOrigin.Begin);
return(outMemoryStream.ToArray());
}
}
public void writeCompressedRaw(byte[] bytes)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream compress = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION))
{
compress.Write(bytes, 0, bytes.Length);
compress.finish();
byte[] data = outMemoryStream.ToArray();
Write(data);
}
}
public static int StartGame()
{
// detect if executable is found
if (!System.IO.File.Exists(Globals.ClientExecutable))
{
return(-1);
}
// generate token
string token = GenerateToken(Globals.LauncherConfig.Email, Globals.LauncherConfig.Password);
// get profile ID
string accountId = "0";
try
{
new HttpUtils.Create(null, Globals.LauncherConfig.BackendUrl).Post("/launcher/profile/login", token, true, (data) => {
using (MemoryStream ms = new MemoryStream())
{
using (ZOutputStream zip = new ZOutputStream(ms))
{
zip.CopyTo(ms);
accountId = System.Text.Encoding.UTF8.GetString(ms.ToArray());
}
}
});
}
catch
{
return(-2);
}
// account is not found
if (accountId == "0")
{
return(-3);
}
// set backend url
Globals.ClientConfig.BackendUrl = Globals.LauncherConfig.BackendUrl;
Json.Save <ClientConfig>(Globals.ClientConfigFile, Globals.ClientConfig);
// start game
ProcessStartInfo clientProcess = new ProcessStartInfo(Globals.ClientExecutable);
clientProcess.Arguments = "-bC5vLmcuaS5u=" + token + " -token=" + accountId + " -screenmode=fullscreen";
clientProcess.UseShellExecute = false;
clientProcess.WorkingDirectory = Environment.CurrentDirectory;
Process.Start(clientProcess);
return(1);
}
private void deflateEntries(out Dictionary <Entry, byte[]> entryDeflatedData, out List <uint> zLengths, uint blockSize)
{
entryDeflatedData = new Dictionary <Entry, byte[]>();
zLengths = new List <uint>();
foreach (Entry current in this.Entries)
{
current.zIndex = (uint)zLengths.Count;
current.Data.Seek(0, SeekOrigin.Begin);
Stream data = current.Data;
List <Tuple <byte[], int> > list = new List <Tuple <byte[], int> >();
while (data.Position < data.Length)
{
byte[] array = new byte[2 * blockSize];
MemoryStream memoryStream = new MemoryStream(array);
byte[] array2 = new byte[blockSize];
int num = data.Read(array2, 0, array2.Length);
ZOutputStream zOutputStream = new ZOutputStream(memoryStream, 9);
zOutputStream.Write(array2, 0, num);
zOutputStream.Flush();
zOutputStream.finish();
int num2 = (int)zOutputStream.TotalOut;
if (num2 > num)
{
list.Add(new Tuple <byte[], int>(array2, num));
}
else
{
if (num2 < (blockSize - 1))
{
list.Add(new Tuple <byte[], int>(array, num2));
}
else
{
list.Add(new Tuple <byte[], int>(array2, num));
}
}
}
int num3 = 0;
foreach (Tuple <byte[], int> current2 in list)
{
num3 += current2.Item2;
zLengths.Add((uint)current2.Item2);
}
byte[] array3 = new byte[num3];
MemoryStream memoryStream2 = new MemoryStream(array3);
foreach (Tuple <byte[], int> current2 in list)
{
memoryStream2.Write(current2.Item1, 0, current2.Item2);
}
entryDeflatedData.Add(current, array3);
}
}
public static byte[] Uncompress(byte[] compressed, int sizeUncompressed)
{
var uncompressed = new byte[sizeUncompressed];
var zstream = new ZOutputStream(new MemoryStream(uncompressed));
zstream.Write(compressed, 0, compressed.Length);
zstream.finish();
if (zstream.TotalOut != sizeUncompressed)
{
throw new IOException("Failure uncompressing data.");
}
return(uncompressed);
}
public long ZlibManagedDeflate()
{
using (var output = new MemoryStream())
{
using (var deflate = new ZOutputStream(output, (ZlibCompression)this.Compression))
{
var buffer = data;
deflate.Write(buffer, 0, buffer.Length);
}
return(output.Length);
}
}
public byte[] ReadCompressed()
{
uint compresed_size = this.ReadUInt32();
uint uncompressed_size = this.ReadUInt32BE();
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream decompress = new ZOutputStream(outMemoryStream))
{
decompress.Write(this.ReadBytes(compresed_size - 4), 0, (int)compresed_size - 4);
decompress.finish();
return(outMemoryStream.ToArray());
}
}
public void writeCompressed(byte[] bytes)
{
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream compress = new ZOutputStream(outMemoryStream, zlibConst.Z_DEFAULT_COMPRESSION)) {
compress.Write(bytes, 0, bytes.Length);
compress.finish();
byte[] data = outMemoryStream.ToArray();
this.Write((uint)data.Length + sizeof(uint));
this.writeUInt32BE((uint)bytes.Length);
this.Write(data);
}
}
/// <summary>
/// zlib 压缩算法
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
public static byte[] Compress(byte[] bytes)
{
using (var ms = new MemoryStream())
{
using (ZOutputStream outZStream = new ZOutputStream(ms, zlibConst.Z_BEST_SPEED))
{
outZStream.Write(bytes, 0, bytes.Length);
outZStream.Flush();
}
return(ms.ToArray());
}
}
public static byte[] decompress(byte[] data, UInt32 realsize)
{
MemoryStream o = new MemoryStream();
ZOutputStream z = new ZOutputStream(o);
MemoryStream i = new MemoryStream(data);
CopyStream(i, z);
byte[] res = o.ToArray();
i.Close();
z.Close();
o.Close();
return(res);
}
public static OSD ZDecompressOSD(byte[] data)
{
OSD ret;
using (MemoryStream input = new MemoryStream(data))
using (MemoryStream output = new MemoryStream())
using (ZOutputStream zout = new ZOutputStream(output))
{
CopyStream(input, zout);
zout.finish();
output.Seek(0, SeekOrigin.Begin);
ret = OSDParser.DeserializeLLSDBinary(output);
}
return ret;
}
public static byte[] ZCompressOSD(OSD data)
{
byte[] ret = null;
using (MemoryStream outMemoryStream = new MemoryStream())
using (ZOutputStream outZStream = new ZOutputStream(outMemoryStream, zlibConst.Z_BEST_COMPRESSION))
using (Stream inMemoryStream = new MemoryStream(OSDParser.SerializeLLSDBinary(data, false)))
{
CopyStream(inMemoryStream, outZStream);
outZStream.finish();
ret = outMemoryStream.ToArray();
}
return ret;
}
/// <summary>
/// Decodes mesh asset. See <see cref="OpenMetaverse.Rendering.FacetedMesh.TryDecodeFromAsset"/>
/// to furter decode it for rendering</summary>
/// <returns>true</returns>
public override bool Decode()
{
try
{
MeshData = new OSDMap();
using (MemoryStream data = new MemoryStream(AssetData))
{
OSDMap header = (OSDMap)OSDParser.DeserializeLLSDBinary(data);
long start = data.Position;
foreach(string partName in header.Keys)
{
if (header[partName].Type != OSDType.Map)
{
MeshData[partName] = header[partName];
continue;
}
OSDMap partInfo = (OSDMap)header[partName];
if (partInfo["offset"] < 0 || partInfo["size"] == 0)
{
MeshData[partName] = partInfo;
continue;
}
byte[] part = new byte[partInfo["size"]];
Buffer.BlockCopy(AssetData, partInfo["offset"] + (int)start, part, 0, part.Length);
using (MemoryStream input = new MemoryStream(part))
{
using (MemoryStream output = new MemoryStream())
{
using (ZOutputStream zout = new ZOutputStream(output))
{
byte[] buffer = new byte[2048];
int len;
while ((len = input.Read(buffer, 0, buffer.Length)) > 0)
{
zout.Write(buffer, 0, len);
}
zout.Flush();
output.Seek(0, SeekOrigin.Begin);
MeshData[partName] = OSDParser.DeserializeLLSDBinary(output);
}
}
}
}
}
return true;
}
catch (Exception ex)
{
Logger.Log("Failed to decode mesh asset", Helpers.LogLevel.Error, ex);
return false;
}
}
public void Deserialize(OSDMap map)
{
try
{
using (MemoryStream input = new MemoryStream(map["Zipped"].AsBinary()))
{
using (MemoryStream output = new MemoryStream())
{
using (ZOutputStream zout = new ZOutputStream(output))
{
byte[] buffer = new byte[2048];
int len;
while ((len = input.Read(buffer, 0, buffer.Length)) > 0)
{
zout.Write(buffer, 0, len);
}
zout.Flush();
output.Seek(0, SeekOrigin.Begin);
MaterialData = OSDParser.DeserializeLLSDBinary(output);
}
}
}
}
catch (Exception ex)
{
Logger.Log("Failed to decode RenderMaterials message:", Helpers.LogLevel.Warning, ex);
MaterialData = new OSDMap();
}
}
/// <summary>
/// decompresses a gzipped OSD object
/// </summary>
/// <param name="meshBytes"></param>
/// <returns></returns>
static OSD DecompressOsd (byte [] meshBytes)
{
OSD decodedOsd = null;
using (MemoryStream outMs = new MemoryStream ()) {
using (ZOutputStream zOut = new ZOutputStream (outMs)) {
using (Stream inMs = new MemoryStream (meshBytes)) {
byte [] readBuffer = new byte [meshBytes.Length];
int readLen;
while ((readLen = inMs.Read (readBuffer, 0, readBuffer.Length)) > 0) {
zOut.Write (readBuffer, 0, readLen);
}
zOut.Flush ();
zOut.finish ();
byte [] decompressedBuf = outMs.GetBuffer (); // ToArray();
decodedOsd = OSDParser.DeserializeLLSDBinary (decompressedBuf);
}
}
}
return decodedOsd;
}
/// <summary>
/// Decompress bytes to osd.
/// </summary>
/// <returns>The decompressed osd.</returns>
/// <param name="input">Input.</param>
public static OSD ZDecompressBytesToOsd(byte[] input)
{
OSD osd;
using (MemoryStream msSinkUnCompressed = new MemoryStream())
{
using (ZOutputStream zOut = new ZOutputStream(msSinkUnCompressed))
{
using (Stream inMs = new MemoryStream(input))
{
CopyStream(inMs, zOut);
zOut.finish();
osd = OSDParser.DeserializeLLSDBinary(msSinkUnCompressed.ToArray());
}
}
}
return osd;
}
/// <summary>
/// Compress an OSD.
/// </summary>
/// <returns>The compressed OSD</returns>
/// <param name="inOsd">In osd.</param>
/// <param name="useHeader">If set to <c>true</c> use header.</param>
public static OSD ZCompressOSD(OSD inOsd, bool useHeader)
{
OSD osd;
using (MemoryStream msSinkCompressed = new MemoryStream())
{
using (ZOutputStream zOut = new ZOutputStream(msSinkCompressed, zlibConst.Z_DEFAULT_COMPRESSION))
{
CopyStream(new MemoryStream(OSDParser.SerializeLLSDBinary(inOsd, useHeader)), zOut);
zOut.finish();
osd = OSD.FromBinary(msSinkCompressed.ToArray());
}
}
return osd;
}
