File Manager

X7ROOT File Manager

Current Path: /opt/alt/tests/alt-php84-brotli_0.5.0-3.el8/brotli/c/enc

opt / alt / tests / alt-php84-brotli_0.5.0-3.el8 / brotli / c / enc /

ðŸ“ ..
ðŸ“ .libs
ðŸ“„ backward_references.c(3.92 KB)
ðŸ“„ backward_references.dep(2.92 KB)
ðŸ“„ backward_references.h(1.25 KB)
ðŸ“„ backward_references.lo(303 B)
ðŸ“„ backward_references_hq.c(29.94 KB)
ðŸ“„ backward_references_hq.dep(3.05 KB)
ðŸ“„ backward_references_hq.h(3.83 KB)
ðŸ“„ backward_references_hq.lo(309 B)
ðŸ“„ backward_references_inc.h(6.36 KB)
ðŸ“„ bit_cost.c(812 B)
ðŸ“„ bit_cost.dep(2.21 KB)
ðŸ“„ bit_cost.h(1.67 KB)
ðŸ“„ bit_cost.lo(281 B)
ðŸ“„ bit_cost_inc.h(4.01 KB)
ðŸ“„ block_encoder_inc.h(1.08 KB)
ðŸ“„ block_splitter.c(6.01 KB)
ðŸ“„ block_splitter.dep(2.31 KB)
ðŸ“„ block_splitter.h(1.63 KB)
ðŸ“„ block_splitter.lo(293 B)
ðŸ“„ block_splitter_inc.h(15.86 KB)
ðŸ“„ brotli_bit_stream.c(48.7 KB)
ðŸ“„ brotli_bit_stream.dep(3.11 KB)
ðŸ“„ brotli_bit_stream.h(4.59 KB)
ðŸ“„ brotli_bit_stream.lo(299 B)
ðŸ“„ cluster.c(1.45 KB)
ðŸ“„ cluster.dep(2.41 KB)
ðŸ“„ cluster.h(1021 B)
ðŸ“„ cluster.lo(279 B)
ðŸ“„ cluster_inc.h(11.14 KB)
ðŸ“„ command.h(6.48 KB)
ðŸ“„ compress_fragment.c(31.53 KB)
ðŸ“„ compress_fragment.dep(2.89 KB)
ðŸ“„ compress_fragment.h(2.75 KB)
ðŸ“„ compress_fragment.lo(299 B)
ðŸ“„ compress_fragment_two_pass.c(23.24 KB)
ðŸ“„ compress_fragment_two_pass.dep(3.07 KB)
ðŸ“„ compress_fragment_two_pass.h(2.34 KB)
ðŸ“„ compress_fragment_two_pass.lo(317 B)
ðŸ“„ context.h(7.27 KB)
ðŸ“„ dictionary_hash.c(86.83 KB)
ðŸ“„ dictionary_hash.dep(344 B)
ðŸ“„ dictionary_hash.h(583 B)
ðŸ“„ dictionary_hash.lo(295 B)
ðŸ“„ encode.c(65.51 KB)
ðŸ“„ encode.dep(4.74 KB)
ðŸ“„ encode.lo(277 B)
ðŸ“„ entropy_encode.c(14.14 KB)
ðŸ“„ entropy_encode.dep(560 B)
ðŸ“„ entropy_encode.h(3.94 KB)
ðŸ“„ entropy_encode.lo(293 B)
ðŸ“„ entropy_encode_static.h(32.12 KB)
ðŸ“„ fast_log.h(6.96 KB)
ðŸ“„ find_match_length.h(2.47 KB)
ðŸ“„ hash.h(13.56 KB)
ðŸ“„ hash_forgetful_chain_inc.h(9.41 KB)
ðŸ“„ hash_longest_match64_inc.h(10.19 KB)
ðŸ“„ hash_longest_match_inc.h(9.75 KB)
ðŸ“„ hash_longest_match_quickly_inc.h(8.5 KB)
ðŸ“„ hash_to_binary_tree_inc.h(12.58 KB)
ðŸ“„ histogram.c(3.05 KB)
ðŸ“„ histogram.dep(1.82 KB)
ðŸ“„ histogram.h(1.68 KB)
ðŸ“„ histogram.lo(283 B)
ðŸ“„ histogram_inc.h(1.37 KB)
ðŸ“„ literal_cost.c(5.47 KB)
ðŸ“„ literal_cost.dep(618 B)
ðŸ“„ literal_cost.h(880 B)
ðŸ“„ literal_cost.lo(289 B)
ðŸ“„ memory.c(4.96 KB)
ðŸ“„ memory.dep(455 B)
ðŸ“„ memory.h(1.66 KB)
ðŸ“„ memory.lo(277 B)
ðŸ“„ metablock.c(20.3 KB)
ðŸ“„ metablock.dep(2.92 KB)
ðŸ“„ metablock.h(3.67 KB)
ðŸ“„ metablock.lo(283 B)
ðŸ“„ metablock_inc.h(7.34 KB)
ðŸ“„ port.h(5.5 KB)
ðŸ“„ prefix.h(1.93 KB)
ðŸ“„ quality.h(5.62 KB)
ðŸ“„ ringbuffer.h(5.57 KB)
ðŸ“„ static_dict.c(18.14 KB)
ðŸ“„ static_dict.dep(796 B)
ðŸ“„ static_dict.h(1.2 KB)
ðŸ“„ static_dict.lo(287 B)
ðŸ“„ static_dict_lut.h(458.65 KB)
ðŸ“„ utf8_util.c(2.21 KB)
ðŸ“„ utf8_util.dep(396 B)
ðŸ“„ utf8_util.h(892 B)
ðŸ“„ utf8_util.lo(283 B)
ðŸ“„ write_bits.h(2.72 KB)

Editing: literal_cost.c

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

/* Literal cost model to allow backward reference replacement to be efficient.
*/

#include "./literal_cost.h"

#include <brotli/types.h>
#include "./fast_log.h"
#include "./port.h"
#include "./utf8_util.h"

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

static size_t UTF8Position(size_t last, size_t c, size_t clamp) {
  if (c < 128) {
    return 0;  /* Next one is the 'Byte 1' again. */
  } else if (c >= 192) {  /* Next one is the 'Byte 2' of utf-8 encoding. */
    return BROTLI_MIN(size_t, 1, clamp);
  } else {
    /* Let's decide over the last byte if this ends the sequence. */
    if (last < 0xe0) {
      return 0;  /* Completed two or three byte coding. */
    } else {  /* Next one is the 'Byte 3' of utf-8 encoding. */
      return BROTLI_MIN(size_t, 2, clamp);
    }
  }
}

static size_t DecideMultiByteStatsLevel(size_t pos, size_t len, size_t mask,
                                        const uint8_t *data) {
  size_t counts[3] = { 0 };
  size_t max_utf8 = 1;  /* should be 2, but 1 compresses better. */
  size_t last_c = 0;
  size_t i;
  for (i = 0; i < len; ++i) {
    size_t c = data[(pos + i) & mask];
    ++counts[UTF8Position(last_c, c, 2)];
    last_c = c;
  }
  if (counts[2] < 500) {
    max_utf8 = 1;
  }
  if (counts[1] + counts[2] < 25) {
    max_utf8 = 0;
  }
  return max_utf8;
}

static void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
                                            const uint8_t *data, float *cost) {
  /* max_utf8 is 0 (normal ASCII single byte modeling),
     1 (for 2-byte UTF-8 modeling), or 2 (for 3-byte UTF-8 modeling). */
  const size_t max_utf8 = DecideMultiByteStatsLevel(pos, len, mask, data);
  size_t histogram[3][256] = { { 0 } };
  size_t window_half = 495;
  size_t in_window = BROTLI_MIN(size_t, window_half, len);
  size_t in_window_utf8[3] = { 0 };

size_t i;
  {  /* Bootstrap histograms. */
    size_t last_c = 0;
    size_t utf8_pos = 0;
    for (i = 0; i < in_window; ++i) {
      size_t c = data[(pos + i) & mask];
      ++histogram[utf8_pos][c];
      ++in_window_utf8[utf8_pos];
      utf8_pos = UTF8Position(last_c, c, max_utf8);
      last_c = c;
    }
  }

/* Compute bit costs with sliding window. */
  for (i = 0; i < len; ++i) {
    if (i >= window_half) {
      /* Remove a byte in the past. */
      size_t c =
          i < window_half + 1 ? 0 : data[(pos + i - window_half - 1) & mask];
      size_t last_c =
          i < window_half + 2 ? 0 : data[(pos + i - window_half - 2) & mask];
      size_t utf8_pos2 = UTF8Position(last_c, c, max_utf8);
      --histogram[utf8_pos2][data[(pos + i - window_half) & mask]];
      --in_window_utf8[utf8_pos2];
    }
    if (i + window_half < len) {
      /* Add a byte in the future. */
      size_t c = data[(pos + i + window_half - 1) & mask];
      size_t last_c = data[(pos + i + window_half - 2) & mask];
      size_t utf8_pos2 = UTF8Position(last_c, c, max_utf8);
      ++histogram[utf8_pos2][data[(pos + i + window_half) & mask]];
      ++in_window_utf8[utf8_pos2];
    }
    {
      size_t c = i < 1 ? 0 : data[(pos + i - 1) & mask];
      size_t last_c = i < 2 ? 0 : data[(pos + i - 2) & mask];
      size_t utf8_pos = UTF8Position(last_c, c, max_utf8);
      size_t masked_pos = (pos + i) & mask;
      size_t histo = histogram[utf8_pos][data[masked_pos]];
      double lit_cost;
      if (histo == 0) {
        histo = 1;
      }
      lit_cost = FastLog2(in_window_utf8[utf8_pos]) - FastLog2(histo);
      lit_cost += 0.02905;
      if (lit_cost < 1.0) {
        lit_cost *= 0.5;
        lit_cost += 0.5;
      }
      /* Make the first bytes more expensive -- seems to help, not sure why.
         Perhaps because the entropy source is changing its properties
         rapidly in the beginning of the file, perhaps because the beginning
         of the data is a statistical "anomaly". */
      if (i < 2000) {
        lit_cost += 0.7 - ((double)(2000 - i) / 2000.0 * 0.35);
      }
      cost[i] = (float)lit_cost;
    }
  }
}

void BrotliEstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
                                       const uint8_t *data, float *cost) {
  if (BrotliIsMostlyUTF8(data, pos, mask, len, kMinUTF8Ratio)) {
    EstimateBitCostsForLiteralsUTF8(pos, len, mask, data, cost);
    return;
  } else {
    size_t histogram[256] = { 0 };
    size_t window_half = 2000;
    size_t in_window = BROTLI_MIN(size_t, window_half, len);

/* Bootstrap histogram. */
    size_t i;
    for (i = 0; i < in_window; ++i) {
      ++histogram[data[(pos + i) & mask]];
    }

/* Compute bit costs with sliding window. */
    for (i = 0; i < len; ++i) {
      size_t histo;
      if (i >= window_half) {
        /* Remove a byte in the past. */
        --histogram[data[(pos + i - window_half) & mask]];
        --in_window;
      }
      if (i + window_half < len) {
        /* Add a byte in the future. */
        ++histogram[data[(pos + i + window_half) & mask]];
        ++in_window;
      }
      histo = histogram[data[(pos + i) & mask]];
      if (histo == 0) {
        histo = 1;
      }
      {
        double lit_cost = FastLog2(in_window) - FastLog2(histo);
        lit_cost += 0.029;
        if (lit_cost < 1.0) {
          lit_cost *= 0.5;
          lit_cost += 0.5;
        }
        cost[i] = (float)lit_cost;
      }
    }
  }
}

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

X7ROOT File Manager

Editing: literal_cost.c

Upload File

Create Folder