public void BasicRoundTrip()
{
var ms = new MemoryStream();
var outStream = new BZip2OutputStream(ms);
byte[] buf = new byte[10000];
var rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
outStream.Close();
ms = new MemoryStream(/*ms.GetBuffer()*/ ms.ToArray());
ms.Seek(0, SeekOrigin.Begin);
using (BZip2InputStream inStream = new BZip2InputStream(ms))
{
byte[] buf2 = new byte[buf.Length]; // How can the Inflater known the length of original data?
int pos = 0;
while (true)
{
int numRead = inStream.Read(buf2, pos, 4096);
if (numRead <= 0)
{
break;
}
pos += numRead;
}
for (int i = 0; i < buf.Length; ++i)
{
Assert.AreEqual(buf2[i], buf[i]);
}
}
}
public static byte[] ZipString(string sBuffer)
{
MemoryStream m_msBZip2 = null;
BZip2OutputStream m_osBZip2 = null;
byte[] result;
try {
m_msBZip2 = new MemoryStream();
Int32 size = sBuffer.Length;
// Prepend the compressed data with the length of the uncompressed data (firs 4 bytes)
//
using (BinaryWriter writer = new BinaryWriter(m_msBZip2, System.Text.Encoding.ASCII)) {
writer.Write(size);
m_osBZip2 = new BZip2OutputStream(m_msBZip2);
m_osBZip2.Write(Encoding.ASCII.GetBytes(sBuffer), 0, sBuffer.Length);
m_osBZip2.Close();
result = m_msBZip2.ToArray();
m_msBZip2.Close();
writer.Close();
}
} finally {
if (m_osBZip2 != null)
{
m_osBZip2.Dispose();
}
if (m_msBZip2 != null)
{
m_msBZip2.Dispose();
}
}
return(result);
}
public static void CompressToFile(string targetFilePath, MemoryStream streamData)
{
// Write compressed data length and compressed data to file
FileStream fs = null;
try
{
fs = new FileStream(targetFilePath, FileMode.Create);
// Write compressed data length
fs.Write(BitConverter.GetBytes(streamData.Length), 0, 4);
// Compress data
using (BZip2OutputStream gzs = new BZip2OutputStream(fs, true))
//ICSharpCode.SharpZipLib.BZip2.BZip2OutputStream(ms))
{
fs = null;
gzs.Write(streamData.GetBuffer(), 0, (int)streamData.Length);
}
}
finally
{
if (fs != null)
{
fs.Dispose();
}
}
}
public static string CatGame1(string str, bool isPress = false)
{
byte[] buffer4;
byte[] bytes = Encoding.UTF8.GetBytes(str);
byte[] rgbKey = Encoding.UTF8.GetBytes("b5nHjsMrqaeNliSs3jyOzgpD");
byte[] rgbIV = Encoding.UTF8.GetBytes("wuD6keVr");
TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
using (MemoryStream stream = new MemoryStream())
{
using (CryptoStream stream2 = new CryptoStream(stream, provider.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write))
{
if (isPress)
{
using (BZip2OutputStream stream3 = new BZip2OutputStream(stream2))
{
stream3.Write(bytes, 0, bytes.Length);
stream3.Close();
}
}
else
{
stream2.Write(bytes, 0, bytes.Length);
}
stream2.Close();
}
buffer4 = stream.ToArray();
stream.Close();
}
return(Convert.ToBase64String(buffer4));
}
//
// inStream --> compress --> outStream
//
public void Compress(Stream inStream, Stream outStream)
{
if (inStream == null)
{
return;
}
if (outStream == null)
{
return;
}
byte[] buffer = new byte[BUFFER_SIZE];
using (BZip2OutputStream bz2out = new BZip2OutputStream(outStream))
{
while (true)
{
int bytesRead = inStream.Read(buffer, 0, buffer.Length);
if (bytesRead <= 0)
{
break;
}
bz2out.Write(buffer, 0, bytesRead);
}
bz2out.Flush();
}
}
public void BasicRoundTrip()
{
var ms = new MemoryStream();
var outStream = new BZip2OutputStream(ms);
var buf = Utils.GetDummyBytes(size: 10000, RandomSeed);
outStream.Write(buf, offset: 0, buf.Length);
outStream.Close();
ms = new MemoryStream(ms.GetBuffer());
ms.Seek(offset: 0, SeekOrigin.Begin);
using BZip2InputStream inStream = new BZip2InputStream(ms);
var buf2 = new byte[buf.Length];
var pos = 0;
while (true)
{
var numRead = inStream.Read(buf2, pos, count: 4096);
if (numRead <= 0)
{
break;
}
pos += numRead;
}
for (var i = 0; i < buf.Length; ++i)
{
Assert.AreEqual(buf2[i], buf[i]);
}
}
override public void AddToStream(Stream stream, EventTracker tracker)
{
if (ChildCount > 1)
{
throw new Exception("Bzip2 file " + Uri + " has " + ChildCount + " children");
}
if (tracker != null)
{
tracker.ExpectingAdded(UriFu.UriToEscapedString(this.Uri));
}
UnclosableStream unclosable;
unclosable = new UnclosableStream(stream);
BZip2OutputStream bz2_out;
bz2_out = new BZip2OutputStream(unclosable);
MemoryStream memory;
memory = new MemoryStream();
// There should just be one child
foreach (FileObject file in Children)
{
file.AddToStream(memory, tracker);
}
bz2_out.Write(memory.ToArray(), 0, (int)memory.Length);
memory.Close();
bz2_out.Close();
}
//
//
//
public MemoryStream Compress(Stream stream)
{
if (stream == null)
{
return(null);
}
byte[] buffer = new byte[BUFFER_SIZE];
MemoryStream outStream = new MemoryStream();
using (BZip2OutputStream bz2Stream = new BZip2OutputStream(outStream))
{
while (true)
{
int bytesRead = stream.Read(buffer, 0, buffer.Length);
if (bytesRead <= 0)
{
break;
}
bz2Stream.Write(buffer, 0, bytesRead);
}
bz2Stream.Flush();
} // OUCH - doesnt work if you dont close the output stream
outStream.Position = 0;
return(outStream);
}
/// <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;
// Compress
using (var outStream = new MemoryStream(input.Length))
using (var bz2 = new BZip2OutputStream(outStream, CompressorTool.BUFFER_SIZE)) {
bz2.Write(input, 0, input.Length);
bz2.Close();
output = outStream.ToArray();
}
if (IsDebugEnabled)
{
log.Debug(CompressorTool.SR.CompressResultMsg, input.Length, output.Length, output.Length / (double)input.Length);
}
return(output);
}
/// <summary>
/// Compress the specified sBuffer.
/// </summary>
/// <param name="sBuffer">S buffer.</param>
public static string Compress(string sBuffer)
{
byte[] compressed = null;
string compressedText = null;
try {
byte[] bytesBuffer = Encoding.UTF8.GetBytes(sBuffer);
using (MemoryStream compressStream = new MemoryStream()) {
using (BZip2OutputStream bzipStream = new BZip2OutputStream(compressStream)) {
bzipStream.Write(bytesBuffer, 0, bytesBuffer.Length);
bzipStream.Flush();
bzipStream.Close();
compressed = compressStream.ToArray();
}
}
} catch (Exception ex) {
ConsoleEx.DebugLog("BZip2 compress error : " + ex.ToString());
} finally {
if (compressed != null)
{
compressedText = Convert.ToBase64String(compressed);
}
}
return(compressedText);
}
/*
* String - CompressString() > DecompressString()
* String - ComrpessStringToBytes() > DecompressStringFromBytes()
*
* Bytes - CompressBytes() > DecompressBytes()
* Bytes - CompressBytesToString() > DecompressBytesFromString()
*/
#region CompressBytes
/// <summary>
/// Compresses a byte array
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static byte[] CompressBytes(this byte[] data)
{
// empty if null
if (data.IsNullOrEmpty())
{
return(null);
}
using (MemoryStream msBZip2 = new MemoryStream())
{
int size = data.Length;
// Prepend the compressed data with the length of the uncompressed data (firs 4 bytes)
using (BinaryWriter writer = new BinaryWriter(msBZip2))
{
writer.Write(size);
using (BZip2OutputStream BZip2OutStream = new BZip2OutputStream(msBZip2))
{
BZip2OutStream.Write(data, 0, size);
}
}
// return the compressed data
return(msBZip2.ToArray());
}
}
public void SaveAs(string name)
{
string Fullname = Application.persistentDataPath + "/" + Game.current.Filename + "-" + name;
BinaryFormatter bf = new BinaryFormatter();
//Save the recording in its own file
FileStream file;
file = File.Create(Fullname + ".rcd"); //you can call it anything you want
bf.Serialize(file, this.Serialize());
file.Close();
return;
//This zipper takes 5 times as long and shrinks the file to 1/3 size
using (FileStream fs = new FileStream(Fullname + ".zip", FileMode.Create))
{
using (MemoryStream objectSerialization = new MemoryStream())
{
BinaryFormatter bformatter = new BinaryFormatter();
bformatter.Serialize(objectSerialization, this.Serialize());
using (BinaryWriter binaryWriter = new BinaryWriter(fs))
{
binaryWriter.Write(objectSerialization.GetBuffer().Length); //write the length first
using (BZip2OutputStream osBZip2 = new BZip2OutputStream(fs))
{
osBZip2.Write(objectSerialization.GetBuffer(), 0, objectSerialization.GetBuffer().Length); //write the compressed file
}
}
}
}
}
public void BasicRoundTrip()
{
MemoryStream ms = new MemoryStream();
BZip2OutputStream outStream = new BZip2OutputStream(ms);
byte[] buf = new byte[10000];
System.Random rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
outStream.Close();
ms = new MemoryStream(ms.GetBuffer());
ms.Seek(0, SeekOrigin.Begin);
using (BZip2InputStream inStream = new BZip2InputStream(ms))
{
byte[] buf2 = new byte[buf.Length];
int pos = 0;
while (true)
{
int numRead = inStream.Read(buf2, pos, 4096);
if (numRead <= 0)
{
break;
}
pos += numRead;
}
for (int i = 0; i < buf.Length; ++i)
{
Assert.AreEqual(buf2[i], buf[i]);
}
}
}
// Token: 0x06003B90 RID: 15248 RVA: 0x00138434 File Offset: 0x00136634
public static string CatGame1(string str, bool isCompress = false)
{
byte[] bytes = Encoding.UTF8.GetBytes(str);
byte[] bytes2 = Encoding.UTF8.GetBytes("b************c**********");
byte[] bytes3 = Encoding.UTF8.GetBytes("a****a**");
TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
byte[] inArray;
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, tripleDESCryptoServiceProvider.CreateEncryptor(bytes2, bytes3), CryptoStreamMode.Write))
{
if (isCompress)
{
using (BZip2OutputStream bzip2OutputStream = new BZip2OutputStream(cryptoStream))
{
bzip2OutputStream.Write(bytes, 0, bytes.Length);
bzip2OutputStream.Close();
}
}
else
{
cryptoStream.Write(bytes, 0, bytes.Length);
}
cryptoStream.Close();
}
inArray = memoryStream.ToArray();
memoryStream.Close();
}
return(Convert.ToBase64String(inArray));
}
public virtual byte[] Compress(byte[] decompressedData)
{
using (MemoryStream ms = new MemoryStream())
{
if (this.Algorithm == CompressionAlgorithm.GZip)
{
GZipStream stream2 = new GZipStream(ms, CompressionMode.Compress, true);
stream2.Write(decompressedData, 0, decompressedData.Length);
stream2.Close();
}
else if (this.Algorithm == CompressionAlgorithm.Deflate)
{
DeflateStream stream3 = new DeflateStream(ms, CompressionMode.Compress, true);
stream3.Write(decompressedData, 0, decompressedData.Length);
stream3.Close();
}
else
{
var bzipStream = new BZip2OutputStream(ms);
bzipStream.Write(decompressedData, 0, decompressedData.Length);
bzipStream.Close();
}
return(ms.ToArray());
}
}
/// <summary>
/// BZip2压缩
/// </summary>
/// <param name="rawData"></param>
/// <returns></returns>
public static byte[] BZip2Compress(byte[] rawData)
{
MemoryStream ms = new MemoryStream();
BZip2OutputStream BZip2 = new BZip2OutputStream(ms);
BZip2.Write(rawData, 0, rawData.Length);
BZip2.Close();
return(ms.ToArray());
}
/// <summary>
/// 压缩
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static byte[] Compress(byte[] input)
{
using (MemoryStream outputStream = new MemoryStream()) {
using (BZip2OutputStream zipStream = new BZip2OutputStream(outputStream)) {
zipStream.Write(input, 0, input.Length);
zipStream.Close();
}
return(outputStream.ToArray());
}
}
/// <summary>
/// BZip2压缩
/// </summary>
/// <param name="data">源字节数组</param>
/// <param name="level">压缩率，1-9，数字越大压缩率越高</param>
/// <returns></returns>
public static byte[] BZip2(byte[] data, int level)
{
using var mstream = new MemoryStream();
using var zipOutStream = new BZip2OutputStream(mstream, level);
zipOutStream.Write(data, 0, data.Length);
byte[] result = mstream.ToArray();
return(result);
}
/// <summary>
/// TODO: description
/// </summary>
/// <param name="sourcePath"></param>
/// <param name="targetPath"></param>
/// <param name="deltaPath"></param>
public void Create(string sourcePath, string targetPath, string deltaPath)
{
Logger.Info("Creating Fossil patch at {0} from {1} to {2}", deltaPath, sourcePath, targetPath);
using (FileStream patch = File.Open(deltaPath, FileMode.Create, FileAccess.Write))
using (BZip2OutputStream zip = new BZip2OutputStream(patch))
{
byte[] patchData = Fossil.Delta.Create(File.ReadAllBytes(sourcePath), File.ReadAllBytes(targetPath));
zip.Write(patchData, 0, patchData.Length);
}
}
/// <summary>
/// 压缩
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string Compress(string input)
{
byte[] buffer = Encoding.UTF8.GetBytes(input);
using (MemoryStream outputStream = new MemoryStream()) {
using (BZip2OutputStream zipStream = new BZip2OutputStream(outputStream)) {
zipStream.Write(buffer, 0, buffer.Length);
zipStream.Close();
}
return(Convert.ToBase64String(outputStream.ToArray()));
}
}
public static byte[] ZipStream(byte[] sBuffer)
{
MemoryStream m_msBZip2 = null;
BZip2OutputStream m_osBZip2 = null;
byte[] result;
try
{
m_msBZip2 = new MemoryStream();
Int32 size = sBuffer.Length;
using (BinaryWriter writer = new BinaryWriter(m_msBZip2, System.Text.Encoding.ASCII))
{
writer.Write(size);
m_osBZip2 = new BZip2OutputStream(m_msBZip2);
m_osBZip2.Write(sBuffer, 0, sBuffer.Length);
m_osBZip2.Close();
result = m_msBZip2.ToArray();
m_msBZip2.Close();
writer.Close();
}
}
finally
{
if (m_osBZip2 != null)
{
m_osBZip2.Dispose();
}
if (m_msBZip2 != null)
{
m_msBZip2.Dispose();
}
}
return(result);
}
public static byte[] Compress(byte[] input)
{
Contract.Requires(input != null);
Contract.Ensures(Contract.Result <byte[]>() != null);
var length = input.Length;
var ms = new MemoryStream(length);
using (var stream = new BZip2OutputStream(ms))
stream.Write(input, 0, length);
return(ms.ToArray());
}
public static string Compress(string input)
{
using (var outputMemoryStream = new MemoryStream())
{
using (var zipStream = new BZip2OutputStream(outputMemoryStream))
{
var inputBytes = Encoding.UTF8.GetBytes(input);
zipStream.Write(inputBytes, 0, inputBytes.Length);
}
var outputBytes = outputMemoryStream.ToArray();
return(Convert.ToBase64String(outputBytes));
}
}
public static byte[] CatHomeMain(byte[] data, byte[] home, byte[] info, bool isCompress = false)
{
MemoryStream memoryStream = null;
CryptoStream cryptoStream = null;
byte[] result;
try
{
var transform = new RijndaelManaged
{
Padding = PaddingMode.PKCS7,
Mode = CipherMode.CBC,
KeySize = 256,
BlockSize = 256
}.CreateEncryptor(home, info);
memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
if (isCompress)
{
var bzip2OutputStream = new BZip2OutputStream(cryptoStream, 1);
bzip2OutputStream.Write(data, 0, data.Length);
bzip2OutputStream.Close();
}
else
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
}
result = memoryStream.ToArray();
}
catch (Exception)
{
result = null;
}
finally
{
if (memoryStream != null)
{
memoryStream.Close();
}
if (cryptoStream != null)
{
cryptoStream.Close();
}
}
return(result);
}
public static byte[] ZipCompress(byte[] byte_0)
{
MemoryStream stream = new MemoryStream();
Stream stream2 = new BZip2OutputStream(stream);
try
{
stream2.Write(byte_0, 0, byte_0.Length);
}
finally
{
stream2.Close();
stream.Close();
}
return(stream.ToArray());
}
/// <summary>
/// Function to compress data.
/// </summary>
/// <param name="inStream">Input stream.</param>
/// <param name="outStream">Output stream.</param>
private void CompressData(Stream inStream, Stream outStream)
{
if (_writeBuffer == null)
{
_writeBuffer = new byte[81920];
}
Debug.Assert(outStream != null, "outStream != null");
using (var bzStream = new BZip2OutputStream(outStream, _compressionRatio))
{
long streamSize = inStream.Length;
bzStream.IsStreamOwner = false;
while (streamSize > 0)
{
if (_token.IsCancellationRequested)
{
return;
}
int readSize = inStream.Read(_writeBuffer, 0, 81920);
if (_token.IsCancellationRequested)
{
return;
}
if (readSize > 0)
{
if (_token.IsCancellationRequested)
{
return;
}
bzStream.Write(_writeBuffer, 0, readSize);
if (_token.IsCancellationRequested)
{
return;
}
}
streamSize -= readSize;
}
}
}
public static byte[] CatHomeMain(byte[] data, byte[] home, byte[] info, bool isPress = false)
{
MemoryStream stream = null;
CryptoStream stream2 = null;
byte[] buffer;
try
{
ICryptoTransform transform = new RijndaelManaged
{
Padding = PaddingMode.PKCS7,
Mode = CipherMode.CBC,
KeySize = 0x100,
BlockSize = 0x100
}.CreateEncryptor(home, info);
stream = new MemoryStream();
stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Write);
if (isPress)
{
BZip2OutputStream stream3 = new BZip2OutputStream(stream2);
stream3.Write(data, 0, data.Length);
stream3.Close();
}
else
{
stream2.Write(data, 0, data.Length);
stream2.FlushFinalBlock();
}
buffer = stream.ToArray();
}
catch (Exception)
{
buffer = null;
}
finally
{
if (stream != null)
{
stream.Close();
}
if (stream2 != null)
{
stream2.Close();
}
}
return(buffer);
}
static public byte[] BZip2CompressArray(byte[] data)
{
MemoryStream ms = new MemoryStream();
using (BZip2OutputStream bz = new BZip2OutputStream(ms, 9))
{
bz.IsStreamOwner = false;
bz.Write(data, 0, data.Length);
}
ms.Position = 0;
byte[] compressed = new byte[ms.Length];
ms.Read(compressed, 0, compressed.Length);
byte[] gzBuffer = new byte[compressed.Length + 4];
System.Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length);
System.Buffer.BlockCopy(BitConverter.GetBytes(data.Length), 0, gzBuffer, 0, 4);
return(gzBuffer);
}
/// <summary>
/// Compress <paramref name="instream">input stream</paramref> sending
/// result to <paramref name="outputstream">output stream</paramref>
/// </summary>
public static long Compress(Stream instream, Stream outstream, int blockSize)
{
System.IO.Stream bos = outstream;
System.IO.Stream bis = instream;
int ch;
BZip2OutputStream bzos = new BZip2OutputStream(bos, blockSize);
byte[] buffer = new byte[512];
while ((ch = bis.Read(buffer, 0, buffer.Length)) != 0)
{
bzos.Write(buffer, 0, ch);
}
bis.Close();
bzos.Flush();
bzos.Close();
return(bzos.Size);
}
void WriteTargetBytes()
{
const int Size = 8192;
byte[] buffer = new byte[Size];
while (writeTarget_ > 0)
{
int thisTime = Size;
if (thisTime > writeTarget_)
{
thisTime = (int)writeTarget_;
}
outStream_.Write(buffer, 0, thisTime);
writeTarget_ -= thisTime;
}
}
