public static bool DecompressZlib(byte[] inData, int startIndex, int length, out byte[] outData, uint outDataRefLen)
{
//length = startIndex + length;
if (inData.Length < startIndex + length)
{
outData = null;
return(false);
}
//
MemoryStream output = new MemoryStream();
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(output);
/*
* for (int i = startIndex; i < length; i += 1024)
* {
* outZStream.Write(inData, i, length - i > 1024 ? 1024 : length - i);
* }*/
outZStream.Write(inData, startIndex, length);
outZStream.Flush();
outZStream.finish();
outData = output.ToArray();
//Core.Unity.Debug.LogError(string.Format("DecompressZlib:zzzzzzzz: {0} {1} {2} {3} {4} {5}", inData.Length, outZStream.Length, output.Length, output.Position, outDataRefLen, outData.Length));
if (output.Length != outDataRefLen)
{
outData = null;
return(false);
}
return(true);
}
private byte[] decompressStream(MemoryStream mem)
{
byte[] data;
using (MemoryStream outStream = new MemoryStream())
using (zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outStream))
try
{
byte[] buffer = new byte[512];
int len;
while ((len = mem.Read(buffer, 0, 512)) > 0)
{
outZStream.Write(buffer, 0, len);
}
outZStream.Flush();
data = outStream.ToArray();
}
catch (zlib.ZStreamException ex)
{
ErrorMsg = ex.Message;
return(null);
}
finally
{
outZStream.finish();
}
return(data);
}
private void CompressZlib(VFile vFile)
{
if (vFile.DataCompressed != null)
{
return;
}
if (vFile.Type != 0)
{
return;
}
if (vFile.Data == null || vFile.Data.Length <= 0)
{
return;
}
byte[] compressed = null;
try
{
using MemoryStream input = new MemoryStream(vFile.Data, 0, vFile.Data.Length);
using MemoryStream output = new MemoryStream();
using zlib.ZOutputStream compressionStream = new zlib.ZOutputStream(
output, zlib.zlibConst.Z_DEFAULT_COMPRESSION
);
input.Position = 0;
byte[] buffer = new byte[2000];
int len;
while ((len = input.Read(buffer, 0, 2000)) > 0)
{
compressionStream.Write(buffer, 0, len);
}
compressionStream.Flush();
compressionStream.finish();
compressed = new byte[output.Length];
output.Position = 0;
output.Read(compressed, 0, compressed.Length);
}
catch (Exception ex)
{
Logger.Exception(ex);
}
if (compressed == null)
{
Logger.Error($"Failed to compress. (Name:{vFile.Name}");
vFile.DataLengthUncompressed = 0;
vFile.DataLengthCompressed = 0;
vFile.DataCompressed = null;
return;
}
vFile.DataLengthUncompressed = (uint)vFile.Data.Length;
vFile.DataLengthCompressed = (uint)compressed.Length;
vFile.DataCompressed = compressed;
}
public static byte[] Compress(byte[] data)
{
MemoryStream ms = new MemoryStream();
zlib.ZOutputStream ds = new zlib.ZOutputStream(ms,3);
ds.Write(data, 0, data.Length);
ds.Flush();
ds.Close();
return ms.ToArray();
}
public static byte[] Compress(byte[] data)
{
MemoryStream ms = new MemoryStream();
zlib.ZOutputStream ds = new zlib.ZOutputStream(ms, 3);
ds.Write(data, 0, data.Length);
ds.Flush();
ds.Close();
return(ms.ToArray());
}
public static Byte[] Decompress(Byte[] data)
{
using (var decompressedDataStream = new MemoryStream())
using (var zOutputStream = new zlib.ZOutputStream(decompressedDataStream))
{
zOutputStream.Write(data, 0, data.Length);
zOutputStream.Flush();
zOutputStream.finish();
return(decompressedDataStream.ToArray());
}
}
public static Byte[] Compress(Byte[] data)
{
using (var compressedDataStream = new MemoryStream())
using (var zOutputStream = new zlib.ZOutputStream(compressedDataStream, zlib.zlibConst.Z_BEST_COMPRESSION))
//using (var zOutputStream = new zlib.ZOutputStream(compressedDataStream, 9))
{
zOutputStream.Write(data, 0, data.Length);
zOutputStream.Flush();
zOutputStream.finish();
return(compressedDataStream.ToArray());
}
}
/// <summary>
/// Writes MLArrays into <c>OutputStream</c>
/// </summary>
/// <remarks>
/// Writes MAT-file header and compressed data (<c>miCompressed</c>).
/// </remarks>
/// <param name="stream"><c>Stream</c></param>
/// <param name="data"><c>Collection</c> of <c>MLArray</c> elements.</param>
/// <param name="compress">Use data compression?</param>
public MatFileWriter(BinaryWriter stream, ICollection data, bool compress)
{
// Write header
WriteHeader(stream);
foreach (MLArray matrix in data)
{
if (compress)
{
// Prepare buffer for MATRIX data
MemoryStream memstrm = new MemoryStream();
BinaryWriter bw = new BinaryWriter(memstrm);
// Write MATRIX bytes into buffer
WriteMatrix(bw, matrix);
// Compress data to save storage
memstrm.Position = 0; // Rewind the stream
MemoryStream compressed = new MemoryStream();
zlib.ZOutputStream zos = new zlib.ZOutputStream(compressed, zlib.zlibConst.Z_DEFAULT_COMPRESSION);
byte[] input = new byte[128];
int len = 0;
while ((len = memstrm.Read(input, 0, input.Length)) > 0)
{
zos.Write(input, 0, len);
}
zos.Flush();
zos.Close(); // important to note that the zlib.ZOutputStream needs to close before writting out the data to the Base.stream
//write COMPRESSED tag and compressed data into output channel
byte[] compressedBytes = compressed.ToArray();
ByteBuffer buf = new ByteBuffer(2 * 4 + compressedBytes.Length);
buf.PutInt(MatDataTypes.miCOMPRESSED);
buf.PutInt(compressedBytes.Length);
buf.Put(compressedBytes, 0, compressedBytes.Length);
stream.Write(buf.Array());
compressed.Close();
}
else
{
// Write MATRIX bytes into buffer
WriteMatrix(stream, matrix);
}
}
stream.Close();
}
static public string XmlToCode(string xmlStr)
{
byte[] bytes;
using (var outputStream = new System.IO.MemoryStream())
{
using (zlib.ZOutputStream compressionStream = new zlib.ZOutputStream(outputStream, zlib.zlibConst.Z_DEFAULT_COMPRESSION))
{
byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(xmlStr);
compressionStream.Write(byteArray, 0, byteArray.Length);
compressionStream.Flush();
}
bytes = outputStream.ToArray();
}
return(System.Convert.ToBase64String(bytes).Replace("+", "-").Replace("/", "_"));
}
static public string CodeToXml(string _code)
{
string code = _code.Replace("-", "+").Replace("_", "/");
byte[] inData = System.Convert.FromBase64String(code);
byte[] outData;
using (MemoryStream outMemoryStream = new MemoryStream())
{
using (zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outMemoryStream))
{
outZStream.Write(inData, 0, inData.Length);
outZStream.Flush();
}
outData = outMemoryStream.ToArray();
}
return(System.Text.Encoding.UTF8.GetString(outData));
}
public static bool CompressZlib(byte[] inData, out byte[] outData)
{
MemoryStream output = new MemoryStream();
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(output, zlib.zlibConst.Z_DEFAULT_COMPRESSION);
/*
* for (int i = 0, len = inData.Length; i < len; i += 1024)
* {
* outZStream.Write(inData, i, len - i > 1024 ? 1024 : len - i);
* }*/
outZStream.Write(inData, 0, inData.Length);
outZStream.Flush();
outZStream.finish();
outData = output.ToArray();
//Core.Unity.Debug.LogError(string.Format("CompressZlib:zzzzzzzz: {0} {1} {2} {3} {4}", inData.Length, outZStream.Length, output.Length, output.Position, outData.Length ));
return(true);
}
/// <summary>
/// Writes MLArrays into <c>OutputStream</c>
/// </summary>
/// <remarks>
/// Writes MAT-file header and compressed data (<c>miCompressed</c>).
/// </remarks>
/// <param name="stream"><c>Stream</c></param>
/// <param name="data"><c>Collection</c> of <c>MLArray</c> elements.</param>
/// <param name="compress">Use data compression?</param>
public MatFileWriter( BinaryWriter stream, ICollection data, bool compress )
{
// Write header
WriteHeader( stream );
foreach( MLArray matrix in data )
{
if (compress)
{
// Prepare buffer for MATRIX data
MemoryStream memstrm = new MemoryStream();
BinaryWriter bw = new BinaryWriter(memstrm);
// Write MATRIX bytes into buffer
WriteMatrix(bw, matrix);
// Compress data to save storage
memstrm.Position = 0; // Rewind the stream
MemoryStream compressed = new MemoryStream();
zlib.ZOutputStream zos = new zlib.ZOutputStream(compressed, zlib.zlibConst.Z_DEFAULT_COMPRESSION);
byte[] input = new byte[128];
int len = 0;
while ((len = memstrm.Read(input, 0, input.Length)) > 0)
zos.Write(input, 0, len);
zos.Flush();
zos.Close(); // important to note that the zlib.ZOutputStream needs to close before writting out the data to the Base.stream
//write COMPRESSED tag and compressed data into output channel
byte[] compressedBytes = compressed.ToArray();
ByteBuffer buf = new ByteBuffer(2 * 4 + compressedBytes.Length);
buf.PutInt(MatDataTypes.miCOMPRESSED);
buf.PutInt(compressedBytes.Length);
buf.Put(compressedBytes, 0, compressedBytes.Length);
stream.Write(buf.Array());
compressed.Close();
}
else
{
// Write MATRIX bytes into buffer
WriteMatrix(stream, matrix);
}
}
stream.Close();
}
private byte[] decompressStream(MemoryStream mem)
{
byte[] data;
using (MemoryStream outStream = new MemoryStream())
using (zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outStream))
try
{
byte[] buffer = new byte[512];
int len;
while ((len = mem.Read(buffer, 0, 512)) > 0)
{
outZStream.Write(buffer, 0, len);
}
outZStream.Flush();
data = outStream.ToArray();
}
catch(zlib.ZStreamException ex)
{
ErrorMsg = ex.Message;
return null;
}
finally
{
outZStream.finish();
}
return data;
}
/// <summary>
/// Loads the image
/// </summary>
public void LoadImg()
{
BinaryReader binr;
fs = new FileStream(path, FileMode.Open);
binr = new BinaryReader(fs);
int w = 0, h = 0;
pixelFormat = s.GetVariable("IMG_PIXEL_FORMAT");
pixelFormat = pixelFormat.ToUpper();
BPP = VarReader.ReadInt32(binr, s, "IMG_BPP");
List <string> order = s.GetVariable("WRITE_ORDER");
for (int q = 0; q < order.Count; q++)
{
switch (order[q])
{
case "FILE_MAGIC":
int maglen = s.GetVariable("FILE_MAGIC_LEN");
List <Byte> magic = binr.ReadBytes(maglen).ToList();
List <Byte> magic2 = s.GetVariable("FILE_MAGIC");
//if (magic.Equals(magic2))
// return;
break;
case "IMG_WIDTH":
w = VarReader.ReadInt32(binr, s, order[q]);
break;
case "IMG_HEIGHT":
h = VarReader.ReadInt32(binr, s, order[q]);
break;
case "IMG_BPP":
BPP = VarReader.ReadInt32(binr, s, order[q]);
break;
case "IMG_PIXELS":
if (s.ContainsVariable("IMG_PIXEL_FORMAT"))
{
byte[] rgb;
int size = 0;
if (s.ContainsVariable("IMG_UNEVEN_PADDING"))
{
if (s.GetVariable("IMG_UNEVEN_PADDING"))
{
int w1 = 0;
if (w % 2 > 0)
{
w1 = 1;
}
size = (w + w1) * h * (bpc * pixelFormat.Length / 8);
}
else
{
size = w * h * (bpc * pixelFormat.Length / 8);
}
}
else
{
size = w * h * (bpc * pixelFormat.Length / 8);
}
if (s.ContainsVariable("IMG_PIXELS_LEN"))
{
size = s.GetVariable("IMG_PIXELS_LEN");
}
if (s.ContainsVariable("IMG_PIXELS_LEN_OFFSET"))
{
binr.BaseStream.Seek(s.GetVariable("IMG_PIXELS_LEN_OFFSET"), SeekOrigin.Begin);
size = VarReader.ReadInt32(binr, s, "IMG_PIXELS_LEN");
}
if (s.ContainsVariable(order[q] + "_OFFSET"))
{
binr.BaseStream.Seek(s.GetVariable(order[q] + "_OFFSET"), SeekOrigin.Begin);
}
rgb = binr.ReadBytes(size);
if (s.ContainsVariable("IMG_DEFLATE"))
{
if (s.GetVariable("IMG_DEFLATE"))
{
System.IO.FileStream inFile = new System.IO.FileStream("CompZ.bin", System.IO.FileMode.Create);
BinaryWriter binZ = new BinaryWriter(inFile);
binZ.Write(rgb);
//binZ.Flush();
binZ.Close();
inFile.Close();
System.IO.FileStream outFileStream = new System.IO.FileStream("DecompZ.bin", System.IO.FileMode.Create);
zlib.ZOutputStream outZStream = new zlib.ZOutputStream(outFileStream);
System.IO.FileStream inFileStream = new System.IO.FileStream("CompZ.bin", System.IO.FileMode.Open);
try
{
byte[] buffer = new byte[2000];
int len;
while ((len = inFileStream.Read(buffer, 0, 2000)) > 0)
{
outZStream.Write(buffer, 0, len);
}
outZStream.Flush();
}
finally
{
outZStream.Close();
outFileStream.Close();
inFileStream.Close();
}
System.IO.FileStream inFile2 = new System.IO.FileStream("DecompZ.bin", System.IO.FileMode.Open);
BinaryReader binZ2 = new BinaryReader(inFile2);
//rgb = new byte[inFile2.Length];
//inFile2.Read(rgb, 0, (int)inFile2.Length);
rgb = binZ2.ReadBytes((int)inFile2.Length);
binZ2.Close();
inFile2.Close();
}
}
if (s.ContainsVariable("IMG_PIXELS_HANDLER"))
{
if (s.GetVariable("IMG_PIXELS_HANDLER"))
{
var ProcessPixels = s.GetVariable("ProcessPixels");
IList <object> rgbp = new List <object>();
for (int i = 0; i < rgb.Length; i++)
{
rgbp.Add(rgb[i]);
}
List <byte> rgbl = ProcessPixels(rgbp, w, h, BPP);
rgb = rgbl.ToArray();
}
}
img = new Bitmap(w, h);
Color[,] pixels = Render(rgb, h, w);
for (int j = 0; j < h; j++)
{
for (int i = 0; i < w; i++)
{
img.SetPixel(i, j, pixels[i, j]);
}
}
}
break;
default:
VarReader.ReadInt32(binr, s, order[q]);
break;
}
}
binr.Close();
fs.Close();
}
public virtual Stream OpenInNewStream(Stream a_Stream, FileAccess fA)
{
bool b0 = true;
if (m_Stream != null && (fA & FileAccess.Write) == FileAccess.Write)
if (!m_Stream.CanWrite)
b0 = false;
if (m_Stream != null && b0)
return m_Stream;
else
{
a_Stream.Position = Offset;
byte[] data = a_Stream.ReadBytes(CompressedSize);
if ((this.Compression & RisenPakCompression.RisenPakCompression_ZLib) == RisenPakCompression.RisenPakCompression_ZLib)
{
b0 = (fA & FileAccess.Write) == FileAccess.Write;
MemoryStream mStream = new MemoryStream(UnCompressedSize);
zlib.ZOutputStream outp = new zlib.ZOutputStream(mStream);
outp.Write(data, 0, data.Length);
outp.Position = 0;
outp.Flush();
outp.finish();
mStream.Position = 0;
return mStream;
}
else if (((this.Compression & RisenPakCompression.RisenPakCompression_None) == RisenPakCompression.RisenPakCompression_None) ||
((this.Compression & RisenPakCompression.RisenPakCompression_Auto) == RisenPakCompression.RisenPakCompression_Auto) )
{
MemoryStream mS = new MemoryStream(data.Length);
mS.Write(data, 0, data.Length);
mS.Position = 0;
return mS;
}
return null;
}
}
