/// <summary> /// Decompresses the compressed data stored in one or more IDAT chunks. /// </summary> private byte[] Decompress() { Inflater inf = new Inflater(); MemoryStream decompressed = new MemoryStream(); MemoryStream compressed = new MemoryStream(); byte[] buf = new byte[1]; // decompress the image data foreach (Chunk c in _image.Chunks) { if (c.Type == "IDAT") { IDATChunk idat = c as IDATChunk; compressed.Write(idat.Data, 0, idat.Data.Length); if (compressed.Length > 15) { inf.SetInput(compressed.ToArray()); while (!inf.IsNeedingInput) { if (inf.Inflate(buf) == -1) { break; } decompressed.WriteByte(buf[0]); } compressed = new MemoryStream(); } } } inf.SetInput(compressed.ToArray()); while (!inf.IsNeedingInput) { if (inf.Inflate(buf) == -1) { break; } decompressed.WriteByte(buf[0]); } if (!inf.IsFinished) { throw new InvalidCompressedDataException("Inflater is not finished but there are no more IDAT chunks."); } byte[] arr = decompressed.ToArray(); decompressed.Close(); return(arr); }
/// <summary> /// Decode a zRIF encoded string to a RIF byte array. /// </summary> /// <param name="zrif">The zRIF string</param> /// <returns>The RIF byte array, or null on error</returns> public static byte[] Decode(string zrif) { byte[] input, output = new byte[1024]; try { // Pad string if not a multiple of 4 if (zrif.Length % 4 != 0) { zrif += new string('=', 4 - (zrif.Length % 4)); } input = Convert.FromBase64String(zrif); } catch (Exception e) when(e is System.FormatException || e is System.NullReferenceException) { Console.Error.WriteLine($"[ERROR] {e.Message}"); return(null); } if (input.Length < 6) { Console.Error.WriteLine("[ERROR] zRIF length too short"); return(null); } if (((input[0] << 8) + input[1]) % 31 != 0) { Console.Error.WriteLine("[ERROR] zRIF header is corrupted"); return(null); } var inflater = new Inflater(); inflater.SetInput(input); inflater.Inflate(output); if (inflater.IsNeedingDictionary) { inflater.SetDictionary(zrif_dict); } switch (inflater.Inflate(output)) { case 1024: return(output); case 512: return(MemCpy(output, 0, 512)); default: return(null); } }
private void ReadBlock() { this.currentBlock = this.reader.ReadBlock(); if (this.currentBlock.IsEmpty) { this.readBuffer = new MemoryStream(); return; } if (this.currentBlock.Compressed) { byte[] buffer = new byte[this.currentBlock.UncompressedLength]; var inflater = new Inflater(); inflater.SetInput(this.currentBlock.Content); inflater.Inflate(buffer); this.readBuffer = new MemoryStream(buffer); } else { this.readBuffer = new MemoryStream(this.currentBlock.Content); } }
public byte[] Send(byte[] payload) { // this doesn't need to be bigger than 1400, but meh, better safe than sorry byte[] result = new byte[1600]; Locked = true; try { _aniDBSocket.SendTo(payload, _remoteIpEndPoint); EndPoint temp = _remoteIpEndPoint; int received = _aniDBSocket.ReceiveFrom(result, ref temp); if (received > 2 && result[0] == 0 && result[1] == 0) { //deflate byte[] buff = new byte[65536]; byte[] input = new byte[received - 2]; Array.Copy(result, 2, input, 0, received - 2); Inflater inf = new Inflater(false); inf.SetInput(input); inf.Inflate(buff); result = buff; received = (int)inf.TotalOut; } Array.Resize(ref result, received); } catch (Exception e) { Logger.Error(e); } Locked = false; return(result); }
private void TreatHeader(FileInArchive archFile) { MemoryStream memoryStream = new MemoryStream(); byte[] buffer = new byte[4096]; if ((int)archFile.descriptor.compressionMethod == 1) { try { Inflater inflater = new Inflater(); inflater.SetInput(archFile.data_start_200); inflater.Inflate(buffer); } catch (Exception ex) { this.Error_FileTableEntry(archFile); } archFile.descriptor.extension = this.GetExtension(buffer); } else { if ((int)archFile.descriptor.compressionMethod != 0) { return; } archFile.descriptor.extension = this.GetExtension(archFile.data_start_200); } }
public static BinaryReader Decompress(BinaryReader br, int size, int outsize) { if (input.Length < size) { input = new byte[size]; } if (output.Length + 16 < outsize) { output = new byte[outsize + 16]; // Add 16 extra bytes to be able to detect uncompression overrun. } br.Read(input, 0, size); inf.Reset(); inf.SetInput(input, 0, size); int decompressedSize = inf.Inflate(output); inf.Reset(); ms.Position = 0; ms.Write(output, 0, outsize); ms.Position = 0; if (decompressedSize != outsize) // Check the size of the uncompressed data against what we expected { throw new Exception(String.Format("Unexpected Decompressed data size! CompressedSize={2:D} DecompressedSize={0:D} Expected Size={1:D}", decompressedSize, outsize, size)); } return(compReader); }
public static int UnCompress(byte[] input, byte[] buffer, ref byte[] result) { var inflater = new Inflater(); inflater.SetInput(input); buffer = buffer ?? new byte[BuffSize]; MemoryStream ms; if (result != null) { ms = new MemoryStream(result); } else { ms = new MemoryStream(input.Length); } var length = 0; while (!inflater.IsFinished) { var count = inflater.Inflate(buffer); ms.Write(buffer, 0, count); length += count; } if (result == null) { result = ms.ToArray(); } ms.Dispose(); return(length); }
private void readChunkUnzip(Inflater inflater, byte[] buffer, int offset, int length) { try { do { int read = inflater.Inflate(buffer, offset, length); if (read <= 0) { if (inflater.Finished()) { throw new EOFException(); } if (inflater.NeedsInput()) { refillInflater(inflater); } else { throw new IOException("Can't inflate " + length + " bytes"); } } else { offset += read; length -= read; } } while (length > 0); } catch (DataFormatException ex) { throw (IOException)(new IOException("inflate error").InitCause(ex)); } }
public static string Decompress(byte[] data) { if (data == null) { return(""); } if (data.Length == 0) { return(""); } Inflater inflater = new Inflater(); inflater.SetInput(data); MemoryStream stream = new MemoryStream(data.Length); try { byte[] buf = new byte[0x400]; while (!inflater.IsFinished) { int count = inflater.Inflate(buf); stream.Write(buf, 0, count); } } finally { stream.Close(); } return(Encoding.Unicode.GetString(stream.ToArray())); }
/// <summary> /// Decompresses data into the byte array /// </summary> /// <param name ="b"> /// The array to read and decompress data into /// </param> /// <param name ="off"> /// The offset indicating where the data should be placed /// </param> /// <param name ="len"> /// The number of bytes to decompress /// </param> /// <returns>The number of bytes read. Zero signals the end of stream</returns> /// <exception cref="SharpZipBaseException"> /// Inflater needs a dictionary /// </exception> public override int Read(byte[] b, int off, int len) { for (;;) { int count; try { count = inf.Inflate(b, off, len); } catch (Exception e) { throw new SharpZipBaseException(e.ToString()); } if (count > 0) { return(count); } if (inf.IsNeedingDictionary) { throw new SharpZipBaseException("Need a dictionary"); } else if (inf.IsFinished) { return(0); } else if (inf.IsNeedingInput) { Fill(); } else { throw new InvalidOperationException("Don't know what to do"); } } }
/// <summary> /// 字符串解压缩 /// </summary> /// <param name="data"></param> /// <returns></returns> public static string Decompress(byte[] data) { if (data == null) { return(""); } if (data.Length == 0) { return(""); } Inflater f = new Inflater(); f.SetInput(data); MemoryStream o = new MemoryStream(data.Length); try { byte[] buf = new byte[1024]; while (!f.IsFinished) { int got = f.Inflate(buf); o.Write(buf, 0, got); } } finally { o.Close(); } return(Encoding.Unicode.GetString(o.ToArray())); }
public override int Read(byte[] buffer, int offset, int count) { if (inf.IsNeedingDictionary) { throw new SharpZipBaseException("Need a dictionary"); } int num = count; while (true) { int num2 = inf.Inflate(buffer, offset, num); offset += num2; num -= num2; if (num == 0 || inf.IsFinished) { break; } if (inf.IsNeedingInput) { Fill(); } else if (num2 == 0) { throw new ZipException("Dont know what to do"); } } return(count - num); }
public static byte[] Decompress(byte[] input, int offset, int len) { byte[] output = new byte[1024]; int outputused = 0; Inflater inflater = new Inflater(); inflater.SetInput(input, offset, len); while (inflater.IsFinished == false) { if (inflater.IsNeedingInput) { throw(new Exception("inflateData: input incomplete!")); } if (outputused == output.Length) { byte[] newOutput = new byte[output.Length * 2]; Array.Copy(output, newOutput, output.Length); output = newOutput; } try { outputused += inflater.Inflate(output, outputused, output.Length - outputused); } catch (FormatException e) { throw(new IOException(e.ToString())); } } inflater.Reset(); byte[] realOutput = new byte[outputused]; Array.Copy(output, realOutput, outputused); return(realOutput); }
public void CopyTo(Stream output, Action <int> onProgress) { if (file.Flags.HasFlag(CABFlags.FileCompressed)) { var inf = new Inflater(true); var buffer = new byte[165535]; do { var bytesToExtract = currentVolume.ReadUInt16(); remainingInArchive -= 2; toExtract -= 2; inf.SetInput(GetBytes(bytesToExtract)); toExtract -= bytesToExtract; while (!inf.IsNeedingInput) { onProgress?.Invoke((int)(100 * output.Position / file.ExpandedSize)); var inflated = inf.Inflate(buffer); output.Write(buffer, 0, inflated); } inf.Reset(); }while (toExtract > 0); } else { do { onProgress?.Invoke((int)(100 * output.Position / file.ExpandedSize)); toExtract -= remainingInArchive; output.Write(GetBytes(remainingInArchive), 0, (int)remainingInArchive); }while (toExtract > 0); } }
private int Decode(byte[] input, int inputLength, byte[] output, out Exception exception) { exception = null; if (_inflater == null) { if (input != null) { // This is a non compressed stream, so simply copy over the bytes to the output Array.Copy(input, output, input.Length); return(input.Length); } return(0); } try { // If the input is null, it means keep processing the current input // (it could have filled the last output and still not be done) // Otherwise, set the new input if (input != null) { _inflater.SetInput(input, 0, inputLength); } return(_inflater.Inflate(output)); } catch (Exception e) { exception = e; Log.To.ChangeTracker.E(Tag, "Failed to read from changes feed, sending to callback...", e); return(-1); } }
public static int[] Inflate(byte[] compressed) { if (compressed == null) { throw new ArgumentNullException(nameof(compressed)); } var inflater = new Inflater(); inflater.SetInput(compressed); using var ms = new MemoryStream(compressed.Length); byte[] buf = new byte[1024]; while (!inflater.IsFinished) { int count = inflater.Inflate(buf); ms.Write(buf, 0, count); } ms.Position = 0; var results = new int[(int)(ms.Length / 4)]; using var br = new BinaryReader(ms); for (int i = 0; i < ms.Length >> 2; i++) { results[i] = br.ReadInt32(); } return(results); }
private void ParseChapterTxtContents() { int destinationIndex = 0; byte[] bytes = new byte[this._TotalContentLen]; byte[] buf = new byte[32768]; foreach (byte[] zippedContent in this._ZippedContentList) { Inflater inflater = new Inflater(); inflater.SetInput(zippedContent); inflater.Inflate(buf); if (destinationIndex < bytes.Length) { Array.Copy((Array)buf, 0, (Array)bytes, destinationIndex, (int)Math.Min(bytes.Length - destinationIndex, inflater.TotalOut)); destinationIndex += (int)inflater.TotalOut; } } for (int index1 = 0; index1 < this._ChaptersOff.Length; ++index1) { int index2 = this._ChaptersOff[index1]; int count = index1 >= this._ChaptersOff.Length - 1 ? bytes.Length - index2 : this._ChaptersOff[index1 + 1] - index2; string str = this._Book.BookEncoding.GetString(bytes, index2, count); this._Book.Chapters[index1].Content = str.Replace("\x2029", "\r\n"); } this._ZippedContentList.Clear(); }
/// <summary> /// Decompresses data into the byte array /// </summary> /// <param name ="b"> /// the array to read and decompress data into /// </param> /// <param name ="off"> /// the offset indicating where the data should be placed /// </param> /// <param name ="len"> /// the number of bytes to decompress /// </param> public override int Read(byte[] b, int off, int len) { for (;;) { int count; try { count = inf.Inflate(b, off, len); } catch (Exception dfe) { throw new Exception(dfe.ToString()); } if (count > 0) { return(count); } if (inf.NeedsDictionary()) { throw new Exception("Need a dictionary"); } else if (inf.Finished()) { return(-1); } else if (inf.NeedsInput()) { Fill(); } else { throw new Exception("Don't know what to do"); } } }
public async ValueTask CopyDataToAsync(Stream output) { var bw = new BinaryWriter(output); WriteHeader(bw); using var fs = _bsa._streamFactory(); using var br = new BinaryReader(fs); foreach (var chunk in _chunks) { var full = new byte[chunk._fullSz]; var isCompressed = chunk._packSz != 0; br.BaseStream.Seek((long)chunk._offset, SeekOrigin.Begin); if (!isCompressed) { await br.BaseStream.ReadAsync(full, 0, full.Length); } else { byte[] compressed = new byte[chunk._packSz]; await br.BaseStream.ReadAsync(compressed, 0, compressed.Length); var inflater = new Inflater(); inflater.SetInput(compressed); inflater.Inflate(full); } await bw.BaseStream.WriteAsync(full, 0, full.Length); } }
/// <summary> /// Reads the data. /// </summary> /// <param name="reader">Reader.</param> /// <param name="bitmapColorTableSize">Size of the bitmap color table.</param> /// <param name="bitmapWidth">Width of the bitmap.</param> /// <param name="bitmapHeight">Height of the bitmap.</param> /// <param name="toRead">To read.</param> public void ReadData(BufferedBinaryReader reader, byte bitmapColorTableSize, ushort bitmapWidth, ushort bitmapHeight, int toRead) { int size = ((bitmapColorTableSize + 1) * 3) + (bitmapWidth * bitmapHeight); byte[] uncompressed = new byte[size]; byte[] compressed = reader.ReadBytes(toRead); Inflater zipInflator = new Inflater(); zipInflator.SetInput(compressed); zipInflator.Inflate(uncompressed, 0, size); int readed = 0; int offset = size; colorTableRGB = new RGB[bitmapColorTableSize + 1]; for (int i = 0; i < bitmapColorTableSize + 1; i++) { byte red = uncompressed[readed]; readed++; byte green = uncompressed[readed]; readed++; byte blue = uncompressed[readed]; readed++; colorTableRGB[i] = new RGB(red, green, blue); offset -= 3; } colorMapPixelData = new byte[offset]; for (int i = 0; i < offset; i++, readed++) { colorMapPixelData[i] = uncompressed[readed]; } }
/// <summary> /// Runs the player logic. /// </summary> public async Task Run(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { var bytesReceived = await Task.Factory.FromAsync( (cb, s) => _socket.BeginReceive(_receiveBuffer, 0, _receiveBuffer.Length, 0, cb, s), _socket.EndReceive, null); if (bytesReceived == 0) { break; } Log.Debug("Received data from '{ClientIp}' ({Len} bytes)", Ip, bytesReceived); var packetSize = (_receiveBuffer[0] << 8) | _receiveBuffer[1]; if (bytesReceived < (packetSize + 2)) { continue; } var inflater = new Inflater(); inflater.SetInput(_receiveBuffer, 2, packetSize); inflater.Inflate(_inflateBuffer, 0, 204800); /* Split the received data into packages, and handle them. */ var messages = Encoding.UTF8.GetString(_inflateBuffer, 0, (int)inflater.TotalOut).Split((char)10); foreach (var message in messages) { if (message != string.Empty) { Handle(message[0] - 32, message[1..]);
/// <summary> /// Performs inflate decompression on the given data. /// </summary> /// <param name="input">the data to decompress</param> /// <param name="output">the decompressed data</param> public static void DecompressZLib(byte[] input, byte[] output) { Inflater item = new Inflater(); item.SetInput(input, 0, input.Length); item.Inflate(output, 0, output.Length); }
/// <summary> /// Decompress the byte array previously returned by /// compress /// </summary> public static byte[] Decompress(sbyte[] value, int offset, int length) { // Create an expandable byte array to hold the decompressed data ByteArrayOutputStream bos = new ByteArrayOutputStream(length); Inflater decompressor = SharpZipLib.CreateInflater(); try { decompressor.SetInput((byte[])(Array)value); // Decompress the data byte[] buf = new byte[1024]; while (!decompressor.IsFinished) { int count = decompressor.Inflate(buf); bos.Write(buf, 0, count); } } finally { } return(bos.ToArray()); }
public void CopyDataTo(Stream output) { var bw = new BinaryWriter(output); WriteHeader(bw); using (var fs = File.OpenRead(_bsa._filename)) using (var br = new BinaryReader(fs)) { foreach (var chunk in _chunks) { var full = new byte[chunk._fullSz]; var isCompressed = chunk._packSz != 0; br.BaseStream.Seek((long)chunk._offset, SeekOrigin.Begin); if (!isCompressed) { br.BaseStream.Read(full, 0, full.Length); } else { byte[] compressed = new byte[chunk._packSz]; br.BaseStream.Read(compressed, 0, compressed.Length); var inflater = new Inflater(); inflater.SetInput(compressed); inflater.Inflate(full); } bw.BaseStream.Write(full, 0, full.Length); } } }
/// <summary>Decompress the byte array previously returned by /// compress /// </summary> public static byte[] Decompress(byte[] value_Renamed) { // Create an expandable byte array to hold the decompressed data System.IO.MemoryStream bos = new System.IO.MemoryStream(value_Renamed.Length); Inflater decompressor = SharpZipLib.CreateInflater(); try { decompressor.SetInput(value_Renamed); // Decompress the data byte[] buf = new byte[1024]; while (!decompressor.IsFinished) { int count = decompressor.Inflate(buf); bos.Write(buf, 0, count); } } finally { } return(bos.ToArray()); }
protected override void inflateVerify(int pos, Inflater inf) { while (!inf.IsFinished) { if (inf.IsNeedingInput) { inf.SetInput(_array, pos, _array.Length - pos); break; } inf.Inflate(VerifyGarbageBuffer, 0, VerifyGarbageBuffer.Length); } while (!inf.IsFinished && !inf.IsNeedingInput) { inf.Inflate(VerifyGarbageBuffer, 0, VerifyGarbageBuffer.Length); } }
public static byte[] Decompress(byte[] input, int offset, int len) { byte[] sourceArray = new byte[0x400]; int num = 0; Inflater inflater = new Inflater(); inflater.SetInput(input, offset, len); while (!inflater.IsFinished) { if (inflater.IsNeedingInput) { throw new Exception("inflateData: input incomplete!"); } if (num == sourceArray.Length) { byte[] buffer2 = new byte[sourceArray.Length * 2]; Array.Copy(sourceArray, buffer2, sourceArray.Length); sourceArray = buffer2; } try { num += inflater.Inflate(sourceArray, num, sourceArray.Length - num); } catch (FormatException exception) { throw new IOException(exception.ToString()); } } inflater.Reset(); byte[] destinationArray = new byte[num]; Array.Copy(sourceArray, destinationArray, num); return(destinationArray); }
/// <summary> /// Reads decompressed data into the provided buffer byte array /// </summary> /// <param name ="buffer"> /// The array to read and decompress data into /// </param> /// <param name ="offset"> /// The offset indicating where the data should be placed /// </param> /// <param name ="count"> /// The number of bytes to decompress /// </param> /// <returns>The number of bytes read. Zero signals the end of stream</returns> /// <exception cref="SharpZipBaseException"> /// Inflater needs a dictionary /// </exception> public override int Read(byte[] buffer, int offset, int count) { if (inf.IsNeedingDictionary) { throw new SharpZipBaseException("Need a dictionary"); } int remainingBytes = count; while (true) { int bytesRead = inf.Inflate(buffer, offset, remainingBytes); offset += bytesRead; remainingBytes -= bytesRead; if (remainingBytes == 0 || inf.IsFinished) { break; } if (inf.IsNeedingInput) { Fill(); } else if (bytesRead == 0) { throw new ZipException("Dont know what to do"); } } return(count - remainingBytes); }
protected void Decompress() { byte[] data = this.Data; if (this.IsCompressed) { int num2; Inflater inflater = new Inflater(); ushort compressedOffset = this.CompressedOffset; inflater.SetInput(data, compressedOffset, data.Length - compressedOffset); List <KeyValuePair <byte[], int> > list = new List <KeyValuePair <byte[], int> >(); int num3 = 0; do { byte[] buffer = new byte[0x28000]; num2 = inflater.Inflate(buffer); list.Add(new KeyValuePair <byte[], int>(buffer, num2)); num3 += num2; }while (num2 != 0); this.Data = new byte[num3 + compressedOffset]; Array.Copy(data, 0, this.Data, 0, compressedOffset); int destinationIndex = compressedOffset; foreach (KeyValuePair <byte[], int> pair in list) { Array.Copy(pair.Key, 0, this.Data, destinationIndex, pair.Value); destinationIndex += pair.Value; } this.IsCompressed = false; Array.Copy(BitConverter.GetBytes(this.Data.Length), 0, this.Data, 0, 4); } }
public void CopyTo(Stream dest) { if ((fileDes.Flags & FileCompressed) != 0) { var inf = new Inflater(true); var buffer = new byte[165535]; do { var bytesToExtract = cabFile.ReadUInt16(); RemainingArchiveStream -= 2u; RemainingFileStream -= 2u; inf.SetInput(GetBytes(bytesToExtract)); RemainingFileStream -= bytesToExtract; while (!inf.IsNeedingInput) { var inflated = inf.Inflate(buffer); dest.Write(buffer, 0, inflated); } inf.Reset(); }while (RemainingFileStream > 0); } else { do { RemainingFileStream -= RemainingArchiveStream; dest.Write(GetBytes(RemainingArchiveStream), 0, (int)RemainingArchiveStream); }while (RemainingFileStream > 0); } }
public static void ReadCompressed(Stream s, List<string> classnames) { long start = s.Position; BinaryReader br = new BinaryReader(s); byte[] mem = new byte[(int)s.Length + 8]; byte[] buf = new byte[3]; s.Read(buf, 0, 3); s.Seek(start+4, SeekOrigin.Begin); int size = br.ReadInt32(); s.Seek(start+8, SeekOrigin.Begin); s.Read(mem, 0, (int)s.Length); s.Close(); br.Close(); try { s = new MemoryStream(mem); if (Encoding.Default.GetString(buf) == "CWS") { Inflater i = new Inflater(); i.SetInput(mem); byte[] mem2 = new byte[size + 8]; i.Inflate(mem2, 8, size); s = new MemoryStream(mem2); mem = new byte[0]; } s.Seek(0x15, SeekOrigin.Begin); br = new BinaryReader(s); while (br.BaseStream.Position < br.BaseStream.Length) { uint taglen = br.ReadUInt16(); uint len = taglen & 0x3f; uint tag = (taglen - len) / 64; if (len == 63) len = br.ReadUInt32(); start = br.BaseStream.Position; if (tag == 82) { FlashABC fabc = new FlashABC(br.BaseStream, len); fabc.FindClasses(classnames); } br.BaseStream.Seek(start + len, SeekOrigin.Begin); } br.Close(); } catch (Exception e) { Debug.Print(e.StackTrace); return; } }
public FlashReadFile(string file) { FileStream fs = new FileStream(file, FileMode.Open); BinaryReader br = new BinaryReader(fs); byte[] mem = new byte[(int)fs.Length + 8]; byte[] buf = new byte[3]; fs.Read(buf, 0, 3); fs.Seek(4, SeekOrigin.Begin); int size = br.ReadInt32(); fs.Seek(8, SeekOrigin.Begin); fs.Read(mem, 0, (int)fs.Length); fs.Close(); br.Close(); s = new MemoryStream(mem); if (Encoding.Default.GetString(buf) == "CWS") { Inflater i = new Inflater(); i.SetInput(mem); byte[] mem2 = new byte[size + 8]; i.Inflate(mem2, 8, size); s = new MemoryStream(mem2); mem = new byte[0]; } s.Seek(0x15, SeekOrigin.Begin); br = new BinaryReader(s); while (br.BaseStream.Position < br.BaseStream.Length) { uint taglen = br.ReadUInt16(); uint len = taglen & 0x3f; uint tag = (taglen - len) / 64; if (len == 63) len = br.ReadUInt32(); long start = br.BaseStream.Position; if (tag == 82) { FlashABC fabc = new FlashABC(br.BaseStream, len); List<string> classnames = new List<string>(); classnames.Add("cPlayerData"); fabc.FindClasses(classnames); } //Debug.Print("{0} {1}", tag, len+2); br.BaseStream.Seek(start + len, SeekOrigin.Begin); } fClass.InitClasses(); br.Close(); }
static int Inflate(Inflater inf, byte [] src, byte [] dest) { int offset, length, remain; inf.Reset (); inf.SetInput (src); offset = 0; while (!inf.IsNeedingInput) { remain = Math.Min (dest.Length - offset, BlockSize); if (remain == 0) break; length = inf.Inflate (dest, offset, remain); offset += length; } return inf.TotalOut; }
public static byte[] Unzip(byte[] buffer) { Assembly callingAssembly = Assembly.GetCallingAssembly(); Assembly executingAssembly = Assembly.GetExecutingAssembly(); if ((callingAssembly != executingAssembly) && !PublicKeysMatch(executingAssembly, callingAssembly)) { return null; } ZipStream stream = new ZipStream(buffer); byte[] buf = new byte[0]; int num = stream.ReadInt(); if (num == 0x4034b50) { short num2 = (short) stream.ReadShort(); int num3 = stream.ReadShort(); int num4 = stream.ReadShort(); if (((num != 0x4034b50) || (num2 != 20)) || ((num3 != 0) || (num4 != 8))) { throw new FormatException("Wrong Header Signature"); } stream.ReadInt(); stream.ReadInt(); stream.ReadInt(); int num5 = stream.ReadInt(); int count = stream.ReadShort(); int num7 = stream.ReadShort(); if (count > 0) { byte[] buffer3 = new byte[count]; stream.Read(buffer3, 0, count); } if (num7 > 0) { byte[] buffer4 = new byte[num7]; stream.Read(buffer4, 0, num7); } byte[] buffer5 = new byte[stream.Length - stream.Position]; stream.Read(buffer5, 0, buffer5.Length); Inflater inflater = new Inflater(buffer5); buf = new byte[num5]; inflater.Inflate(buf, 0, buf.Length); buffer5 = null; } else { int num8 = num >> 0x18; num -= num8 << 0x18; if (num == 0x7d7a7b) { switch (num8) { case 1: { int num12; int num9 = stream.ReadInt(); buf = new byte[num9]; for (int i = 0; i < num9; i += num12) { int num11 = stream.ReadInt(); num12 = stream.ReadInt(); byte[] buffer6 = new byte[num11]; stream.Read(buffer6, 0, buffer6.Length); new Inflater(buffer6).Inflate(buf, i, num12); } break; } case 2: { byte[] buffer7 = new byte[] { 0x94, 0xad, 0xc3, 0x85, 0xa5, 0x2a, 0xbd, 9 }; byte[] buffer8 = new byte[] { 0xbf, 0x45, 3, 0x1a, 0x41, 80, 14, 0xbf }; using (ICryptoTransform transform = GetDesTransform(buffer7, buffer8, true)) { buf = Unzip(transform.TransformFinalBlock(buffer, 4, buffer.Length - 4)); } break; } } if (num8 != 3) { goto Label_026B; } byte[] key = new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; byte[] iv = new byte[] { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }; using (ICryptoTransform transform2 = GetAesTransform(key, iv, true)) { buf = Unzip(transform2.TransformFinalBlock(buffer, 4, buffer.Length - 4)); goto Label_026B; } } throw new FormatException("Unknown Header"); } Label_026B: stream.Close(); stream = null; return buf; }
private void decompress(AnyObjectId id, Inflater inf, int p) { try { while (!inf.IsFinished) p += inf.Inflate(bytes, p, objectSize - p); } catch (IOException dfe) { CorruptObjectException coe; coe = new CorruptObjectException(id, "bad stream", dfe); throw coe; } if (p != objectSize) throw new CorruptObjectException(id, "incorrect Length"); }
public override void Read(hsStream s, hsResMgr mgr) { base.Read(s, mgr); // Cache it. fVersion = mgr.Version; // Cyan stores these values, but we're just going to // save the stream and have fun with it... fBuffer = new byte[s.ReadInt()]; Compression type = (Compression)s.ReadByte(); uint len = s.ReadUInt(); if (type == Compression.kZlib) { short streamType = s.ReadShort(); byte[] buf = s.ReadBytes((int)len - 2); // Create a zlib-compatible inflator // Note: incoming has no zlib header/footer // System.IO.Compression sucks. Inflater zlib = new Inflater(true); zlib.Inflate(buf); Buffer.BlockCopy(BitConverter.GetBytes(streamType), 0, fBuffer, 0, 2); Buffer.BlockCopy(buf, 0, fBuffer, 2, buf.Length); } else fBuffer = s.ReadBytes((int)len); }
void CheckReader() { if (reader == null) { if (!record.IsCompressed) throw new InvalidOperationException(); int compressedSize = checked((int)record.Size); int uncompressedSize = checked((int)compressedReader.ReadUInt32()); byte[] compressedData = new byte[compressedSize]; byte[] uncompressedData = new byte[uncompressedSize]; int compressedRead = compressedReader.Read(compressedData, 0, compressedSize); Inflater inflater = new Inflater(); inflater.SetInput(compressedData); int uncompressedRead = inflater.Inflate(uncompressedData, 0, uncompressedSize); reader = new BinaryReader(new MemoryStream(uncompressedData, false)); endOffset = uncompressedSize; } }
public static string Decompress(String str) { // Initialize decompressor. byte[] compressedBytes = Convert.FromBase64String(str); Inflater decompressor = new Inflater(); decompressor.SetInput(compressedBytes); // Give the decompressor the // data to decompress. byte[] ret = null; using (MemoryStream memStream = new MemoryStream(compressedBytes.Length)) { // Decompress the data byte[] buf = new byte[compressedBytes.Length + 100]; while (!decompressor.IsFinished) { memStream.Write(buf, 0, decompressor.Inflate(buf)); } memStream.Close(); ret = memStream.ToArray(); } return ASCIIEncoding.UTF8.GetString(ret); }
private bool CheckSwf(bool is_comp) { this.format = MediaFormat.SWF; this.reader = new BinaryReader(this.stream); if (is_comp) { int size = -1; this.reader.BaseStream.Position = 4; // Skip head size = Convert.ToInt32(this.reader.ReadUInt32()); // Read swf head byte[] uncompressed = new byte[size]; this.reader.BaseStream.Position = 0; this.reader.Read(uncompressed, 0, 8); // Read compressed data byte[] compressed = this.reader.ReadBytes(size); this.stream.Close(); // Close the old stream // Uncompress Inflater zipInflator = new Inflater(); zipInflator.SetInput(compressed); zipInflator.Inflate(uncompressed, 8, size - 8); // Setup new uncompressed reader this.reader = new BinaryReader(new MemoryStream(uncompressed)); this.reader.BaseStream.Position = 0; } // Skip header signature/version etc etc this.reader.BaseStream.Position = 8; // Read rect uint bits = ReadUBits(5); ReadSBits(bits); // Read xmin this.width = ReadSBits(bits) / 20; // Read xmax ReadSBits(bits); // Read ymin this.height = ReadSBits(bits) / 20; // Read ymax return true; }