Пример #1
0
        internal ZipReturn LocalFileOpenReadStream(Stream zipFs, bool raw, out Stream readStream, out ulong streamSize, out ushort compressionMethod)
        {
            streamSize        = 0;
            compressionMethod = _compressionMethod;

            readStream = null;
            zipFs.Seek((long)_dataLocation, SeekOrigin.Begin);

            switch (_compressionMethod)
            {
            case 0:
                readStream = zipFs;
                streamSize = _compressedSize;     // same as UncompressedSize
                break;

            case 8:
                if (raw)
                {
                    readStream = zipFs;
                    streamSize = _compressedSize;
                }
                else
                {
                    //readStream = new ZlibBaseStream(zipFs, CompressionMode.Decompress, CompressionLevel.Default, ZlibStreamFlavor.DEFLATE, true);
                    readStream = new System.IO.Compression.DeflateStream(zipFs, System.IO.Compression.CompressionMode.Decompress, true);
                    streamSize = UncompressedSize;
                }

                break;

            case 9:
                readStream = new Deflate64Stream(zipFs, System.IO.Compression.CompressionMode.Decompress);
                streamSize = UncompressedSize;
                break;

            //case 10:
            //    readStream = new BlastStream(zipFs);
            //    streamSize = UncompressedSize;
            //    break;

            case 12:
                readStream = new CBZip2InputStream(zipFs, false);
                streamSize = UncompressedSize;
                break;

            case 14:
            {
                zipFs.ReadByte();         // Major version
                zipFs.ReadByte();         // Minor version
                int    headerSize = zipFs.ReadByte() + (zipFs.ReadByte() << 8);
                byte[] header     = new byte[headerSize];
                zipFs.Read(header, 0, headerSize);
                readStream = new LzmaStream(header, zipFs);
                streamSize = UncompressedSize;
                break;
            }

            case 20:
            case 93:
                readStream = new ZstdSharp.DecompressionStream(zipFs);
                streamSize = UncompressedSize;
                break;

            case 98:
            {
                int    headerSize = 2;
                byte[] header     = new byte[headerSize];
                zipFs.Read(header, 0, headerSize);
                readStream = new PpmdStream(new PpmdProperties(header), zipFs, false);
                streamSize = UncompressedSize;
                break;
            }
            }

            return(readStream == null ? ZipReturn.ZipErrorGettingDataStream : ZipReturn.ZipGood);
        }
Пример #2
0
        internal Stream GetStream()
        {
            factory.BaseStream.Seek(factory.BaseOffset + (long)PackedStreams[0].StartPosition, SeekOrigin.Begin);
            Stream stream = null;

            foreach (var type in GetCompressions())
            {
                switch (type.CompressionType)
                {
                case CompressionType.LZMA:
                {
                    if (type.Coder.Method.Length == 3 &&
                        type.Coder.Method[0] == 3 &&
                        type.Coder.Method[1] == 1 &&
                        type.Coder.Method[2] == 1)
                    {
                        stream = new LzmaStream(type.Coder.Properties, factory.BaseStream, (long)PackedStreams[0].PackedSize, (long)UnpackedStreamSizes[0]);
                    }
                    else if (type.Coder.Method.Length == 1 &&
                             type.Coder.Method[0] == 33)
                    {
                        stream = new LzmaStream(type.Coder.Properties, factory.BaseStream, (long)PackedStreams[0].PackedSize, (long)UnpackedStreamSizes[0]);
                    }
                }
                break;

                case CompressionType.PPMd:
                {
                    stream = new PpmdStream(new PpmdProperties(type.Coder.Properties), factory.BaseStream, false);
                }
                break;

                case CompressionType.BZip2:
                {
                    stream = new BZip2Stream(factory.BaseStream, CompressionMode.Decompress, true);
                }
                break;

                case CompressionType.BCJ:
                {
                    stream = new BCJFilter(false, stream);
                }
                break;

                case CompressionType.BCJ2:
                {
                    long pos = factory.BaseStream.Position;

                    byte[] data1 = new byte[PackedStreams[1].PackedSize];
                    factory.BaseStream.Seek(factory.BaseOffset + (long)PackedStreams[1].StartPosition, SeekOrigin.Begin);
                    factory.BaseStream.Read(data1, 0, data1.Length);
                    byte[] data2 = new byte[PackedStreams[2].PackedSize];
                    factory.BaseStream.Seek(factory.BaseOffset + (long)PackedStreams[2].StartPosition, SeekOrigin.Begin);
                    factory.BaseStream.Read(data2, 0, data2.Length);
                    byte[] control = new byte[PackedStreams[3].PackedSize];
                    factory.BaseStream.Seek(factory.BaseOffset + (long)PackedStreams[3].StartPosition, SeekOrigin.Begin);
                    factory.BaseStream.Read(control, 0, control.Length);

                    factory.BaseStream.Seek(pos, SeekOrigin.Begin);
                    stream = new BCJ2Filter(control, data1, data2, stream);
                }
                break;

                default:
                {
                    throw new NotSupportedException("Unknown coder.");
                }
                }
            }
            return(stream);
        }