Dispose() защищенный Метод

protected Dispose ( bool disposing ) : void
disposing bool
Результат void
Пример #1
0
 protected override void Dispose(bool disposing)
 {
     try {
         base.Dispose(disposing);
     } finally {
         deflateStream.Dispose();
     }
 }
Пример #2
0
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         deflateStream.Dispose();
     }
     base.Dispose(disposing);
 }
Пример #3
0
        public static void CompressCanWrite()
        {
            var ms = new MemoryStream();
            var zip = new DeflateStream(ms, CompressionMode.Compress);
            Assert.True(zip.CanWrite);

            zip.Dispose();
            Assert.False(zip.CanWrite);
        }
Пример #4
0
        /// <summary> Copy the contents of a stored file into an opened stream. </summary>
        /// <param name="zfe"> Entry information of file to extract. </param>
        /// <param name="stream"> Stream to store the uncompressed data. </param>
        /// <returns> True if success, false if not. </returns>
        /// <remarks> Unique compression methods are Store and Deflate. </remarks>
        public bool ExtractFile(ZipFileEntry zfe, [NotNull] Stream stream)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            if (!stream.CanWrite)
            {
                throw new InvalidOperationException("Stream cannot be written");
            }

            // check signature
            byte[] signature = new byte[4];
            zipFileStream.Seek(zfe.HeaderOffset, SeekOrigin.Begin);
            zipFileStream.Read(signature, 0, 4);
            if (BitConverter.ToUInt32(signature, 0) != 0x04034b50)
            {
                return(false);
            }

            // Select input stream for inflating or just reading
            Stream inStream;

            switch (zfe.Method)
            {
            case Compression.Store:
                inStream = zipFileStream;
                break;

            case Compression.Deflate:
                inStream = new DeflateStream(zipFileStream, CompressionMode.Decompress, true);
                break;

            default:
                return(false);
            }

            // Buffered copy
            byte[] buffer = new byte[16384];
            zipFileStream.Seek(zfe.FileOffset, SeekOrigin.Begin);
            uint bytesPending = zfe.FileSize;

            while (bytesPending > 0)
            {
                int bytesRead = inStream.Read(buffer, 0, (int)Math.Min(bytesPending, buffer.Length));
                stream.Write(buffer, 0, bytesRead);
                bytesPending -= (uint)bytesRead;
            }
            stream.Flush();

            if (zfe.Method == Compression.Deflate)
            {
                inStream.Dispose();
            }
            return(true);
        }
Пример #5
0
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         if (deflateStream != null)
         {
             deflateStream.Dispose();
             deflateStream = null;
         }
     }
     base.Dispose(disposing);
 }
Пример #6
0
        /// <summary>
        /// Copy the contents of a stored file into an opened stream
        /// </summary>
        /// <param name="_zfe">Entry information of file to extract</param>
        /// <param name="_stream">Stream to store the uncompressed data</param>
        /// <returns>True if success, false if not.</returns>
        /// <remarks>Unique compression methods are Store and Deflate</remarks>
        public Boolean ExtractFile(ZipFileEntry _zfe, Stream _stream)
        {
            if (!_stream.CanWrite)
            {
                throw new InvalidOperationException("Stream cannot be written");
            }

            // check signature
            Byte[] signature = new Byte[4];
            ZipFileStream.Seek(_zfe.HeaderOffset, SeekOrigin.Begin);
            ZipFileStream.Read(signature, 0, 4);
            if (BitConverter.ToUInt32(signature, 0) != 0x04034b50)
            {
                return(false);
            }

            // Select input stream for inflating or just reading
            Stream inStream;

            switch (_zfe.Method)
            {
            case Compression.Store:
                inStream = ZipFileStream;
                break;

            case Compression.Deflate:
                inStream = new DeflateStream(ZipFileStream, CompressionMode.Decompress, true);
                break;

            default:
                return(false);
            }

            // Buffered copy
            Byte[] buffer = new Byte[16384];
            ZipFileStream.Seek(_zfe.FileOffset, SeekOrigin.Begin);
            UInt32 bytesPending = _zfe.FileSize;

            while (bytesPending > 0)
            {
                Int32 bytesRead = inStream.Read(buffer, 0, (Int32)Math.Min(bytesPending, buffer.Length));
                _stream.Write(buffer, 0, bytesRead);
                bytesPending -= (UInt32)bytesRead;
            }
            _stream.Flush();

            if (_zfe.Method == Compression.Deflate)
            {
                inStream.Dispose();
            }
            return(true);
        }
 public static byte[] DeflateCompress(byte[] DATA)
 {
     MemoryStream ms = new MemoryStream();
     DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress, true);
     stream.Write(DATA, 0, DATA.Length);
     stream.Close();
     stream.Dispose();
     stream = null;
     byte[] buffer = StreamDataHelper.ReadDataToBytes(ms);
     ms.Close();
     ms.Dispose();
     ms = null;
     return buffer;
 }
Пример #8
0
 public static int CompressTileBlock(int xStart, int yStart, short width, short height, byte[] buffer, int bufferStart)
 {
     int result;
     using (MemoryStream memoryStream = new MemoryStream())
     {
         using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
         {
             binaryWriter.Write(xStart);
             binaryWriter.Write(yStart);
             binaryWriter.Write(width);
             binaryWriter.Write(height);
             NetMessage.CompressTileBlock_Inner(binaryWriter, xStart, yStart, (int)width, (int)height);
             int num = buffer.Length;
             if ((long)bufferStart + memoryStream.Length > (long)num)
             {
                 result = (int)((long)(num - bufferStart) + memoryStream.Length);
             }
             else
             {
                 memoryStream.Position = 0L;
                 MemoryStream memoryStream2 = new MemoryStream();
                 using (DeflateStream deflateStream = new DeflateStream(memoryStream2, CompressionMode.Compress, true))
                 {
                     memoryStream.CopyTo(deflateStream);
                     deflateStream.Flush();
                     deflateStream.Close();
                     deflateStream.Dispose();
                 }
                 if (memoryStream.Length <= memoryStream2.Length)
                 {
                     memoryStream.Position = 0L;
                     buffer[bufferStart] = 0;
                     bufferStart++;
                     memoryStream.Read(buffer, bufferStart, (int)memoryStream.Length);
                     result = (int)memoryStream.Length + 1;
                 }
                 else
                 {
                     memoryStream2.Position = 0L;
                     buffer[bufferStart] = 1;
                     bufferStart++;
                     memoryStream2.Read(buffer, bufferStart, (int)memoryStream2.Length);
                     result = (int)memoryStream2.Length + 1;
                 }
             }
         }
     }
     return result;
 }
Пример #9
0
 protected override void Dispose(bool disposing)
 {
     try
     {
         if (disposing && _deflateStream != null)
         {
             _deflateStream.Dispose();
         }
         _deflateStream = null;
     }
     finally
     {
         base.Dispose(disposing);
     }
 }
        public static Stream CompressStream(Stream instream)
        {
            MemoryStream outstream = new MemoryStream((int)instream.Length);
            DeflateStream comp = new DeflateStream(outstream, CompressionMode.Compress, true);

            int numBytes;
            byte[] buffer = new byte[4096];
            while ((numBytes = instream.Read(buffer, 0, 4096)) != 0) {
                comp.Write(buffer, 0, numBytes);
            }
            comp.Flush();
            comp.Dispose();

            // return to the beginning of the stream
            outstream.Position = 0;

            //Debug.WriteLine("Compression: " + instream.Length.ToString() + " to " + outstream.Length.ToString());
            return outstream;
        }
        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) {
            Stream compressedStream = null;

            switch (_contentEncoding) {
                case "gzip":
                    compressedStream = 
                        new GZipStream(stream, CompressionMode.Compress, leaveOpen: true);
                    break;
                case "deflate":
                    compressedStream =
                        new DeflateStream(stream, CompressionMode.Compress, leaveOpen: true);
                    break;
            }

            return _initialContent.CopyToAsync(compressedStream).ContinueWith(tsk => {
                if (compressedStream != null) {
                    compressedStream.Dispose();
                }
            });
        }
        public void CompressorNotClosed_DecompressorStillSuccessful(bool closeCompressorBeforeDecompression)
        {
            const string Input = "example";

            var ms = new MemoryStream();

            using (var compressor = new DeflateStream(ms, CompressionLevel.Optimal, leaveOpen: closeCompressorBeforeDecompression))
            {
                compressor.Write(Encoding.ASCII.GetBytes(Input));
                compressor.Flush();
                if (closeCompressorBeforeDecompression)
                {
                    compressor.Dispose();
                }

                ms.Position = 0;
                using (var decompressor = new DeflateStream(ms, CompressionMode.Decompress, leaveOpen: true))
                {
                    var decompressed = new MemoryStream();
                    decompressor.CopyTo(decompressed);
                    Assert.Equal(Input, Encoding.ASCII.GetString(decompressed.ToArray()));
                }
            }
        }
Пример #13
0
        public static void CanDisposeDeflateStream()
        {
            var ms = new MemoryStream();
            var zip = new DeflateStream(ms, CompressionMode.Compress);
            zip.Dispose();

            // Base Stream should be null after dispose 
            Assert.Null(zip.BaseStream);

            zip.Dispose(); // Should be a no-op
        }
Пример #14
0
        public static async Task CanReadBaseStreamAfterDispose()
        {
            var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));
            var newMs = StripHeaderAndFooter.Strip(ms);

            var zip = new DeflateStream(newMs, CompressionMode.Decompress, true);
            var baseStream = zip.BaseStream;
            zip.Dispose();

            int size = 1024;
            Byte[] bytes = new Byte[size];
            baseStream.Read(bytes, 0, size); // This will throw if the underlying stream is not writeable as expected

            baseStream.Position = 0;
            await baseStream.ReadAsync(bytes, 0, size); 
        }
 public static Stream DeflateCompress(Stream DATA)
 {
     byte[] buffer = StreamDataHelper.ReadDataToBytes(DATA);
     MemoryStream ms = new MemoryStream();
     DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress, true);
     stream.Write(buffer, 0, buffer.Length);
     stream.Close();
     stream.Dispose();
     stream = null;
     if (ms.CanSeek)
     {
         ms.Position = 0;
     }
     return ms;
 }
		public void DisposeTest ()
		{
			MemoryStream backing = new MemoryStream (compressed_data);
			DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
			decompress.Dispose ();
			decompress.Dispose ();
		}
Пример #17
0
    // **********************************************************************

    public static Stream GetDataStream(FileStream fs)
    {
      byte[] buffer = new byte[prefix.Length];

      if(CheckPrefix(fs, buffer))
        return fs;

      Stream stream = null;

      try
      {
        fs.Position = 0;
        stream = new GZipStream(fs, CompressionMode.Decompress, true);

        if(CheckPrefix(stream, buffer))
          return stream;
      }
      catch { }

      if(stream != null)
      {
        stream.Dispose();
        stream = null;
      }

      try
      {
        fs.Position = 0;
        stream = new DeflateStream(fs, CompressionMode.Decompress, true);

        if(CheckPrefix(stream, buffer))
          return stream;
      }
      catch { }

      if(stream != null)
      {
        stream.Dispose();
        stream = null;
      }

      throw new FormatException("Неверный формат файла");
    }
Пример #18
0
 public static int CompressTileBlock(int xStart, int yStart, short width, short height, byte[] buffer, int bufferStart)
 {
     using (MemoryStream memoryStream1 = new MemoryStream())
     {
         using (BinaryWriter writer = new BinaryWriter((Stream)memoryStream1))
         {
             writer.Write(xStart);
             writer.Write(yStart);
             writer.Write(width);
             writer.Write(height);
             NetMessage.CompressTileBlock_Inner(writer, xStart, yStart, (int)width, (int)height);
             int length = buffer.Length;
             if ((long)bufferStart + memoryStream1.Length > (long)length)
                 return (int)((long)(length - bufferStart) + memoryStream1.Length);
             memoryStream1.Position = 0L;
             MemoryStream memoryStream2 = new MemoryStream();
             using (DeflateStream deflateStream = new DeflateStream((Stream)memoryStream2, CompressionMode.Compress, true))
             {
                 memoryStream1.CopyTo((Stream)deflateStream);
                 deflateStream.Flush();
                 deflateStream.Close();
                 deflateStream.Dispose();
             }
             if (memoryStream1.Length <= memoryStream2.Length)
             {
                 memoryStream1.Position = 0L;
                 buffer[bufferStart] = (byte)0;
                 ++bufferStart;
                 memoryStream1.Read(buffer, bufferStart, (int)memoryStream1.Length);
                 return (int)memoryStream1.Length + 1;
             }
             memoryStream2.Position = 0L;
             buffer[bufferStart] = (byte)1;
             ++bufferStart;
             memoryStream2.Read(buffer, bufferStart, (int)memoryStream2.Length);
             return (int)memoryStream2.Length + 1;
         }
     }
 }
Пример #19
0
 internal byte[] Compress(byte[] decompressedBuffer)
 {
     MemoryStream memStream = new MemoryStream();
     DeflateStream zip = new DeflateStream(memStream, CompressionMode.Compress, true);
     zip.Write(decompressedBuffer, 0, decompressedBuffer.Length);
     zip.Close();
     memStream.Position = 0;
     byte[] buffer = new byte[memStream.Length + 2];
     //Console.WriteLine(BitConverter.ToString(memStream.ToArray()));
     memStream.Read(buffer, 2, buffer.Length - 2);
     memStream.Close();
     memStream.Dispose();
     zip.Dispose();
     System.Buffer.BlockCopy(new byte[] { 0x78, 0x9C }, 0, buffer, 0, 2);
     return buffer;
 }
Пример #20
0
        byte[] DecompressEntry( BinaryReader reader, ushort compressionMethod, int compressedSize, int uncompressedSize )
        {
            if( compressionMethod == 0 ) { // Store/Raw
                return reader.ReadBytes( uncompressedSize );
            } else if( compressionMethod == 8 ) { // Deflate
                byte[] data = new byte[uncompressedSize];
                byte[] compressedData = reader.ReadBytes( compressedSize );
                MemoryStream stream = new MemoryStream( compressedData );
                int index = 0, read = 0;
                DeflateStream deflater = new DeflateStream( stream, CompressionMode.Decompress );

                while( index < uncompressedSize &&
                      ( read = deflater.Read( data, index, data.Length - index ) ) > 0 ) {
                    index += read;
                }

                deflater.Dispose();
                return data;
            } else {
                Utils.LogDebug( "Unsupported .zip entry compression method: " + compressionMethod );
                reader.ReadBytes( compressedSize );
                return null;
            }
        }
Пример #21
0
        public void Zlib_Streams_VariousSizes()
        {
            byte[] working = new byte[WORKING_BUFFER_SIZE];
            int n = -1;
            Int32[] Sizes = { 8000, 88000, 188000, 388000, 580000, 1580000 };

            for (int p = 0; p < Sizes.Length; p++)
            {
                // both binary and text files
                for (int m = 0; m < 2; m++)
                {
                    int sz = this.rnd.Next(Sizes[p]) + Sizes[p];
                    string FileToCompress = System.IO.Path.Combine(TopLevelDir, String.Format("Zlib_Streams.{0}.{1}", sz, (m == 0) ? "txt" : "bin"));
                    Assert.IsFalse(System.IO.File.Exists(FileToCompress), "The temporary file '{0}' already exists.", FileToCompress);
                    TestContext.WriteLine("Creating file {0}   {1} bytes", FileToCompress, sz);
                    if (m == 0)
                        CreateAndFillFileText(FileToCompress, sz);
                    else
                        _CreateAndFillBinary(FileToCompress, sz, false);

                    int crc1 = DoCrc(FileToCompress);
                    TestContext.WriteLine("Initial CRC: 0x{0:X8}", crc1);

                    // try both GZipStream and DeflateStream
                    for (int k = 0; k < 2; k++)
                    {
                        // compress with Ionic and System.IO.Compression
                        for (int i = 0; i < 2; i++)
                        {
                            string CompressedFileRoot = String.Format("{0}.{1}.{2}.compressed", FileToCompress,
                                              (k == 0) ? "GZIP" : "DEFLATE",
                                              (i == 0) ? "Ionic" : "BCL");

                            int x = k + i * 2;
                            int z = (x == 0) ? 4 : 1;
                            // why 4 trials??   (only for GZIP and Ionic)
                            for (int h = 0; h < z; h++)
                            {
                                string CompressedFile = (x == 0)
                                    ? CompressedFileRoot + ".trial" + h
                                    : CompressedFileRoot;

                                using (var input = System.IO.File.OpenRead(FileToCompress))
                                {
                                    using (var raw = System.IO.File.Create(CompressedFile))
                                    {
                                        Stream compressor = null;
                                        try
                                        {
                                            switch (x)
                                            {
                                                case 0: // k == 0, i == 0
                                                    compressor = new Ionic.Zlib.GZipStream(raw, CompressionMode.Compress, true);
                                                    break;
                                                case 1: // k == 1, i == 0
                                                    compressor = new Ionic.Zlib.DeflateStream(raw, CompressionMode.Compress, true);
                                                    break;
                                                case 2: // k == 0, i == 1
                                                    compressor = new System.IO.Compression.GZipStream(raw, System.IO.Compression.CompressionMode.Compress, true);
                                                    break;
                                                case 3: // k == 1, i == 1
                                                    compressor = new System.IO.Compression.DeflateStream(raw, System.IO.Compression.CompressionMode.Compress, true);
                                                    break;
                                            }
                                            //TestContext.WriteLine("Compress with: {0} ..", compressor.GetType().FullName);

                                            TestContext.WriteLine("........{0} ...", System.IO.Path2.GetFileName(CompressedFile));

                                            if (x == 0)
                                            {
                                                if (h != 0)
                                                {
                                                    Ionic.Zlib.GZipStream gzip = compressor as Ionic.Zlib.GZipStream;

                                                    if (h % 2 == 1)
                                                        gzip.FileName = FileToCompress;

                                                    if (h > 2)
                                                        gzip.Comment = "Compressing: " + FileToCompress;

                                                }
                                            }

                                            n = -1;
                                            while ((n = input.Read(working, 0, working.Length)) != 0)
                                            {
                                                compressor.Write(working, 0, n);
                                            }

                                        }
                                        finally
                                        {
                                            if (compressor != null)
                                                compressor.Dispose();
                                        }
                                    }
                                }

                                // now, decompress with Ionic and System.IO.Compression
                                // for (int j = 0; j < 2; j++)
                                for (int j = 1; j >= 0; j--)
                                {
                                    using (var input = System.IO.File.OpenRead(CompressedFile))
                                    {
                                        Stream decompressor = null;
                                        try
                                        {
                                            int w = k + j * 2;
                                            switch (w)
                                            {
                                                case 0: // k == 0, j == 0
                                                    decompressor = new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true);
                                                    break;
                                                case 1: // k == 1, j == 0
                                                    decompressor = new Ionic.Zlib.DeflateStream(input, CompressionMode.Decompress, true);
                                                    break;
                                                case 2: // k == 0, j == 1
                                                    decompressor = new System.IO.Compression.GZipStream(input, System.IO.Compression.CompressionMode.Decompress, true);
                                                    break;
                                                case 3: // k == 1, j == 1
                                                    decompressor = new System.IO.Compression.DeflateStream(input, System.IO.Compression.CompressionMode.Decompress, true);
                                                    break;
                                            }

                                            //TestContext.WriteLine("Decompress: {0} ...", decompressor.GetType().FullName);
                                            string DecompressedFile =
                                                String.Format("{0}.{1}.decompressed", CompressedFile, (j == 0) ? "Ionic" : "BCL");

                                            TestContext.WriteLine("........{0} ...", System.IO.Path2.GetFileName(DecompressedFile));

                                            using (var s2 = System.IO.File.Create(DecompressedFile))
                                            {
                                                n = -1;
                                                while (n != 0)
                                                {
                                                    n = decompressor.Read(working, 0, working.Length);
                                                    if (n > 0)
                                                        s2.Write(working, 0, n);
                                                }
                                            }

                                            int crc2 = DoCrc(DecompressedFile);
                                            Assert.AreEqual<UInt32>((UInt32)crc1, (UInt32)crc2);

                                        }
                                        finally
                                        {
                                            if (decompressor != null)
                                                decompressor.Dispose();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            TestContext.WriteLine("Done.");
        }
Пример #22
0
        public static void SaveMap()
        {
            if (!Main.mapEnabled || MapHelper.saveLock)
            {
                return;
            }
            string text = Main.playerPathName.Substring(0, Main.playerPathName.Length - 4);
            lock (MapHelper.padlock)
            {
                try
                {
                    MapHelper.saveLock = true;
                    try
                    {
                        Directory.CreateDirectory(text);
                    }
                    catch
                    {
                    }
                    text = string.Concat(new object[]
					{
						text,
						Path.DirectorySeparatorChar,
						Main.worldID,
						".map"
					});
                    Stopwatch stopwatch = new Stopwatch();
                    stopwatch.Start();
                    bool flag2 = false;
                    if (!Main.gameMenu)
                    {
                        flag2 = true;
                    }
                    using (MemoryStream memoryStream = new MemoryStream(4000))
                    {
                        using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
                        {
                            using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress))
                            {
                                int num = 0;
                                byte[] array = new byte[16384];
                                binaryWriter.Write(Main.curRelease);
                                Main.MapFileMetadata.IncrementAndWrite(binaryWriter);
                                binaryWriter.Write(Main.worldName);
                                binaryWriter.Write(Main.worldID);
                                binaryWriter.Write(Main.maxTilesY);
                                binaryWriter.Write(Main.maxTilesX);
                                binaryWriter.Write(419);
                                binaryWriter.Write(225);
                                binaryWriter.Write(3);
                                binaryWriter.Write(256);
                                binaryWriter.Write(256);
                                binaryWriter.Write(256);
                                byte b = 1;
                                byte b2 = 0;
                                int i;
                                for (i = 0; i < 419; i++)
                                {
                                    if (MapHelper.tileOptionCounts[i] != 1)
                                    {
                                        b2 |= b;
                                    }
                                    if (b == 128)
                                    {
                                        binaryWriter.Write(b2);
                                        b2 = 0;
                                        b = 1;
                                    }
                                    else
                                    {
                                        b = (byte)(b << 1);
                                    }
                                }
                                if (b != 1)
                                {
                                    binaryWriter.Write(b2);
                                }
                                i = 0;
                                b = 1;
                                b2 = 0;
                                while (i < 225)
                                {
                                    if (MapHelper.wallOptionCounts[i] != 1)
                                    {
                                        b2 |= b;
                                    }
                                    if (b == 128)
                                    {
                                        binaryWriter.Write(b2);
                                        b2 = 0;
                                        b = 1;
                                    }
                                    else
                                    {
                                        b = (byte)(b << 1);
                                    }
                                    i++;
                                }
                                if (b != 1)
                                {
                                    binaryWriter.Write(b2);
                                }
                                for (i = 0; i < 419; i++)
                                {
                                    if (MapHelper.tileOptionCounts[i] != 1)
                                    {
                                        binaryWriter.Write((byte)MapHelper.tileOptionCounts[i]);
                                    }
                                }
                                for (i = 0; i < 225; i++)
                                {
                                    if (MapHelper.wallOptionCounts[i] != 1)
                                    {
                                        binaryWriter.Write((byte)MapHelper.wallOptionCounts[i]);
                                    }
                                }
                                binaryWriter.Flush();
                                for (int j = 0; j < Main.maxTilesY; j++)
                                {
                                    if (!flag2)
                                    {
                                        float num2 = (float)j / (float)Main.maxTilesY;
                                        Main.statusText = string.Concat(new object[]
										{
											Lang.gen[66],
											" ",
											(int)(num2 * 100f + 1f),
											"%"
										});
                                    }
                                    for (int k = 0; k < Main.maxTilesX; k++)
                                    {
                                        MapTile mapTile = Main.Map[k, j];
                                        byte b4;
                                        byte b3 = b4 = 0;
                                        bool flag3 = true;
                                        bool flag4 = true;
                                        int num3 = 0;
                                        int num4 = 0;
                                        byte b5 = 0;
                                        int num5;
                                        ushort num6;
                                        int num7;
                                        if (mapTile.Light <= 18)
                                        {
                                            flag4 = false;
                                            flag3 = false;
                                            num5 = 0;
                                            num6 = 0;
                                            num7 = 0;
                                            int num8 = k + 1;
                                            int l = Main.maxTilesX - k - 1;
                                            while (l > 0)
                                            {
                                                if (Main.Map[num8, j].Light > 18)
                                                {
                                                    break;
                                                }
                                                num7++;
                                                l--;
                                                num8++;
                                            }
                                        }
                                        else
                                        {
                                            b5 = mapTile.Color;
                                            num6 = mapTile.Type;
                                            if (num6 < MapHelper.wallPosition)
                                            {
                                                num5 = 1;
                                                num6 -= MapHelper.tilePosition;
                                            }
                                            else if (num6 < MapHelper.liquidPosition)
                                            {
                                                num5 = 2;
                                                num6 -= MapHelper.wallPosition;
                                            }
                                            else if (num6 < MapHelper.skyPosition)
                                            {
                                                num5 = (int)(3 + (num6 - MapHelper.liquidPosition));
                                                flag3 = false;
                                            }
                                            else if (num6 < MapHelper.dirtPosition)
                                            {
                                                num5 = 6;
                                                flag4 = false;
                                                flag3 = false;
                                            }
                                            else if (num6 < MapHelper.hellPosition)
                                            {
                                                num5 = 7;
                                                if (num6 < MapHelper.rockPosition)
                                                {
                                                    num6 -= MapHelper.dirtPosition;
                                                }
                                                else
                                                {
                                                    num6 -= MapHelper.rockPosition;
                                                }
                                            }
                                            else
                                            {
                                                num5 = 6;
                                                flag3 = false;
                                            }
                                            if (mapTile.Light == 255)
                                            {
                                                flag4 = false;
                                            }
                                            if (flag4)
                                            {
                                                num7 = 0;
                                                int num8 = k + 1;
                                                int l = Main.maxTilesX - k - 1;
                                                num3 = num8;
                                                while (l > 0)
                                                {
                                                    MapTile mapTile2 = Main.Map[num8, j];
                                                    if (!mapTile.EqualsWithoutLight(ref mapTile2))
                                                    {
                                                        num4 = num8;
                                                        break;
                                                    }
                                                    l--;
                                                    num7++;
                                                    num8++;
                                                }
                                            }
                                            else
                                            {
                                                num7 = 0;
                                                int num8 = k + 1;
                                                int l = Main.maxTilesX - k - 1;
                                                while (l > 0)
                                                {
                                                    MapTile mapTile3 = Main.Map[num8, j];
                                                    if (!mapTile.Equals(ref mapTile3))
                                                    {
                                                        break;
                                                    }
                                                    l--;
                                                    num7++;
                                                    num8++;
                                                }
                                            }
                                        }
                                        if (b5 > 0)
                                        {
                                            b3 |= (byte)(b5 << 1);
                                        }
                                        if (b3 != 0)
                                        {
                                            b4 |= 1;
                                        }
                                        b4 |= (byte)(num5 << 1);
                                        if (flag3 && num6 > 255)
                                        {
                                            b4 |= 16;
                                        }
                                        if (flag4)
                                        {
                                            b4 |= 32;
                                        }
                                        if (num7 > 0)
                                        {
                                            if (num7 > 255)
                                            {
                                                b4 |= 128;
                                            }
                                            else
                                            {
                                                b4 |= 64;
                                            }
                                        }
                                        array[num] = b4;
                                        num++;
                                        if (b3 != 0)
                                        {
                                            array[num] = b3;
                                            num++;
                                        }
                                        if (flag3)
                                        {
                                            array[num] = (byte)num6;
                                            num++;
                                            if (num6 > 255)
                                            {
                                                array[num] = (byte)(num6 >> 8);
                                                num++;
                                            }
                                        }
                                        if (flag4)
                                        {
                                            array[num] = mapTile.Light;
                                            num++;
                                        }
                                        if (num7 > 0)
                                        {
                                            array[num] = (byte)num7;
                                            num++;
                                            if (num7 > 255)
                                            {
                                                array[num] = (byte)(num7 >> 8);
                                                num++;
                                            }
                                        }
                                        for (int m = num3; m < num4; m++)
                                        {
                                            array[num] = Main.Map[m, j].Light;
                                            num++;
                                        }
                                        k += num7;
                                        if (num >= 4096)
                                        {
                                            deflateStream.Write(array, 0, num);
                                            num = 0;
                                        }
                                    }
                                }
                                if (num > 0)
                                {
                                    deflateStream.Write(array, 0, num);
                                }
                                deflateStream.Dispose();
                                FileUtilities.WriteAllBytes(text, memoryStream.ToArray());
                            }
                        }
                    }
                }
                catch (Exception value)
                {
                    using (StreamWriter streamWriter = new StreamWriter("client-crashlog.txt", true))
                    {
                        streamWriter.WriteLine(DateTime.Now);
                        streamWriter.WriteLine(value);
                        streamWriter.WriteLine("");
                    }
                }
                MapHelper.saveLock = false;
            }
        }
Пример #23
0
        internal override void Receive()
        {
            lock (TcpClient)
            {
                base.Receive();
                if (DataLength == 0) return;

                var response = new byte[DataLength];
                var bytesRead = 0;
                do
                {
                    Settings.Launcher.UpdateProgressInvokable(string.Format("Downloading: {0}kb / {1}kb", bytesRead / 1024, DataLength / 1024), bytesRead / 1024, DataLength / 1024);
                    bytesRead += TcpClient.GetStream().Read(response, bytesRead, Math.Min(DataLength - bytesRead, 4096));
                    //System.Threading.Thread.Sleep(50); //simulate remote connect
                } while (bytesRead < DataLength);

                var memstream = new MemoryStream(response);
                var gzstream = new DeflateStream(memstream, CompressionMode.Decompress);

                var worldSettingsSizeBytes = new byte[sizeof(int)];
                bytesRead = 0;
                while (bytesRead < sizeof(int))
                {
                    bytesRead += gzstream.Read(worldSettingsSizeBytes, bytesRead, sizeof(int) - bytesRead); //read the size of the world config xml
                }
                UncompressedLength = bytesRead;
                var worldSettingsBytes = new byte[BitConverter.ToInt32(worldSettingsSizeBytes, 0)];

                bytesRead = 0;
                while (bytesRead < worldSettingsBytes.Length)
                {
                    bytesRead += gzstream.Read(worldSettingsBytes, bytesRead, worldSettingsBytes.Length - bytesRead);
                }
                UncompressedLength += bytesRead;
                WorldSettings.LoadSettings(worldSettingsBytes);

                var chunkTotal = WorldData.SizeInChunksX * WorldData.SizeInChunksZ;
                var chunkCount = 1;
                for (var x = 0; x < WorldData.SizeInChunksX; x++) //loop through each chunk and load it
                {
                    for (var z = 0; z < WorldData.SizeInChunksZ; z++)
                    {
                        Settings.Launcher.UpdateProgressInvokable(string.Format("Loading Chunks: {0} / {1}", chunkCount, chunkTotal), chunkCount, chunkTotal);

                        bytesRead = 0;
                        var chunkBytes = new byte[Chunk.SIZE_IN_BYTES];
                        while (bytesRead < chunkBytes.Length)
                        {
                            var byteCount = gzstream.Read(chunkBytes, bytesRead, chunkBytes.Length - bytesRead);
                            if (byteCount <= 0) throw new Exception("Received incomplete world."); //gm: was sometimes getting zero here because the gzipstream wasnt getting flushed properly, might as well leave the check here
                            bytesRead += byteCount;
                        }
                        UncompressedLength += bytesRead;

                        WorldData.LoadChunk(WorldData.Chunks[x, z], chunkBytes);

                        chunkCount++;
                    }
                }

                gzstream.Dispose();
                memstream.Dispose();
            }

            WorldData.InitializeAllLightMaps();

            Settings.Launcher.UpdateProgressInvokable("World Ready", 0, 0);
            WorldData.IsLoaded = true;
        }
        //#endif
        public void SendTileRowCompressed(int xStart, int yStart, short width, short height, bool packChests)
        {
            Begin(Packet.SEND_TILE_ROW);

            var bufferStart = this.bin.BaseStream.Position;
            using (MemoryStream memoryStream = new MemoryStream())
            {
                using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
                {
                    binaryWriter.Write(xStart);
                    binaryWriter.Write(yStart);
                    binaryWriter.Write(width);
                    binaryWriter.Write(height);
                    NetMessage.CompressTileBlock_Inner(binaryWriter, xStart, yStart, (int)width, (int)height);
                    int num = this.buf.Length;
                    if ((long)bufferStart + memoryStream.Length > (long)num)
                    {
                        //result = (int)((long)(num - bufferStart) + memoryStream.Length);
                    }
                    else
                    {
                        memoryStream.Position = 0L;
                        MemoryStream memoryStream2 = new MemoryStream();
                        using (DeflateStream deflateStream = new DeflateStream(memoryStream2, CompressionMode.Compress, true))
                        {
                            memoryStream.CopyTo(deflateStream);
                            deflateStream.Flush();
                            deflateStream.Close();
                            deflateStream.Dispose();
                        }
                        if (memoryStream.Length <= memoryStream2.Length)
                        {
                            memoryStream.Position = 0L;
                            //buffer[bufferStart] = 0;
                            Byte(0);
                            //memoryStream.Read(buffer, bufferStart, (int)memoryStream.Length);
                            //result = (int)memoryStream.Length + 1;

                            var b = new byte[128];
                            int read = 0;
                            while ((read = memoryStream.Read(b, 0, b.Length)) > 0)
                            {
                                Byte(b, read);
                            }
                        }
                        else
                        {
                            memoryStream2.Position = 0L;
                            Byte(1);
                            //memoryStream2.Read(buffer, bufferStart, (int)memoryStream2.Length);
                            //memoryStream2.CopyTo(sink);
                            //result = (int)memoryStream2.Length + 1;

                            var b = new byte[128];
                            int read = 0;
                            while ((read = memoryStream2.Read(b, 0, b.Length)) > 0)
                            {
                                Byte(b, read);
                            }
                        }
                    }
                }
            }

            End();
        }
Пример #25
0
        /// <summary>
        /// Gets the client-side save state as a string.
        /// </summary>
        /// <returns></returns>
        string GetSaveString(Document document)
        {
            Contract.Requires<ArgumentNullException>(document != null);

            using (var stream = new MemoryStream())
            using (var encode = new CryptoStream(stream, new ToBase64Transform(), CryptoStreamMode.Write))
            using (var deflate = new DeflateStream(encode, CompressionMode.Compress))
            using (var writer = XmlDictionaryWriter.CreateBinaryWriter(deflate))
            {
                document.Save(writer);

                // flush output
                writer.Dispose();
                deflate.Dispose();
                encode.Dispose();

                return Encoding.ASCII.GetString(stream.ToArray());
            }
        }
Пример #26
0
        public static async Task FlushAsyncFailsAfterDispose()
        {

            var ms = new MemoryStream();
            var ds = new DeflateStream(ms, CompressionMode.Compress);
            ds.Dispose();

            await Assert.ThrowsAsync<ObjectDisposedException>(async () =>
            {
                await ds.FlushAsync();
            });
        }
Пример #27
0
            public void compressData() {
                MemoryStream outbuf = new MemoryStream();
                DeflateStream compress = new DeflateStream(outbuf, CompressionMode.Compress);
                
                compress.Write(data.buf, 0, data.Length);
                compress.Close();
                byte[] compData = outbuf.ToArray();
                retvalue = compData.Length;

                compress.Dispose();
                outbuf.Dispose();
            }
Пример #28
0
 public static void FlushFailsAfterDispose()
 {
     var ms = new MemoryStream();
     var ds = new DeflateStream(ms, CompressionMode.Compress);
     ds.Dispose();
     Assert.Throws<ObjectDisposedException>(() => { ds.Flush(); });
 }
Пример #29
0
        /// <summary>
        ///     Copy the contents of a stored file into an opened stream
        /// </summary>
        /// <param name="zfe">Entry information of file to extract</param>
        /// <param name="stream">Stream to store the uncompressed data</param>
        /// <returns>True if success, false if not.</returns>
        /// <remarks>Unique compression methods are Store and Deflate</remarks>
        public bool ExtractFile(ZipFileEntry zfe, Stream stream)
        {
            if (!stream.CanWrite)
                throw new InvalidOperationException("Stream cannot be written");

            // check signature
            var signature = new byte[4];
            _zipFileStream.Seek(zfe.HeaderOffset, SeekOrigin.Begin);
            _zipFileStream.Read(signature, 0, 4);
            if (BitConverter.ToUInt32(signature, 0) != 0x04034b50)
                return false;

            // Select input stream for inflating or just reading
            Stream inStream;
            switch (zfe.Method)
            {
                case Compression.Store:
                    inStream = _zipFileStream;
                    break;
                case Compression.Deflate:
                    inStream = new DeflateStream(_zipFileStream, CompressionMode.Decompress, true);
                    break;
                default:
                    return false;
            }

            // Buffered copy
            var buffer = new byte[16384];
            _zipFileStream.Seek(zfe.FileOffset, SeekOrigin.Begin);
            var bytesPending = zfe.FileSize;
            while (bytesPending > 0)
            {
                var bytesRead = inStream.Read(buffer, 0, (int) Math.Min(bytesPending, buffer.Length));
                stream.Write(buffer, 0, bytesRead);
                bytesPending -= (uint) bytesRead;
            }
            stream.Flush();

            if (zfe.Method == Compression.Deflate)
                inStream.Dispose();
            return true;
        }
Пример #30
0
 internal byte[] Decompress(byte[] compressedBuffer, int decompressedSize)
 {
     MemoryStream memStream = new MemoryStream();
     memStream.Write(compressedBuffer, 2, compressedBuffer.Length - 2);
     byte[] buffer = new byte[decompressedSize];
     memStream.Position = 0;
     DeflateStream zip = new DeflateStream(memStream, CompressionMode.Decompress);
     zip.Read(buffer, 0, buffer.Length);
     zip.Close();
     zip.Dispose();
     memStream.Close();
     memStream.Dispose();
     return buffer;
 }
Пример #31
0
        public static void SaveMap()
        {
            int i;
            int num;
            int num1;
            ushort type;
            int num2;
            if (!Main.mapEnabled || MapHelper.saveLock)
            {
                return;
            }
            string str = Main.playerPathName.Substring(0, Main.playerPathName.Length - 4);
            lock (MapHelper.padlock)
            {
                try
                {
                    MapHelper.saveLock = true;
                    try
                    {
                        Directory.CreateDirectory(str);
                    }
                    catch (Exception ex)
                    {
            #if DEBUG
                        Console.WriteLine(ex);
                        System.Diagnostics.Debugger.Break();

            #endif
                    }
                    object[] directorySeparatorChar = new object[] { str, Path.DirectorySeparatorChar, Main.worldID, ".map" };
                    str = string.Concat(directorySeparatorChar);
                    (new Stopwatch()).Start();
                    bool flag = false;
                    if (!Main.gameMenu)
                    {
                        flag = true;
                    }
                    using (MemoryStream memoryStream = new MemoryStream(4000))
                    {
                        using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
                        {
                            using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress))
                            {
                                int num3 = 0;
                                byte[] light = new byte[16384];
                                binaryWriter.Write(Main.curRelease);
                                Main.MapFileMetadata.IncrementAndWrite(binaryWriter);
                                binaryWriter.Write(Main.worldName);
                                binaryWriter.Write(Main.worldID);
                                binaryWriter.Write(Main.maxTilesY);
                                binaryWriter.Write(Main.maxTilesX);
                                binaryWriter.Write((short)419);
                                binaryWriter.Write((short)225);
                                binaryWriter.Write((short)3);
                                binaryWriter.Write((short)256);
                                binaryWriter.Write((short)256);
                                binaryWriter.Write((short)256);
                                byte num4 = 1;
                                byte num5 = 0;
                                for (i = 0; i < 419; i++)
                                {
                                    if (MapHelper.tileOptionCounts[i] != 1)
                                    {
                                        num5 = (byte)(num5 | num4);
                                    }
                                    if (num4 != 128)
                                    {
                                        num4 = (byte)(num4 << 1);
                                    }
                                    else
                                    {
                                        binaryWriter.Write(num5);
                                        num5 = 0;
                                        num4 = 1;
                                    }
                                }
                                if (num4 != 1)
                                {
                                    binaryWriter.Write(num5);
                                }
                                i = 0;
                                num4 = 1;
                                num5 = 0;
                                while (i < 225)
                                {
                                    if (MapHelper.wallOptionCounts[i] != 1)
                                    {
                                        num5 = (byte)(num5 | num4);
                                    }
                                    if (num4 != 128)
                                    {
                                        num4 = (byte)(num4 << 1);
                                    }
                                    else
                                    {
                                        binaryWriter.Write(num5);
                                        num5 = 0;
                                        num4 = 1;
                                    }
                                    i++;
                                }
                                if (num4 != 1)
                                {
                                    binaryWriter.Write(num5);
                                }
                                for (i = 0; i < 419; i++)
                                {
                                    if (MapHelper.tileOptionCounts[i] != 1)
                                    {
                                        binaryWriter.Write((byte)MapHelper.tileOptionCounts[i]);
                                    }
                                }
                                for (i = 0; i < 225; i++)
                                {
                                    if (MapHelper.wallOptionCounts[i] != 1)
                                    {
                                        binaryWriter.Write((byte)MapHelper.wallOptionCounts[i]);
                                    }
                                }
                                binaryWriter.Flush();
                                for (int j = 0; j < Main.maxTilesY; j++)
                                {
                                    if (!flag)
                                    {
                                        float single = (float)j / (float)Main.maxTilesY;
                                        object[] objArray = new object[] { Lang.gen[66], " ", (int)(single * 100f + 1f), "%" };
                                        Main.statusText = string.Concat(objArray);
                                    }
                                    for (int k = 0; k < Main.maxTilesX; k++)
                                    {
                                        MapTile item = Main.Map[k, j];
                                        int num6 = 0;
                                        byte num7 = (byte)num6;
                                        byte num8 = (byte)num6;
                                        int num9 = 0;
                                        bool flag1 = true;
                                        bool flag2 = true;
                                        int num10 = 0;
                                        int num11 = 0;
                                        byte color = 0;
                                        if (item.Light > 18)
                                        {
                                            color = item.Color;
                                            type = item.Type;
                                            if (type < MapHelper.wallPosition)
                                            {
                                                num1 = 1;
                                                type = (ushort)(type - MapHelper.tilePosition);
                                            }
                                            else if (type < MapHelper.liquidPosition)
                                            {
                                                num1 = 2;
                                                type = (ushort)(type - MapHelper.wallPosition);
                                            }
                                            else if (type < MapHelper.skyPosition)
                                            {
                                                num1 = 3 + (type - MapHelper.liquidPosition);
                                                flag1 = false;
                                            }
                                            else if (type < MapHelper.dirtPosition)
                                            {
                                                num1 = 6;
                                                flag2 = false;
                                                flag1 = false;
                                            }
                                            else if (type >= MapHelper.hellPosition)
                                            {
                                                num1 = 6;
                                                flag1 = false;
                                            }
                                            else
                                            {
                                                num1 = 7;
                                                type = (type >= MapHelper.rockPosition ? (ushort)(type - MapHelper.rockPosition) : (ushort)(type - MapHelper.dirtPosition));
                                            }
                                            if (item.Light == 255)
                                            {
                                                flag2 = false;
                                            }
                                            if (!flag2)
                                            {
                                                num9 = 0;
                                                num = k + 1;
                                                num2 = Main.maxTilesX - k - 1;
                                                while (num2 > 0)
                                                {
                                                    MapTile mapTile = Main.Map[num, j];
                                                    if (!item.Equals(ref mapTile))
                                                    {
                                                        break;
                                                    }
                                                    num2--;
                                                    num9++;
                                                    num++;
                                                }
                                            }
                                            else
                                            {
                                                num9 = 0;
                                                num = k + 1;
                                                num2 = Main.maxTilesX - k - 1;
                                                num10 = num;
                                                while (num2 > 0)
                                                {
                                                    MapTile item1 = Main.Map[num, j];
                                                    if (!item.EqualsWithoutLight(ref item1))
                                                    {
                                                        num11 = num;
                                                        goto Label0;
                                                    }
                                                    else
                                                    {
                                                        num2--;
                                                        num9++;
                                                        num++;
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            flag2 = false;
                                            flag1 = false;
                                            num1 = 0;
                                            type = 0;
                                            num9 = 0;
                                            num = k + 1;
                                            num2 = Main.maxTilesX - k - 1;
                                            while (num2 > 0)
                                            {
                                                if (Main.Map[num, j].Light > 18)
                                                {
                                                    goto Label0;
                                                }
                                                num9++;
                                                num2--;
                                                num++;
                                            }
                                        }
                                    Label0:
                                        if (color > 0)
                                        {
                                            num7 = (byte)(num7 | (byte)(color << 1));
                                        }
                                        if (num7 != 0)
                                        {
                                            num8 = (byte)(num8 | 1);
                                        }
                                        num8 = (byte)(num8 | (byte)(num1 << 1));
                                        if (flag1 && type > 255)
                                        {
                                            num8 = (byte)(num8 | 16);
                                        }
                                        if (flag2)
                                        {
                                            num8 = (byte)(num8 | 32);
                                        }
                                        if (num9 > 0)
                                        {
                                            num8 = (num9 <= 255 ? (byte)(num8 | 64) : (byte)(num8 | 128));
                                        }
                                        light[num3] = num8;
                                        num3++;
                                        if (num7 != 0)
                                        {
                                            light[num3] = num7;
                                            num3++;
                                        }
                                        if (flag1)
                                        {
                                            light[num3] = (byte)type;
                                            num3++;
                                            if (type > 255)
                                            {
                                                light[num3] = (byte)(type >> 8);
                                                num3++;
                                            }
                                        }
                                        if (flag2)
                                        {
                                            light[num3] = item.Light;
                                            num3++;
                                        }
                                        if (num9 > 0)
                                        {
                                            light[num3] = (byte)num9;
                                            num3++;
                                            if (num9 > 255)
                                            {
                                                light[num3] = (byte)(num9 >> 8);
                                                num3++;
                                            }
                                        }
                                        for (int l = num10; l < num11; l++)
                                        {
                                            light[num3] = Main.Map[l, j].Light;
                                            num3++;
                                        }
                                        k = k + num9;
                                        if (num3 >= 4096)
                                        {
                                            deflateStream.Write(light, 0, num3);
                                            num3 = 0;
                                        }
                                    }
                                }
                                if (num3 > 0)
                                {
                                    deflateStream.Write(light, 0, num3);
                                }
                                deflateStream.Dispose();
                                FileUtilities.WriteAllBytes(str, memoryStream.ToArray());
                            }
                        }
                    }
                }
                catch (Exception exception1)
                {
                    Exception exception = exception1;
                    using (StreamWriter streamWriter = new StreamWriter("client-crashlog.txt", true))
                    {
                        streamWriter.WriteLine(DateTime.Now);
                        streamWriter.WriteLine(exception);
                        streamWriter.WriteLine("");
                    }
                }
                MapHelper.saveLock = false;
            }
        }
Пример #32
0
        public byte[] CompressDataSet(DataSet ds)
        {
            ds.RemotingFormat = SerializationFormat.Binary;
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            bf.Serialize(ms, ds);

            byte[] inbyt = ms.ToArray();
            MemoryStream objStream = new MemoryStream();

            DeflateStream objZS = new DeflateStream(objStream, CompressionMode.Compress);
            objZS.Write(inbyt, 0, inbyt.Length);
            objZS.Flush();
            objZS.Close();

            byte[] b = objStream.ToArray();
            objZS.Dispose();

            return b;
        }
Пример #33
0
            public void bitmapCompressData() {
                byte[] bm = new byte[data.Length/4];
                byte[] dt = new byte[data.Length];
                int bi = 0, di = 0;

                for (int i=0; i<data.Length; i+=sizeof(UInt32))
                    if (data.buf[i+3] == 0) 
                        bm[bi++]=0x00;
                    else {
                        bm[bi++]=0xFF;
                        dt[di++] = data.buf[i];
                        dt[di++] = data.buf[i+1];
                        dt[di++] = data.buf[i+2];
                    }
                MemoryStream outbuf = new MemoryStream();
                DeflateStream compress = new DeflateStream(outbuf, CompressionMode.Compress);

                compress.Write(bm, 0, bi);
                compress.Write(dt, 0, di);
                compress.Close();
                byte[] compData = outbuf.ToArray();
                retvalue = compData.Length;

                compress.Dispose();
                outbuf.Dispose();
            }
		public void CheckGetCanWriteProp ()
		{
			MemoryStream backing = new MemoryStream ();
			DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
			Assert.IsFalse (decompress.CanWrite, "#A1");
			Assert.IsTrue (backing.CanWrite, "#A2");
			decompress.Dispose ();
			Assert.IsFalse (decompress.CanWrite, "#A3");
			Assert.IsFalse (backing.CanWrite, "#A4");

			backing = new MemoryStream ();
			DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
			Assert.IsTrue (compress.CanWrite, "#B1");
			Assert.IsTrue (backing.CanWrite, "#B2");
			compress.Dispose ();
			Assert.IsFalse (decompress.CanWrite, "#B3");
			Assert.IsFalse (backing.CanWrite, "#B4");
		}
Пример #35
0
        public bool DecompressMovieHeader()
        {
            MovieBox moov = this.Children.OfType<MovieBox>().SingleOrDefault();
            if (moov == null) return false;
            CompressedMovieBox cmov = moov.Children.OfType<CompressedMovieBox>().SingleOrDefault();
            if (cmov == null) return false;
            DataCompressionBox dcom = cmov.Children.OfType<DataCompressionBox>().SingleOrDefault();
            if (dcom == null) return false;
            CompressedMovieDataBox cmvd = cmov.Children.OfType<CompressedMovieDataBox>().SingleOrDefault();
            if (cmvd == null) return false;

            if (dcom.Format != "zlib") throw new FileFormatException("Unsupported compression type: " + dcom.Format);

            Stream contentStream = cmvd.GetContentStream();
            contentStream.ReadByte();
            contentStream.ReadByte();
            Stream compressedStream = new DeflateStream(contentStream, CompressionMode.Decompress, true);
            MemoryStream uncompressedStream = new MemoryStream();
            compressedStream.CopyTo(uncompressedStream);
            uncompressedStream.Flush();
            compressedStream.Dispose();
            uncompressedStream.Seek(0, SeekOrigin.Begin);

            BaseMedia uncompressedMoov = new BaseMedia(uncompressedStream);

            MovieBox newMoov = uncompressedMoov.Children.OfType<MovieBox>().SingleOrDefault();
            if (newMoov != null)
            {
                int insertionPoint = Children.IndexOf(moov);
                Children.Remove(moov);
                FreeSpaceBox free = new FreeSpaceBox(moov.EffectiveSize);
                ((ObservableCollection<Box>)Children).Insert(insertionPoint, free);
                ((ObservableCollection<Box>)Children).Add(newMoov);
            }
            return true;
        }
Пример #36
0
        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            Stream compressedStream = new DeflateStream(stream, CompressionMode.Compress, leaveOpen: true);

           return (_originalContent == null)? Task.Run(() => GetMensagem()):
               _originalContent.CopyToAsync(compressedStream).ContinueWith(tsk =>
            { if (compressedStream != null) compressedStream.Dispose(); });
        }
 public static byte[] DeflateDecompress(byte[] data)
 {
     MemoryStream ms = new MemoryStream(data);
     DeflateStream stream = new DeflateStream(ms, CompressionMode.Decompress);
     byte[] buffer = StreamDataHelper.ReadDataToBytes(stream);
     ms.Close();
     ms.Dispose();
     ms = null;
     stream.Close();
     stream.Dispose();
     stream = null;
     return buffer;
 }