/// <summary> /// Writes a compressed string. /// </summary> public void WriteCompressedString(string value) { if (value != null) { int length = value.Length; if (length > 100) { this.WriteByte(1); byte[] compressed = ZlibStream.CompressString(value); this.WriteInt(compressed.Length + 4); this.WriteIntEndian(length); this.Write(compressed); } else { this.WriteByte(0); this.WriteString(value); } } else { this.WriteByte(0); this.WriteInt(0); } }
public static void AddCompressed(this List <byte> _Packet, string _Value, bool addbool = true) { if (addbool) { _Packet.AddBool(Constants.PacketCompression); } if (Constants.PacketCompression) { if (_Value == null) { _Packet.AddInt(-1); } else { byte[] Compressed = ZlibStream.CompressString(_Value); _Packet.AddInt(Compressed.Length + 4); _Packet.AddIntEndian(_Value.Length); _Packet.AddRange(Compressed); } } else { _Packet.AddString(_Value); } }
/// <summary> /// Writes the <see cref="AvatarProfileResponseMessage"/> to the specified <see cref="MessageWriter"/>. /// </summary> /// <param name="writer"> /// <see cref="MessageWriter"/> that will be used to write the <see cref="AvatarProfileResponseMessage"/>. /// </param> public override void WriteMessage(MessageWriter writer) { if (AvatarData == null) { throw new InvalidOperationException("AvatarData cannot be null."); } AvatarData.WriteMessageComponent(writer); var mem = new MemoryStream(); using (var bw = new BinaryWriter(mem)) { var villageJson = VillageJson; var compressedVillage = ZlibStream.CompressString(villageJson); bw.Write(villageJson.Length); bw.Write(compressedVillage); writer.Write(mem.ToArray(), true); } writer.Write(TroopsDonated); writer.Write(TroopsReceived); writer.Write((int)WarCoolDown.TotalSeconds); writer.Write(Unknown2); writer.Write(Unknown3); }
private static string JsonToBpString(string json) { var zlibBpString = ZlibStream.CompressString(json); var base64BpString = Convert.ToBase64String(zlibBpString); return(base64BpString); }
public static void AddCompressableString(this List <byte> _Writer, string String) { if (String != null) { int length = String.Length; if (length > 100) { _Writer.Add(1); byte[] Compressed = ZlibStream.CompressString(String); _Writer.AddInt(Compressed.Length + 4); _Writer.AddIntEndian(length); _Writer.AddRange(Compressed); } else { _Writer.Add(0); _Writer.AddString(String); } } else { _Writer.Add(0); _Writer.AddInt(0); } }
public override void Encode() { List <byte> data = new List <byte>(); string text = File.ReadAllText("replay-json.txt"); data.AddRange(ZlibStream.CompressString(text)); Encrypt(data.ToArray()); }
/// <summary> /// Adds the compressed data. /// </summary> /// <param name="_Packet">The packet.</param> /// <param name="_Value">The value.</param> public static void AddCompressed(this List <byte> _Packet, string _Value) { byte[] Compressed = ZlibStream.CompressString(_Value); _Packet.AddInt(Compressed.Length + 4); _Packet.AddInt(_Value.Length); _Packet.AddRange(Compressed); }
internal static void AddCompressedString(this ByteWriter Writer, string Value) { byte[] Data = ZlibStream.CompressString(Value); Writer.AddInt(Data.Length + 4); Writer.AddIntEndian(Value.Length); Writer.AddRange(Data); }
/// <summary> /// Encodes the <see cref="Message" />, using the <see cref="Writer" /> instance. /// </summary> internal override void Encode() { byte[] Compressed = ZlibStream.CompressString(this.Replay); this.Data.AddInt(Compressed.Length + 4); this.Data.AddIntEndian(this.Replay.Length); this.Data.AddRange(Compressed); }
public static byte[] SerializeAndCompressResults(Logging.ProcessedPost post) { if (post.AnalysisResults == null) { return(null); } string jsonAnalysisResults = JsonConvert.SerializeObject(post.AnalysisResults); return(ZlibStream.CompressString(jsonAnalysisResults)); }
private void Run() { Console.WriteLine("Compressing a string..."); int lengthOriginal = GoPlacidly.Length; // do the compression: byte[] b = ZlibStream.CompressString(GoPlacidly); int lengthCompressed = b.Length; Console.WriteLine(); Console.WriteLine(" Original Length: {0}", lengthOriginal); Console.WriteLine("Compressed Length: {0}", lengthCompressed); Console.WriteLine(" Compression %: {0:n1}%", lengthCompressed / (0.01 * lengthOriginal)); Console.WriteLine("Compressed Data : {0}", ByteArrayToHexString(b)); Console.WriteLine(); // now let's do some timed trials Console.WriteLine("Doing timing runs...."); CompressionTrialResult result; result = DoTrial("Zlib", ZlibStream.CompressString, ZlibStream.UncompressString, GoPlacidly, 10000); result.Show(); result = DoTrial("GZip", GZipStream.CompressString, GZipStream.UncompressString, GoPlacidly, 10000); result.Show(); result = DoTrial("Deflate", DeflateStream.CompressString, DeflateStream.UncompressString, GoPlacidly, 10000); result.Show(); // All these classes use the same underlying algorithm - DEFLATE - // which means they all produce compressed forms that are roughly the // same size. The difference between them is only in the metadata // surrounding the raw compressed streams, and the level of integrity // checking they provide. For example, during compression, the // GzipStream internally calculates an Alder checksum on the data; // during decompression, it verifies that checksum, as an integrity // check. The other classes don't do this. Therefore the GZipStream // will always take slightly longer in compression and decompression // than the others, and will produce compressed streams that are // slightly larger. The results will show that. }
/// <summary> /// Writes the <see cref="VillageMessageComponent"/> to the specified <see cref="MessageWriter"/>. /// </summary> /// <param name="writer"> /// <see cref="MessageWriter"/> that will be used to write the <see cref="VillageMessageComponent"/>. /// </param> /// <exception cref="ArgumentNullException"><paramref name="writer"/> is null.</exception> public override void WriteMessageComponent(MessageWriter writer) { ThrowIfWriterNull(writer); writer.Write(HomeId); writer.Write((int)ShieldDuration.TotalSeconds); writer.Write((int)GuardDuration.TotalSeconds); // 1800 = 8.x.x writer.Write(Unknown1); // 69119 = 8.x.x seems to change, might be a TimeSpan. if (VillageJson != null) { writer.Write(true); // Uses BinaryWriter for little-endian writing. var mem = new MemoryStream(); using (var bw = new BinaryWriter(mem)) { var homeJson = VillageJson; var compressedHomeJson = ZlibStream.CompressString(homeJson); bw.Write(homeJson.Length); bw.Write(compressedHomeJson); writer.Write(mem.ToArray(), true); } } else { writer.Write(false); } if (EventJson != null) { writer.Write(true); // Uses BinaryWriter for little-endian writing. var mem = new MemoryStream(); using (var bw = new BinaryWriter(mem)) { var eventJson = EventJson; var compressedEventJson = ZlibStream.CompressString(eventJson); bw.Write(eventJson.Length); bw.Write(compressedEventJson); writer.Write(mem.ToArray(), true); } } else { writer.Write(false); } }
/// <summary> /// Adds the compressed data. /// </summary> /// <param name="_Packet">The packet.</param> /// <param name="_Value">The value.</param> public static void AddCompressed(this List <byte> _Packet, string _Value, bool addbool = true) { if (addbool) { _Packet.AddBool(true); } byte[] Compressed = ZlibStream.CompressString(_Value); _Packet.AddInt(Compressed.Length + 4); _Packet.AddRange(BitConverter.GetBytes(_Value.Length)); _Packet.AddRange(Compressed); }
public void Handle(RequestData data) { HttpListenerResponse serverResponse = data.Context.Response; Log.Info($"Authentication requested from client at {data.Context.Request.RemoteEndPoint}"); serverResponse.StatusCode = (int)HttpStatusCode.OK; serverResponse.ContentType = "text/plain"; serverResponse.AddHeader("Content-Encoding", "deflate"); EftClient client = data.Client; byte[] messageBytes = ZlibStream.CompressString(AuthenticationService.Authenticate(ref client, data.Body)); serverResponse.OutputStream.Write(messageBytes, 0, messageBytes.Length); serverResponse.SetCookie(new Cookie("PHPSESSID", client.UniqueSession));; serverResponse.Close(); }
/// <summary> /// /// </summary> /// <param name="writer"></param> public void WriteToPacketWriter(PacketWriter writer) { var json = ToJson(); var decompressedLength = json.Length; var compressedJson = ZlibStream.CompressString(json); using (var binaryWriter = new BinaryWriter(new MemoryStream())) { binaryWriter.Write(decompressedLength); binaryWriter.Write(compressedJson); var homeData = ((MemoryStream)binaryWriter.BaseStream).ToArray(); writer.Write(homeData, 0, homeData.Length); } }
public static void EncodeJson(string json) { if (string.IsNullOrWhiteSpace(json)) { return; } //compress string with zlib inflation, convert inflated string to base-64 string //append it to the constant hash //copy to clipboard Clipboard.SetText($"{Hash}{Convert.ToBase64String(ZlibStream.CompressString(json))}"); //inform user about me fecking his clipboard up :) MessageBox.Show(@"Encoded save copied to your clipboard.", @"Encoded and copied", MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification, false); }
public void Handle(RequestData data) { HttpListenerResponse serverResponse = data.Context.Response; Log.Info($"Locale requested from client at {data.Context.Request.RemoteEndPoint}"); serverResponse.StatusCode = (int)HttpStatusCode.OK; serverResponse.ContentType = "text/plain"; serverResponse.AddHeader("Content-Encoding", "deflate"); if (data.Client != null) { serverResponse.SetCookie(new Cookie("PHPSESSID", data.Client.UniqueSession)); } ; byte[] messageBytes = ZlibStream.CompressString(Serializer.Read("./Templates/Localization/Languages.json")); serverResponse.OutputStream.Write(messageBytes, 0, messageBytes.Length); serverResponse.Close(); }
public void putDataBlob(string cmd, TestData data) { if (connEnable) { try{ string uriStr = "http://" + serverUrl + cmd; Debug.Log("start Upload url=" + uriStr); WebClient client = new WebClient(); client.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); //byte[] byteDocs = Encoding.UTF8.GetBytes(JsonUtility.ToJson(data)); byte[] byteDocs = ZlibStream.CompressString(JsonUtility.ToJson(data)); client.UploadDataCompleted += new UploadDataCompletedEventHandler(UploadBlobResult); client.UploadDataAsync(new System.Uri(uriStr), "POST", byteDocs); Debug.Log("Start Uploading result"); } catch (System.Exception e) { Debug.Log("Connection error: " + e); } } }
public static void AddCompressedString(this List <byte> list, string data) { if (data == null) { list.AddInt32(-1); } else { MemoryStream mem = new MemoryStream(); using (BinaryWriter bw = new BinaryWriter(mem)) { byte[] compressedString = ZlibStream.CompressString(data); bw.Write(data.Length); bw.Write(compressedString); } list.AddInt32(mem.ToArray().Length); list.AddRange(mem.ToArray()); } }
/// <summary> /// Writes the <see cref="LoginFailedMessage"/> to the specified <see cref="MessageWriter"/>. /// </summary> /// <param name="writer"> /// <see cref="MessageWriter"/> that will be used to write the <see cref="LoginFailedMessage"/>. /// </param> /// <exception cref="ArgumentNullException"><paramref name="writer"/> is null.</exception> public override void WriteMessage(MessageWriter writer) { ThrowIfWriterNull(writer); writer.Write((int)Reason); writer.Write(FingerprintJson); writer.Write(Hostname); writer.Write(ContentUrl); writer.Write(MarketUrl); writer.Write(Message); writer.Write((int)MaintenanceDuration.TotalSeconds); writer.Write(Unknown4); if (FingerprintJsonCompressed != null) { // Uses BinaryWriter for little-endian writing. var mem = new MemoryStream(); using (var bw = new BinaryWriter(mem)) { var fingerprintJson = FingerprintJsonCompressed; var compressedFingerprintJson = ZlibStream.CompressString(fingerprintJson); bw.Write(fingerprintJson.Length); bw.Write(compressedFingerprintJson); writer.Write(mem.ToArray(), true); } } else { writer.Write(-1); } writer.Write(Unknown6); writer.Write(Unknown7); writer.Write(Unknown8); writer.Write(Unknown9); }
public static byte[] CompressZlib(this string source) { return(ZlibStream.CompressString(source)); }
public void SetHomeJSON(string json) { m_vSerializedVillage = ZlibStream.CompressString(json); }
// These two data types are supported in DotNetZip, but only if .NET Framework is targeted. //private SelfExtractorFlavor _selfExtractorFlavor; //private SelfExtractorSaveOptions _selfExtractorSaveOptions; public void CallAll() { // These two apis are supported in DotNetZip, but only if .NET Framework is targeted. //_zipFile.SaveSelfExtractor(_string, _selfExtractorFlavor); //_zipFile.SaveSelfExtractor(_string, _selfExtractorSaveOptions); //Project: Ionic.Zip _bZip2InputStream.Close(); _bZip2InputStream.Flush(); _int = _bZip2InputStream.Read(_bytes, _int, _int); _int = _bZip2InputStream.ReadByte(); _long = _bZip2InputStream.Seek(_long, _seekOrigin); _bZip2InputStream.SetLength(_long); _bZip2InputStream.Write(_bytes, _int, _int); _bZip2OutputStream.Close(); _bZip2OutputStream.Flush(); _int = _bZip2OutputStream.Read(_bytes, _int, _int); _long = _bZip2OutputStream.Seek(_long, _seekOrigin); _bZip2OutputStream.SetLength(_long); _bZip2OutputStream.Write(_bytes, _int, _int); _parallelBZip2OutputStream.Close(); _parallelBZip2OutputStream.Flush(); _int = _parallelBZip2OutputStream.Read(_bytes, _int, _int); _long = _parallelBZip2OutputStream.Seek(_long, _seekOrigin); _parallelBZip2OutputStream.SetLength(_long); _parallelBZip2OutputStream.Write(_bytes, _int, _int); _crc32.Combine(_int, _int); _int = _crc32.ComputeCrc32(_int, _byte); _int = _crc32.GetCrc32(_stream); _int = _crc32.GetCrc32AndCopy(_stream, _stream); _crc32.Reset(); _crc32.SlurpBlock(_bytes, _int, _int); _crc32.UpdateCRC(_byte); _crc32.UpdateCRC(_byte, _int); _crcCalculatorStream.Close(); _crcCalculatorStream.Flush(); _int = _crcCalculatorStream.Read(_bytes, _int, _int); _long = _crcCalculatorStream.Seek(_long, _seekOrigin); _crcCalculatorStream.SetLength(_long); _crcCalculatorStream.Write(_bytes, _int, _int); _zipEntriesCollection = _fileSelector.SelectEntries(_zipFile); _zipEntriesCollection = _fileSelector.SelectEntries(_zipFile, _string); _stringsCollection = _fileSelector.SelectFiles(_string); _stringsReadOnly = _fileSelector.SelectFiles(_string, _bool); _string = _fileSelector.ToString(); _bool = _comHelper.CheckZip(_string); _bool = _comHelper.CheckZipPassword(_string, _string); _comHelper.FixZipDirectory(_string); _string = _comHelper.GetZipLibraryVersion(); _bool = _comHelper.IsZipFile(_string); _bool = _comHelper.IsZipFileWithExtract(_string); _countingStream.Adjust(_long); _countingStream.Flush(); _int = _countingStream.Read(_bytes, _int, _int); _long = _countingStream.Seek(_long, _seekOrigin); _countingStream.SetLength(_long); _countingStream.Write(_bytes, _int, _int); _zipEntry.Extract(); _zipEntry.Extract(_extractExistingFileAction); _zipEntry.Extract(_string); _zipEntry.Extract(_string, _extractExistingFileAction); _zipEntry.Extract(_stream); _zipEntry.ExtractWithPassword(_extractExistingFileAction, _string); _zipEntry.ExtractWithPassword(_string); _zipEntry.ExtractWithPassword(_string, _extractExistingFileAction, _string); _zipEntry.ExtractWithPassword(_string, _string); _zipEntry.ExtractWithPassword(_stream, _string); _crcCalculatorStream = _zipEntry.OpenReader(); _crcCalculatorStream = _zipEntry.OpenReader(_string); _zipEntry.SetEntryTimes(_datetime, _datetime, _datetime); _string = _zipEntry.ToString(); _zipEntry = _zipFile.AddDirectory(_string); _zipEntry = _zipFile.AddDirectory(_string, _string); _zipEntry = _zipFile.AddDirectoryByName(_string); _zipEntry = _zipFile.AddEntry(_string, _bytes); _zipEntry = _zipFile.AddEntry(_string, _openDelegate, _closeDelegate); _zipEntry = _zipFile.AddEntry(_string, _writeDelegate); _zipEntry = _zipFile.AddEntry(_string, _string); _zipEntry = _zipFile.AddEntry(_string, _string, _encoding); _zipEntry = _zipFile.AddEntry(_string, _stream); _zipEntry = _zipFile.AddFile(_string); _zipEntry = _zipFile.AddFile(_string, _string); _zipFile.AddFiles(_strings); _zipFile.AddFiles(_strings, _bool, _string); _zipFile.AddFiles(_strings, _string); _zipEntry = _zipFile.AddItem(_string); _zipEntry = _zipFile.AddItem(_string, _string); _zipFile.AddSelectedFiles(_string); _zipFile.AddSelectedFiles(_string, _bool); _zipFile.AddSelectedFiles(_string, _string); _zipFile.AddSelectedFiles(_string, _string, _bool); _zipFile.AddSelectedFiles(_string, _string, _string); _zipFile.AddSelectedFiles(_string, _string, _string, _bool); _bool = _zipFile.ContainsEntry(_string); _zipFile.Dispose(); _zipFile.ExtractAll(_string); _zipFile.ExtractAll(_string, _extractExistingFileAction); _zipFile.ExtractSelectedEntries(_string); _zipFile.ExtractSelectedEntries(_string, _extractExistingFileAction); _zipFile.ExtractSelectedEntries(_string, _string); _zipFile.ExtractSelectedEntries(_string, _string, _string); _zipFile.ExtractSelectedEntries(_string, _string, _string, _extractExistingFileAction); _enumerator = _zipFile.GetNewEnum(); _zipFile.Initialize(_string); _zipFile.RemoveEntries(_zipEntriesCollection); _zipFile.RemoveEntries(_stringsCollection); _zipFile.RemoveEntry(_zipEntry); _zipFile.RemoveEntry(_string); _int = _zipFile.RemoveSelectedEntries(_string); _int = _zipFile.RemoveSelectedEntries(_string, _string); _zipFile.Save(); _zipFile.Save(_string); _zipFile.Save(_stream); _zipEntriesCollection = _zipFile.SelectEntries(_string); _zipEntriesCollection = _zipFile.SelectEntries(_string, _string); _string = _zipFile.ToString(); _zipEntry = _zipFile.UpdateDirectory(_string); _zipEntry = _zipFile.UpdateDirectory(_string, _string); _zipEntry = _zipFile.UpdateEntry(_string, _bytes); _zipEntry = _zipFile.UpdateEntry(_string, _openDelegate, _closeDelegate); _zipEntry = _zipFile.UpdateEntry(_string, _writeDelegate); _zipEntry = _zipFile.UpdateEntry(_string, _string); _zipEntry = _zipFile.UpdateEntry(_string, _string, _encoding); _zipEntry = _zipFile.UpdateEntry(_string, _stream); _zipEntry = _zipFile.UpdateFile(_string); _zipFile.UpdateFile(_string, _string); _zipFile.UpdateFiles(_strings); _zipFile.UpdateFiles(_strings, _string); _zipFile.UpdateItem(_string); _zipFile.UpdateItem(_string, _string); _zipFile.UpdateSelectedFiles(_string, _string, _string, _bool); _zipInputStream.Flush(); _zipEntry = _zipInputStream.GetNextEntry(); _int = _zipInputStream.Read(_bytes, _int, _int); _long = _zipInputStream.Seek(_long, _seekOrigin); _zipInputStream.SetLength(_long); _string = _zipInputStream.ToString(); _zipInputStream.Write(_bytes, _int, _int); _bool = _zipOutputStream.ContainsEntry(_string); _zipOutputStream.Flush(); _zipEntry = _zipOutputStream.PutNextEntry(_string); _int = _zipOutputStream.Read(_bytes, _int, _int); _long = _zipOutputStream.Seek(_long, _seekOrigin); _zipOutputStream.SetLength(_long); _string = _zipOutputStream.ToString(); _zipOutputStream.Write(_bytes, _int, _int); _deflateStream.Flush(); _int = _deflateStream.Read(_bytes, _int, _int); _long = _deflateStream.Seek(_long, _seekOrigin); _deflateStream.SetLength(_long); _deflateStream.Write(_bytes, _int, _int); _gZipStream.Flush(); _int = _gZipStream.Read(_bytes, _int, _int); _long = _gZipStream.Seek(_long, _seekOrigin); _gZipStream.SetLength(_long); _gZipStream.Write(_bytes, _int, _int); _parallelDeflateOutputStream.Close(); _parallelDeflateOutputStream.Flush(); _int = _parallelDeflateOutputStream.Read(_bytes, _int, _int); _parallelDeflateOutputStream.Reset(_stream); _long = _parallelDeflateOutputStream.Seek(_long, _seekOrigin); _parallelDeflateOutputStream.SetLength(_long); _parallelDeflateOutputStream.Write(_bytes, _int, _int); // Static _bool = ZipFile.CheckZip(_string); _bool = ZipFile.CheckZip(_string, _bool, _textWriter); _bool = ZipFile.CheckZipPassword(_string, _string); ZipFile.FixZipDirectory(_string); _bool = ZipFile.IsZipFile(_string); _bool = ZipFile.IsZipFile(_string, _bool); _bool = ZipFile.IsZipFile(_stream, _bool); _zipFile = ZipFile.Read(_string); _zipFile = ZipFile.Read(_string, _readOptions); _zipFile = ZipFile.Read(_stream); _zipFile = ZipFile.Read(_stream, _readOptions); _uint = Adler.Adler32(_uint, _bytes, _int, _int); _bytes = DeflateStream.CompressBuffer(_bytes); _bytes = DeflateStream.CompressString(_string); _bytes = DeflateStream.UncompressBuffer(_bytes); _string = DeflateStream.UncompressString(_bytes); _bytes = GZipStream.CompressBuffer(_bytes); _bytes = GZipStream.CompressString(_string); _bytes = GZipStream.UncompressBuffer(_bytes); _string = GZipStream.UncompressString(_bytes); _bytes = ZlibStream.CompressBuffer(_bytes); _bytes = ZlibStream.CompressString(_string); _bytes = ZlibStream.UncompressBuffer(_bytes); _string = ZlibStream.UncompressString(_bytes); }
/// <summary> /// 圧縮 /// </summary> public byte[] Deflate() { //データ部圧縮 //compress datas List <int> originalContentDataSizeTable = new List <int>(); List <byte[]> compressedContentDataTable = new List <byte[]>(_contentFileInfoTable.Count); int compressedContentDataTableSize = 0; for (int contentIndex = 0; contentIndex < _contentFileInfoTable.Count; contentIndex++) { var fileInfo = _contentFileInfoTable[contentIndex]; var data = System.IO.File.ReadAllBytes(fileInfo.FullName); originalContentDataSizeTable.Add(data.Length); var compressed = ZlibStream.CompressBuffer(data); compressedContentDataTableSize += compressed.Length; compressedContentDataTable.Add(compressed); } //ファイル名部圧縮 //compress name table byte[] compressedContentNameTable = null; int compressedContentNameTableSize = 0; { //全ファイル名結合 System.Text.StringBuilder builder = new System.Text.StringBuilder(); foreach (var s in _contentNameTable) { builder.Append(s); compressedContentNameTableSize += System.Text.Encoding.UTF8.GetByteCount(s); } compressedContentNameTable = ZlibStream.CompressString(builder.ToString()); } //コンテンツ情報部圧縮 //compress contents byte[] compressedContentTable = null; { byte[] headerTable = new byte[SZipContent.Size * _contentFileInfoTable.Count]; using (MemoryStream stream = new MemoryStream(headerTable)) { using (BinaryWriter writer = new BinaryWriter(stream)) { for (int contentIndex = 0; contentIndex < _contentFileInfoTable.Count; contentIndex++) { var content = new SZipContent(); System.UInt32 crc = SZipUtility.FNVHash(compressedContentDataTable[contentIndex]); content.Set(_contentNameTable[contentIndex].Length, originalContentDataSizeTable[contentIndex], compressedContentDataTable[contentIndex].Length, crc); content.Write(writer); } } } compressedContentTable = ZlibStream.CompressBuffer(headerTable); } //ヘッダ生成 //create szip header var header = new SZipHeader(); header.Set((System.Int16)_contentFileInfoTable.Count, SZipUtility.FNVHash(compressedContentNameTable), SZipUtility.FNVHash(compressedContentTable), compressedContentTable.Length, compressedContentNameTableSize, compressedContentNameTable.Length); //書き込み //write to byte[] { int totalSize = SZipHeader.Size + compressedContentTable.Length + compressedContentNameTable.Length + compressedContentDataTableSize; byte[] output = new byte[totalSize]; using (MemoryStream stream = new MemoryStream(output)) { using (BinaryWriter writer = new BinaryWriter(stream)) { //ヘッダ header.Write(writer); //コンテンツ writer.Write(compressedContentTable); //コンテンツ名 writer.Write(compressedContentNameTable); //データ foreach (var data in compressedContentDataTable) { writer.Write(data); } } } return(output); } }
public static byte[] CompressBytes(string input) { byte[] output = ZlibStream.CompressString(input); return(output); }
/// <summary> /// Compress plain text to byte array /// </summary> public static byte[] Compress(string text) { return(ZlibStream.CompressString(text)); }
private static byte[] EncodeAndCompressRpcRequest(RpcRequest request) { string encodedRequest = Rencode.Encode(new object[] { request.RequestId, request.Method, request.Arguments.ToArray(), request.KeyWordArguments }); return(ZlibStream.CompressString(encodedRequest)); }
public static byte[] CompressBytes(string input) { return(ZlibStream.CompressString(input)); }