SetCoderProperties() public method

public SetCoderProperties ( CoderPropID propIDs, object properties ) : void
propIDs CoderPropID
properties object
return void
示例#1
1
        public static MemoryStream Compress(MemoryStream inStream)
        {
            inStream.Position = 0;

            CoderPropId[] propIDs =
            {
                CoderPropId.DictionarySize,
                CoderPropId.PosStateBits,
                CoderPropId.LitContextBits,
                CoderPropId.LitPosBits,
                CoderPropId.Algorithm
            };

            object[] properties =
            {
                (1 << 16),
                2,
                3,
                0,
                2
            };

            var outStream = new MemoryStream();
            var encoder = new Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outStream);
            for (var i = 0; i < 8; i++)
                outStream.WriteByte((byte) (inStream.Length >> (8 * i)));
            encoder.Code(inStream, outStream, -1, -1, null);
            outStream.Flush();
            outStream.Position = 0;

            return outStream;
        }
示例#2
1
        public void writeCompressedData(byte[] data)
        {
            int dicSize;
            if (compressionLevel <= 5) {
               dicSize = 1 << (compressionLevel * 2 + 14);
            } else if (compressionLevel == 6) {
                dicSize = 1 << 25;
            } else {
                dicSize = 1 << 26;
            }
            object[] properties =
                {
                    (Int32)dicSize,
                    (Int32)(2),
                    (Int32)(3),
                    (Int32)(0),
                    (Int32)(2),
                    (Int32)(compressionLevel < 7 ? 32 : 64),
                    "bt4",
                    true
                };

            Encoder encoder = new Encoder();
            encoder.SetCoderProperties(propIDs, properties);

            MemoryStream inStream = new MemoryStream(data);
            MemoryStream outStream = new MemoryStream();
            encoder.Code(inStream, outStream, -1, -1, null);
            byte[] compressedData = outStream.ToArray();

            //This is the custom way of OpenCTM to write the LZMA properties
            writeLittleInt(compressedData.Length);
            encoder.WriteCoderProperties(BaseStream);
            Write(compressedData);
        }
        public static void CompressFileLZMA(string inFile, string outFile)
        {
            Int32 dictionary     = 1 << 23;
            Int32 posStateBits   = 2;
            Int32 litContextBits = 3;     // for normal files
            // UInt32 litContextBits = 0; // for 32-bit data
            Int32 litPosBits = 0;
            // UInt32 litPosBits = 2; // for 32-bit data
            Int32  algorithm    = 2;
            Int32  numFastBytes = 128;
            string mf           = "bt4";
            bool   eos          = true;
            bool   stdInMode    = false;

            CoderPropID[] propIDs =
            {
                CoderPropID.DictionarySize,
                CoderPropID.PosStateBits,
                CoderPropID.LitContextBits,
                CoderPropID.LitPosBits,
                CoderPropID.Algorithm,
                CoderPropID.NumFastBytes,
                CoderPropID.MatchFinder,
                CoderPropID.EndMarker
            };
            object[] properties =
            {
                (Int32)(dictionary),
                (Int32)(posStateBits),
                (Int32)(litContextBits),
                (Int32)(litPosBits),
                (Int32)(algorithm),
                (Int32)(numFastBytes),
                mf,
                eos
            };
            using (FileStream inStream = new FileStream(inFile, FileMode.Open))
            {
                using (FileStream outStream = new FileStream(outFile, FileMode.Create))
                {
                    SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
                    encoder.SetCoderProperties(propIDs, properties);
                    encoder.WriteCoderProperties(outStream);
                    Int64 fileSize;
                    if (eos || stdInMode)
                    {
                        fileSize = -1;
                    }
                    else
                    {
                        fileSize = inStream.Length;
                    }
                    for (int i = 0; i < 8; i++)
                    {
                        outStream.WriteByte((Byte)(fileSize >> (8 * i)));
                    }
                    encoder.Code(inStream, outStream, -1, -1, null);
                }
            }
        }
示例#4
0
        /// <summary>
        /// Compress input stream into output stream using LZMA.
        /// Remeber to set desirable positions input and output streams.
        /// Input reading starts at inStream.Position and ends at inStream.Length.
        /// Output writing starts at outStream.Position.
        /// </summary>
        /// <param name="inStream">Input stream</param>
        /// <param name="outStream">Output stream</param>
        public static void Compress(Stream inStream, Stream outStream)
        {
            Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();

            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outStream);

            var writer = new BinaryWriter(outStream, Encoding.UTF8);
            // Write original size.
            writer.Write(inStream.Length - inStream.Position);

            // Save position with compressed size.
            long positionForCompressedSize = outStream.Position;
            // Leave placeholder for size after compression.
            writer.Write((Int64)0);

            long positionForCompressedDataStart = outStream.Position;
            encoder.Code(inStream, outStream, -1, -1, null);
            long positionAfterCompression = outStream.Position;

            // Seek back to the placeholder for compressed size.
            outStream.Position = positionForCompressedSize;

            // Write size after compression.
            writer.Write((Int64)(positionAfterCompression - positionForCompressedDataStart));

            // Restore position.
            outStream.Position = positionAfterCompression;
        }
示例#5
0
        // Compress track back to a file that the games can read
        public static void Compress(string filePath, DecompressedTrack track)
        {
            // Setup LZMA encoder
            SevenZip.Compression.LZMA.Encoder encoder      = new SevenZip.Compression.LZMA.Encoder();
            SevenZip.CoderPropID[]            coderPropIDs = { SevenZip.CoderPropID.DictionarySize, SevenZip.CoderPropID.LitContextBits, SevenZip.CoderPropID.LitPosBits, SevenZip.CoderPropID.PosStateBits };
            object[] properties = LzmaPropertiesFromBytes(track.Properties);
            encoder.SetCoderProperties(coderPropIDs, properties);

            // Write compressed track to file
            using (FileStream fileStream = File.OpenWrite(filePath))
            {
                // Write track header
                fileStream.Write(track.Header, 0, track.Header.Length);

                // Write LZMA header
                encoder.WriteCoderProperties(fileStream);
                fileStream.Write(BitConverter.GetBytes(track.Data.Length), 0, 4);

                // Write compressed track data
                using (MemoryStream memoryStream = new MemoryStream(track.Data))
                {
                    encoder.Code(memoryStream, fileStream, memoryStream.Length, -1, null);
                }
            }
        }
示例#6
0
 public static void Compress(Stream inStream, Stream outStream, ICodeProgress progress)
 {
     SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
     encoder.SetCoderProperties(propIDs, properties);
     //encoder.WriteCoderProperties(outStream);
     encoder.Code(inStream, outStream, -1, -1, progress);
 }
示例#7
0
        private static byte[] compress(byte[] decompressed)
        {
            byte[] retVal         = null;
            bool   eos            = true;
            Int32  dictionary     = 1 << 16;
            Int32  posStateBits   = 2;
            Int32  litContextBits = 3; // for normal files
                                       // UInt32 litContextBits = 0; // for 32-bit data
            Int32 litPosBits = 0;
            // UInt32 litPosBits = 2; // for 32-bit data
            Int32  algorithm    = 2;
            Int32  numFastBytes = 64;
            string mf           = "bt4";

            var propIDs = new CoderPropID[]
            {
                CoderPropID.DictionarySize,
                CoderPropID.PosStateBits,
                CoderPropID.LitContextBits,
                CoderPropID.LitPosBits,
                CoderPropID.Algorithm,
                CoderPropID.NumFastBytes,
                CoderPropID.MatchFinder,
                CoderPropID.EndMarker
            };
            var properties = new object[]
            {
                dictionary,
                posStateBits,
                litContextBits,
                litPosBits,
                algorithm,
                numFastBytes,
                mf,
                eos
            };

            SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
            using (Stream strmInStream = new MemoryStream(decompressed))
            {
                strmInStream.Seek(0, 0);
                using (MemoryStream strmOutStream = new MemoryStream())
                {
                    encoder.SetCoderProperties(propIDs, properties);
                    encoder.WriteCoderProperties(strmOutStream);
                    Int64 fileSize = strmInStream.Length;
                    for (int i = 0; i < 8; i++)
                    {
                        strmOutStream.WriteByte((Byte)(fileSize >> (8 * i)));
                    }
                    encoder.Code(strmInStream, strmOutStream, -1, -1, null);
                    retVal = strmOutStream.ToArray();
                }
            }
            return(retVal);
        }
示例#8
0
        public static void Compress(Stream inputStream, Stream outputStream)
        {
            Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outputStream);
            long fileSize = inputStream.Length;
            for (int i = 0; i < 8; i++)
                outputStream.WriteByte((Byte)(fileSize >> (8 * i)));

            encoder.Code(inputStream, outputStream, -1, -1, null);
        }
 public static byte[] Compress(byte[] inputBytes)
 {
     MemoryStream inStream = new MemoryStream(inputBytes);
     MemoryStream outStream = new MemoryStream();
     Encoder encoder = new Encoder();
     encoder.SetCoderProperties(propIDs, properties);
     encoder.WriteCoderProperties(outStream);
     long fileSize = inStream.Length;
     for (int i = 0; i < 8; i++)
         outStream.WriteByte((Byte)(fileSize >> (8 * i)));
     encoder.Code(inStream, outStream, -1, -1, null);
     return outStream.ToArray();
 }
示例#10
0
        public static byte[] Compress(byte[] inputBytes)
        {
            MemoryStream inStream  = new MemoryStream(inputBytes);
            MemoryStream outStream = new MemoryStream();

            SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outStream);
            long fileSize = inStream.Length;

            for (int i = 0; i < 8; i++)
            {
                outStream.WriteByte((Byte)(fileSize >> (8 * i)));
            }
            encoder.Code(inStream, outStream, -1, -1, null);
            return(outStream.ToArray());
        }
示例#11
0
        /// <summary>
        /// Compresses the inputBytes in Lzma.
        /// </summary>
        /// <param name="inputBytes">Bytes to compress.</param>
        /// <returns>Compressed bytes.</returns>
        public static byte[] Compress(byte[] inputBytes)
        {
            if (inputBytes == null)
                throw new ArgumentNullException("inputBytes");

            var inStream = new MemoryStream(inputBytes);
            var outStream = new MemoryStream();
            var encoder = new Encoder();

            encoder.SetCoderProperties(PropertiesIDs, Properties);
            encoder.WriteCoderProperties(outStream);
            var fileSize = inStream.Length;
            for (int i = 0; i < 8; i++)
                outStream.WriteByte((byte)(fileSize >> (8 * i)));

            encoder.Code(inStream, outStream, -1, -1, null);
            return outStream.ToArray();
        }
示例#12
0
 public static System.IO.Stream Compress(System.IO.Stream stream, uint length, bool EOF = false)
 {
     SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
     System.IO.MemoryStream sout = new System.IO.MemoryStream();
     if (EOF)
     {
         encoder.SetCoderProperties(new SevenZip.CoderPropID[] { SevenZip.CoderPropID.EndMarker }, new object[] { true });
     }
     else
     {
         //写入文件长度
         sout.Write(BitConverter.GetBytes(length), 0, 4);
     }
     encoder.WriteCoderProperties(sout);
     encoder.Code(stream, sout, (int)length, -1, null);
     sout.Position = 0;
     return sout;
 }
示例#13
0
        public static byte[] Compress(byte[] bytes)
        {
            using (MemoryStream input = new MemoryStream(bytes))
            {
                MemoryStream output = new MemoryStream();
                Encoder encoder = new Encoder();
                encoder.SetCoderProperties(propIDs, properties);
                encoder.WriteCoderProperties(output);

                if (BitConverter.IsLittleEndian)
                {
                    byte[] LengthHeader = BitConverter.GetBytes(input.Length);
                    output.Write(LengthHeader, 0, LengthHeader.Length);
                }

                encoder.Code(input, output, input.Length, -1, null);
                return output.ToArray();
            }
        }
        private static Stream CompressInternal(Stream inStream)
        {
            var outStream = new MemoryStream();
            var encoder   = new LZMA.Encoder();

            encoder.SetCoderProperties(s_propertiesIds, s_properties);
            encoder.WriteCoderProperties(outStream);

            // Uncompressed size.
            var outSize      = inStream.Length;
            var outSizeBytes = BitConverter.GetBytes(outSize);

            outStream.Write(outSizeBytes, 0, 4);

            encoder.Code(inStream, outStream, -1, -1, null);

            outStream.Seek(0, SeekOrigin.Begin);
            return(outStream);
        }
        public static bool Compress(byte[] inputBytes, string FileName, bool Overwrite)
        {
            if (File.Exists(FileName)) {
                if(Overwrite) {
                    File.Delete(FileName);
                } else {
                    return false;
                }
            }

            //MemoryStream inStream = new MemoryStream(inputBytes);
            using(FileStream outStream = File.Create(FileName)) {
                MemoryStream inStream = new MemoryStream(inputBytes);
                SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
                encoder.SetCoderProperties(propIDs, properties);
                encoder.WriteCoderProperties(outStream);
                long fileSize = inStream.Length;
                for (int i = 0; i < 8; i++)
                    outStream.WriteByte((Byte)(fileSize >> (8 * i)));
                encoder.Code(inStream, outStream, -1, -1, null);
            }
            return true;
        }
示例#16
0
    private static void Compress(Stream inputStream, Stream outputStream, LZMADictionarySize dictSize)
    {
        SevenZip.Compression.LZMA.Encoder coder = new SevenZip.Compression.LZMA.Encoder();
        Int32 dictSize32 = (Int32)dictSize;
        coder.SetCoderProperties (new SevenZip.CoderPropID[] {SevenZip.CoderPropID.DictionarySize}, new object[] {dictSize32});
        // Write encoder properties to output stream
        coder.WriteCoderProperties(outputStream);

        // Write size of input stream to output stream.
        outputStream.Write(BitConverter.GetBytes(inputStream.Length), 0, 8);

        // Encode
        coder.Code(inputStream, outputStream, inputStream.Length, -1, null);
        outputStream.Flush();
        outputStream.Close();
    }
示例#17
0
        public override byte[] Code(Byte[] data)
        {
            int dictionary = 1 << 23;
            Int32 posStateBits = 2;
            Int32 litContextBits = 3; // for normal files
            // UInt32 litContextBits = 0; // for 32-bit data
            Int32 litPosBits = 0;
            // UInt32 litPosBits = 2; // for 32-bit data
            Int32 algorithm = 2;
            Int32 numFastBytes = 128;

            CoderPropID[] propIDs =
                {
                    CoderPropID.DictionarySize,
                    CoderPropID.PosStateBits,
                    CoderPropID.LitContextBits,
                    CoderPropID.LitPosBits,
                    CoderPropID.Algorithm,
                    CoderPropID.NumFastBytes,
                    CoderPropID.MatchFinder,
                    CoderPropID.EndMarker
                };
            object[] properties =
                {
                    (Int32)(dictionary),
                    (Int32)(posStateBits),
                    (Int32)(litContextBits),
                    (Int32)(litPosBits),
                    (Int32)(algorithm),
                    (Int32)(numFastBytes),
                    "bt4",
                    false
                };

            MemoryStream inpuMemoryStream = new MemoryStream(data);
            MemoryStream outputMemoryStream = new MemoryStream();
            SevenZip.Compression.LZMA.Encoder encoder = new Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outputMemoryStream);
            Int64 fileSize = inpuMemoryStream.Length;
            for (int i = 0; i < 8; i++)
            {
                byte b = (Byte) (fileSize >> (8*i));
                outputMemoryStream.WriteByte(b);
            }

            encoder.Code(inpuMemoryStream, outputMemoryStream, -1, -1, null);
            var outBuffer = outputMemoryStream.ToArray();

            return outBuffer;
            //int keyIndex = 0;

            //for (uint i = 0; i < data.Length; ++i)
            //{
            //    data[i] ^= mKey[keyIndex];
            //    if (keyIndex < mKey.Length - 1)
            //    {
            //        ++keyIndex;
            //    }
            //    else
            //    {
            //        keyIndex = 0;
            //    }
            //}

            //return data;
        }
示例#18
0
        public static void Main()
        {
            var l = new HttpListener();

            l.Prefixes.Add("http://*:80/");
            l.Start();

            Console.WriteLine("HttpListener is listening...");

            while (l.IsListening)
            {
                var cont = l.GetContext();

                Console.WriteLine("Incoming request for: {0}", cont.Request.RawUrl.Replace("/", @"\"));

                var fname = Environment.CurrentDirectory + cont.Request.RawUrl.Replace("/", @"\");
                if (!File.Exists(fname))
                {
                    var modfname = fname.Substring(0, fname.Length - 4);
                    if (Path.GetExtension(fname) == ".7zl" && File.Exists(modfname))
                    {
                        var outStream = new FileStream(fname, FileMode.Create, FileAccess.Write);
                        var inStream  = new FileStream(modfname, FileMode.Open, FileAccess.Read);

                        var encoder = new LZ.Encoder();
                        encoder.SetCoderProperties(PropIDs, Properties);
                        encoder.WriteCoderProperties(outStream);

                        var instreamLen = inStream.Length;

                        outStream.Write(BitConverter.GetBytes(instreamLen), 0, 8);

                        encoder.Code(inStream, outStream, -1, -1, null);

                        outStream.Close();
                        inStream.Close();
                    }
                    else
                    {
                        cont.Response.Close();
                        continue;
                    }
                }

                var buff = File.ReadAllBytes(fname);

                var mime = "text/html";

                switch (Path.GetExtension(fname))
                {
                case "txt":
                    mime = "text/plain";
                    break;

                case "tga":
                    mime = "image/targa";
                    break;

                case "bmp":
                case "png":
                case "gif":
                case "tiff":
                case "jpeg":
                    mime = String.Format("image/{0}", Path.GetExtension(fname));
                    break;

                case "tif":
                    mime = "image/tiff";
                    break;

                case "jpg":
                case "jpe":
                    mime = "image/jpeg";
                    break;

                case "js":
                    mime = "text/javascript";
                    break;

                case "css":
                    mime = "text/css";
                    break;
                }
                try
                {
                    cont.Response.ContentType     = mime;
                    cont.Response.ContentLength64 = buff.Length;
                    cont.Response.OutputStream.Write(buff, 0, buff.Length);
                    //cont.Response.Close();
                }
                catch (HttpListenerException)
                {
                }
            }
        }
示例#19
0
		static SevenZipHelper() {
			encoder = new Encoder();
			encoder.SetCoderProperties(propIDs, properties);

			decoder = new Decoder();
		}
示例#20
0
文件: LzmaAlone.cs 项目: ChewSo/omaha
		static int Main2(string[] args)
		{
			System.Console.WriteLine("\nLZMA# 4.61  2008-11-23\n");

			if (args.Length == 0)
			{
				PrintHelp();
				return 0;
			}

			SwitchForm[] kSwitchForms = new SwitchForm[13];
			int sw = 0;
			kSwitchForms[sw++] = new SwitchForm("?", SwitchType.Simple, false);
			kSwitchForms[sw++] = new SwitchForm("H", SwitchType.Simple, false);
			kSwitchForms[sw++] = new SwitchForm("A", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("D", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("FB", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("LC", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("LP", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("PB", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("MF", SwitchType.UnLimitedPostString, false, 1);
			kSwitchForms[sw++] = new SwitchForm("EOS", SwitchType.Simple, false);
			kSwitchForms[sw++] = new SwitchForm("SI", SwitchType.Simple, false);
			kSwitchForms[sw++] = new SwitchForm("SO", SwitchType.Simple, false);
			kSwitchForms[sw++] = new SwitchForm("T", SwitchType.UnLimitedPostString, false, 1);


			Parser parser = new Parser(sw);
			try
			{
				parser.ParseStrings(kSwitchForms, args);
			}
			catch
			{
				return IncorrectCommand();
			}

			if (parser[(int)Key.Help1].ThereIs || parser[(int)Key.Help2].ThereIs)
			{
				PrintHelp();
				return 0;
			}

			System.Collections.ArrayList nonSwitchStrings = parser.NonSwitchStrings;

			int paramIndex = 0;
			if (paramIndex >= nonSwitchStrings.Count)
				return IncorrectCommand();
			string command = (string)nonSwitchStrings[paramIndex++];
			command = command.ToLower();

			bool dictionaryIsDefined = false;
			Int32 dictionary = 1 << 21;
			if (parser[(int)Key.Dictionary].ThereIs)
			{
				Int32 dicLog;
				if (!GetNumber((string)parser[(int)Key.Dictionary].PostStrings[0], out dicLog))
					IncorrectCommand();
				dictionary = (Int32)1 << dicLog;
				dictionaryIsDefined = true;
			}
			string mf = "bt4";
			if (parser[(int)Key.MatchFinder].ThereIs)
				mf = (string)parser[(int)Key.MatchFinder].PostStrings[0];
			mf = mf.ToLower();

			if (command == "b")
			{
				const Int32 kNumDefaultItereations = 10;
				Int32 numIterations = kNumDefaultItereations;
				if (paramIndex < nonSwitchStrings.Count)
					if (!GetNumber((string)nonSwitchStrings[paramIndex++], out numIterations))
						numIterations = kNumDefaultItereations;
				return LzmaBench.LzmaBenchmark(numIterations, (UInt32)dictionary);
			}

			string train = "";
			if (parser[(int)Key.Train].ThereIs)
				train = (string)parser[(int)Key.Train].PostStrings[0];

			bool encodeMode = false;
			if (command == "e")
				encodeMode = true;
			else if (command == "d")
				encodeMode = false;
			else
				IncorrectCommand();

			bool stdInMode = parser[(int)Key.StdIn].ThereIs;
			bool stdOutMode = parser[(int)Key.StdOut].ThereIs;

			Stream inStream = null;
			if (stdInMode)
			{
				throw (new Exception("Not implemeted"));
			}
			else
			{
				if (paramIndex >= nonSwitchStrings.Count)
					IncorrectCommand();
				string inputName = (string)nonSwitchStrings[paramIndex++];
				inStream = new FileStream(inputName, FileMode.Open, FileAccess.Read);
			}

			FileStream outStream = null;
			if (stdOutMode)
			{
				throw (new Exception("Not implemeted"));
			}
			else
			{
				if (paramIndex >= nonSwitchStrings.Count)
					IncorrectCommand();
				string outputName = (string)nonSwitchStrings[paramIndex++];
				outStream = new FileStream(outputName, FileMode.Create, FileAccess.Write);
			}

			FileStream trainStream = null;
			if (train.Length != 0)
				trainStream = new FileStream(train, FileMode.Open, FileAccess.Read);

			if (encodeMode)
			{
				if (!dictionaryIsDefined)
					dictionary = 1 << 23;

				Int32 posStateBits = 2;
				Int32 litContextBits = 3; // for normal files
				// UInt32 litContextBits = 0; // for 32-bit data
				Int32 litPosBits = 0;
				// UInt32 litPosBits = 2; // for 32-bit data
				Int32 algorithm = 2;
				Int32 numFastBytes = 128;

				bool eos = parser[(int)Key.EOS].ThereIs || stdInMode;

				if (parser[(int)Key.Mode].ThereIs)
					if (!GetNumber((string)parser[(int)Key.Mode].PostStrings[0], out algorithm))
						IncorrectCommand();

				if (parser[(int)Key.FastBytes].ThereIs)
					if (!GetNumber((string)parser[(int)Key.FastBytes].PostStrings[0], out numFastBytes))
						IncorrectCommand();
				if (parser[(int)Key.LitContext].ThereIs)
					if (!GetNumber((string)parser[(int)Key.LitContext].PostStrings[0], out litContextBits))
						IncorrectCommand();
				if (parser[(int)Key.LitPos].ThereIs)
					if (!GetNumber((string)parser[(int)Key.LitPos].PostStrings[0], out litPosBits))
						IncorrectCommand();
				if (parser[(int)Key.PosBits].ThereIs)
					if (!GetNumber((string)parser[(int)Key.PosBits].PostStrings[0], out posStateBits))
						IncorrectCommand();

				CoderPropID[] propIDs = 
				{
					CoderPropID.DictionarySize,
					CoderPropID.PosStateBits,
					CoderPropID.LitContextBits,
					CoderPropID.LitPosBits,
					CoderPropID.Algorithm,
					CoderPropID.NumFastBytes,
					CoderPropID.MatchFinder,
					CoderPropID.EndMarker
				};
				object[] properties = 
				{
					(Int32)(dictionary),
					(Int32)(posStateBits),
					(Int32)(litContextBits),
					(Int32)(litPosBits),
					(Int32)(algorithm),
					(Int32)(numFastBytes),
					mf,
					eos
				};

				Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
				encoder.SetCoderProperties(propIDs, properties);
				encoder.WriteCoderProperties(outStream);
				Int64 fileSize;
				if (eos || stdInMode)
					fileSize = -1;
				else
					fileSize = inStream.Length;
				for (int i = 0; i < 8; i++)
					outStream.WriteByte((Byte)(fileSize >> (8 * i)));
				if (trainStream != null)
				{
					CDoubleStream doubleStream = new CDoubleStream();
					doubleStream.s1 = trainStream;
					doubleStream.s2 = inStream;
					doubleStream.fileIndex = 0;
					inStream = doubleStream;
					long trainFileSize = trainStream.Length;
					doubleStream.skipSize = 0;
					if (trainFileSize > dictionary)
						doubleStream.skipSize = trainFileSize - dictionary;
					trainStream.Seek(doubleStream.skipSize, SeekOrigin.Begin);
					encoder.SetTrainSize((uint)(trainFileSize - doubleStream.skipSize));
				}
				encoder.Code(inStream, outStream, -1, -1, null);
			}
			else if (command == "d")
			{
				byte[] properties = new byte[5];
				if (inStream.Read(properties, 0, 5) != 5)
					throw (new Exception("input .lzma is too short"));
				Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();
				decoder.SetDecoderProperties(properties);
				if (trainStream != null)
				{
					if (!decoder.Train(trainStream))
						throw (new Exception("can't train"));
				}
				long outSize = 0;
				for (int i = 0; i < 8; i++)
				{
					int v = inStream.ReadByte();
					if (v < 0)
						throw (new Exception("Can't Read 1"));
					outSize |= ((long)(byte)v) << (8 * i);
				}
				long compressedSize = inStream.Length - inStream.Position;
				decoder.Code(inStream, outStream, compressedSize, outSize, null);
			}
			else
				throw (new Exception("Command Error"));
			return 0;
		}
示例#21
0
        /// <summary>
        /// Compresses the report for uploading.
        /// </summary>
        /// <param name="progress">The <see cref="ProgressManager"/> instance that the
        /// Upload function is using.</param>
        /// <param name="progressChanged">The progress changed event handler that should
        /// be called for upload progress updates.</param>
        private void Compress(SteppedProgressManager progress,
                              ProgressChangedEventHandler progressChanged)
        {
            using (FileStream archiveStream = new FileStream(ReportBaseName + ".tar",
                                                             FileMode.Create, FileAccess.Write))
            {
                //Add the report into a tar file
                TarArchive archive = TarArchive.CreateOutputTarArchive(archiveStream);
                foreach (FileInfo file in Report.Files)
                {
                    TarEntry entry = TarEntry.CreateEntryFromFile(file.FullName);
                    entry.Name = Path.GetFileName(entry.Name);
                    archive.WriteEntry(entry, false);
                }
                archive.Close();
            }

            ProgressManager step = new ProgressManager();

            progress.Steps.Add(new SteppedProgressManagerStep(step, 0.5f, "Compressing"));
            CoderPropID[] propIDs =
            {
                CoderPropID.DictionarySize,
                CoderPropID.PosStateBits,
                CoderPropID.LitContextBits,
                CoderPropID.LitPosBits,
                CoderPropID.Algorithm,
                CoderPropID.NumFastBytes,
                CoderPropID.MatchFinder,
                CoderPropID.EndMarker
            };
            object[] properties =
            {
                (Int32)(1 << 24),                                               //Dictionary Size
                (Int32)2,                                                       //PosState Bits
                (Int32)0,                                                       //LitContext Bits
                (Int32)2,                                                       //LitPos Bits
                (Int32)2,                                                       //Algorithm
                (Int32)128,                                                     //Fast Bytes
                "bt4",                                                          //Match Finger
                true                                                            //Write end-of-stream
            };

            SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
            encoder.SetCoderProperties(propIDs, properties);

            using (FileStream sevenZipFile = new FileStream(ReportBaseName + ".tar.7z",
                                                            FileMode.Create))
                using (FileStream tarStream = new FileStream(ReportBaseName + ".tar",
                                                             FileMode.Open, FileAccess.Read, FileShare.Read, 262144, FileOptions.DeleteOnClose))
                {
                    encoder.WriteCoderProperties(sevenZipFile);
                    Int64 fileSize = -1;
                    for (int i = 0; i < 8; i++)
                    {
                        sevenZipFile.WriteByte((Byte)(fileSize >> (8 * i)));
                    }

                    step.Total = tarStream.Length;
                    ICodeProgress callback = progressChanged == null ? null :
                                             new SevenZipProgressCallback(this, progress, step, progressChanged);
                    encoder.Code(tarStream, sevenZipFile, -1, -1, callback);
                }
        }
示例#22
0
        /// <inheritdoc />
        public byte[] Compress(byte[] data, Action<double> progressFunc = null)
        {
            CoderPropID[] propIDs = {
                CoderPropID.DictionarySize,
                CoderPropID.PosStateBits,
                CoderPropID.LitContextBits,
                CoderPropID.LitPosBits,
                CoderPropID.Algorithm,
                CoderPropID.NumFastBytes,
                CoderPropID.MatchFinder,
                CoderPropID.EndMarker
            };
            object[] properties = {
                1 << 23,
                2,
                3,
                0,
                2,
                128,
                "bt4",
                false
            };

            var x = new MemoryStream();
            var encoder = new Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(x);
            Int64 fileSize;
            fileSize = data.Length;
            for (int i = 0; i < 8; i++)
                x.WriteByte((Byte)(fileSize >> (8 * i)));

            ICodeProgress progress = null;
            if (progressFunc != null)
                progress = new CompressionLogger(progressFunc, data.Length);
            encoder.Code(new MemoryStream(data), x, -1, -1, progress);

            return x.ToArray();
        }
示例#23
0
        public static void CompressFileLZMA(MemoryStream inFile, string outFile)
        {
            int    dictionary     = 33554432;
            int    posStateBits   = 2;
            int    litContextBits = 3;
            int    litPosBits     = 0;
            int    algorithm      = 2;
            int    numFastBytes   = 32;
            string mf             = "bt4";
            bool   eos            = true;
            bool   stdInMode      = false;


            CoderPropID[] propIDs =
            {
                CoderPropID.DictionarySize,
                CoderPropID.PosStateBits,
                CoderPropID.LitContextBits,
                CoderPropID.LitPosBits,
                CoderPropID.Algorithm,
                CoderPropID.NumFastBytes,
                CoderPropID.MatchFinder,
                CoderPropID.EndMarker
            };

            object[] properties =
            {
                dictionary,
                posStateBits,
                litContextBits,
                litPosBits,
                algorithm,
                numFastBytes,
                mf,
                eos
            };
            byte[] TibiaHeader = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
            using FileStream outStream = new FileStream(outFile, FileMode.Create);
            outStream.Write(TibiaHeader);
            SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outStream);
            long fileSize;

            if (eos || stdInMode)
            {
                fileSize = -1;
            }
            else
            {
                fileSize = inFile.Length;
            }
            for (int i = 0; i < 8; i++)
            {
                outStream.WriteByte((Byte)(fileSize >> (8 * i)));
            }

            encoder.Code(inFile, outStream, -1, -1, null);

            MemoryStream   tmp  = new MemoryStream();
            int            size = (int)outStream.Length - 32;
            MyBinaryWriter bw   = new MyBinaryWriter(tmp);

            bw.Write(new byte[] { 0x70, 0x0A, 0xFA, 0x80, 0x24 });
            bw.Write7BitEncodedInt(size);

            if (tmp.Length == 8)
            {
                outStream.Position = 0x18;
            }
            else
            {
                outStream.Position = 0x19;
            }

            outStream.Write(tmp.ToArray(), 0, (int)tmp.Length);

            outStream.Position = 0;
            outStream.Close();
        }
		internal static void WriteLzmaProperties(Encoder encoder){
			#region LZMA properties definition

			CoderPropID[] propIDs ={
				CoderPropID.DictionarySize,
				CoderPropID.PosStateBits,
				CoderPropID.LitContextBits,
				CoderPropID.LitPosBits,
				CoderPropID.Algorithm,
				CoderPropID.NumFastBytes,
				CoderPropID.MatchFinder,
				CoderPropID.EndMarker
			};
			object[] properties ={
				_lzmaDictionarySize,
				2,
				3,
				0,
				2,
				256,
				"bt4",
				false
			};

			#endregion

			encoder.SetCoderProperties(propIDs, properties);
		}
示例#25
0
		static public int LzmaBenchmark(Int32 numIterations, UInt32 dictionarySize)
		{
			if (numIterations <= 0)
				return 0;
			if (dictionarySize < (1 << 18))
			{
				System.Console.WriteLine("\nError: dictionary size for benchmark must be >= 19 (512 KB)");
				return 1;
			}
			System.Console.Write("\n       Compressing                Decompressing\n\n");

			Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
			Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();


			CoderPropID[] propIDs = 
			{ 
				CoderPropID.DictionarySize,
			};
			object[] properties = 
			{
				(Int32)(dictionarySize),
			};

			UInt32 kBufferSize = dictionarySize + kAdditionalSize;
			UInt32 kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;

			encoder.SetCoderProperties(propIDs, properties);
			System.IO.MemoryStream propStream = new System.IO.MemoryStream();
			encoder.WriteCoderProperties(propStream);
			byte[] propArray = propStream.ToArray();

			CBenchRandomGenerator rg = new CBenchRandomGenerator();

			rg.Set(kBufferSize);
			rg.Generate();
			CRC crc = new CRC();
			crc.Init();
			crc.Update(rg.Buffer, 0, rg.BufferSize);

			CProgressInfo progressInfo = new CProgressInfo();
			progressInfo.ApprovedStart = dictionarySize;

			UInt64 totalBenchSize = 0;
			UInt64 totalEncodeTime = 0;
			UInt64 totalDecodeTime = 0;
			UInt64 totalCompressedSize = 0;

			MemoryStream inStream = new MemoryStream(rg.Buffer, 0, (int)rg.BufferSize);
			MemoryStream compressedStream = new MemoryStream((int)kCompressedBufferSize);
			CrcOutStream crcOutStream = new CrcOutStream();
			for (Int32 i = 0; i < numIterations; i++)
			{
				progressInfo.Init();
				inStream.Seek(0, SeekOrigin.Begin);
				compressedStream.Seek(0, SeekOrigin.Begin);
				encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
				TimeSpan sp2 = DateTime.UtcNow - progressInfo.Time;
				UInt64 encodeTime = (UInt64)sp2.Ticks;

				long compressedSize = compressedStream.Position;
				if (progressInfo.InSize == 0)
					throw (new Exception("Internal ERROR 1282"));

				UInt64 decodeTime = 0;
				for (int j = 0; j < 2; j++)
				{
					compressedStream.Seek(0, SeekOrigin.Begin);
					crcOutStream.Init();

					decoder.SetDecoderProperties(propArray);
					UInt64 outSize = kBufferSize;
					System.DateTime startTime = DateTime.UtcNow;
					decoder.Code(compressedStream, crcOutStream, 0, (Int64)outSize, null);
					TimeSpan sp = (DateTime.UtcNow - startTime);
					decodeTime = (ulong)sp.Ticks;
					if (crcOutStream.GetDigest() != crc.GetDigest())
						throw (new Exception("CRC Error"));
				}
				UInt64 benchSize = kBufferSize - (UInt64)progressInfo.InSize;
				PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
				System.Console.Write("     ");
				PrintResults(dictionarySize, decodeTime, kBufferSize, true, (ulong)compressedSize);
				System.Console.WriteLine();

				totalBenchSize += benchSize;
				totalEncodeTime += encodeTime;
				totalDecodeTime += decodeTime;
				totalCompressedSize += (ulong)compressedSize;
			}
			System.Console.WriteLine("---------------------------------------------------");
			PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
			System.Console.Write("     ");
			PrintResults(dictionarySize, totalDecodeTime,
					kBufferSize * (UInt64)numIterations, true, totalCompressedSize);
			System.Console.WriteLine("    Average");
			return 0;
		}
示例#26
0
        private void CreateManifest_(List<FileInfo> results, string[] args)
        {
            string dataDir = args[0];
            string patcherExe = args[1];
            string destPath = args[2];
            string outputFilename = args[3];
            string projectPath = args[4];
            SetStatus("Getting patcher version", 0);
            ProcessOutput patcher = null;
            try
            {
                patcher = ProcessOutput.Run(patcherExe, "-version", "", null, false, false);
            }
            catch (System.Exception) { }
            string patcherVersion = "[Fix me by hand]";
            if (patcher != null)
            {
                patcher.Wait();
                patcherVersion = patcher.stdout.Aggregate((i, j) => i + "\n" + j);
            }

            CoderPropID[] propIDs =
            {
                CoderPropID.DictionarySize,
                CoderPropID.PosStateBits,
                CoderPropID.LitContextBits,
                CoderPropID.LitPosBits,
                CoderPropID.NumFastBytes,
                CoderPropID.MatchFinder,
                CoderPropID.EndMarker,
            };
            object[] properties =
            {
                (Int32)(1<<26),
                (Int32)(2),
                (Int32)(3),
                (Int32)(2),
                (Int32)(128),
                "bt4",
                false,
            };

            SetStatus("Starting XML file...", 0);

            XmlDocument doc = new XmlDocument();
            XmlElement rootNode = doc.CreateElement("dayzrp");
            XmlElement serversNode = doc.CreateElement("servers");
            XmlElement patchNode = doc.CreateElement("patch");
            XmlAttribute data = doc.CreateAttribute("data");
            XmlAttribute launcherVersion = doc.CreateAttribute("launcherVersion");
            XmlAttribute launcherUrl = doc.CreateAttribute("launcherUrl");
            XmlAttribute patchMode = doc.CreateAttribute("mode");
            launcherVersion.Value = patcherVersion;
            launcherUrl.Value = Path.GetFileName(patcherExe);
            data.Value = dataDir;
            patchMode.Value = "lzma";
            patchNode.Attributes.Append(data);
            patchNode.Attributes.Append(launcherUrl);
            patchNode.Attributes.Append(launcherVersion);
            patchNode.Attributes.Append(patchMode);

            XmlComment comment = doc.CreateComment("<server name='RP1 : S1' host='81.170.227.227' port='2302'/>");
            serversNode.AppendChild(comment);

            rootNode.AppendChild(serversNode);
            rootNode.AppendChild(patchNode);
            doc.AppendChild(rootNode);

            int progress = 0;
            double progressCount = (double)results.Count * 2;
            foreach (var file in results)
            {
                XmlElement fileNode = doc.CreateElement("file");
                XmlAttribute path = doc.CreateAttribute("path");
                XmlAttribute hash = doc.CreateAttribute("hash");
                XmlAttribute url = doc.CreateAttribute("url");
                string nameValue = GetRelativeName(file, projectPath);
                string hashValue;
                SetStatus("Hashing " + nameValue, progress++ / progressCount);
                using (Stream stream = file.OpenRead())
                {
                    hashValue = StringExtension.ToHexString(m_md5.ComputeHash(stream));
                    stream.Close();
                }
                path.Value = nameValue;
                hash.Value = hashValue;
                url.Value = dataDir + "/" + nameValue + ".lzma";
                fileNode.Attributes.Append(path);
                fileNode.Attributes.Append(hash);
                fileNode.Attributes.Append(url);
                patchNode.AppendChild(fileNode);

                SetStatus("Compressing " + nameValue, progress++ / progressCount);
                using (Stream inStream = file.OpenRead())
                {
                    string outFile = Path.Combine(destPath, nameValue + ".lzma");
                    EnsurePathExists(outFile);
                //	if( (new FileInfo(outFile)).Exists )
                //		continue;
                    Stream outStream = new FileStream(outFile, FileMode.Create, FileAccess.Write);

                    LZMA.Encoder encoder = new LZMA.Encoder();
                    encoder.SetCoderProperties(propIDs, properties);

                    encoder.WriteCoderProperties(outStream);
                    Int64 fileSize;
                    fileSize = inStream.Length;
                    for (int i = 0; i < 8; i++)
                        outStream.WriteByte((Byte)(fileSize >> (8 * i)));

                    encoder.Code(inStream, outStream, -1, -1, null);

                    inStream.Close();
                    outStream.Close();
                }
            }
            SetStatus("Saving XML...", 1);
            doc.Save(outputFilename);
            SetStatus("Done!", 0);

            Dispatcher.BeginInvoke(DispatcherPriority.Send, (Action)delegate()
            {
                builtButton.IsEnabled = true;
            });
        }