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]); } }
// netz.compress.ICompress implementation public long Compress(string file, string zipFile) { long length = -1; FileStream ifs = null; FileStream ofs = null; try { ifs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read); ofs = File.Open(zipFile, FileMode.Create, FileAccess.Write, FileShare.None); DeflaterOutputStream dos = new DeflaterOutputStream(ofs, new Deflater(Deflater.BEST_COMPRESSION)); byte[] buff = new byte[ifs.Length]; while(true) { int r = ifs.Read(buff, 0, buff.Length); if(r <= 0) break; dos.Write(buff, 0, r); } dos.Flush(); dos.Finish(); length = dos.Length; dos.Close(); } finally { if(ifs != null) ifs.Close(); if(ofs != null) ofs.Close(); } return length; }
public override byte[] Encode(byte[] data) { var o = new MemoryStream(); var compressed = new DeflaterOutputStream(o, new Deflater(1)); compressed.Write(data, 0, data.Length); compressed.Flush(); compressed.Close(); return o.ToArray(); }
internal static Byte[] Deflate(Byte[] b) { System.IO.MemoryStream ms = new System.IO.MemoryStream(); DeflaterOutputStream outStream =new DeflaterOutputStream( ms); outStream.Write(b, 0, b.Length); outStream.Flush(); outStream.Finish(); Byte[] result=ms.ToArray(); outStream.Close(); ms.Close(); return result; }
/* * Name function: Compress * Purpose: compress a part of the byte array into a Zlib Block * Input: - buffer: byte array * - offset: starting offset inside the array * - count: num of bytes to compress starting from the offset * Output: compressed byte array block, the structure is: * - magic word * - max segment size * - total compressed size * - total uncompressed size * - segment list * - compressed data list */ public static byte[] Compress(byte[] buffer, int offset, int count) { if(buffer == null) throw new ArgumentNullException(); if (count < 0) throw new FormatException(); if (offset + count > buffer.Length) throw new IndexOutOfRangeException(); MemoryStream headBlock = new MemoryStream(); MemoryStream dataBlock = new MemoryStream(); DeflaterOutputStream zipStream; int numSeg = (int)Math.Ceiling((double)count / (double)maxSegmentSize); headBlock.WriteValueU32(magic); headBlock.WriteValueU32(maxSegmentSize); headBlock.WriteValueU32(0x0); //total compressed size, still to calculate headBlock.WriteValueS32(count); //total uncompressed size for (int i = count; i > 0; i -= (int)maxSegmentSize) { int copyBytes = Math.Min(i, (int)maxSegmentSize); uint precCompSize = (uint)dataBlock.Length; zipStream = new DeflaterOutputStream(dataBlock); zipStream.Write(buffer, offset + (count - i), copyBytes); zipStream.Flush(); zipStream.Finish(); headBlock.WriteValueU32((uint)dataBlock.Length - precCompSize); //compressed segment size headBlock.WriteValueS32(copyBytes); //uncompressed segment size //Console.WriteLine(" Segment size: {0}, total read: {1}, compr size: {2}", maxSegmentSize, copyBytes, (uint)dataBlock.Length - precCompSize); } headBlock.Seek(8, SeekOrigin.Begin); headBlock.WriteValueS32((int)dataBlock.Length); // total compressed size byte[] finalBlock = new byte[headBlock.Length + dataBlock.Length]; Buffer.BlockCopy(headBlock.ToArray(), 0, finalBlock, 0, (int)headBlock.Length); Buffer.BlockCopy(dataBlock.ToArray(), 0, finalBlock, (int)headBlock.Length, (int)dataBlock.Length); headBlock.Close(); dataBlock.Close(); return finalBlock; }
public static string Compress(byte[] data) { using(var m = new MemoryStream()) { switch(technique) { case "ZipStream": var br = new BinaryWriter(m); var z = new DeflaterOutputStream(m); br.Write(data.Length); z.Write(data, 0, data.Length); z.Flush(); z.Close(); break; } return technique + ":" + Convert.ToBase64String(m.GetBuffer()); } }
public static string Compress(byte[] data, ICodeProgress progress) { using(var m = new MemoryStream()) { switch(technique) { case "ZipStream": var br = new BinaryWriter(m); var z = new DeflaterOutputStream(m); br.Write(data.Length); z.Write(data, 0, data.Length); z.Flush(); z.Close(); break; case "7Zip": default: return Convert.ToBase64String(SevenZipRadical.Compression.LZMA.SevenZipRadicalHelper.Compress(data, progress)); } return technique + ":" + Convert.ToBase64String(m.GetBuffer()); } }
public static string Compress(byte[] data) { string result; using (MemoryStream memoryStream = new MemoryStream()) { string text = CompressionHelper.technique; if (text != null) { if (CompressionHelper.<>f__switch$map1F == null) { CompressionHelper.<>f__switch$map1F = new Dictionary<string, int>(1) { { "ZipStream", 0 } }; } int num; if (CompressionHelper.<>f__switch$map1F.TryGetValue(text, out num)) { if (num == 0) { BinaryWriter binaryWriter = new BinaryWriter(memoryStream); DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(memoryStream); binaryWriter.Write(data.Length); deflaterOutputStream.Write(data, 0, data.Length); deflaterOutputStream.Flush(); deflaterOutputStream.Close(); } } } result = CompressionHelper.technique + ":" + Convert.ToBase64String(memoryStream.GetBuffer()); } return result; }
public static byte[] Compress( byte []b, int offset, int len ) { try { /*zLib e = new zLib(); byte []compressedData = null; e.CompressStream( b, ref compressedData );*/ MemoryStream ms = new MemoryStream(); DeflaterOutputStream defl = new DeflaterOutputStream( ms ); defl.Write(b, offset, len ); defl.Flush(); defl.Close(); byte[] compressedData = (byte[])ms.ToArray(); //HexViewer.View( compressedData, 0, compressedData.Length ); return compressedData; } catch(Exception e) { Console.WriteLine( e.Message ); return null; } }
/// <summary> /// deflates (zlib) a VideoCopy, returning a byte array suitable for insertion into a JMD file /// the byte array includes width and height dimensions at the beginning /// this is run asynchronously for speedup, as compressing can be slow /// </summary> /// <param name="v">video frame to compress</param> /// <returns>zlib compressed frame, with width and height prepended</returns> byte[] GzipFrame(VideoCopy v) { MemoryStream m = new MemoryStream(); // write frame height and width first m.WriteByte((byte)(v.BufferWidth >> 8)); m.WriteByte((byte)(v.BufferWidth & 255)); m.WriteByte((byte)(v.BufferHeight >> 8)); m.WriteByte((byte)(v.BufferHeight & 255)); var g = new DeflaterOutputStream(m, new Deflater(token.compressionlevel)); g.IsStreamOwner = false; // leave memory stream open so we can pick its contents g.Write(v.VideoBuffer, 0, v.VideoBuffer.Length); g.Flush(); g.Close(); byte[] ret = m.GetBuffer(); Array.Resize(ref ret, (int)m.Length); m.Close(); return ret; }
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 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; }
private static void WriteDataChunks() { byte[] pixels = _image.ToByteArray(); byte[] data = new byte[_image.PixelWidth * _image.PixelHeight * 4 + _image.PixelHeight]; int rowLength = _image.PixelWidth * 4 + 1; for (int y = 0; y < _image.PixelHeight; y++) { byte compression = 0; if (y > 0) { compression = 2; } data[y * rowLength] = compression; for (int x = 0; x < _image.PixelWidth; x++) { // Calculate the offset for the new array. int dataOffset = y * rowLength + x * 4 + 1; // Calculate the offset for the original pixel array. int pixelOffset = (y * _image.PixelWidth + x) * 4; data[dataOffset + 0] = pixels[pixelOffset + 0]; data[dataOffset + 1] = pixels[pixelOffset + 1]; data[dataOffset + 2] = pixels[pixelOffset + 2]; data[dataOffset + 3] = pixels[pixelOffset + 3]; if (y > 0) { int lastOffset = ((y - 1) * _image.PixelWidth + x) * 4; data[dataOffset + 0] -= pixels[lastOffset + 0]; data[dataOffset + 1] -= pixels[lastOffset + 1]; data[dataOffset + 2] -= pixels[lastOffset + 2]; data[dataOffset + 3] -= pixels[lastOffset + 3]; } } } byte[] buffer = null; int bufferLength = 0; MemoryStream memoryStream = null; try { memoryStream = new MemoryStream(); using (DeflaterOutputStream zStream = new DeflaterOutputStream(memoryStream)) { zStream.Write(data, 0, data.Length); zStream.Flush(); zStream.Finish(); bufferLength = (int)memoryStream.Length; buffer = memoryStream.GetBuffer(); } } finally { if (memoryStream != null) { memoryStream.Dispose(); } } int numChunks = bufferLength / MaxBlockSize; if (bufferLength % MaxBlockSize != 0) { numChunks++; } for (int i = 0; i < numChunks; i++) { int length = bufferLength - i * MaxBlockSize; if (length > MaxBlockSize) { length = MaxBlockSize; } WriteChunk(PngChunkTypes.Data, buffer, i * MaxBlockSize, length); } }
private static byte[] getOutputByCompress(byte[] toByteArray) { int unCompressedLength = 0; int compressedLength = 0; byte[] input = toByteArray; unCompressedLength = input.Length; MemoryStream memoryStream = new MemoryStream(); Deflater compressor = new Deflater(); DeflaterOutputStream defos = new DeflaterOutputStream(memoryStream, compressor); defos.Write(input, 0, input.Length); defos.Flush(); defos.Finish(); byte[] output = memoryStream.ToArray(); compressedLength = output.Length; memoryStream.Close(); defos.Close(); //set compress flag and compressedLength, unCompressedLength byte[] sendData = new byte[output.Length + TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfInt() + TransferUtil.getLengthOfInt()]; sendData[0] = TransferObject.COMPRESS_FLAG; //0:normal; 1:compress TransferOutputStream fos = new TransferOutputStream(sendData); fos.skipAByte(); fos.writeInt(unCompressedLength); fos.writeInt(compressedLength); Array.Copy(output, 0, sendData, TransferUtil.getLengthOfByte() + TransferUtil.getLengthOfInt() + TransferUtil.getLengthOfInt(), output.Length); return sendData; }
/// <summary> /// Compress the specified data. /// </summary> /// <param name='data'> /// Data. /// </param> static string Compress(byte[] data) { MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); DeflaterOutputStream zs = new DeflaterOutputStream(ms); bw.Write(data.Length); zs.Write(data,0,data.Length); zs.Flush(); zs.Close (); bw.Close(); return "ZipStream:" + Convert.ToBase64String(ms.GetBuffer()); }
public static byte[] ZipBytes(byte[] input) { MemoryStream ms = new MemoryStream(); Deflater zipper = new Deflater(); zipper.SetLevel(5); Stream st = new DeflaterOutputStream(ms, zipper); st.Write(input, 0, input.Length); st.Flush(); st.Close(); byte[] result = (byte[])ms.ToArray(); return result; }