示例#1
0
        public static int CopyOneBlockToRingBuffer(object r, global::encode.encode.BrotliCompressor compressor)
        {
            int block_size = compressor.input_block_size();
            global::Array <uint> bytes_read = new global::Array <uint>(new uint[] { ((uint)(0)) });

            uint[] data = ((uint[])(((object)(global::haxe.lang.Runtime.callField(r, "Read", 914388854, new global::Array <object>(new object[] { block_size, bytes_read }))))));
            if ((data == null))
            {
                return(0);
            }

            compressor.CopyInputToRingBuffer(((int)(bytes_read[0])), data);
            int remaining = ((int)(((uint)((block_size - bytes_read[0])))));

            while ((remaining > 0))
            {
                global::Array <uint> more_bytes_read = new global::Array <uint>(new uint[] { ((uint)(0)) });
                data = ((uint[])(((object)(global::haxe.lang.Runtime.callField(r, "Read", 914388854, new global::Array <object>(new object[] { remaining, more_bytes_read }))))));
                if ((data == null))
                {
                    break;
                }

                compressor.CopyInputToRingBuffer(((int)(more_bytes_read[0])), data);
                bytes_read[0] = ((uint)((bytes_read[0] + more_bytes_read[0])));
                remaining     = ((int)(((uint)((remaining - more_bytes_read[0])))));
            }

            return((int)(bytes_read[0]));
        }
示例#2
0
        public static bool BrotliCompressWithCustomDictionary(int dictsize, uint[] dict, global::encode.encode.BrotliParams @params, object input, object output)
        {
            int in_bytes = 0;
            global::Array <int>    out_bytes = new global::Array <int>(new int[] { 0 });
            global::Array <object> @out      = new global::Array <object>();
            bool final_block = false;

            global::encode.encode.BrotliCompressor compressor = new global::encode.encode.BrotliCompressor(((global::encode.encode.BrotliParams)(@params)));
            if ((dictsize != 0))
            {
                compressor.BrotliSetCustomDictionary(dictsize, dict);
            }

            while (!(final_block))
            {
                in_bytes = global::encode.Encode.CopyOneBlockToRingBuffer(input, compressor);
                if ((in_bytes != 0))
                {
                    final_block = global::encode.Encode.BrotliInIsFinished(input);
                }
                else
                {
                    final_block = true;
                }

                out_bytes[0] = 0;
                if (!(compressor.WriteBrotliData(final_block, false, out_bytes, @out)))
                {
                    return(false);
                }

                if (((out_bytes[0] > 0) && (!(global::haxe.lang.Runtime.toBool(((object)(global::haxe.lang.Runtime.callField(output, "Write", 1669782719, new global::Array <object>(new object[] { ((uint[])(@out[0])), out_bytes[0] })))))))))
                {
                    return(false);
                }
            }

            return(true);
        }
示例#3
0
        public static void __hx_ctor_encode_encode_BrotliCompressor(global::encode.encode.BrotliCompressor __hx_this, global::encode.encode.BrotliParams @params)
        {
            unchecked {
                {
                    int[] this1 = null;
                    this1 = new int[4];
                    __hx_this.saved_dist_cache_ = ((int[])(this1));
                }

                {
                    int[] this1 = null;
                    this1 = new int[4];
                    __hx_this.dist_cache_ = ((int[])(this1));
                }

                __hx_this.params_             = @params;
                __hx_this.hashers_            = new global::encode.hash.Hashers();
                __hx_this.input_pos_          = 0;
                __hx_this.num_commands_       = 0;
                __hx_this.num_literals_       = 0;
                __hx_this.last_insert_len_    = 0;
                __hx_this.last_flush_pos_     = 0;
                __hx_this.last_processed_pos_ = 0;
                __hx_this.prev_byte_          = ((uint)(0));
                __hx_this.prev_byte2_         = ((uint)(0));
                __hx_this.storage_size_       = 0;
                double tmp = global::System.Math.Max(((double)(1)), ((double)(__hx_this.params_.quality)));
                __hx_this.params_.quality = ((int)(tmp));
                if ((__hx_this.params_.lgwin < global::encode.Encode.kMinWindowBits))
                {
                    __hx_this.params_.lgwin = global::encode.Encode.kMinWindowBits;
                }
                else if ((__hx_this.params_.lgwin > global::encode.Encode.kMaxWindowBits))
                {
                    __hx_this.params_.lgwin = global::encode.Encode.kMaxWindowBits;
                }

                if ((__hx_this.params_.lgblock == 0))
                {
                    __hx_this.params_.lgblock = (((__hx_this.params_.quality < global::encode.Encode.kMinQualityForBlockSplit)) ? (14) : (16));
                    if (((__hx_this.params_.quality >= 9) && (__hx_this.params_.lgwin > __hx_this.params_.lgblock)))
                    {
                        double tmp1 = global::System.Math.Min(((double)(21)), ((double)(__hx_this.params_.lgwin)));
                        __hx_this.params_.lgblock = ((int)(tmp1));
                    }
                }
                else
                {
                    double tmp2 = global::System.Math.Min(((double)(global::encode.Encode.kMaxInputBlockBits)), ((double)(global::System.Math.Max(((double)(global::encode.Encode.kMinInputBlockBits)), ((double)(__hx_this.params_.lgblock))))));
                    __hx_this.params_.lgblock = ((int)(tmp2));
                }

                __hx_this.max_backward_distance_ = (((1 << __hx_this.params_.lgwin)) - 16);
                __hx_this.ringbuffer_            = new global::encode.RingBuffer(((int)(global::System.Math.Max(((double)((__hx_this.params_.lgwin + 1))), ((double)((__hx_this.params_.lgblock + 1)))))), __hx_this.params_.lgblock);
                if ((__hx_this.params_.quality > 9))
                {
                    __hx_this.literal_cost_mask_ = (((1 << __hx_this.params_.lgblock)) - 1);
                    __hx_this.literal_cost_      = global::FunctionMalloc.mallocFloat((__hx_this.literal_cost_mask_ + 1));
                }

                __hx_this.cmd_buffer_size_ = ((int)(global::System.Math.Max(((double)(262144)), ((double)((1 << __hx_this.params_.lgblock))))));
                __hx_this.commands_        = new global::Array <object>();
                if ((__hx_this.params_.lgwin == 16))
                {
                    __hx_this.last_byte_      = ((uint)(0));
                    __hx_this.last_byte_bits_ = ((uint)(1));
                }
                else if ((__hx_this.params_.lgwin == 17))
                {
                    __hx_this.last_byte_      = ((uint)(1));
                    __hx_this.last_byte_bits_ = ((uint)(7));
                }
                else
                {
                    __hx_this.last_byte_      = ((uint)((((__hx_this.params_.lgwin - 17) << 1) | 1)));
                    __hx_this.last_byte_bits_ = ((uint)(4));
                }

                ((int[])(__hx_this.dist_cache_))[0] = 4;
                ((int[])(__hx_this.dist_cache_))[1] = 11;
                ((int[])(__hx_this.dist_cache_))[2] = 15;
                ((int[])(__hx_this.dist_cache_))[3] = 16;
                global::DefaultFunctions.memcpy_Int(__hx_this.saved_dist_cache_, 0, __hx_this.dist_cache_, 0, (((int[])(__hx_this.dist_cache_)) as global::System.Array).Length);
                __hx_this.hash_type_ = ((int)(global::System.Math.Min(((double)(9)), ((double)(__hx_this.params_.quality)))));
                __hx_this.hashers_.Init(__hx_this.hash_type_);
            }
        }