| public SetInput ( byte input ) : void | ||
| input | byte | /// the buffer containing the input data. /// |
| return | void | |
public byte[] Compress(byte[] input)
{
// Create the compressor with highest level of compression
Deflater compressor = new Deflater();
compressor.SetLevel(Deflater.BEST_COMPRESSION);
// Give the compressor the data to compress
compressor.SetInput(input);
compressor.Finish();
/*
* Create an expandable byte array to hold the compressed data.
* You cannot use an array that's the same size as the orginal because
* there is no guarantee that the compressed data will be smaller than
* the uncompressed data.
*/
MemoryStream bos = new MemoryStream(input.Length);
// Compress the data
byte[] buf = new byte[1024];
while (!compressor.IsFinished)
{
int count = compressor.Deflate(buf);
bos.Write(buf, 0, count);
}
// Get the compressed data
return bos.ToArray();
}
private const int CopyBufferSize = 32*1024; // 32kb
public void Compress(Stream source, Stream destination)
{
/*
var deflater = new DeflaterOutputStream(destination, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
var dataBuffer = new byte[CopyBufferSize];
StreamUtils.Copy(source, deflater, dataBuffer);
*/
var def = new Deflater(Deflater.DEFAULT_COMPRESSION, true);
var inputData = new byte[source.Length - source.Position];
source.Read(inputData, 0, inputData.Length);
var buffer = new byte[CopyBufferSize];
def.SetInput( inputData, 0, inputData.Length );
def.Finish();
while(!def.IsFinished)
{
int outputLen = def.Deflate(buffer, 0, buffer.Length);
destination.Write( buffer, 0, outputLen );
}
def.Reset();
}
public static byte[] Compress(string str)
{
byte[] bytes = Encoding.Unicode.GetBytes(str);
Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
deflater.SetInput(bytes);
deflater.Finish();
MemoryStream stream = new MemoryStream(bytes.Length);
try
{
byte[] output = new byte[0x400];
while (!deflater.IsFinished)
{
int count = deflater.Deflate(output);
stream.Write(output, 0, count);
}
}
finally
{
stream.Close();
}
byte[] buffer3 = stream.ToArray();
if ((buffer3.Length % 2) == 0)
{
return buffer3;
}
byte[] buffer4 = new byte[buffer3.Length + 1];
for (int i = 0; i < buffer3.Length; i++)
{
buffer4[i] = buffer3[i];
}
buffer4[buffer3.Length] = 0;
return buffer4;
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public byte[] Compress(Stream input)
{
String s = String.Format("Compressing output with level {0:d}", CompressionLevel);
//Log.Debug(this, s);
Deflater deflater = new Deflater(CompressionLevel, false);
byte[] uncompressedData = new byte[(Int32)input.Length];
input.Seek(0, SeekOrigin.Begin);
input.Read(uncompressedData, 0, uncompressedData.Length);
byte[] buffer = new byte[input.Length];
try
{
deflater.SetInput(uncompressedData);
deflater.Finish();
int bytesDeflated = deflater.Deflate(buffer, 0, buffer.Length);
byte[] compressedData = new byte[bytesDeflated];
Array.Copy(buffer, compressedData, bytesDeflated);
//Log.Debug(this, "Compression completed.");
return compressedData;
}
catch (Exception e)
{
Log.Error(this, e);
throw e;
}
}
public static void IOCompress(byte[] input, int len, byte[] output, out int deflatedLength)
{
Deflater item = new Deflater();
item.SetInput(input, 0, len);
item.Finish();
deflatedLength = item.Deflate(output, 0, output.Length);
}
public void Compress()
{
var deflater = new Deflater();
byte[] packet = PacketData;
deflater.SetInput(packet, 0, packet.Length);
deflater.Finish();
var compBuffer = new byte[1024];
var ret = new List<byte>();
while (!deflater.IsFinished)
{
try
{
deflater.Deflate(compBuffer);
ret.AddRange(compBuffer);
Array.Clear(compBuffer, 0, compBuffer.Length);
}
catch (Exception ex)
{
return;
}
}
deflater.Reset();
Seek((byte)_headerType, SeekOrigin.Begin);
// Write the compressed bytes over whatever is there.
Write(ret.ToArray());
// Set the stream length to the end of the actual packet data.
// This makes sure we don't have any 'junk' packets at the end.
OutStream.SetLength(BaseStream.Position);
}
/// <summary>Compresses the specified byte range using the
/// specified compressionLevel (constants are defined in
/// java.util.zip.Deflater).
/// </summary>
public static byte[] Compress(byte[] value_Renamed, int offset, int length, int compressionLevel)
{
/* Create an expandable byte array to hold the compressed data.
* You cannot use an array that's the same size as the orginal because
* there is no guarantee that the compressed data will be smaller than
* the uncompressed data. */
System.IO.MemoryStream bos = new System.IO.MemoryStream(length);
Deflater compressor = new Deflater();
try
{
compressor.SetLevel(compressionLevel);
compressor.SetInput(value_Renamed, offset, length);
compressor.Finish();
// Compress the data
byte[] buf = new byte[1024];
while (!compressor.IsFinished)
{
int count = compressor.Deflate(buf);
bos.Write(buf, 0, count);
}
}
finally
{
}
return bos.ToArray();
}
/// <summary>
/// Performs deflate compression on the given data.
/// </summary>
/// <param name="input">the data to compress</param>
/// <param name="output">the compressed data</param>
public static void CompressZLib(byte[] input, byte[] output, int compressionLevel, out int deflatedLength)
{
Deflater item = new Deflater(compressionLevel);
item.SetInput(input, 0, input.Length);
item.Finish();
deflatedLength = item.Deflate(output, 0, output.Length);
}
/// <summary>
/// Sends packet (might be compressed)
/// </summary>
/// <returns></returns>
public void SendTo(IRealmClient client)
{
if (TotalLength <= WCellDef.MAX_UNCOMPRESSED_UPDATE_PACKET)
{
client.Send(GetFinalizedPacket());
}
else
{
var segment = ((SegmentStream)BaseStream).Segment;
//var input = ((MemoryStream)BaseStream).ToArray();
var inputOffset = HeaderSize;
//Compression.CompressZLib(packetBuffer, outputBuffer, RealmServer.Instance.Configuration.CompressionLevel, out deflatedLength);
var length = ContentLength;
if (length > 0x7FFF)
{
log.Warn("Sent UpdatePacket with Length {0} to {1} in {2}", length, client,
client.ActiveCharacter.Zone as IWorldSpace ?? client.ActiveCharacter.Region);
}
var maxOutputLength = length + FullUpdatePacketHeaderSize;
var outSegment = BufferManager.GetSegment(maxOutputLength);
var deflater = new Deflater(RealmServerConfiguration.CompressionLevel);
deflater.SetInput(segment.Buffer.Array, segment.Offset + inputOffset, length);
//deflater.SetInput(input, 0 + inputOffset, length);
deflater.Finish();
int deflatedLength = deflater.Deflate(outSegment.Buffer.Array,
outSegment.Offset + FullUpdatePacketHeaderSize, length);
var totalLength = deflatedLength + FullUpdatePacketHeaderSize;
if (totalLength > MaxPacketSize)
{
//TODO: Split up packet if packet size exceeds max length
throw new Exception("Compressed Update packet exceeded max length: " + totalLength);
}
SendPacket(client, outSegment, totalLength, length);
outSegment.DecrementUsage();
}
}
public static byte[] Compress(byte[] input, int level)
{
byte[] bytesOut;
byte[] temp = new byte[input.Length];
Deflater deflater = new Deflater(level, true);
try
{
deflater.SetInput(input, 0, input.Length);
deflater.Finish();
bytesOut = new byte[deflater.Deflate(temp)];
}
catch (Exception e)
{
throw e;
}
Array.Copy(temp, 0, bytesOut, 0, bytesOut.Length);
return bytesOut;
}
public static byte[] Compress(byte[] content)
{
//return content;
Deflater compressor = new Deflater();
compressor.SetLevel(Deflater.BEST_COMPRESSION);
compressor.SetInput(content);
compressor.Finish();
using (MemoryStream bos = new MemoryStream(content.Length))
{
var buf = new byte[1024];
while (!compressor.IsFinished)
{
int n = compressor.Deflate(buf);
bos.Write(buf, 0, n);
}
return bos.ToArray();
}
}
private void WriteWhole(Deflater def, int typeCode, byte[] data)
{
int sz = data.Length;
int hdrlen = 0;
_buffer[hdrlen++] = (byte)((typeCode << 4) | sz & 15);
sz = (int)(((uint)sz) >> 4);
while (sz > 0)
{
_buffer[hdrlen - 1] |= 0x80;
_buffer[hdrlen++] = (byte)(sz & 0x7f);
sz = (int)(((uint)sz) >> 7);
}
_packDigest.Update(_buffer, 0, hdrlen);
_crc.Update(_buffer, 0, hdrlen);
_packOut.Write(_buffer, 0, hdrlen);
def.Reset();
def.SetInput(data);
def.Finish();
while (!def.IsFinished)
{
int datlen = def.Deflate(_buffer);
_packDigest.Update(_buffer, 0, datlen);
_crc.Update(_buffer, 0, datlen);
_packOut.Write(_buffer, 0, datlen);
}
}
/// <summary>
/// End compression.
/// </summary>
private void EndCompress()
{
// If no buffer exists, return.
if (_buffer == null)
return;
// Input buffer.
byte[] input = _buffer.ToArray();
// Dump buffer
_buffer.Clear();
_buffer = null;
// Create a new memory stream.
using (MemoryStream ms = new MemoryStream())
{
Deflater compress = new Deflater();
compress.SetInput(input);
compress.Finish();
// the result buffer
byte[] result = new byte[input.Length];
// Loop it just in case (shouldn't happen BUT, zlib's been known to cause a size increase)
while (!compress.IsFinished)
{
int length = compress.Deflate(result);
ms.Write(result, 0, length);
}
// Write the size of the compressed data, and the data.
WriteInt((int)ms.Length);
WriteBytes(ms.ToArray());
}
}
/// <summary>
/// Writes the MPK to a specific filename
/// </summary>
/// <param name="fname"></param>
public void Write(string fname)
{
Deflater def;
byte[] buf, dir, name;
var files = new MPKFile[_files.Count];
using (var dirmem = new MemoryStream(_files.Count*MPKFileHeader.MaxSize))
{
int index = 0;
uint offset = 0;
uint diroffset = 0;
foreach (MPKFile file in _files.Values)
{
file.Header.DirectoryOffset = diroffset;
file.Header.Offset = offset;
files[index] = file;
using (var wrtr = new BinaryWriter(dirmem, Encoding.UTF8))
{
file.Header.Write(wrtr);
}
offset += file.Header.UncompressedSize;
diroffset += file.Header.CompressedSize;
index++;
}
def = new Deflater();
def.SetInput(dirmem.GetBuffer(), 0, (int) dirmem.Position);
def.Finish();
dir = new byte[dirmem.Position];
def.Deflate(dir);
_sizeDir = (int) def.TotalOut;
}
def = new Deflater();
_crc.Reset();
_crc.Update(dir, 0, _sizeDir);
def.SetInput(Encoding.UTF8.GetBytes(_name));
def.Finish();
name = new byte[_name.Length];
def.Deflate(name);
_numFiles = _files.Count;
_sizeName = (int) def.TotalOut;
using (var filemem = new MemoryStream())
{
using (var wrtr = new BinaryWriter(filemem, Encoding.UTF8))
{
wrtr.Write((int) _crc.Value);
wrtr.Write(_sizeDir);
wrtr.Write(_sizeName);
wrtr.Write(_numFiles);
buf = new byte[16];
Buffer.BlockCopy(filemem.GetBuffer(), 0, buf, 0, 16);
for (byte i = 0; i < 16; i++)
{
buf[i] ^= i;
}
}
}
using (FileStream fileStream = File.Open(fname, FileMode.Create, FileAccess.Write))
{
using (var wrtr = new BinaryWriter(fileStream, Encoding.UTF8))
{
wrtr.Write(Magic);
wrtr.Write((byte) 2);
wrtr.Write(buf, 0, 16);
wrtr.Write(name, 0, _sizeName);
wrtr.Write(dir, 0, _sizeDir);
foreach (MPKFile file in files)
{
wrtr.Write(file.CompressedData);
}
}
}
}
//cualquiera de las dos funciones de comprimir causa un leak de memoria enorme
public static int ComprimirBuffer(byte[] in_buffer,ref byte[] out_buffer)
{
out_buffer=new byte[in_buffer.Length+300];
Deflater compresor=new Deflater();
compresor.SetInput(in_buffer);
compresor.Flush();
compresor.Finish();
int compressedsize=compresor.Deflate(out_buffer,0,(int)(in_buffer.Length)+300);
compresor=null;
return compressedsize;
}
// make string smaller (or try it at least ;)
public string Deflate(string input)
{
byte[] inputData = Convert.FromBase64String(input);
Deflater deflater = new Deflater(Deflater.BEST_SPEED, false);
deflater.SetInput(inputData);
deflater.Finish();
using (var ms = new MemoryStream())
{
var outputBuffer = new byte[65536 * 4];
while (deflater.IsNeedingInput == false)
{
var read = deflater.Deflate(outputBuffer);
ms.Write(outputBuffer, 0, read);
if (deflater.IsFinished == true)
break;
}
deflater.Reset();
return Convert.ToBase64String( ms.ToArray());
}
}
public static byte[] Deflate(byte [] input, int offset, int length)
{
System.IO.MemoryStream output = new System.IO.MemoryStream ();
Deflater deflater = new Deflater ();
deflater.SetInput (input, offset, length);
byte [] buf = new byte [1024];
int deflate_length;
while ((deflate_length = deflater.Deflate (buf)) > 0)
output.Write (buf, 0, deflate_length);
output.Close ();
return output.ToArray ();
}
/// <summary>
/// Loads a MPK file
/// </summary>
/// <param name="fname">The filename to load</param>
public void Load(string fname)
{
var fi = new FileInfo(fname);
if (!fi.Exists)
{
throw new FileNotFoundException("File does not exist", fname);
}
using (FileStream file = fi.OpenRead())
{
_buf = new byte[fi.Length];
file.Read(_buf, 0, _buf.Length);
}
_hdr = new MPKFileHeader { Name = fname, UncompressedSize = (uint)fi.Length, TimeStamp = (uint)DateTime.Now.ToFileTime() };
var def = new Deflater();
def.SetInput(_buf, 0, _buf.Length);
def.Finish();
// create temporary buffer
var tempbuffer = new byte[_buf.Length + _buf.Length / 5];
_hdr.CompressedSize = (uint)def.Deflate(tempbuffer, 0, tempbuffer.Length);
_compBuf = new byte[_hdr.CompressedSize];
Buffer.BlockCopy(tempbuffer, 0, _compBuf, 0, (int)_hdr.CompressedSize);
var crc = new Crc32();
crc.Update(_compBuf, 0, (int)_hdr.CompressedSize);
_hdr.CRC = crc;
}
/// <summary>
/// Build a binary data frame form the frame object.
/// </summary>
/// <param name="frame">ID3 Frame</param>
/// <returns>binary frame representation</returns>
public byte[] Make(FrameBase frame, out ushort flags)
{
flags = GetFlags(frame);
var buffer = frame.Make();
var memoryStream = new MemoryStream();
var writer = new BinaryWriter(memoryStream);
if (frame.Group.HasValue == true)
writer.Write((byte)frame.Group);
if (frame.Compression == true)
{
switch (Version)
{
case 3:
{
writer.Write(Swap.Int32(buffer.Length));
break;
}
case 4:
{
writer.Write(Sync.UnsafeBigEndian(Swap.UInt32((uint)buffer.Length)));
break;
}
default:
{
throw new NotImplementedException("ID3v2 Version " + Version + " is not supported.");
}
}
var buf = new byte[2048];
var deflater = new Deflater(Deflater.BEST_COMPRESSION);
deflater.SetInput(buffer, 0, buffer.Length);
deflater.Finish();
while (!deflater.IsNeedingInput)
{
int len = deflater.Deflate(buf, 0, buf.Length);
if (len <= 0)
{
break;
}
memoryStream.Write(buf, 0, len);
}
if (!deflater.IsNeedingInput)
{
//TODO: Skip and remove invalid frames.
throw new InvalidFrameException("Can't decompress frame '" + frame.FrameId + "' missing data");
}
}
else
{
memoryStream.Write(buffer, 0, buffer.Length);
}
if (frame.Encryption == true)
{
//TODO: Encryption
throw new NotImplementedException("Encryption is not implemented, consequently it is not supported.");
}
if (frame.Unsynchronisation == true)
{
MemoryStream synchStream = new MemoryStream();
Sync.Unsafe(memoryStream, synchStream, (uint)memoryStream.Position);
memoryStream = synchStream;
}
return memoryStream.ToArray();
}
/// <exception cref="System.IO.IOException"></exception>
private void Deflate(TemporaryBuffer.Heap tinyPack, byte[] content)
{
Deflater deflater = new Deflater();
byte[] buf = new byte[128];
deflater.SetInput(content, 0, content.Length);
deflater.Finish();
do
{
int n = deflater.Deflate(buf, 0, buf.Length);
if (n > 0)
{
tinyPack.Write(buf, 0, n);
}
}
while (!deflater.IsFinished);
}
/// <exception cref="System.IO.IOException"></exception>
private void WriteWhole(Deflater def, int typeCode, byte[] data)
{
int sz = data.Length;
int hdrlen = 0;
buf[hdrlen++] = unchecked((byte)((typeCode << 4) | sz & 15));
sz = (int)(((uint)sz) >> 4);
while (sz > 0)
{
buf[hdrlen - 1] |= unchecked((int)(0x80));
buf[hdrlen++] = unchecked((byte)(sz & unchecked((int)(0x7f))));
sz = (int)(((uint)sz) >> 7);
}
packDigest.Update(buf, 0, hdrlen);
crc.Update(buf, 0, hdrlen);
packOut.Write(buf, 0, hdrlen);
def.Reset();
def.SetInput(data);
def.Finish();
while (!def.IsFinished)
{
int datlen = def.Deflate(buf);
packDigest.Update(buf, 0, datlen);
crc.Update(buf, 0, datlen);
packOut.Write(buf, 0, datlen);
}
}
