Example #1
0
 public static void __hx_ctor_encode_brotli_bit_stream_BlockEncoder(global::encode.brotli_bit_stream.BlockEncoder __hx_this, int alphabet_size, int num_block_types, global::Array <int> block_types, global::Array <int> block_lengths)
 {
     __hx_this.block_split_code_ = new global::encode.brotli_bit_stream.BlockSplitCode();
     __hx_this.alphabet_size_    = alphabet_size;
     __hx_this.num_block_types_  = num_block_types;
     __hx_this.block_types_      = block_types;
     __hx_this.block_lengths_    = block_lengths;
     __hx_this.block_ix_         = 0;
     __hx_this.block_len_        = (((block_lengths.length == 0)) ? (0) : (block_lengths[0]));
     __hx_this.entropy_ix_       = 0;
 }
Example #2
0
        public static bool StoreMetaBlock(uint[] input, int start_pos, int length, int mask, uint prev_byte, uint prev_byte2, bool is_last, int num_direct_distance_codes, int distance_postfix_bits, int literal_context_mode, global::Array <object> commands, int n_commands, global::encode.metablock.MetaBlockSplit mb, global::Array <int> storage_ix, uint[] storage)
        {
            unchecked {
                if (!(global::encode.Brotli_bit_stream.StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage)))
                {
                    return(false);
                }

                if ((length == 0))
                {
                    global::encode.Brotli_bit_stream.JumpToByteBoundary(storage_ix, storage);
                    return(true);
                }

                global::encode.brotli_bit_stream.BlockEncoder literal_enc  = new global::encode.brotli_bit_stream.BlockEncoder(256, mb.literal_split.num_types, mb.literal_split.types, mb.literal_split.lengths);
                global::encode.brotli_bit_stream.BlockEncoder command_enc  = new global::encode.brotli_bit_stream.BlockEncoder(704, mb.command_split.num_types, mb.command_split.types, mb.command_split.lengths);
                global::encode.brotli_bit_stream.BlockEncoder distance_enc = new global::encode.brotli_bit_stream.BlockEncoder(((16 + num_direct_distance_codes) + ((48 << distance_postfix_bits))), mb.distance_split.num_types, mb.distance_split.types, mb.distance_split.lengths);
                literal_enc.BuildAndStoreBlockSwitchEntropyCodes(storage_ix, storage);
                command_enc.BuildAndStoreBlockSwitchEntropyCodes(storage_ix, storage);
                distance_enc.BuildAndStoreBlockSwitchEntropyCodes(storage_ix, storage);
                global::encode.Write_bits.WriteBits(2, ((uint)(distance_postfix_bits)), storage_ix, storage);
                global::encode.Write_bits.WriteBits(4, ((uint)((num_direct_distance_codes >> distance_postfix_bits))), storage_ix, storage);
                {
                    int _g1 = 0;
                    int _g  = mb.literal_split.num_types;
                    while ((_g1 < _g))
                    {
                        ++_g1;
                        global::encode.Write_bits.WriteBits(2, ((uint)(literal_context_mode)), storage_ix, storage);
                    }
                }

                if (((((int[])(mb.literal_context_map)) as global::System.Array).Length == 0))
                {
                    global::encode.Brotli_bit_stream.StoreTrivialContextMap(mb.literal_histograms.length, 6, storage_ix, storage);
                }
                else
                {
                    global::encode.Brotli_bit_stream.EncodeContextMap(mb.literal_context_map, mb.literal_histograms.length, storage_ix, storage);
                }

                if (((((int[])(mb.distance_context_map)) as global::System.Array).Length == 0))
                {
                    global::encode.Brotli_bit_stream.StoreTrivialContextMap(mb.distance_histograms.length, 2, storage_ix, storage);
                }
                else
                {
                    global::encode.Brotli_bit_stream.EncodeContextMap(mb.distance_context_map, mb.distance_histograms.length, storage_ix, storage);
                }

                literal_enc.BuildAndStoreEntropyCodes(mb.literal_histograms, storage_ix, storage);
                command_enc.BuildAndStoreEntropyCodes(mb.command_histograms, storage_ix, storage);
                distance_enc.BuildAndStoreEntropyCodes(mb.distance_histograms, storage_ix, storage);
                int pos = start_pos;
                {
                    int _g11 = 0;
                    while ((_g11 < n_commands))
                    {
                        global::encode.command.Command cmd = ((global::encode.command.Command)(commands[_g11++]));
                        int lennumextra = ((int)(((uint)(((uint)((((uint)(cmd.cmd_extra_[0])) >> 16)))))));
                        global::Array <uint> lenextra = cmd.cmd_extra_;
                        command_enc.StoreSymbol(((int)(cmd.cmd_prefix_[0])), storage_ix, storage);
                        if ((lennumextra >= 32))
                        {
                            global::encode.Write_bits.WriteBits((lennumextra - 32), lenextra[0], storage_ix, storage);
                        }

                        global::encode.Write_bits.WriteBits((((lennumextra < 32)) ? (lennumextra) : (32)), lenextra[1], storage_ix, storage);
                        if (((((int[])(mb.literal_context_map)) as global::System.Array).Length == 0))
                        {
                            int _g3 = 0;
                            int _g2 = cmd.insert_len_;
                            while ((_g3 < _g2))
                            {
                                ++_g3;
                                literal_enc.StoreSymbol(((int)(((uint)(((uint[])(input))[(pos & mask)])))), storage_ix, storage);
                                ++pos;
                            }
                        }
                        else
                        {
                            int _g31 = 0;
                            int _g21 = cmd.insert_len_;
                            while ((_g31 < _g21))
                            {
                                ++_g31;
                                int literal = ((int)(((uint)(((uint[])(input))[(pos & mask)]))));
                                literal_enc.StoreSymbolWithContext(6, literal, ((int)(global::encode.Context.ContextFunction(prev_byte, prev_byte2, literal_context_mode))), mb.literal_context_map, storage_ix, storage);
                                prev_byte2 = prev_byte;
                                prev_byte  = ((uint)(literal));
                                ++pos;
                            }
                        }

                        pos += cmd.copy_len_;
                        if ((cmd.copy_len_ > 0))
                        {
                            prev_byte2 = ((uint)(((uint[])(input))[((pos - 2) & mask)]));
                            prev_byte  = ((uint)(((uint[])(input))[((pos - 1) & mask)]));
                            if (((bool)((cmd.cmd_prefix_[0] >= 128))))
                            {
                                int dist_code    = ((int)(cmd.dist_prefix_[0]));
                                int distnumextra = ((int)(((uint)(((uint)((((uint)(cmd.dist_extra_[0])) >> 24)))))));
                                int distextra    = ((int)(((uint)((cmd.dist_extra_[0] & 16777215)))));
                                if (((((int[])(mb.distance_context_map)) as global::System.Array).Length == 0))
                                {
                                    distance_enc.StoreSymbol(dist_code, storage_ix, storage);
                                }
                                else
                                {
                                    distance_enc.StoreSymbolWithContext(2, dist_code, cmd.DistanceContext(), mb.distance_context_map, storage_ix, storage);
                                }

                                global::encode.Write_bits.WriteBits(distnumextra, ((uint)(distextra)), storage_ix, storage);
                            }
                        }
                    }
                }

                if (is_last)
                {
                    global::encode.Brotli_bit_stream.JumpToByteBoundary(storage_ix, storage);
                }

                return(true);
            }
        }