public byte[] Compress(byte[] bytData, params int[] ratio) { int compRatio = 9; try { if (ratio[0] > 0) { compRatio = ratio[0]; } } catch { throw; } try { var ms = new MemoryStream(); var defl = new Deflater(compRatio, false); Stream s = new DeflaterOutputStream(ms, defl); s.Write(bytData, 0, bytData.Length); s.Close(); byte[] compressedData = ms.ToArray(); return compressedData; } catch { throw; } }
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(); }
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); }
public ChunkDataPacket() { if (zLibDeflater == null) zLibDeflater = new Deflater(CompressionLevel); if (LockObject == null) LockObject = new object(); }
/// <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(); }
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); }
/// <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 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> /// Construct an object writer for the specified repository. /// </summary> /// <param name="repo"> </param> public ObjectWriter(Repository repo) { _r = repo; _buf = new byte[0x2000]; _md = new MessageDigest(); _def = new Deflater(_r.Config.getCore().getCompression()); }
public ObjectWriter(Repository repo) { this.r = repo; buf = new byte[8192]; md = new MessageDigest(); // [henon] Sha1 hash digest generator def = new Deflater(r.Config.Core.Compression); }
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 void TestInflateDeflate() { MemoryStream ms = new MemoryStream(); Deflater deflater = new Deflater(6); DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater); byte[] buf = new byte[1000000]; System.Random rnd = new Random(); rnd.NextBytes(buf); outStream.Write(buf, 0, buf.Length); outStream.Flush(); outStream.Finish(); ms.Seek(0, SeekOrigin.Begin); InflaterInputStream inStream = new InflaterInputStream(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) { Assertion.AssertEquals(buf2[i], buf[i]); } }
public ZlibStream(Stream inner, Inflater inflater, int buffSize) { _innerStream = inner; _in = inflater; _inBuff = new byte[buffSize]; _outBuff = _inBuff; _out = new Deflater(); }
/// <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> /// Compress an array of bytes. /// </summary> /// <param name="_pBytes">An array of bytes to be compressed.</param> /// <returns>Compressed bytes.</returns> /// <example> /// Following example demonstrates the way of compressing an ASCII string text. /// <code> /// public void Compress() /// { /// string source = "Hello, world!"; /// byte[] source_bytes = System.Text.Encoding.ASCII.GetBytes(source); /// byte[] compressed = DataCompression.Compress(source_bytes); /// /// // Process the compressed bytes here. /// } /// </code> /// </example> /// <remarks>It is the best practice that use the overrided <b>DataCompression.Compress</b> method with <see cref="System.String"/> parameter to compress a string.</remarks> public static byte[] Compress(byte[] _pBytes) { MemoryStream ms = new MemoryStream(); Deflater mDeflater = new Deflater(Deflater.BEST_COMPRESSION); DeflaterOutputStream outputStream = new DeflaterOutputStream(ms, mDeflater, 131072); outputStream.Write(_pBytes, 0, _pBytes.Length); outputStream.Close(); return ms.ToArray(); }
private ICSharpCode.SharpZipLib.Zip.Compression.Deflater Deflater() { if (deflater == null) { deflater = new ICSharpCode.SharpZipLib.Zip.Compression.Deflater(config.GetCompressionLevel ()); } else { deflater.Reset(); } return(deflater); }
MemoryStream Deflate(byte[] data, int level, bool zlib) { MemoryStream memoryStream = new MemoryStream(); Deflater deflater = new Deflater(level, !zlib); using ( DeflaterOutputStream outStream = new DeflaterOutputStream(memoryStream, deflater) ) { outStream.IsStreamOwner = false; outStream.Write(data, 0, data.Length); outStream.Flush(); outStream.Finish(); } return memoryStream; }
public static void Serialize(Stream stream, PiaFile piaFile) { if (stream == null) throw new ArgumentNullException("Stream"); if (piaFile == null) throw new ArgumentNullException("PiaFile"); try { // Header var headerString = piaFile.Header.ToString(); var headerBytes = Encoding.Default.GetBytes(headerString); stream.Write(headerBytes, 0, headerBytes.Length); // Nodes var nodeString = _serializeNode(piaFile); var nodeBytes = Encoding.Default.GetBytes(nodeString); // Deflation byte[] deflatedBytes; var deflater = new Deflater(Deflater.DEFAULT_COMPRESSION); using (var ms = new MemoryStream()) { var deflateStream = new DeflaterOutputStream(ms, deflater); deflateStream.Write(nodeBytes, 0, nodeBytes.Length); deflateStream.Finish(); deflatedBytes = ms.ToArray(); } // Checksum var checkSum = new byte[12]; BitConverter.GetBytes(deflater.Adler).CopyTo(checkSum, 0); // Adler BitConverter.GetBytes(nodeBytes.Length).CopyTo(checkSum, 4); // InflatedSize BitConverter.GetBytes(deflatedBytes.Length).CopyTo(checkSum, 8); // DeflatedSize stream.Write(checkSum, 0, checkSum.Length); // Final write stream.Write(deflatedBytes, 0, deflatedBytes.Length); } catch (Exception) { throw; } }
public byte[] Compress(byte[] bytData) { try { var ms = new MemoryStream(); var defl = new Deflater(9, false); Stream s = new DeflaterOutputStream(ms, defl); s.Write(bytData, 0, bytData.Length); s.Close(); byte[] compressedData = ms.ToArray(); return compressedData; } catch { throw; } }
/// <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(); } }
/// <summary> /// Write out bytes to the underlying stream after compressing them using deflate /// </summary> /// <param name="buffer">The array of bytes to write</param> /// <param name="offset">The offset into the supplied buffer to start</param> /// <param name="count">The number of bytes to write</param> public override void Write(byte[] buffer, int offset, int count) { if (m_stream == null) { Deflater deflater; switch(CompressionLevel) { case CompressionLevels.High: deflater = new Deflater(Deflater.BEST_COMPRESSION, true); break; case CompressionLevels.Low: deflater = new Deflater(Deflater.BEST_SPEED, true); break; case CompressionLevels.Normal: default: deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, true); break; } m_stream = new DeflaterOutputStream(BaseStream, deflater); } m_stream.Write(buffer, offset, count); }
public static int Deflate(byte[] inBuffer, ref byte[] outBuffer) { int newLen = 0, flagOffset = 1; outBuffer[0] = inBuffer[0]; if (inBuffer[0] == 0) { flagOffset = 2; outBuffer[1] = inBuffer[1]; } if (inBuffer.Length > 30) { using (MemoryStream ms = new MemoryStream()) { Deflater deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, false); using (DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater)) { outStream.IsStreamOwner = false; outStream.Write(inBuffer, flagOffset, inBuffer.Length - flagOffset); outStream.Flush(); outStream.Finish(); } ms.Position = 0; ms.Read(outBuffer, flagOffset + 1, (int)ms.Length); newLen = (int)ms.Length + flagOffset + 1; outBuffer[flagOffset] = 0x5a; } } else { Buffer.BlockCopy(inBuffer, flagOffset, outBuffer, flagOffset + 1, inBuffer.Length - flagOffset); outBuffer[flagOffset] = 0xa5; newLen = inBuffer.Length + 1; } return newLen; }
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize) { if ( baseOutputStream == null ) { throw new ArgumentNullException("baseOutputStream"); } if (baseOutputStream.CanWrite == false) { throw new ArgumentException("Must support writing", "baseOutputStream"); } if (deflater == null) { throw new ArgumentNullException("deflater"); } if (bufferSize <= 0) { throw new ArgumentOutOfRangeException("bufferSize"); } baseOutputStream_ = baseOutputStream; buffer_ = new byte[bufferSize]; deflater_ = deflater; }
/// <summary> /// ѹ�����ݣ����ѹ����ֵΪ-1��ʾ��������������ѹ������ /// </summary> /// <param name="val">ԭʼ������</param> /// <returns>ѹ����������</returns> public byte[] Compress(byte[] val) { byte[] buf; if (overSize != -1 && val.Length > overSize) { using (MemoryStream destStream = new MemoryStream()) { Deflater deflater = new Deflater(Deflater.DEFAULT_COMPRESSION, true); using (DeflaterOutputStream compressStream = new DeflaterOutputStream(destStream, deflater)) { compressStream.Write(val, 0, val.Length); compressStream.Finish(); buf = new byte[destStream.Length + 1]; destStream.ToArray().CopyTo(buf, 1); } buf[0] = 1; // ��ѹ����־ return buf; } } else { buf = new byte[val.Length + 1]; val.CopyTo(buf, 1); buf[0] = 0; // δѹ����־ return buf; } }
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize) { this.isStreamOwner_ = true; if (baseOutputStream == null) { throw new ArgumentNullException("baseOutputStream"); } if (!baseOutputStream.CanWrite) { throw new ArgumentException("Must support writing", "baseOutputStream"); } if (deflater == null) { throw new ArgumentNullException("deflater"); } if (bufferSize < 0x200) { throw new ArgumentOutOfRangeException("bufferSize"); } this.baseOutputStream_ = baseOutputStream; this.buffer_ = new byte[bufferSize]; this.deflater_ = deflater; }
public void TestInflateDeflate() { MemoryStream ms = new MemoryStream(); Deflater deflater = new Deflater(6); DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater); byte[] buf = new byte[1000000]; System.Random rnd = new Random(); rnd.NextBytes(buf); outStream.Write(buf, 0, buf.Length); outStream.Flush(); outStream.Finish(); ms.Seek(0, SeekOrigin.Begin); InflaterInputStream inStream = new InflaterInputStream(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) { Assertion.AssertEquals(buf2[i], buf[i]); } }
/// <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); }
internal ZipStream(Deflater deflater, byte[] zbuf) { this.deflater = deflater; this.zbuf = zbuf; }
/// <summary> /// Creates a new DeflaterOutputStream with the given Deflater and /// default buffer size. /// </summary> /// <param name="baseOutputStream"> /// the output stream where deflated output should be written. /// </param> /// <param name="defl"> /// the underlying deflater. /// </param> public DeflaterOutputStream(Stream baseOutputStream, Deflater defl) : this(baseOutputStream, defl, 512) { }
private ICSharpCode.SharpZipLib.Zip.Compression.Deflater Deflater() { if (deflater == null) { deflater = new ICSharpCode.SharpZipLib.Zip.Compression.Deflater(config.GetCompressionLevel ()); } else { deflater.Reset(); } return deflater; }