예제 #1
0
        public static async Task <BA2FileEntryBuilder> Create(BA2FileEntryState state, Stream src, DiskSlabAllocator slab)
        {
            var builder = new BA2FileEntryBuilder
            {
                _state   = state,
                _rawSize = (int)src.Length,
                _dataSrc = src
            };

            if (!state.Compressed)
            {
                return(builder);
            }

            await using (var ms = new MemoryStream())
            {
                await using (var ds = new DeflaterOutputStream(ms))
                {
                    ds.IsStreamOwner = false;
                    await builder._dataSrc.CopyToAsync(ds);
                }

                builder._dataSrc = slab.Allocate(ms.Length);
                ms.Position      = 0;
                await ms.CopyToAsync(builder._dataSrc);

                builder._dataSrc.Position = 0;
                builder._size             = (int)ms.Length;
            }
            return(builder);
        }
예제 #2
0
        /// ファイルを書き込みます。
        protected void WriteFile(string type, uint opt0, uint opt1, Stream source)
        {
            //Console.WriteLine("taOb extract length {0}", source.Length);

            MemoryStream dest = new MemoryStream();

            using (DeflaterOutputStream gzip = new DeflaterOutputStream(dest))
            {
                gzip.IsStreamOwner = false;

                byte[] b = new byte[4096];
                StreamUtils.Copy(source, gzip, b);
            }
            dest.Seek(0, SeekOrigin.Begin);
            //Console.WriteLine("taOb length {0}", dest.Length);

            byte[] chunk_type = System.Text.Encoding.ASCII.GetBytes(type);
            byte[] chunk_data = new byte[dest.Length + 20];

            Array.Copy(chunk_type, 0, chunk_data, 0, 4);

            byte[] buf;
            buf = BitConverter.GetBytes((UInt32)opt0);
            Array.Copy(buf, 0, chunk_data, 4, 4);
            buf = BitConverter.GetBytes((UInt32)opt1);
            Array.Copy(buf, 0, chunk_data, 8, 4);

            buf = BitConverter.GetBytes((UInt32)source.Length);
            Array.Copy(buf, 0, chunk_data, 12, 4);
            buf = BitConverter.GetBytes((UInt32)dest.Length);
            Array.Copy(buf, 0, chunk_data, 16, 4);

            dest.Read(chunk_data, 20, (int)dest.Length);
            PNGWriter.WriteChunk(writer, "taOb", chunk_data);
        }
예제 #3
0
        private void openGameBox(string fileName)
        {
            IModel model = controller.Model;

            model.ClearTransientState();
            try {
                model.OpenGameBox(fileName);
                model.GameLibrary.AddReference(model.CurrentGameBox.Reference);
                model.CurrentGameBox.OpenBuiltInScenario(model.CurrentGameBox.StartupScenarioFileName);
            } catch {
                model.OpenGameBox(model.GameLibrary.DefaultGameBox);
                model.CurrentGameBox.OpenBuiltInScenario(model.CurrentGameBox.StartupScenarioFileName);
                throw;
            } finally {
                byte[] gameData;
                using (MemoryStream stream = new MemoryStream()) {
                    using (DeflaterOutputStream compressionStream = new DeflaterOutputStream(stream)) {
                        model.CurrentGameBox.CurrentGame.Save(compressionStream, false);
                        compressionStream.Flush();
                    }
                    stream.Flush();
                    gameData = stream.ToArray();
                }
                ++model.StateChangeSequenceNumber;
                controller.NetworkClient.Send(new GameLoadedMessage(model.StateChangeSequenceNumber, gameData));
                controller.View.ResetGraphicsElements();
            }
        }
예제 #4
0
        public void SetPictureData(byte[] pictureData)
        {
            base.PictureData = (pictureData);
            UncompressedSize = (pictureData.Length);

            // info of chicago project:
            // "... LZ compression algorithm in the format used by GNU Zip deflate/inflate with a 32k window ..."
            // not sure what to do, when lookup tables exceed 32k ...

            try
            {
                MemoryStream         bos = new MemoryStream();
                DeflaterOutputStream dos = new DeflaterOutputStream(bos);
                dos.Write(pictureData, 0, pictureData.Length);
                dos.Dispose();
                raw_pictureData = bos.ToArray();
            }
            catch (IOException e)
            {
                throw new RuntimeException("Can't compress metafile picture data", e);
            }

            CompressedSize = (raw_pictureData.Length);
            IsCompressed   = (true);
        }
예제 #5
0
        /// <summary>
        /// 数据压缩
        /// </summary>
        /// <param name="data">待压缩数据</param>
        /// <param name="offset">数据起始位置</param>
        /// <param name="len">数据长度</param>
        /// <param name="os">压缩后的数据输出流</param>
        /// <param name="deflater">压缩器</param>
        public static void Compress(byte[] data, int offset, int len, Stream os, Deflater deflater)
        {
            DeflaterOutputStream dos = new DeflaterOutputStream(os, deflater, 1024 * 4);

            dos.Write(data, offset, len);
            dos.Finish();
        }
예제 #6
0
 /// <exception cref="System.IO.IOException"/>
 private static void ProcessExtraSamples(DeflaterOutputStream zip, DeflaterOutputStream mzip, byte[] outBuf
                                         , int samplePerPixel, int bitsPerSample, int width, int height)
 {
     if (bitsPerSample == 8)
     {
         byte[] mask  = new byte[width * height];
         int    mptr  = 0;
         int    optr  = 0;
         int    total = width * height * samplePerPixel;
         for (int k = 0; k < total; k += samplePerPixel)
         {
             for (int s = 0; s < samplePerPixel - 1; ++s)
             {
                 outBuf[optr++] = outBuf[k + s];
             }
             mask[mptr++] = outBuf[k + samplePerPixel - 1];
         }
         zip.Write(outBuf, 0, optr);
         mzip.Write(mask, 0, mptr);
     }
     else
     {
         throw new iText.IO.IOException(iText.IO.IOException.ExtraSamplesAreNotSupported);
     }
 }
        public void DeflatorStreamOwnership()
        {
            var memStream = new TrackedMemoryStream();
            var s         = new DeflaterOutputStream(memStream);

            Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
            Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");

            s.Close();

            Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
            Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");

            memStream = new TrackedMemoryStream();
            s         = new DeflaterOutputStream(memStream);

            Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
            Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");

            s.IsStreamOwner = false;
            s.Close();

            Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
            Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
        }
예제 #8
0
        /// <summary>
        ///     Compresses the specified string to compress.
        /// </summary>
        /// <param name="stringToCompress">The string to compress.</param>
        /// <returns>
        ///     A <see cref="CompressedItem"/> containing details about
        ///     the compressed string.
        /// </returns>
        /// <externalUnit cref="CompressedItem"/>
        /// <externalUnit cref="MemoryStream"/>
        /// <externalUnit cref="Encoding"/>
        /// <externalUnit cref="DeflaterOutputStream"/>
        /// <revision revisor="dev06" date="1/11/2009" version="1.0.0.0">
        ///     Member Created
        /// </revision>
        public static CompressedItem Compress(string stringToCompress)
        {
            // create parm for return
            var compressedItem = new CompressedItem();

            // get the bytes of the string
            byte[] uncompressedData =
                Encoding.Unicode.GetBytes(stringToCompress);

            // save the uncompressed size of the byte array to
            // use when decompressing
            compressedItem.UncompressedSize = uncompressedData.Length;

            // create a stream for storing the compressed data
            using (var compressedStream = new MemoryStream())
            {
                // create stream for compressing the data
                using (var zipStream =
                           new DeflaterOutputStream(compressedStream))
                {
                    // write the data to the stream - which will compress it
                    // and put it it the compressed stream object
                    zipStream.Write(
                        uncompressedData, 0, uncompressedData.Length);
                }

                // set the compressed data on the return item
                compressedItem.Data = compressedStream.ToArray();
            }

            return(compressedItem);
        }
예제 #9
0
        /// <exception cref="System.IO.IOException"></exception>
        private byte[] CompressPackFormat(int type, byte[] data)
        {
            byte[] hdr        = new byte[64];
            int    rawLength  = data.Length;
            int    nextLength = (int)(((uint)rawLength) >> 4);

            hdr[0] = unchecked ((byte)((nextLength > 0 ? unchecked ((int)(0x80)) : unchecked ((int
                                                                                               )(0x00))) | (type << 4) | (rawLength & unchecked ((int)(0x0F)))));
            rawLength = nextLength;
            int n = 1;

            while (rawLength > 0)
            {
                nextLength = (int)(((uint)nextLength) >> 7);
                hdr[n++]   = unchecked ((byte)((nextLength > 0 ? unchecked ((int)(0x80)) : unchecked (
                                                    (int)(0x00))) | (rawLength & unchecked ((int)(0x7F)))));
                rawLength = nextLength;
            }
            ByteArrayOutputStream @out = new ByteArrayOutputStream();

            @out.Write(hdr, 0, n);
            DeflaterOutputStream d = new DeflaterOutputStream(@out);

            d.Write(data);
            d.Finish();
            return(@out.ToByteArray());
        }
예제 #10
0
        /// <summary>
        /// Compressed data using the zlib compression library.
        /// </summary>
        /// <param name="data">Data to be compressed.</param>
        /// <param name="gnf">GNF class that is associated with that data.</param>
        /// <returns>Compressed data</returns>
        private static byte[] GetCompressedZlibData(byte[] data, GNF gnf)
        {
            if (data == null || data.Length == 0)
            {
                return(data);
            }

            using (var inStream = new MemoryStream(data))
            {
                var outStream      = new MemoryStream();
                var compressStream = new DeflaterOutputStream(outStream, new Deflater(Deflater.DEFAULT_COMPRESSION));

                int bufferSize;
                var buffer = new byte[4096];

                while ((bufferSize = inStream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    compressStream.Write(buffer, 0, bufferSize);
                }

                compressStream.Close();
                byte[] outStreamData = outStream.ToArray();

                gnf.Size = (uint)outStreamData.Length;
                return(outStreamData);
            }
        }
        private bool FlushCompressedBlock()
        {
            using (var data = new MemoryStream())
            {
                /*var blockLength = Array.FindLastIndex(this._BlockBytes, this._BlockOffset - 1, b => b != 0);
                 * blockLength = 1 + (blockLength < 0 ? 0 : blockLength);*/
                var blockLength = this._BlockOffset;

                var zlib = new DeflaterOutputStream(data);
                zlib.Write(this._BlockBytes, 0, blockLength);
                zlib.Finish();
                data.Flush();

                var compressedLength = (int)data.Length;
                if (data.Length < blockLength)
                {
                    this._BaseStream.WriteValueS32(32 + compressedLength, this._Endian);
                    this._BaseStream.WriteValueU8(1);
                    CompressedBlockHeader compressedBlockHeader;
                    compressedBlockHeader.UncompressedSize = (uint)blockLength;
                    compressedBlockHeader.Unknown04        = 32;
                    compressedBlockHeader.Unknown08        = 81920;
                    compressedBlockHeader.Unknown0C        = 135200769;
                    compressedBlockHeader.CompressedSize   = (uint)compressedLength;
                    compressedBlockHeader.Unknown14        = 0;
                    compressedBlockHeader.Unknown18        = 0;
                    compressedBlockHeader.Unknown1C        = 0;
                    compressedBlockHeader.Write(this._BaseStream, this._Endian);
                    this._BaseStream.Write(data.GetBuffer(), 0, compressedLength);
                    this._BlockOffset = 0;
                    return(true);
                }
            }
            return(false);
        }
        public void CloseInflatorWithNestedUsing()
        {
            string tempFile = null;

            try {
                tempFile = Path.GetTempPath();
            } catch (SecurityException) {
            }

            Assert.IsNotNull(tempFile, "No permission to execute this test?");

            tempFile = Path.Combine(tempFile, "SharpZipTest.Zip");
            using (FileStream diskFile = File.Create(tempFile))
                using (DeflaterOutputStream deflator = new DeflaterOutputStream(diskFile))
                    using (StreamWriter textWriter = new StreamWriter(deflator)) {
                        textWriter.Write("Hello");
                        textWriter.Flush();
                    }

            using (FileStream diskFile = File.OpenRead(tempFile))
                using (InflaterInputStream deflator = new InflaterInputStream(diskFile))
                    using (StreamReader textReader = new StreamReader(deflator)) {
                        char[] buffer    = new char[5];
                        int    readCount = textReader.Read(buffer, 0, 5);
                        Assert.AreEqual(5, readCount);

                        var b = new StringBuilder();
                        b.Append(buffer);
                        Assert.AreEqual("Hello", b.ToString());
                    }

            File.Delete(tempFile);
        }
예제 #13
0
        internal DeflateStream(Stream compressedStream, CompressionMode mode, bool leaveOpen, bool gzip)
        {
            if (compressedStream == null)
            {
                throw new ArgumentNullException("compressedStream");
            }

            switch (mode)
            {
            case CompressionMode.Compress:
                if (!compressedStream.CanWrite)
                {
                    throw new ArgumentException("The base stream is not writeable.");
                }
                OutputStream outStream = new OutputStreamImpl(compressedStream);
                _writer = gzip ? new GZIPOutputStream(outStream) : new DeflaterOutputStream(outStream, new Deflater(Deflater.DEFAULT_COMPRESSION, true));
                break;

            case CompressionMode.Decompress:
                if (!compressedStream.CanRead)
                {
                    throw new ArgumentException("The base stream is not readable.");
                }
                InputStream inStream = new InputStreamImpl(compressedStream);
                _reader = gzip ? new GZIPInputStream(inStream) : new InflaterInputStream(inStream, new Inflater(true));
                break;

            default:
                throw new ArgumentException("mode");
            }

            _baseStream = compressedStream;
            _leaveOpen  = leaveOpen;
            _open       = true;
        }
예제 #14
0
        public override void Run()
        {
            var tasks = new Task[options.Threads];

            for (var i = 0; i < options.Threads; i++)
            {
                var i1 = i;
                tasks[i] = ThreadAffinity.RunAffinity(1uL << i, () =>
                {
                    using (Stream s = new MemoryStream())
                    {
                        using var stream = new DeflaterOutputStream(s, new Deflater(Deflater.BEST_COMPRESSION));
                        using var sw = new StreamWriter(stream);

                        sw.Write(datas[i1]);
                        sw.Flush();
                        stream.Finish();
                    }

                    BenchmarkRunner.ReportProgress();
                });
            }

            Task.WaitAll(tasks);
        }
예제 #15
0
        protected void WriteTaOb(BinaryWriter bw, string type, uint opt0, uint opt1, byte[] data)
        {
            Console.WriteLine("WriteTaOb {0}", type);
            Console.WriteLine("taOb extract length {0}", data.Length);
            byte[] chunk_type = System.Text.Encoding.ASCII.GetBytes(type);

            MemoryStream dest = new MemoryStream();

            using (DeflaterOutputStream gzip = new DeflaterOutputStream(dest))
            {
                gzip.IsStreamOwner = false;
                gzip.Write(data, 0, data.Length);
            }
            dest.Seek(0, SeekOrigin.Begin);
            Console.WriteLine("taOb length {0}", dest.Length);
            byte[] chunk_data = new byte[dest.Length + 20];

            Array.Copy(chunk_type, 0, chunk_data, 0, 4);
            byte[] buf;
            buf = BitConverter.GetBytes((UInt32)opt0);
            Array.Copy(buf, 0, chunk_data, 4, 4);
            buf = BitConverter.GetBytes((UInt32)opt1);
            Array.Copy(buf, 0, chunk_data, 8, 4);
            buf = BitConverter.GetBytes((UInt32)data.Length);
            Array.Copy(buf, 0, chunk_data, 12, 4);
            buf = BitConverter.GetBytes((UInt32)dest.Length);
            Array.Copy(buf, 0, chunk_data, 16, 4);

            dest.Read(chunk_data, 20, (int)dest.Length);
            WriteChunk(bw, "taOb", chunk_data);
        }
예제 #16
0
        private void CompressData()
        {
            if (_bsa.HeaderType == VersionType.SSE)
            {
                var r = new MemoryStream();
                using (var w = LZ4Stream.Encode(r, new LZ4EncoderSettings()
                {
                    CompressionLevel = LZ4Level.L10_OPT
                }))
                    (new MemoryStream(_rawData)).CopyTo(w);

                _rawData = r.ToArray();
            }
            else if (_bsa.HeaderType == VersionType.FO3 || _bsa.HeaderType == VersionType.TES4)
            {
                var r = new MemoryStream();
                using (var w = new DeflaterOutputStream(r))
                    (new MemoryStream(_rawData)).CopyTo(w);

                _rawData = r.ToArray();
            }
            else
            {
                throw new NotImplementedException($"Can't compress data for {_bsa.HeaderType} BSAs.");
            }
        }
예제 #17
0
        internal static bool _compress(Stream uncompressed, out byte[] res)
        {
            using (MemoryStream result = new MemoryStream())
            {
                if (uncompressed.Length == 0)
                {
                    res = null;
                    return(false);
                }
                BinaryWriter w = new BinaryWriter(result);

                using (DeflaterOutputStream ds = new DeflaterOutputStream(result)
                {
                    IsStreamOwner = false
                })
                {
                    uncompressed.CopyTo(ds);
                }

                if (result.Length < uncompressed.Length)
                {
                    res = result.ToArray();
                    return(true);
                }
                else
                {
                    res = null;
                    return(false);
                }
            }
        }
예제 #18
0
        public static ChunkBuilder Create(BA2DX10EntryState state, ChunkState chunk, Stream src)
        {
            var builder = new ChunkBuilder {
                _chunk = chunk
            };

            using (var ms = new MemoryStream())
            {
                src.CopyToLimit(ms, (int)chunk.FullSz);
                builder._data = ms.ToArray();
            }

            if (!chunk.Compressed)
            {
                return(builder);
            }

            using (var ms = new MemoryStream())
            {
                using (var ds = new DeflaterOutputStream(ms))
                {
                    ds.Write(builder._data, 0, builder._data.Length);
                }

                builder._data = ms.ToArray();
            }

            builder._packSize = (uint)builder._data.Length;

            return(builder);
        }
        public void CloseDeflatorWithNestedUsing()
        {
            string tempFile = null;

            try
            {
                tempFile = Path.GetTempPath();
            }
            catch (SecurityException)
            {
            }

            Assert.IsNotNull(tempFile, "No permission to execute this test?");

            tempFile = Path.Combine(tempFile, "SharpZipTest.Zip");
            using (FileStream diskFile = File.Create(tempFile))
                using (DeflaterOutputStream deflator = new DeflaterOutputStream(diskFile))
                    using (StreamWriter txtFile = new StreamWriter(deflator))
                    {
                        txtFile.Write("Hello");
                        txtFile.Flush();
                    }

            File.Delete(tempFile);
        }
예제 #20
0
        public static BA2FileEntryBuilder Create(BA2FileEntryState state, Stream src)
        {
            var builder = new BA2FileEntryBuilder {
                _state = state
            };

            using (var ms = new MemoryStream())
            {
                src.CopyTo(ms);
                builder._data = ms.ToArray();
            }
            builder._rawSize = builder._data.Length;

            if (state.Compressed)
            {
                using (var ms = new MemoryStream())
                {
                    using (var ds = new DeflaterOutputStream(ms))
                    {
                        ds.Write(builder._data, 0, builder._data.Length);
                    }
                    builder._data = ms.ToArray();
                }
                builder._size = builder._data.Length;
            }
            return(builder);
        }
예제 #21
0
        public override void Initialize()
        {
            var tasks = new Task[options.Threads];

            for (var i = 0; i < options.Threads; i++)
            {
                var i1 = i;

                tasks[i1] = Task.Run(() =>
                {
                    var data = DataGenerator.GenerateString((int)(volume / options.Threads));

                    using var s = new MemoryStream();
                    using (var stream = new DeflaterOutputStream(s, new Deflater(Deflater.BEST_COMPRESSION)))
                    {
                        using var sw = new StreamWriter(stream);
                        sw.Write(data);
                        sw.Flush();
                        stream.Finish();

                        stream.IsStreamOwner = false;
                    }

                    s.Seek(0, SeekOrigin.Begin);

                    datas[i1] = s.ToArray();
                });
            }

            Task.WaitAll(tasks);
        }
예제 #22
0
        /// <summary>
        /// 使用zlib压缩一段数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        private byte[] compressBuffer(byte[] input)
        {
            byte[] result = null;

            using (MemoryStream outputStream = new MemoryStream())
            {
                using (MemoryStream inputStream = new MemoryStream(input))
                {
                    using (DeflaterOutputStream outZStream = new DeflaterOutputStream(outputStream, new Deflater(Deflater.DEFAULT_COMPRESSION)))
                    {
                        try
                        {
                            inputStream.CopyTo(outZStream);
                            outZStream.Flush();
                            outZStream.Finish();
                        }
                        finally
                        {
                            outputStream.Seek(0, SeekOrigin.Begin);
                            result = new byte[outputStream.Length];
                            outputStream.Read(result, 0, (int)outputStream.Length);
                        }
                    }
                }
            }

            return(result);
        }
예제 #23
0
        /// <summary>
        /// 数据压缩
        /// </summary>
        /// <param name="s">待压缩数据输入流</param>
        /// <param name="os">压缩后的数据输出流</param>
        /// <param name="deflater">压缩器</param>
        public static void Compress(Stream s, Stream os, Deflater deflater)
        {
            DeflaterOutputStream dos = new DeflaterOutputStream(os, deflater, 1024 * 4);

            Stdio.CopyStream(s, dos);
            dos.Finish();
        }
예제 #24
0
 /// <summary>
 /// Compress the contents of the provided array
 /// </summary>
 /// <param name="data">An uncompressed byte array</param>
 /// <returns></returns>
 public static byte[] Compress(byte[] data)
 {
     using (MemoryStream out1 = new MemoryStream())
     {
         Deflater             deflater             = new Deflater(0, false);
         DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(out1, deflater);
         try
         {
             //for (int i = 0; i < data.Length; i++)
             //deflaterOutputStream.WriteByte(data[i]);
             deflaterOutputStream.Write(data, 0, data.Length);   //Tony Qu changed the code
             return(out1.ToArray());
         }
         catch (IOException e)
         {
             throw new RecordFormatException(e.ToString());
         }
         finally
         {
             out1.Close();
             if (deflaterOutputStream != null)
             {
                 deflaterOutputStream.Close();
             }
         }
     }
 }
예제 #25
0
        protected override void InternalWriteStream(MemoryStream AStream)
        {
            PdfNumber    FLength;
            PdfArray     FFilter;
            MemoryStream TmpStream;

            FLength = FAttributes.PdfNumberByName("Length");
            FFilter = (PdfArray)FAttributes.ValueByName("Filter");

            TmpStream = new MemoryStream();
            DeflaterOutputStream s = null;

            if (FFilter.FindName("FlateDecode") != null)
            {
                s = new DeflaterOutputStream(TmpStream);
                byte[] bytedata = FStream.ToArray();
                s.Write(bytedata, 0, bytedata.Length);
                s.Finish();
            }
            else
            {
                FStream.WriteTo(TmpStream);
            }

            FLength.Value = TmpStream.Length;
            FAttributes.WriteToStream(AStream);
            Generic._WriteString("\r\n" + "stream" + "\r\n", AStream);

            TmpStream.WriteTo(AStream);
            if (s != null)
            {
                s.Close();
            }
            Generic._WriteString("\n" + "endstream", AStream);
        }
예제 #26
0
        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);
        }
예제 #27
0
파일: defcomp.cs 프로젝트: Eisai/pragmasql
		// 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;
		}
        /// <summary>
        /// Encodes the specified data.
        /// </summary>
        public byte[] Encode(byte[] data, PdfFlateEncodeMode mode)
        {
            MemoryStream ms = new MemoryStream();

            // DeflateStream/GZipStream does not work immediately and I have not the leisure to work it out.
            // So I keep on using SharpZipLib even with .NET 2.0.

            int level = Deflater.DEFAULT_COMPRESSION;

            switch (mode)
            {
            case PdfFlateEncodeMode.BestCompression:
                level = Deflater.BEST_COMPRESSION;
                break;

            case PdfFlateEncodeMode.BestSpeed:
                level = Deflater.BEST_SPEED;
                break;
            }
            DeflaterOutputStream zip = new DeflaterOutputStream(ms, new Deflater(level, false));

            zip.Write(data, 0, data.Length);
            zip.Finish();
            return(ms.ToArray());
        }
예제 #29
0
        public static async Task <ChunkBuilder> Create(BA2DX10EntryState state, ChunkState chunk, Stream src, DiskSlabAllocator slab)
        {
            var builder = new ChunkBuilder {
                _chunk = chunk
            };

            if (!chunk.Compressed)
            {
                builder._dataSlab = slab.Allocate(chunk.FullSz);
                await src.CopyToWithStatusAsync((int)chunk.FullSz, builder._dataSlab, $"Writing {state.Path} {chunk.StartMip}:{chunk.EndMip}");
            }
            else
            {
                var deflater = new Deflater(Deflater.BEST_COMPRESSION);
                await using var ms = new MemoryStream();
                await using (var ds = new DeflaterOutputStream(ms, deflater))
                {
                    ds.IsStreamOwner = false;
                    await src.CopyToWithStatusAsync((int)chunk.FullSz, ds, $"Compressing {state.Path} {chunk.StartMip}:{chunk.EndMip}");
                }

                builder._dataSlab = slab.Allocate(ms.Length);
                ms.Position       = 0;
                await ms.CopyToWithStatusAsync(ms.Length, builder._dataSlab, $"Writing {state.Path} {chunk.StartMip}:{chunk.EndMip}");

                builder._packSize = (uint)ms.Length;
            }
            builder._dataSlab.Position = 0;

            return(builder);
        }
        private static byte[] Compress(byte[] data)
        {
            byte[] array;
            try
            {
                Deflater             deflater             = new Deflater();
                MemoryStream         memoryStream         = new MemoryStream(data.Length);
                DeflaterOutputStream deflaterOutputStream = new DeflaterOutputStream(memoryStream, deflater);
                deflaterOutputStream.Write(data, 0, data.Length);
                deflaterOutputStream.Flush();
                deflaterOutputStream.Finish();
                array = memoryStream.ToArray();
            }
            catch (Exception)
            {
                return(null);
            }
            byte[] bytes = BitConverter.GetBytes((ulong)((long)data.Length));
            int    num   = array.Length + FileUtil.BNET_COMPRESSED_HEADER_SIZE;

            byte[] array2 = new byte[num];
            int    num2   = 0;

            Array.Copy(FileUtil.BNET_COMPRESSED_MAGIC_BYTES, 0, array2, num2, FileUtil.BNET_COMPRESSED_MAGIC_BYTES.Length);
            num2 += FileUtil.BNET_COMPRESSED_MAGIC_BYTES.Length;
            Array.Copy(FileUtil.BNET_COMPRESSED_VERSION_BYTES, 0, array2, num2, FileUtil.BNET_COMPRESSED_VERSION_BYTES.Length);
            num2 += FileUtil.BNET_COMPRESSED_VERSION_BYTES.Length;
            Array.Copy(bytes, 0, array2, num2, bytes.Length);
            num2 += bytes.Length;
            Array.Copy(array, 0, array2, num2, array.Length);
            return(array2);
        }
        /// <summary>
        /// SharpZipѹËõ
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static byte[] CompressSharpZip(byte[] buffer)
        {
            if (buffer == null || buffer.Length == 0)
            {
                return buffer;
            }

            using (MemoryStream inStream = new MemoryStream(buffer))
            {
                MemoryStream outStream = new MemoryStream();
                Deflater mDeflater = new Deflater(Deflater.BEST_COMPRESSION);
                DeflaterOutputStream compressStream = new DeflaterOutputStream(outStream, mDeflater);
                int mSize;
                byte[] mWriteData = new Byte[4096];
                while ((mSize = inStream.Read(mWriteData, 0, 4096)) > 0)
                {
                    compressStream.Write(mWriteData, 0, mSize);
                }
                compressStream.Finish();
                inStream.Close();
                return outStream.ToArray();
            }
        }
예제 #32
0
		/// <summary>
		/// Get an output stream for the specified <see cref="BlubbEntry"/>
		/// </summary>
		/// <param name="entry">The entry to get an output stream for.</param>
		/// <returns>The output stream obtained for the entry.</returns>
		Stream GetOutputStream( BlubbZipEntry entry ) {
			Stream result = baseStream_;

			if( entry.IsCrypted == true ) {
				result = CreateAndInitEncryptionStream( result, entry );
			}

			switch( entry.CompressionMethod ) {
				case CompressionMethod.Stored:
					result = new UncompressedStream( result );
					break;

				case CompressionMethod.Deflated:
					DeflaterOutputStream dos = new DeflaterOutputStream( result, new Deflater( 9, true ) );
					dos.IsStreamOwner = false;
					result = dos;
					break;

				default:
					throw new BlubbZipException( "Unknown compression method " + entry.CompressionMethod );
			}
			return result;
		}
예제 #33
0
		/// <summary>
		/// Get an output stream for the specified <see cref="ZipEntry"/>
		/// </summary>
		/// <param name="entry">The entry to get an output stream for.</param>
		/// <returns>The output stream obtained for the entry.</returns>
		Stream GetOutputStream(ZipEntry entry)
		{
			Stream result = baseStream_;

			if ( entry.IsCrypted == true ) {
#if NETCF_1_0
				throw new ZipException("Encryption not supported for Compact Framework 1.0");
#else
				result = CreateAndInitEncryptionStream(result, entry);
#endif
			}

			switch ( entry.CompressionMethod ) {
				case CompressionMethod.Stored:
					result = new UncompressedStream(result);
					break;

				case CompressionMethod.Deflated:
					DeflaterOutputStream dos = new DeflaterOutputStream(result, new Deflater(9, true));
					dos.IsStreamOwner = false;
					result = dos;
					break;

				default:
					throw new ZipException("Unknown compression method " + entry.CompressionMethod);
			}
			return result;
		}