Home | History | Annotate | Download | only in enc 
      1 /* Copyright 2016 Google Inc. All Rights Reserved.
      2 
      3    Distributed under MIT license.
      4    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
      5 */
      6 
      7 /* Constants and formulas that affect speed-ratio trade-offs and thus define
      8    quality levels. */
      9 
     10 #ifndef BROTLI_ENC_QUALITY_H_
     11 #define BROTLI_ENC_QUALITY_H_
     12 
     13 #include "../common/platform.h"
     14 #include <brotli/encode.h>
     15 #include "./params.h"
     16 
     17 #define FAST_ONE_PASS_COMPRESSION_QUALITY 0
     18 #define FAST_TWO_PASS_COMPRESSION_QUALITY 1
     19 #define ZOPFLIFICATION_QUALITY 10
     20 #define HQ_ZOPFLIFICATION_QUALITY 11
     21 
     22 #define MAX_QUALITY_FOR_STATIC_ENTROPY_CODES 2
     23 #define MIN_QUALITY_FOR_BLOCK_SPLIT 4
     24 #define MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS 4
     25 #define MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS 4
     26 #define MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH 5
     27 #define MIN_QUALITY_FOR_CONTEXT_MODELING 5
     28 #define MIN_QUALITY_FOR_HQ_CONTEXT_MODELING 7
     29 #define MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING 10
     30 
     31 /* For quality below MIN_QUALITY_FOR_BLOCK_SPLIT there is no block splitting,
     32    so we buffer at most this much literals and commands. */
     33 #define MAX_NUM_DELAYED_SYMBOLS 0x2FFF
     34 
     35 /* Returns hash-table size for quality levels 0 and 1. */
     36 static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
     37   return quality == FAST_ONE_PASS_COMPRESSION_QUALITY ? 1 << 15 : 1 << 17;
     38 }
     39 
     40 /* The maximum length for which the zopflification uses distinct distances. */
     41 #define MAX_ZOPFLI_LEN_QUALITY_10 150
     42 #define MAX_ZOPFLI_LEN_QUALITY_11 325
     43 
     44 /* Do not thoroughly search when a long copy is found. */
     45 #define BROTLI_LONG_COPY_QUICK_STEP 16384
     46 
     47 static BROTLI_INLINE size_t MaxZopfliLen(const BrotliEncoderParams* params) {
     48   return params->quality <= 10 ?
     49       MAX_ZOPFLI_LEN_QUALITY_10 :
     50       MAX_ZOPFLI_LEN_QUALITY_11;
     51 }
     52 
     53 /* Number of best candidates to evaluate to expand Zopfli chain. */
     54 static BROTLI_INLINE size_t MaxZopfliCandidates(
     55   const BrotliEncoderParams* params) {
     56   return params->quality <= 10 ? 1 : 5;
     57 }
     58 
     59 static BROTLI_INLINE void SanitizeParams(BrotliEncoderParams* params) {
     60   params->quality = BROTLI_MIN(int, BROTLI_MAX_QUALITY,
     61       BROTLI_MAX(int, BROTLI_MIN_QUALITY, params->quality));
     62   if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
     63     params->large_window = BROTLI_FALSE;
     64   }
     65   if (params->lgwin < BROTLI_MIN_WINDOW_BITS) {
     66     params->lgwin = BROTLI_MIN_WINDOW_BITS;
     67   } else {
     68     int max_lgwin = params->large_window ? BROTLI_LARGE_MAX_WINDOW_BITS :
     69                                            BROTLI_MAX_WINDOW_BITS;
     70     if (params->lgwin > max_lgwin) params->lgwin = max_lgwin;
     71   }
     72 }
     73 
     74 /* Returns optimized lg_block value. */
     75 static BROTLI_INLINE int ComputeLgBlock(const BrotliEncoderParams* params) {
     76   int lgblock = params->lgblock;
     77   if (params->quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
     78       params->quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
     79     lgblock = params->lgwin;
     80   } else if (params->quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
     81     lgblock = 14;
     82   } else if (lgblock == 0) {
     83     lgblock = 16;
     84     if (params->quality >= 9 && params->lgwin > lgblock) {
     85       lgblock = BROTLI_MIN(int, 18, params->lgwin);
     86     }
     87   } else {
     88     lgblock = BROTLI_MIN(int, BROTLI_MAX_INPUT_BLOCK_BITS,
     89         BROTLI_MAX(int, BROTLI_MIN_INPUT_BLOCK_BITS, lgblock));
     90   }
     91   return lgblock;
     92 }
     93 
     94 /* Returns log2 of the size of main ring buffer area.
     95    Allocate at least lgwin + 1 bits for the ring buffer so that the newly
     96    added block fits there completely and we still get lgwin bits and at least
     97    read_block_size_bits + 1 bits because the copy tail length needs to be
     98    smaller than ring-buffer size. */
     99 static BROTLI_INLINE int ComputeRbBits(const BrotliEncoderParams* params) {
    100   return 1 + BROTLI_MAX(int, params->lgwin, params->lgblock);
    101 }
    102 
    103 static BROTLI_INLINE size_t MaxMetablockSize(
    104     const BrotliEncoderParams* params) {
    105   int bits =
    106       BROTLI_MIN(int, ComputeRbBits(params), BROTLI_MAX_INPUT_BLOCK_BITS);
    107   return (size_t)1 << bits;
    108 }
    109 
    110 /* When searching for backward references and have not seen matches for a long
    111    time, we can skip some match lookups. Unsuccessful match lookups are very
    112    expensive and this kind of a heuristic speeds up compression quite a lot.
    113    At first 8 byte strides are taken and every second byte is put to hasher.
    114    After 4x more literals stride by 16 bytes, every put 4-th byte to hasher.
    115    Applied only to qualities 2 to 9. */
    116 static BROTLI_INLINE size_t LiteralSpreeLengthForSparseSearch(
    117     const BrotliEncoderParams* params) {
    118   return params->quality < 9 ? 64 : 512;
    119 }
    120 
    121 static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
    122                                        BrotliHasherParams* hparams) {
    123   if (params->quality > 9) {
    124     hparams->type = 10;
    125   } else if (params->quality == 4 && params->size_hint >= (1 << 20)) {
    126     hparams->type = 54;
    127   } else if (params->quality < 5) {
    128     hparams->type = params->quality;
    129   } else if (params->lgwin <= 16) {
    130     hparams->type = params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
    131   } else if (params->size_hint >= (1 << 20) && params->lgwin >= 19) {
    132     hparams->type = 6;
    133     hparams->block_bits = params->quality - 1;
    134     hparams->bucket_bits = 15;
    135     hparams->hash_len = 5;
    136     hparams->num_last_distances_to_check =
    137         params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
    138   } else {
    139     hparams->type = 5;
    140     hparams->block_bits = params->quality - 1;
    141     hparams->bucket_bits = params->quality < 7 ? 14 : 15;
    142     hparams->num_last_distances_to_check =
    143         params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
    144   }
    145 
    146   if (params->lgwin > 24) {
    147     /* Different hashers for large window brotli: not for qualities <= 2,
    148        these are too fast for large window. Not for qualities >= 10: their
    149        hasher already works well with large window. So the changes are:
    150        H3 --> H35: for quality 3.
    151        H54 --> H55: for quality 4 with size hint > 1MB
    152        H6 --> H65: for qualities 5, 6, 7, 8, 9. */
    153     if (hparams->type == 3) {
    154       hparams->type = 35;
    155     }
    156     if (hparams->type == 54) {
    157       hparams->type = 55;
    158     }
    159     if (hparams->type == 6) {
    160       hparams->type = 65;
    161     }
    162   }
    163 }
    164 
    165 #endif  /* BROTLI_ENC_QUALITY_H_ */
    166