File Manager

X7ROOT File Manager

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

opt / alt / tests / alt-php84-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: quality.h

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

/* Constants and formulas that affect speed-ratio trade-offs and thus define
   quality levels. */

#ifndef BROTLI_ENC_QUALITY_H_
#define BROTLI_ENC_QUALITY_H_

#include "../common/platform.h"
#include <brotli/encode.h>
#include "params.h"

#define FAST_ONE_PASS_COMPRESSION_QUALITY 0
#define FAST_TWO_PASS_COMPRESSION_QUALITY 1
#define ZOPFLIFICATION_QUALITY 10
#define HQ_ZOPFLIFICATION_QUALITY 11

#define MAX_QUALITY_FOR_STATIC_ENTROPY_CODES 2
#define MIN_QUALITY_FOR_BLOCK_SPLIT 4
#define MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS 4
#define MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS 4
#define MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH 5
#define MIN_QUALITY_FOR_CONTEXT_MODELING 5
#define MIN_QUALITY_FOR_HQ_CONTEXT_MODELING 7
#define MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING 10

/* For quality below MIN_QUALITY_FOR_BLOCK_SPLIT there is no block splitting,
   so we buffer at most this much literals and commands. */
#define MAX_NUM_DELAYED_SYMBOLS 0x2FFF

/* Returns hash-table size for quality levels 0 and 1. */
static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
  return quality == FAST_ONE_PASS_COMPRESSION_QUALITY ? 1 << 15 : 1 << 17;
}

/* The maximum length for which the zopflification uses distinct distances. */
#define MAX_ZOPFLI_LEN_QUALITY_10 150
#define MAX_ZOPFLI_LEN_QUALITY_11 325

/* Do not thoroughly search when a long copy is found. */
#define BROTLI_LONG_COPY_QUICK_STEP 16384

static BROTLI_INLINE size_t MaxZopfliLen(const BrotliEncoderParams* params) {
  return params->quality <= 10 ?
      MAX_ZOPFLI_LEN_QUALITY_10 :
      MAX_ZOPFLI_LEN_QUALITY_11;
}

/* Number of best candidates to evaluate to expand Zopfli chain. */
static BROTLI_INLINE size_t MaxZopfliCandidates(
  const BrotliEncoderParams* params) {
  return params->quality <= 10 ? 1 : 5;
}

static BROTLI_INLINE void SanitizeParams(BrotliEncoderParams* params) {
  params->quality = BROTLI_MIN(int, BROTLI_MAX_QUALITY,
      BROTLI_MAX(int, BROTLI_MIN_QUALITY, params->quality));
  if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
    params->large_window = BROTLI_FALSE;
  }
  if (params->lgwin < BROTLI_MIN_WINDOW_BITS) {
    params->lgwin = BROTLI_MIN_WINDOW_BITS;
  } else {
    int max_lgwin = params->large_window ? BROTLI_LARGE_MAX_WINDOW_BITS :
                                           BROTLI_MAX_WINDOW_BITS;
    if (params->lgwin > max_lgwin) params->lgwin = max_lgwin;
  }
}

/* Returns optimized lg_block value. */
static BROTLI_INLINE int ComputeLgBlock(const BrotliEncoderParams* params) {
  int lgblock = params->lgblock;
  if (params->quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
      params->quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
    lgblock = params->lgwin;
  } else if (params->quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
    lgblock = 14;
  } else if (lgblock == 0) {
    lgblock = 16;
    if (params->quality >= 9 && params->lgwin > lgblock) {
      lgblock = BROTLI_MIN(int, 18, params->lgwin);
    }
  } else {
    lgblock = BROTLI_MIN(int, BROTLI_MAX_INPUT_BLOCK_BITS,
        BROTLI_MAX(int, BROTLI_MIN_INPUT_BLOCK_BITS, lgblock));
  }
  return lgblock;
}

/* Returns log2 of the size of main ring buffer area.
   Allocate at least lgwin + 1 bits for the ring buffer so that the newly
   added block fits there completely and we still get lgwin bits and at least
   read_block_size_bits + 1 bits because the copy tail length needs to be
   smaller than ring-buffer size. */
static BROTLI_INLINE int ComputeRbBits(const BrotliEncoderParams* params) {
  return 1 + BROTLI_MAX(int, params->lgwin, params->lgblock);
}

static BROTLI_INLINE size_t MaxMetablockSize(
    const BrotliEncoderParams* params) {
  int bits =
      BROTLI_MIN(int, ComputeRbBits(params), BROTLI_MAX_INPUT_BLOCK_BITS);
  return (size_t)1 << bits;
}

/* When searching for backward references and have not seen matches for a long
   time, we can skip some match lookups. Unsuccessful match lookups are very
   expensive and this kind of a heuristic speeds up compression quite a lot.
   At first 8 byte strides are taken and every second byte is put to hasher.
   After 4x more literals stride by 16 bytes, every put 4-th byte to hasher.
   Applied only to qualities 2 to 9. */
static BROTLI_INLINE size_t LiteralSpreeLengthForSparseSearch(
    const BrotliEncoderParams* params) {
  return params->quality < 9 ? 64 : 512;
}

/* Quality to hasher mapping:

- q02: h02 (longest_match_quickly), b16, l5

- q03: h03 (longest_match_quickly), b17, l5

- q04: h04 (longest_match_quickly), b17, l5
   - q04: h54 (longest_match_quickly), b20, l7 | for large files

- q05: h58 (longest_match_simd   ), b14, l4
   - q05: h68 (longest_match64_simd ), b15, l5 | for large files
   - q05: h40 (forgetful_chain      ), b15, l4 | for small window

- q06: h58 (longest_match_simd   ), b14, l4
   - q06: h68 (longest_match64_simd ), b15, l5 | for large files
   - q06: h40 (forgetful_chain      ), b15, l4 | for small window

- q07: h58 (longest_match_simd   ), b15, l4
   - q07: h68 (longest_match64_simd ), b15, l5 | for large files
   - q07: h41 (forgetful_chain      ), b15, l4 | for small window

- q08: h05 (longest_match        ), b15, l4
   - q08: h06 (longest_match64      ), b15, l5 | for large files
   - q08: h41 (forgetful_chain      ), b15, l4 | for small window

- q09: h05 (longest_match        ), b15, l4
   - q09: h06 (longest_match64      ), b15, l5 | for large files
   - q09: h42 (forgetful_chain      ), b15, l4 | for small window

- q10: t10 (to_binary_tree       ), b17, l128

- q11: t10 (to_binary_tree       ), b17, l128

Where "q" is quality, "h" is hasher type, "b" is bucket bits,
  "l" is source len. */
static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
                                       BrotliHasherParams* hparams) {
  if (params->quality > 9) {
    hparams->type = 10;
  } else if (params->quality == 4 && params->size_hint >= (1 << 20)) {
    hparams->type = 54;
  } else if (params->quality < 5) {
    hparams->type = params->quality;
  } else if (params->lgwin <= 16) {
    hparams->type = params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
  } else if (params->size_hint >= (1 << 20) && params->lgwin >= 19) {
#if defined(BROTLI_MAX_SIMD_QUALITY)
    hparams->type = params->quality <= BROTLI_MAX_SIMD_QUALITY ? 68 : 6;
#else
    hparams->type = 6;
#endif
    hparams->block_bits = params->quality - 1;
    hparams->bucket_bits = 15;
    hparams->num_last_distances_to_check =
        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
  } else {
    /* TODO(eustas): often previous setting (H6) is faster and denser; consider
                     adding an option to use it. */
#if defined(BROTLI_MAX_SIMD_QUALITY)
    hparams->type = params->quality <= BROTLI_MAX_SIMD_QUALITY ? 58 : 5;
#else
    hparams->type = 5;
#endif
    hparams->block_bits = params->quality - 1;
    hparams->bucket_bits = params->quality < 7 ? 14 : 15;
    hparams->num_last_distances_to_check =
        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
  }

if (params->lgwin > 24) {
    /* Different hashers for large window brotli: not for qualities <= 2,
       these are too fast for large window. Not for qualities >= 10: their
       hasher already works well with large window. So the changes are:
       H3 --> H35: for quality 3.
       H54 --> H55: for quality 4 with size hint > 1MB
       H6/H68 --> H65: for qualities 5, 6, 7, 8, 9. */
    if (hparams->type == 3) {
      hparams->type = 35;
    }
    if (hparams->type == 54) {
      hparams->type = 55;
    }
    if (hparams->type == 6 || hparams->type == 68) {
      hparams->type = 65;
    }
  }
}

#endif  /* BROTLI_ENC_QUALITY_H_ */

X7ROOT File Manager

Editing: quality.h

Upload File

Create Folder