File Manager

X7ROOT File Manager

Current Path: /opt/alt/tests/alt-php83-pecl-brotli_0.18.3-2.el8/brotli/c/enc

opt / alt / tests / alt-php83-pecl-brotli_0.18.3-2.el8 / brotli / c / enc /

?? ..
?? .libs
?? backward_references.c(6.13 KB)
?? backward_references.dep(2.56 KB)
?? backward_references.h(1.18 KB)
?? backward_references.lo(303 B)
?? backward_references_hq.c(35.88 KB)
?? backward_references_hq.dep(2.56 KB)
?? backward_references_hq.h(3.68 KB)
?? backward_references_hq.lo(309 B)
?? backward_references_inc.h(7.99 KB)
?? bit_cost.c(1.39 KB)
?? bit_cost.dep(1.64 KB)
?? bit_cost.h(896 B)
?? bit_cost.lo(281 B)
?? bit_cost_inc.h(4.02 KB)
?? block_encoder_inc.h(1.11 KB)
?? block_splitter.c(7.16 KB)
?? block_splitter.dep(1.84 KB)
?? block_splitter.h(1.59 KB)
?? block_splitter.lo(293 B)
?? block_splitter_inc.h(18.44 KB)
?? brotli_bit_stream.c(49.72 KB)
?? brotli_bit_stream.dep(1.94 KB)
?? brotli_bit_stream.h(3.26 KB)
?? brotli_bit_stream.lo(299 B)
?? cluster.c(1.42 KB)
?? cluster.dep(1.7 KB)
?? cluster.h(997 B)
?? cluster.lo(279 B)
?? cluster_inc.h(11.55 KB)
?? command.c(1 KB)
?? command.dep(1.24 KB)
?? command.h(6.77 KB)
?? command.lo(279 B)
?? compound_dictionary.c(6.5 KB)
?? compound_dictionary.dep(543 B)
?? compound_dictionary.h(2.38 KB)
?? compound_dictionary.lo(303 B)
?? compress_fragment.c(32.1 KB)
?? compress_fragment.dep(2 KB)
?? compress_fragment.h(3.49 KB)
?? compress_fragment.lo(299 B)
?? compress_fragment_two_pass.c(26.18 KB)
?? compress_fragment_two_pass.dep(2.08 KB)
?? compress_fragment_two_pass.h(2.79 KB)
?? compress_fragment_two_pass.lo(317 B)
?? dictionary_hash.c(7.75 KB)
?? dictionary_hash.dep(537 B)
?? dictionary_hash.h(1.5 KB)
?? dictionary_hash.lo(295 B)
?? dictionary_hash_inc.h(143.28 KB)
?? encode.c(76.58 KB)
?? encode.dep(3.59 KB)
?? encode.lo(277 B)
?? encoder_dict.c(22.83 KB)
?? encoder_dict.dep(2.58 KB)
?? encoder_dict.h(4.9 KB)
?? encoder_dict.lo(289 B)
?? entropy_encode.c(14.23 KB)
?? entropy_encode.dep(531 B)
?? entropy_encode.h(3.96 KB)
?? entropy_encode.lo(293 B)
?? entropy_encode_static.h(32.37 KB)
?? fast_log.c(5.9 KB)
?? fast_log.dep(366 B)
?? fast_log.h(1.61 KB)
?? fast_log.lo(281 B)
?? find_match_length.h(2.12 KB)
?? hash.h(23.73 KB)
?? hash_base.h(1.34 KB)
?? hash_composite_inc.h(4.98 KB)
?? hash_forgetful_chain_inc.h(11.05 KB)
?? hash_longest_match64_inc.h(10.41 KB)
?? hash_longest_match64_simd_inc.h(11.56 KB)
?? hash_longest_match_inc.h(10.34 KB)
?? hash_longest_match_quickly_inc.h(9.26 KB)
?? hash_longest_match_simd_inc.h(11.48 KB)
?? hash_rolling_inc.h(7.06 KB)
?? hash_to_binary_tree_inc.h(12.77 KB)
?? histogram.c(3.18 KB)
?? histogram.dep(1.51 KB)
?? histogram.h(1.77 KB)
?? histogram.lo(283 B)
?? histogram_inc.h(1.37 KB)
?? literal_cost.c(5.74 KB)
?? literal_cost.dep(505 B)
?? literal_cost.h(889 B)
?? literal_cost.lo(289 B)
?? matching_tag_mask.h(2.29 KB)
?? memory.c(5.39 KB)
?? memory.dep(360 B)
?? memory.h(4.2 KB)
?? memory.lo(277 B)
?? metablock.c(26.07 KB)
?? metablock.dep(1.9 KB)
?? metablock.h(3.93 KB)
?? metablock.lo(283 B)
?? metablock_inc.h(7.46 KB)
?? params.h(1.14 KB)
?? prefix.h(1.9 KB)
?? quality.h(7.68 KB)
?? ringbuffer.h(5.83 KB)
?? state.h(3.01 KB)
?? static_dict.c(20.39 KB)
?? static_dict.dep(1.14 KB)
?? static_dict.h(1.19 KB)
?? static_dict.lo(287 B)
?? static_dict_lut.c(7.25 KB)
?? static_dict_lut.dep(685 B)
?? static_dict_lut.h(1.55 KB)
?? static_dict_lut.lo(295 B)
?? static_dict_lut_inc.h(457.82 KB)
?? static_init.c(1.74 KB)
?? static_init.dep(451 B)
?? static_init.h(840 B)
?? static_init.lo(287 B)
?? utf8_util.c(2.22 KB)
?? utf8_util.dep(369 B)
?? utf8_util.h(878 B)
?? utf8_util.lo(283 B)
?? write_bits.h(2.77 KB)

Editing: block_splitter.c

Distributed under MIT license.
   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
*/

/* Block split point selection utilities. */

#include "block_splitter.h"

#include "../common/platform.h"
#include "bit_cost.h"
#include "cluster.h"
#include "command.h"
#include "fast_log.h"
#include "histogram.h"
#include "memory.h"
#include "quality.h"

#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif

static const size_t kMaxLiteralHistograms = 100;
static const size_t kMaxCommandHistograms = 50;
static const double kLiteralBlockSwitchCost = 28.1;
static const double kCommandBlockSwitchCost = 13.5;
static const double kDistanceBlockSwitchCost = 14.6;
static const size_t kLiteralStrideLength = 70;
static const size_t kCommandStrideLength = 40;
static const size_t kDistanceStrideLength = 40;
static const size_t kSymbolsPerLiteralHistogram = 544;
static const size_t kSymbolsPerCommandHistogram = 530;
static const size_t kSymbolsPerDistanceHistogram = 544;
static const size_t kMinLengthForBlockSplitting = 128;
static const size_t kIterMulForRefining = 2;
static const size_t kMinItersForRefining = 100;

static size_t CountLiterals(const Command* cmds, const size_t num_commands) {
  /* Count how many we have. */
  size_t total_length = 0;
  size_t i;
  for (i = 0; i < num_commands; ++i) {
    total_length += cmds[i].insert_len_;
  }
  return total_length;
}

static void CopyLiteralsToByteArray(const Command* cmds,
                                    const size_t num_commands,
                                    const uint8_t* data,
                                    const size_t offset,
                                    const size_t mask,
                                    uint8_t* literals) {
  size_t pos = 0;
  size_t from_pos = offset & mask;
  size_t i;
  for (i = 0; i < num_commands; ++i) {
    size_t insert_len = cmds[i].insert_len_;
    if (from_pos + insert_len > mask) {
      size_t head_size = mask + 1 - from_pos;
      memcpy(literals + pos, data + from_pos, head_size);
      from_pos = 0;
      pos += head_size;
      insert_len -= head_size;
    }
    if (insert_len > 0) {
      memcpy(literals + pos, data + from_pos, insert_len);
      pos += insert_len;
    }
    from_pos = (from_pos + insert_len + CommandCopyLen(&cmds[i])) & mask;
  }
}

static BROTLI_INLINE uint32_t MyRand(uint32_t* seed) {
  /* Initial seed should be 7. In this case, loop length is (1 << 29). */
  *seed *= 16807U;
  return *seed;
}

static BROTLI_INLINE double BitCost(size_t count) {
  return count == 0 ? -2.0 : FastLog2(count);
}

#define HISTOGRAMS_PER_BATCH 64
#define CLUSTERS_PER_BATCH 16

#define FN(X) X ## Literal
#define DataType uint8_t
/* NOLINTNEXTLINE(build/include) */
#include "block_splitter_inc.h"
#undef DataType
#undef FN

#define FN(X) X ## Command
#define DataType uint16_t
/* NOLINTNEXTLINE(build/include) */
#include "block_splitter_inc.h"
#undef FN

#define FN(X) X ## Distance
/* NOLINTNEXTLINE(build/include) */
#include "block_splitter_inc.h"
#undef DataType
#undef FN

void BrotliInitBlockSplit(BlockSplit* self) {
  self->num_types = 0;
  self->num_blocks = 0;
  self->types = 0;
  self->lengths = 0;
  self->types_alloc_size = 0;
  self->lengths_alloc_size = 0;
}

void BrotliDestroyBlockSplit(MemoryManager* m, BlockSplit* self) {
  BROTLI_FREE(m, self->types);
  BROTLI_FREE(m, self->lengths);
}

/* Extracts literals, command distance and prefix codes, then applies
 * SplitByteVector to create partitioning. */
void BrotliSplitBlock(MemoryManager* m,
                      const Command* cmds,
                      const size_t num_commands,
                      const uint8_t* data,
                      const size_t pos,
                      const size_t mask,
                      const BrotliEncoderParams* params,
                      BlockSplit* literal_split,
                      BlockSplit* insert_and_copy_split,
                      BlockSplit* dist_split) {
  {
    size_t literals_count = CountLiterals(cmds, num_commands);
    uint8_t* literals = BROTLI_ALLOC(m, uint8_t, literals_count);
    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literals)) return;
    /* Create a continuous array of literals. */
    CopyLiteralsToByteArray(cmds, num_commands, data, pos, mask, literals);
    /* Create the block split on the array of literals.
     * Literal histograms can have alphabet size up to 256.
     * Though, to accommodate context modeling, less than half of maximum size
     * is allowed. */
    SplitByteVectorLiteral(
        m, literals, literals_count,
        kSymbolsPerLiteralHistogram, kMaxLiteralHistograms,
        kLiteralStrideLength, kLiteralBlockSwitchCost, params,
        literal_split);
    if (BROTLI_IS_OOM(m)) return;
    BROTLI_FREE(m, literals);
    /* NB: this might be a good place for injecting extra splitting without
     *     increasing encoder complexity; however, output partition would be less
     *     optimal than one produced with forced splitting inside
     *     SplitByteVector (FindBlocks / ClusterBlocks). */
  }

{
    /* Compute prefix codes for commands. */
    uint16_t* insert_and_copy_codes = BROTLI_ALLOC(m, uint16_t, num_commands);
    size_t i;
    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(insert_and_copy_codes)) return;
    for (i = 0; i < num_commands; ++i) {
      insert_and_copy_codes[i] = cmds[i].cmd_prefix_;
    }
    /* Create the block split on the array of command prefixes. */
    SplitByteVectorCommand(
        m, insert_and_copy_codes, num_commands,
        kSymbolsPerCommandHistogram, kMaxCommandHistograms,
        kCommandStrideLength, kCommandBlockSwitchCost, params,
        insert_and_copy_split);
    if (BROTLI_IS_OOM(m)) return;
    /* TODO(eustas): reuse for distances? */
    BROTLI_FREE(m, insert_and_copy_codes);
  }

{
    /* Create a continuous array of distance prefixes. */
    uint16_t* distance_prefixes = BROTLI_ALLOC(m, uint16_t, num_commands);
    size_t j = 0;
    size_t i;
    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(distance_prefixes)) return;
    for (i = 0; i < num_commands; ++i) {
      const Command* cmd = &cmds[i];
      if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
        distance_prefixes[j++] = cmd->dist_prefix_ & 0x3FF;
      }
    }
    /* Create the block split on the array of distance prefixes. */
    SplitByteVectorDistance(
        m, distance_prefixes, j,
        kSymbolsPerDistanceHistogram, kMaxCommandHistograms,
        kDistanceStrideLength, kDistanceBlockSwitchCost, params,
        dist_split);
    if (BROTLI_IS_OOM(m)) return;
    BROTLI_FREE(m, distance_prefixes);
  }
}

#if defined(BROTLI_TEST)
size_t BrotliCountLiteralsForTest(const Command*, size_t);
size_t BrotliCountLiteralsForTest(const Command* cmds, size_t num_commands) {
  return CountLiterals(cmds, num_commands);
}
void BrotliCopyLiteralsToByteArrayForTest(
    const Command*, size_t, const uint8_t*, size_t, size_t, uint8_t*);
void BrotliCopyLiteralsToByteArrayForTest(const Command* cmds,
    size_t num_commands, const uint8_t* data, size_t offset, size_t mask,
    uint8_t* literals) {
  CopyLiteralsToByteArray(cmds, num_commands, data, offset, mask, literals);
}
#endif

#if defined(__cplusplus) || defined(c_plusplus)
}  /* extern "C" */
#endif

X7ROOT File Manager

Editing: block_splitter.c

Upload File

Create Folder