예제 #1
0
        public JZlibEncoder(int compressionLevel, int windowBits, int memLevel, byte[] dictionary)
        {
            Contract.Requires(compressionLevel >= 0 && compressionLevel <= 9);
            Contract.Requires(windowBits >= 9 && windowBits <= 15);
            Contract.Requires(memLevel >= 1 && memLevel <= 9);

            int resultCode = this.z.DeflateInit(
                compressionLevel, windowBits, memLevel,
                JZlib.W_ZLIB);     // Default: ZLIB format

            if (resultCode != JZlib.Z_OK)
            {
                ZlibUtil.Fail(this.z, "initialization failure", resultCode);
            }
            else
            {
                resultCode = this.z.DeflateSetDictionary(dictionary, dictionary.Length);
                if (resultCode != JZlib.Z_OK)
                {
                    ZlibUtil.Fail(this.z, "failed to set the dictionary", resultCode);
                }
            }

            this.wrapperOverhead = ZlibUtil.WrapperOverhead(ZlibWrapper.Zlib);
        }
예제 #2
0
        public JZlibDecoder(ZlibWrapper wrapper)
        {
            int resultCode = this.z.Init(ZlibUtil.ConvertWrapperType(wrapper));

            if (resultCode != JZlib.Z_OK)
            {
                ZlibUtil.Fail(this.z, "initialization failure", resultCode);
            }
        }
예제 #3
0
        public JZlibDecoder(byte[] dictionary)
        {
            Contract.Requires(dictionary != null);
            this.dictionary = dictionary;

            int resultCode;

            resultCode = this.z.InflateInit(JZlib.W_ZLIB);
            if (resultCode != JZlib.Z_OK)
            {
                ZlibUtil.Fail(this.z, "initialization failure", resultCode);
            }
        }
예제 #4
0
        /**
         * Creates a new zlib encoder with the specified {@code compressionLevel},
         * the specified {@code windowBits}, the specified {@code memLevel}, and
         * the specified wrapper.
         *
         * @param compressionLevel
         *        {@code 1} yields the fastest compression and {@code 9} yields the
         *        best compression.  {@code 0} means no compression.  The default
         *        compression level is {@code 6}.
         * @param windowBits
         *        The base two logarithm of the size of the history buffer.  The
         *        value should be in the range {@code 9} to {@code 15} inclusive.
         *        Larger values result in better compression at the expense of
         *        memory usage.  The default value is {@code 15}.
         * @param memLevel
         *        How much memory should be allocated for the internal compression
         *        state.  {@code 1} uses minimum memory and {@code 9} uses maximum
         *        memory.  Larger values result in better and faster compression
         *        at the expense of memory usage.  The default value is {@code 8}
         *
         * @throws CompressionException if failed to initialize zlib
         */
        public JZlibEncoder(ZlibWrapper wrapper, int compressionLevel, int windowBits, int memLevel)
        {
            Contract.Requires(compressionLevel >= 0 && compressionLevel <= 9);
            Contract.Requires(windowBits >= 9 && windowBits <= 15);
            Contract.Requires(memLevel >= 1 && memLevel <= 9);

            int resultCode = this.z.Init(
                compressionLevel, windowBits, memLevel,
                ZlibUtil.ConvertWrapperType(wrapper));

            if (resultCode != JZlib.Z_OK)
            {
                ZlibUtil.Fail(this.z, "initialization failure", resultCode);
            }

            this.wrapperOverhead = ZlibUtil.WrapperOverhead(wrapper);
        }
예제 #5
0
        protected override void Encode(IChannelHandlerContext context, IByteBuffer message, IByteBuffer output)
        {
            if (this.finished)
            {
                output.WriteBytes(message);
                return;
            }

            int inputLength = message.ReadableBytes;

            if (inputLength == 0)
            {
                return;
            }

            try
            {
                // Configure input.
                bool inHasArray = message.HasArray;
                this.z.avail_in = inputLength;
                if (inHasArray)
                {
                    this.z.next_in       = message.Array;
                    this.z.next_in_index = message.ArrayOffset + message.ReaderIndex;
                }
                else
                {
                    var array = new byte[inputLength];
                    message.GetBytes(message.ReaderIndex, array);
                    this.z.next_in       = array;
                    this.z.next_in_index = 0;
                }
                int oldNextInIndex = this.z.next_in_index;

                // Configure output.
                int maxOutputLength = (int)Math.Ceiling(inputLength * 1.001) + 12 + this.wrapperOverhead;
                output.EnsureWritable(maxOutputLength);
                this.z.avail_out      = maxOutputLength;
                this.z.next_out       = output.Array;
                this.z.next_out_index = output.ArrayOffset + output.WriterIndex;
                int oldNextOutIndex = this.z.next_out_index;

                int resultCode;
                try
                {
                    resultCode = this.z.Deflate(JZlib.Z_SYNC_FLUSH);
                }
                finally
                {
                    message.SkipBytes(this.z.next_in_index - oldNextInIndex);
                }

                if (resultCode != JZlib.Z_OK)
                {
                    ZlibUtil.Fail(this.z, "compression failure", resultCode);
                }

                int outputLength = this.z.next_out_index - oldNextOutIndex;
                if (outputLength > 0)
                {
                    output.SetWriterIndex(output.WriterIndex + outputLength);
                }
            }
            finally
            {
                this.z.next_in  = null;
                this.z.next_out = null;
            }
        }
예제 #6
0
        protected internal override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
        {
            if (this.finished)
            {
                // Skip data received after finished.
                input.SkipBytes(input.ReadableBytes);
                return;
            }

            int inputLength = input.ReadableBytes;

            if (inputLength == 0)
            {
                return;
            }

            try
            {
                // Configure input.
                this.z.avail_in = inputLength;
                if (input.HasArray)
                {
                    this.z.next_in       = input.Array;
                    this.z.next_in_index = input.ArrayOffset + input.ReaderIndex;
                }
                else
                {
                    var array = new byte[inputLength];
                    input.GetBytes(input.ReaderIndex, array);
                    this.z.next_in       = array;
                    this.z.next_in_index = 0;
                }
                int oldNextInIndex = this.z.next_in_index;

                // Configure output.
                int         maxOutputLength = inputLength << 1;
                IByteBuffer decompressed    = context.Allocator.Buffer(maxOutputLength);

                try
                {
                    while (true)
                    {
                        this.z.avail_out = maxOutputLength;
                        decompressed.EnsureWritable(maxOutputLength);
                        this.z.next_out       = decompressed.Array;
                        this.z.next_out_index = decompressed.ArrayOffset + decompressed.WriterIndex;
                        int oldNextOutIndex = this.z.next_out_index;

                        // Decompress 'in' into 'out'
                        int resultCode   = this.z.Inflate(JZlib.Z_SYNC_FLUSH);
                        int outputLength = this.z.next_out_index - oldNextOutIndex;
                        if (outputLength > 0)
                        {
                            decompressed.SetWriterIndex(decompressed.WriterIndex + outputLength);
                        }

                        if (resultCode == JZlib.Z_NEED_DICT)
                        {
                            if (this.dictionary == null)
                            {
                                ZlibUtil.Fail(this.z, "decompression failure", resultCode);
                            }
                            else
                            {
                                resultCode = this.z.InflateSetDictionary(this.dictionary, this.dictionary.Length);
                                if (resultCode != JZlib.Z_OK)
                                {
                                    ZlibUtil.Fail(this.z, "failed to set the dictionary", resultCode);
                                }
                            }
                            continue;
                        }
                        if (resultCode == JZlib.Z_STREAM_END)
                        {
                            this.finished = true; // Do not decode anymore.
                            this.z.InflateEnd();
                            break;
                        }
                        if (resultCode == JZlib.Z_OK)
                        {
                            continue;
                        }
                        if (resultCode == JZlib.Z_BUF_ERROR)
                        {
                            if (this.z.avail_in <= 0)
                            {
                                break;
                            }

                            continue;
                        }
                        //default
                        ZlibUtil.Fail(this.z, "decompression failure", resultCode);
                    }
                }
                finally
                {
                    input.SkipBytes(this.z.next_in_index - oldNextInIndex);
                    if (decompressed.IsReadable())
                    {
                        output.Add(decompressed);
                    }
                    else
                    {
                        decompressed.Release();
                    }
                }
            }
            finally
            {
                this.z.next_in  = null;
                this.z.next_out = null;
            }
        }