BaseTools/Source/C/BrotliCompress/enc/command.h

   1 /* Copyright 2013 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 /* This class models a sequence of literals and a backward reference copy. */
   8
   9 #ifndef BROTLI_ENC_COMMAND_H_
  10 #define BROTLI_ENC_COMMAND_H_
  11
  12 #include "../common/constants.h"
  13 #include "../common/platform.h"
  14 #include <brotli/types.h>
  15 #include "./fast_log.h"
  16 #include "./params.h"
  17 #include "./prefix.h"
  18
  19 #if defined(__cplusplus) || defined(c_plusplus)
  20 extern "C" {
  21 #endif
  22
  23 static uint32_t kInsBase[] =   { 0, 1, 2, 3, 4, 5, 6, 8, 10, 14, 18, 26, 34, 50,
  24     66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594 };
  25 static uint32_t kInsExtra[] =  { 0, 0, 0, 0, 0, 0, 1, 1,  2,  2,  3,  3,  4,  4,
  26     5,   5,   6,   7,   8,   9,   10,   12,   14,    24 };
  27 static uint32_t kCopyBase[] =  { 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30,
  28     38, 54,  70, 102, 134, 198, 326,   582, 1094,  2118 };
  29 static uint32_t kCopyExtra[] = { 0, 0, 0, 0, 0, 0, 0, 0,  1,  1,  2,  2,  3,  3,
  30      4,  4,   5,   5,   6,   7,   8,     9,   10,    24 };
  31
  32 static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
  33   if (insertlen < 6) {
  34     return (uint16_t)insertlen;
  35   } else if (insertlen < 130) {
  36     uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
  37     return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
  38   } else if (insertlen < 2114) {
  39     return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
  40   } else if (insertlen < 6210) {
  41     return 21u;
  42   } else if (insertlen < 22594) {
  43     return 22u;
  44   } else {
  45     return 23u;
  46   }
  47 }
  48
  49 static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
  50   if (copylen < 10) {
  51     return (uint16_t)(copylen - 2);
  52   } else if (copylen < 134) {
  53     uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
  54     return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
  55   } else if (copylen < 2118) {
  56     return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
  57   } else {
  58     return 23u;
  59   }
  60 }
  61
  62 static BROTLI_INLINE uint16_t CombineLengthCodes(
  63     uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
  64   uint16_t bits64 =
  65       (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3u));
  66   if (use_last_distance && inscode < 8u && copycode < 16u) {
  67     return (copycode < 8u) ? bits64 : (bits64 | 64u);
  68   } else {
  69     /* Specification: 5 Encoding of ... (last table) */
  70     /* offset = 2 * index, where index is in range [0..8] */
  71     uint32_t offset = 2u * ((copycode >> 3u) + 3u * (inscode >> 3u));
  72     /* All values in specification are K * 64,
  73        where   K = [2, 3, 6, 4, 5, 8, 7, 9, 10],
  74            i + 1 = [1, 2, 3, 4, 5, 6, 7, 8,  9],
  75        K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1,  2] = D.
  76        All values in D require only 2 bits to encode.
  77        Magic constant is shifted 6 bits left, to avoid final multiplication. */
  78     offset = (offset << 5u) + 0x40u + ((0x520D40u >> offset) & 0xC0u);
  79     return (uint16_t)(offset | bits64);
  80   }
  81 }
  82
  83 static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
  84                                         BROTLI_BOOL use_last_distance,
  85                                         uint16_t* code) {
  86   uint16_t inscode = GetInsertLengthCode(insertlen);
  87   uint16_t copycode = GetCopyLengthCode(copylen);
  88   *code = CombineLengthCodes(inscode, copycode, use_last_distance);
  89 }
  90
  91 static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
  92   return kInsBase[inscode];
  93 }
  94
  95 static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
  96   return kInsExtra[inscode];
  97 }
  98
  99 static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
 100   return kCopyBase[copycode];
 101 }
 102
 103 static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
 104   return kCopyExtra[copycode];
 105 }
 106
 107 typedef struct Command {
 108   uint32_t insert_len_;
 109   /* Stores copy_len in low 25 bits and copy_code - copy_len in high 7 bit. */
 110   uint32_t copy_len_;
 111   /* Stores distance extra bits. */
 112   uint32_t dist_extra_;
 113   uint16_t cmd_prefix_;
 114   /* Stores distance code in low 10 bits
 115      and number of extra bits in high 6 bits. */
 116   uint16_t dist_prefix_;
 117 } Command;
 118
 119 /* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
 120 static BROTLI_INLINE void InitCommand(Command* self,
 121     const BrotliDistanceParams* dist, size_t insertlen,
 122     size_t copylen, int copylen_code_delta, size_t distance_code) {
 123   /* Don't rely on signed int representation, use honest casts. */
 124   uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
 125   self->insert_len_ = (uint32_t)insertlen;
 126   self->copy_len_ = (uint32_t)(copylen | (delta << 25));
 127   /* The distance prefix and extra bits are stored in this Command as if
 128      npostfix and ndirect were 0, they are only recomputed later after the
 129      clustering if needed. */
 130   PrefixEncodeCopyDistance(
 131       distance_code, dist->num_direct_distance_codes,
 132       dist->distance_postfix_bits, &self->dist_prefix_, &self->dist_extra_);
 133   GetLengthCode(
 134       insertlen, (size_t)((int)copylen + copylen_code_delta),
 135       TO_BROTLI_BOOL((self->dist_prefix_ & 0x3FF) == 0), &self->cmd_prefix_);
 136 }
 137
 138 static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
 139   self->insert_len_ = (uint32_t)insertlen;
 140   self->copy_len_ = 4 << 25;
 141   self->dist_extra_ = 0;
 142   self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
 143   GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
 144 }
 145
 146 static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(
 147     const Command* self, const BrotliDistanceParams* dist) {
 148   if ((self->dist_prefix_ & 0x3FFu) <
 149       BROTLI_NUM_DISTANCE_SHORT_CODES + dist->num_direct_distance_codes) {
 150     return self->dist_prefix_ & 0x3FFu;
 151   } else {
 152     uint32_t dcode = self->dist_prefix_ & 0x3FFu;
 153     uint32_t nbits = self->dist_prefix_ >> 10;
 154     uint32_t extra = self->dist_extra_;
 155     uint32_t postfix_mask = (1U << dist->distance_postfix_bits) - 1U;
 156     uint32_t hcode = (dcode - dist->num_direct_distance_codes -
 157         BROTLI_NUM_DISTANCE_SHORT_CODES) >>
 158         dist->distance_postfix_bits;
 159     uint32_t lcode = (dcode - dist->num_direct_distance_codes -
 160         BROTLI_NUM_DISTANCE_SHORT_CODES) & postfix_mask;
 161     uint32_t offset = ((2U + (hcode & 1U)) << nbits) - 4U;
 162     return ((offset + extra) << dist->distance_postfix_bits) + lcode +
 163         dist->num_direct_distance_codes + BROTLI_NUM_DISTANCE_SHORT_CODES;
 164   }
 165 }
 166
 167 static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
 168   uint32_t r = self->cmd_prefix_ >> 6;
 169   uint32_t c = self->cmd_prefix_ & 7;
 170   if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
 171     return c;
 172   }
 173   return 3;
 174 }
 175
 176 static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
 177   return self->copy_len_ & 0x1FFFFFF;
 178 }
 179
 180 static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
 181   uint32_t modifier = self->copy_len_ >> 25;
 182   int32_t delta = (int8_t)((uint8_t)(modifier | ((modifier & 0x40) << 1)));
 183   return (uint32_t)((int32_t)(self->copy_len_ & 0x1FFFFFF) + delta);
 184 }
 185
 186 #if defined(__cplusplus) || defined(c_plusplus)
 187 }  /* extern "C" */
 188 #endif
 189
 190 #endif  /* BROTLI_ENC_COMMAND_H_ */