public void Close() { if (Map != null) { Map.Dispose(); Map = null; } Address = null; Length = 0; Compression = CompressionType.None; }
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionType compressionType, bool leaveOpen = false) { return Open(stream, archiveType, new CompressionInfo { Type = compressionType }, leaveOpen); }
public static byte[] Decompress(string file, CompressionType cmp) { byte[] ret = new byte[0]; switch (cmp) { case CompressionType.Uncompressed: ret = File.ReadAllBytes(file); break; case CompressionType.Kosinski: ret = Kosinski.Decompress(file); break; case CompressionType.KosinskiM: ret = ModuledKosinski.Decompress(file, LevelData.littleendian ? Endianness.LittleEndian : Endianness.BigEndian); break; case CompressionType.Nemesis: ret = Nemesis.Decompress(file); break; case CompressionType.Enigma: ret = Enigma.Decompress(file, LevelData.littleendian ? Endianness.LittleEndian : Endianness.BigEndian); break; case CompressionType.SZDD: ret = SZDDComp.SZDDComp.Decompress(file); break; default: break; } return ret; }
public static byte[] CompressBytes(CompressionType type, byte[] fileBytes) { MemoryStream ms = new MemoryStream(); Stream compressedStream = null; if (type == CompressionType.deflate) { compressedStream = new DeflateStream(ms, CompressionMode.Compress, true); } else if (type == CompressionType.gzip) { compressedStream = new GZipStream(ms, CompressionMode.Compress, true); } if (type != CompressionType.none) { //write the bytes to the compressed stream compressedStream.Write(fileBytes, 0, fileBytes.Length); compressedStream.Close(); byte[] output = ms.ToArray(); ms.Close(); return output; } //not compressed return fileBytes; }
internal ZipEntry(Stream fileStream, string entryName, CompressionType compressionType) : this(entryName, compressionType) { if (!fileStream.CanRead) throw new IOException("Can not read from file stream"); _fileStream = fileStream; IsDirty = true; }
/// <summary> /// Compressor that takes the <paramref name="text"/> and puts it in the <paramref name="outputStream"/> in a compressed format /// </summary> /// <param name="outputStream">Stream to write the compressed value to</param> /// <param name="text">Text to compress</param> /// <param name="encoding">Encoding to be used when compressing</param> /// <param name="compressionType">Type of compression to be used when compressing</param> public void CompressText(Stream outputStream, string text, Encoding encoding, CompressionType compressionType) { this.logger?.LogDebug($"Compressing the following text with the '{compressionType}' format: {text}"); switch (compressionType) { case CompressionType.Gzip: using (GZipStream gZipStream = new GZipStream(outputStream, CompressionMode.Compress)) { using (StreamWriter streamWriter = new StreamWriter(gZipStream)) { streamWriter.Write(text); streamWriter.Flush(); } } break; case CompressionType.Deflate: using (DeflateStream deflateStream = new DeflateStream(outputStream, CompressionMode.Compress)) { using (StreamWriter streamWriter = new StreamWriter(deflateStream)) { streamWriter.Write(text); streamWriter.Flush(); } } break; default: throw new ArgumentOutOfRangeException(nameof(compressionType), compressionType, null); } this.logger?.LogDebug("Compression successful"); }
public static RawData ImaqFlatten(Image image, FlattenType type, CompressionType compression, int quality) { uint size = 0; IntPtr rv = Interop.imaqFlatten(image.NativeObj, type, compression, quality, ref size); return new RawData(rv, size, true); }
void NetworkUpdateWorld(byte[] data) { World world = (World)FindObjectOfType(typeof(World)); world.loadDefaultWorld(); string size = ""; CompressionType compression; using (MemoryStream stream = new MemoryStream(data)) { using (WorldInputStream reader = new WorldInputStream(stream)) { reader.Read(world); size = stream.Length.GetSizeReadable(); compression = reader.compressionType; } } UnityEngine.Debug.Log("world received (" + size + " | " + compression + ")"); GameObject player = GameObject.FindWithTag("Player"); if (player) player.SendMessage("Respawn"); CircularObjectPool.instance.RecallAllObjectsForType("Debris"); }
protected void ArchiveStreamReadExtractAll(IEnumerable<string> testArchives, CompressionType compression) { foreach (var path in testArchives) { ResetScratch(); using (Stream stream = File.OpenRead(path)) using (var archive = ArchiveFactory.Open(stream)) { Assert.IsTrue(archive.IsSolid); using (var reader = archive.ExtractAllEntries()) { ReaderTests.UseReader(this, reader, compression); } VerifyFiles(); if (archive.Entries.First().CompressionType == CompressionType.Rar) { return; } foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { entry.WriteToDirectory(SCRATCH_FILES_PATH, ExtractOptions.ExtractFullPath | ExtractOptions.Overwrite); } } VerifyFiles(); } }
public static IWriter Open(Stream stream, ArchiveType archiveType, CompressionType compressionType) { return Open(stream, archiveType, new CompressionInfo { Type = compressionType }); }
public static byte[] DecompressBytes(CompressionType type, byte[] compressedBytes) { using (var ms = new MemoryStream()) { Stream decompressedStream = null; if (type == CompressionType.deflate) { decompressedStream = new DeflateStream(ms, CompressionMode.Decompress, true); } else if (type == CompressionType.gzip) { decompressedStream = new GZipStream(ms, CompressionMode.Decompress, true); } if (type != CompressionType.none) { //write the bytes to the compressed stream decompressedStream.Write(compressedBytes, 0, compressedBytes.Length); decompressedStream.Close(); byte[] output = ms.ToArray(); ms.Close(); return output; } //not compressed return compressedBytes; } }
public static async Task<Stream> CompressAsync(CompressionType type, Stream original) { using (var ms = new MemoryStream()) { Stream compressedStream = null; if (type == CompressionType.deflate) { compressedStream = new DeflateStream(ms, CompressionMode.Compress); } else if (type == CompressionType.gzip) { compressedStream = new GZipStream(ms, CompressionMode.Compress); } if (type != CompressionType.none) { using (compressedStream) { await original.CopyToAsync(compressedStream); } //NOTE: If we just try to return the ms instance, it will simply not work // a new stream needs to be returned that contains the compressed bytes. // I've tried every combo and this appears to be the only thing that works. byte[] output = ms.ToArray(); return new MemoryStream(ms.ToArray()); } //not compressed return original; } }
/// <summary> /// Constructor /// </summary> /// <param name="StreamUsing">The stream for the page</param> /// <param name="Compression">The compression we're using (gzip or deflate)</param> /// <param name="Type">Minification type to use (defaults to HTML)</param> public UglyStream(Stream StreamUsing, CompressionType Compression, MinificationType Type = MinificationType.HTML) : base() { this.Compression = Compression; this.StreamUsing = StreamUsing; this.Type = Type; }
public virtual Stream GetDataInputStream(CompressionType compression) { try { switch (compression) { case CompressionType.None: using (FileStream fstr = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { long length = fstr.Seek(0, SeekOrigin.End); fstr.Seek(0, SeekOrigin.Begin); byte[] data = new byte[length]; fstr.Read(data, 0, data.Length); return new MemoryStream(data); } case CompressionType.GZip: Stream stream1 = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); return new GZipStream(stream1, CompressionMode.Decompress); case CompressionType.Zlib: Stream stream2 = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); return new ZlibStream(stream2, CompressionMode.Decompress); case CompressionType.Deflate: Stream stream3 = new FileStream(_filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); return new DeflateStream(stream3, CompressionMode.Decompress); default: throw new ArgumentException("Invalid CompressionType specified", "compression"); } } catch (Exception ex) { throw new NbtIOException("Failed to open compressed NBT data stream for input.", ex); } }
public DataSource(FileMap map, CompressionType compression) { Address = map.Address; Length = map.Length; Map = map; Compression = compression; }
// File : Create new, Append to existing, Raz existing // ArchiveType : Rar = 0, Zip = 1, Tar = 2, SevenZip = 3, GZip = 4 // CompressionType : None = 0, GZip = 1, BZip2 = 2, PPMd = 3, Deflate = 4, Rar = 5, LZMA = 6, BCJ = 7, BCJ2 = 8, Unknown = 9, // Zip compression type : BZip2 // GZip compression type : GZip // example from https://github.com/adamhathcock/sharpcompress/wiki/API-Examples // this example dont work to add file to an existing zip public static void Test_Compress(string compressFile, IEnumerable<string> files, string baseDirectory = null, ArchiveType archiveType = ArchiveType.Zip, CompressionType compressionType = CompressionType.BZip2, CompressionLevel compressionLevel = CompressionLevel.Default) { //FileOption if (baseDirectory != null && !baseDirectory.EndsWith("\\")) baseDirectory = baseDirectory + "\\"; CompressionInfo compressionInfo = new CompressionInfo(); compressionInfo.DeflateCompressionLevel = compressionLevel; compressionInfo.Type = compressionType; //Trace.WriteLine("SharpCompressManager : DeflateCompressionLevel {0}", compressionInfo.DeflateCompressionLevel); //Trace.WriteLine("SharpCompressManager : CompressionType {0}", compressionInfo.Type); Trace.WriteLine($"open compressed file \"{compressFile}\""); // File.OpenWrite ==> OpenOrCreate using (FileStream stream = File.OpenWrite(compressFile)) using (IWriter writer = WriterFactory.Open(stream, archiveType, compressionInfo)) //using (IWriter writer = WriterFactory.Open(stream, archiveType, CompressionType.BZip2)) { foreach (string file in files) { string entryPath; if (baseDirectory != null && file.StartsWith(baseDirectory)) entryPath = file.Substring(baseDirectory.Length); else entryPath = zPath.GetFileName(file); Trace.WriteLine($"add file \"{entryPath}\" \"{file}\""); writer.Write(entryPath, file); } } }
public DataSource(VoidPtr addr, int len, CompressionType compression) { Address = addr; Length = len; Map = null; Compression = compression; }
private static byte[] UnCompress(this byte[] bytes, CompressionType type) { if (bytes == null || bytes.Length == 0) return new byte[0]; using (var stream = type == CompressionType.GZip ? (Stream)new GZipStream(new MemoryStream(bytes), CompressionMode.Decompress) : new DeflateStream(new MemoryStream(bytes), CompressionMode.Decompress)) { var buffer = new byte[4096]; using (var memory = new MemoryStream()) { int count; do { count = stream.Read(buffer, 0, buffer.Length); if (count > 0) { memory.Write(buffer, 0, count); } } while (count > 0); bytes = memory.ToArray(); } } return bytes; }
public void RequestImage(ImageType img_type, CompressionType comp_type = CompressionType.LZ4) { byte[] send_params = new byte[2]; switch (comp_type) { case CompressionType.Uncompressed: send_params[0] = COMPR_TYPE_NONE; break; case CompressionType.LZ4: send_params[0] = COMPR_TYPE_LZ4; break; default: break; } switch (img_type) { case ImageType.Depth: send_params[1] = IMG_TYPE_DEPTH; break; case ImageType.Image: send_params[1] = IMG_TYPE_IMAGE; break; case ImageType.IR: send_params[1] = IMG_TYPE_IR; break; default: break; } sock.Send(send_params); buf = sock.Recv(); switch (comp_type) { case CompressionType.Uncompressed: buf.CopyTo(decompressed, 0); break; case CompressionType.LZ4: dcmp.DecompressKnownSize(buf, decompressed, 640 * 480 * (img_type == ImageType.Depth ? depth_bpp : (img_type == ImageType.Image ? image_bpp : ir_bpp))); break; default: break; } bmp_d = bmp.LockBits(new Rectangle(0, 0, 640, 480), ImageLockMode.WriteOnly, (img_type == ImageType.Depth ? PixelFormat.Format16bppRgb555 : (img_type == ImageType.Image ? PixelFormat.Format24bppRgb : PixelFormat.Format8bppIndexed))); // http://msdn.microsoft.com/en-us/library/system.drawing.imaging.bitmapdata.aspx IntPtr ptr = bmp_d.Scan0; // Copy the RGB values back to the bitmap System.Runtime.InteropServices.Marshal.Copy(decompressed, 0, ptr, bmp_d.Width * bmp_d.Height * (img_type == ImageType.Depth ? depth_bpp : (img_type == ImageType.Image ? image_bpp : ir_bpp))); // elvileg mindenképp 640x480x2, fixme // Unlock the bits. bmp.UnlockBits(bmp_d); // elvileg ez a leggyorsabb mód a másolásra, ennél gyorsabban nem lehet... }
private static void SetMaxSize(CompressionType compression, ImporterSettings settings) { switch (compression) { case CompressionType.Dxt: case CompressionType.Dxt1: case CompressionType.Dxt5: case CompressionType.ShelfHeroshot: case CompressionType.ShelfHeroshotBlackWhite: settings.MaxSize = 1024; break; case CompressionType.Dxt_2K: case CompressionType.Dxt1_2K: case CompressionType.Dxt5_2K: case CompressionType.NoesisLifestyleFeatures: case CompressionType.FilterTest: settings.MaxSize = 1024*2; break; case CompressionType.Thumbnail140: case CompressionType.Thumbnail256: settings.MaxSize = 256; break; default: settings.MaxSize = 1024*2; break; } }
internal YuiMinifier(int columnWidth, CompressionType compressionType) { compressor = new CssCompressor { CompressionType = compressionType, LineBreakPosition = columnWidth, }; }
public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, CompressionType compressionType) { using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write)) { writableArchive.SaveTo(stream, new CompressionInfo {Type = compressionType}); } }
public void HandleResource(HttpContextBase httpContext, ResourceType resourceType, CompressionType compressionType, IProcessedResourceContentInfo resourceInfo) { SetContentTypeHeader(resourceType, httpContext); m_HttpResponseCompressor.Compress(httpContext, compressionType); m_HttpResponseCacher.Cache(httpContext, resourceInfo.LastModifyDate); SetResponseCharset(httpContext); httpContext.Response.BinaryWrite(resourceInfo.Content); }
public YuiCssTransformer(CompressionType compressionType = CompressionType.Standard, int lineBreakPosition = -1, bool removeComments = true) { _compressor = new CssCompressor { CompressionType = compressionType, LineBreakPosition = lineBreakPosition, RemoveComments = removeComments }; }
public static unsafe void Compact(CompressionType type, VoidPtr srcAddr, int srcLen, Stream outStream, ResourceNode r) { switch (type) { case CompressionType.LZ77: { LZ77.Compact(srcAddr, srcLen, outStream, r, false); break; } case CompressionType.ExtendedLZ77: { LZ77.Compact(srcAddr, srcLen, outStream, r, true); break; } case CompressionType.RunLength: { RunLength.Compact(srcAddr, srcLen, outStream, r); break; } } }
internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType, string path, long size, DateTime? lastModified, bool closeStream) : base(archive, null, compressionType) { this.stream = stream; this.path = path; this.size = size; this.lastModified = lastModified; this.closeStream = closeStream; }
/// <summary> /// Compresses a byte array using the specified compression, and returns a compressed byte array. /// </summary> /// <param name="input">The input to compress.</param> /// <param name="compressionType">Type of the compression to apply.</param> /// <param name="textEncoding">The encoding to apply to the input string.</param> /// <returns>A byte array representing the compressed input string</returns> public static byte[] CompressToBytes(string input, CompressionType compressionType, Encoding textEncoding) { if (string.IsNullOrEmpty(input)) return new byte[0]; if (textEncoding == null) throw new ArgumentNullException("textEncoding", "textEncoding cannot be null"); byte[] bytes = textEncoding.GetBytes(input); return CompressToBytes(bytes, 0, bytes.Length, compressionType); }
internal ZipEntry(string fileName, string entryName, CompressionType compressionType) : this(entryName, compressionType) { _fileName = fileName; var fi = new FileInfo(fileName); if (!fi.Exists) throw new FileNotFoundException("File not found", fileName); _lastModified = fi.LastWriteTime; IsDirty = true; }
internal TarWritableArchiveEntry(int index, TarArchive archive, Stream stream, CompressionType compressionType, string path, long size, DateTime? lastModified) : base(index, archive, null, compressionType) { this.Stream = stream; this.path = path; this.size = size; this.lastModified = lastModified; }
public ProcessedResourceGroupInfo ProcessResource(ResourceElementGroup resourceElementGroup, CompressionType compressionType) { if (resourceElementGroup == null) throw new ArgumentNullException("resourceElementGroup"); int cacheDuration = resourceElementGroup.CacheDuration > 0 ? resourceElementGroup.CacheDuration : 60; return m_ResourceCacher.GetOrAddCachedResource(resourceElementGroup.ResourceType, resourceElementGroup.Name, compressionType, () => ProcessResource(compressionType, resourceElementGroup, resourceElementGroup.ResourceType), TimeSpan.FromMinutes(cacheDuration)); }
public AsyncClient(ISocketService SocketService, CompressionType eCompression) : base(SocketService, eCompression, 4096, 0, 0) { }
public SocketServer(ISocketService SocketService, CompressionType eCompression, int iSocketBuffer, int iIdleCheckInterval, int iIdleTimeOut) : base(SocketService, eCompression, iSocketBuffer, iIdleCheckInterval, iIdleTimeOut) { }
void IHttpHandler.ProcessRequest(HttpContext context) { HttpResponse response = context.Response; string fileset = context.Server.UrlDecode(context.Request["s"]); ClientDependencyType type; try { type = (ClientDependencyType)Enum.Parse(typeof(ClientDependencyType), context.Request["t"], true); } catch { throw new ArgumentException("Could not parse the type set in the request"); } if (string.IsNullOrEmpty(fileset)) { throw new ArgumentException("Must specify a fileset in the request"); } string compositeFileName = ""; byte[] outputBytes = null; //get the map to the composite file for this file set, if it exists. CompositeFileMap map = CompositeFileXmlMapper.Instance.GetCompositeFile(fileset); if (map != null && map.HasFileBytes) { ProcessFromFile(context, map, out compositeFileName, out outputBytes); } else { bool fromFile = false; lock (m_Lock) { //check again... if (map == null || !map.HasFileBytes) { //need to do the combining, etc... and save the file map //get the file list string[] strFiles = DecodeFrom64(fileset).Split(';'); //combine files and get the definition types of them (internal vs external resources) List <CompositeFileDefinition> fDefs; byte[] fileBytes = CompositeFileProcessor.CombineFiles(strFiles, context, type, out fDefs); //compress data CompressionType cType = GetCompression(context); outputBytes = CompositeFileProcessor.CompressBytes(cType, fileBytes); SetContentEncodingHeaders(context, cType); //save combined file compositeFileName = CompositeFileProcessor.SaveCompositeFile(outputBytes, type); if (!string.IsNullOrEmpty(compositeFileName)) { //Update the XML file map CompositeFileXmlMapper.Instance.CreateMap(fileset, cType.ToString(), fDefs .Where(f => f.IsLocalFile) .Select(x => new FileInfo(context.Server.MapPath(x.Uri))).ToList(), compositeFileName); } } else { //files are there now, process from file. fromFile = true; } } if (fromFile) { ProcessFromFile(context, map, out compositeFileName, out outputBytes); } } SetCaching(context, compositeFileName); context.Response.ContentType = type == ClientDependencyType.Javascript ? "text/javascript" : "text/css"; context.Response.OutputStream.Write(outputBytes, 0, outputBytes.Length); }
public void WriteLayout(LayoutData layout, CompressionType compression, string fgfilename, string bgfilename) { WriteFG(layout, compression, fgfilename); WriteBG(layout, compression, bgfilename); }
/// <summary> /// Serializes the specified object into a stream using the <see cref="XmlFormat"/> /// obtained from the <see cref="ConfigurationService"/>. /// </summary> /// <param name="obj">The object.</param> /// <param name="stream">The stream.</param> /// <param name="compressionType">Type of compression, default is GZip.</param> public static void Serialize(object obj, Stream stream, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) { Serialize(obj, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()), compressionType, cancellationToken); }
/// <summary> /// Deserializes an object from the specified stream. /// </summary> /// <typeparam name="T">object type expected from the serialized stream</typeparam> /// <param name="stream">The stream.</param> /// <param name="compressionType">Type of compression, default is GZip.</param> /// <returns>A fresh object instance.</returns> public static T Deserialize <T>(Stream stream, CompressionType compressionType = CompressionType.GZip) { return((T)Deserialize(stream, compressionType)); }
public CompressionConfiguration(CompressionType type, CompressionLevel level) { _type = type; _level = level; }
public static CompatibilityAssetBundleManifest BuildAssetBundles(string outputPath, bool forceRebuild, CompressionType compressionMode, BuildTarget buildTarget) { var options = BuildAssetBundleOptions.None; switch (compressionMode) { case CompressionType.None: options |= BuildAssetBundleOptions.UncompressedAssetBundle; break; case CompressionType.Lz4: options |= BuildAssetBundleOptions.ChunkBasedCompression; break; } if (forceRebuild) { options |= BuildAssetBundleOptions.ForceRebuildAssetBundle; } Directory.CreateDirectory(outputPath); return(CompatibilityBuildPipeline.BuildAssetBundles(outputPath, options, buildTarget)); }
public SocketServer(ISocketService SocketService, CompressionType eCompression, int iSocketBuffer) : base(SocketService, eCompression, iSocketBuffer, 0, 0) { }
/// <summary> /// Sets the compression to use for the transport. /// </summary> /// <param name="compression"> the compression to set </param> /// <returns>this Builder <see>ProtocolOptions.Compression</see></returns> public new DseClusterBuilder WithCompression(CompressionType compression) { base.WithCompression(compression); return(this); }
public void ReadLayout(string fgfilename, string bgfilename, CompressionType fgcompression, CompressionType bgcompression, LayoutData layout) { ReadFG(fgfilename, fgcompression, layout); ReadBG(bgfilename, bgcompression, layout); }
public ContentInfo(string description, long contentType, string extension, string mimeType, CompressionType compression, Magic[] magics) : this(description, contentType, extension, mimeType, compression) { this.Magics = magics; }
/// <summary> /// Compresses the bytes if the browser supports it /// </summary> public override byte[] CompressBytes(CompressionType type, byte[] fileBytes) { return(SimpleCompressor.CompressBytes(type, fileBytes)); }
public IProducerBuilder <TMessage> CompressionType(CompressionType compressionType) { _compressionType = compressionType; return(this); }
public SocketServer(ISocketService SocketService, CompressionType eCompression) : base(SocketService, eCompression, 4096, 0, 0) { }
public CompressionEventArgs(CompressionType type) { Type = type; }
public AsyncClient(ISocketService SocketService, CompressionType eCompression, int iSocketBuffer) : base(SocketService, eCompression, iSocketBuffer, 0, 0) { }
/// <summary> /// Constructor /// </summary> /// <param name="StreamUsing">The stream for the page</param> /// <param name="Compression">The compression we're using (gzip or deflate)</param> /// <param name="Type">Minification type to use (defaults to HTML)</param> public UglyStream(Stream StreamUsing, CompressionType Compression, MinificationType Type = MinificationType.HTML) { this.Compression = Compression; this.StreamUsing = StreamUsing; this.Type = Type; }
public SmartStream ReadEntry(Node entry) { if (m_isDisposed) { throw new ObjectDisposedException(nameof(BundleFileBlockReader)); } // find block offsets int blockIndex; long blockCompressedOffset = 0; long blockDecompressedOffset = 0; for (blockIndex = 0; blockDecompressedOffset + m_blocksInfo.StorageBlocks[blockIndex].UncompressedSize <= entry.Offset; blockIndex++) { blockCompressedOffset += m_blocksInfo.StorageBlocks[blockIndex].CompressedSize; blockDecompressedOffset += m_blocksInfo.StorageBlocks[blockIndex].UncompressedSize; } long entryOffsetInsideBlock = entry.Offset - blockDecompressedOffset; using (SmartStream entryStream = CreateStream(entry.Size)) { long left = entry.Size; m_stream.Position = m_dataOffset + blockCompressedOffset; // copy data of all blocks used by current entry to new stream while (left > 0) { long blockStreamOffset; Stream blockStream; StorageBlock block = m_blocksInfo.StorageBlocks[blockIndex]; if (m_cachedBlockIndex == blockIndex) { // data of the previous entry is in the same block as this one // so we don't need to unpack it once again. Instead we can use cached stream blockStreamOffset = 0; blockStream = m_cachedBlockStream; m_stream.Position += block.CompressedSize; } else { CompressionType compressType = block.Flags.GetCompression(); if (compressType == CompressionType.None) { blockStreamOffset = m_dataOffset + blockCompressedOffset; blockStream = m_stream; } else { blockStreamOffset = 0; m_cachedBlockIndex = blockIndex; m_cachedBlockStream.Move(CreateStream(block.UncompressedSize)); switch (compressType) { case CompressionType.Lzma: SevenZipHelper.DecompressLZMAStream(m_stream, block.CompressedSize, m_cachedBlockStream, block.UncompressedSize); break; case CompressionType.Lz4: case CompressionType.Lz4HC: using (Lz4DecodeStream lzStream = new Lz4DecodeStream(m_stream, block.CompressedSize)) { lzStream.ReadBuffer(m_cachedBlockStream, block.UncompressedSize); } break; default: throw new NotImplementedException($"Bundle compression '{compressType}' isn't supported"); } blockStream = m_cachedBlockStream; } } // consider next offsets: // 1) block - if it is new stream then offset is 0, otherwise offset of this block in the bundle file // 2) entry - if this is first block for current entry then it is offset of this entry related to this block // otherwise 0 long blockSize = block.UncompressedSize - entryOffsetInsideBlock; blockStream.Position = blockStreamOffset + entryOffsetInsideBlock; entryOffsetInsideBlock = 0; long size = Math.Min(blockSize, left); blockStream.CopyStream(entryStream, size); blockIndex++; blockCompressedOffset += block.CompressedSize; left -= size; } if (left < 0) { throw new Exception($"Read more than expected"); } entryStream.Position = 0; return(entryStream.CreateReference()); } }
/// <summary> /// Serializes the specified object into a stream. /// </summary> /// <param name="obj">The object.</param> /// <param name="stream">The stream.</param> /// <param name="config">The configuration.</param> /// <param name="includeAssemblies">if set to <c>true</c> include need assemblies.</param> /// <param name="compressionType">Type of compression, default is GZip.</param> public static void Serialize(object obj, Stream stream, Configuration config, bool includeAssemblies, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) { try { Core.Serializer serializer = new Core.Serializer(obj, config); if (compressionType == CompressionType.Zip) { Serialize(obj, stream, config, includeAssemblies, CompressionLevel.Optimal, cancellationToken); } else { Serialize(stream, serializer, cancellationToken); } } catch (PersistenceException) { throw; } catch (Exception e) { throw new PersistenceException("Unexpected exception during Serialization.", e); } }
protected void ArchiveStreamReadExtractAll(string testArchive, CompressionType compression) { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); ArchiveStreamReadExtractAll(testArchive.AsEnumerable(), compression); }
protected void ArchiveStreamReadExtractAll(IEnumerable <string> testArchives, CompressionType compression) { foreach (var path in testArchives) { ResetScratch(); using (Stream stream = File.OpenRead(path)) using (var archive = ArchiveFactory.Open(stream)) { Assert.True(archive.IsSolid); using (var reader = archive.ExtractAllEntries()) { ReaderTests.UseReader(this, reader, compression); } VerifyFiles(); if (archive.Entries.First().CompressionType == CompressionType.Rar) { return; } foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) { entry.WriteToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions() { ExtractFullPath = true, Overwrite = true }); } } VerifyFiles(); } }
public void ExtractTakesIntoAccountEncoding(Type extractorType, string extension, ArchiveType archiveType, CompressionType compressionType) { const string characterSetToTest = "âçÿú¢ŤṵﻝﺕﻻⱩῠᾌ"; var memoryStream = new MemoryStream(); memoryStream.WriteByte(1); using (var tempFolder = TemporaryDirectory.Create()) { var fileName = Path.Combine(tempFolder.DirectoryPath, $"package.{extension}"); using (Stream stream = File.OpenWrite(fileName)) using (var writer = WriterFactory.Open(stream, archiveType, new WriterOptions(compressionType) { ArchiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 } })) { foreach (var c in characterSetToTest) { memoryStream.Position = 0; writer.Write($"{c}", memoryStream); } } var extractor = (IPackageExtractor)Activator.CreateInstance(extractorType, ConsoleLog.Instance); var targetDir = GetTargetDir(extractorType, fileName); extractor.Extract(fileName, targetDir); foreach (var c in characterSetToTest) { File.Exists(Path.Combine(targetDir, c.ToString())).Should().BeTrue(); } } }
public void AddStream(Stream stream, string fileNameInZip, CompressionType compressionType) { this.AddStream(stream, fileNameInZip, ZipCompression.Default, DateTime.Now, compressionType); }
/// <summary> /// Serializes the specified object into a stream. /// </summary> /// <param name="obj">The object.</param> /// <param name="stream">The stream.</param> /// <param name="config">The configuration.</param> /// <param name="compressionType">Type of compression, default is GZip.</param> public static void Serialize(object obj, Stream stream, Configuration config, CompressionType compressionType = CompressionType.GZip, CancellationToken cancellationToken = default(CancellationToken)) { Serialize(obj, stream, config, false, compressionType, cancellationToken); }
public void Add(string fileName, string fileNameInZip, CompressionType compressionType) { this.Add(fileName, fileNameInZip, DateTime.Now, compressionType); }
public void Add(string fileName, CompressionType compressionType) { string fileName1 = ZipPackage.GetFileName(fileName); this.Add(fileName, fileName1, compressionType); }
/// <summary> /// Get Zip Stream by type. /// </summary> /// <param name="memoryStream">Instance of MemoryStream.</param> /// <param name="compressionMode">Compression mode.</param> /// <param name="compressionType">Compression type.</param> /// <returns>Instance of Stream.</returns> private static Stream GetZipStream(MemoryStream memoryStream, CompressionMode compressionMode, CompressionType compressionType) { if (compressionType == CompressionType.GZip) { return(new GZipStream(memoryStream, compressionMode)); } else { return(new DeflateStream(memoryStream, compressionMode)); } }
public abstract byte[] CompressBytes(CompressionType type, byte[] fileBytes);
public void TryReadLayout(string fgfilename, string bgfilename, CompressionType compression, LayoutData layout) { TryReadFG(fgfilename, compression, layout); TryReadBG(bgfilename, compression, layout); }