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);
}
