Index: third_party/brotli/enc/command.h |
diff --git a/third_party/brotli/enc/command.h b/third_party/brotli/enc/command.h |
index b5cc872bfca44a58bdb12e79705e2b9d56f1a067..d4a301967e41c3993d03b93aeebdcf4bdbc7b7af 100644 |
--- a/third_party/brotli/enc/command.h |
+++ b/third_party/brotli/enc/command.h |
@@ -4,16 +4,20 @@ |
See file LICENSE for detail or copy at https://opensource.org/licenses/MIT |
*/ |
-// This class models a sequence of literals and a backward reference copy. |
+/* This class models a sequence of literals and a backward reference copy. */ |
#ifndef BROTLI_ENC_COMMAND_H_ |
#define BROTLI_ENC_COMMAND_H_ |
+#include "../common/constants.h" |
+#include <brotli/port.h> |
+#include <brotli/types.h> |
#include "./fast_log.h" |
#include "./prefix.h" |
-#include "./types.h" |
-namespace brotli { |
+#if defined(__cplusplus) || defined(c_plusplus) |
+extern "C" { |
+#endif |
static uint32_t kInsBase[] = { 0, 1, 2, 3, 4, 5, 6, 8, 10, 14, 18, 26, 34, 50, |
66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594 }; |
@@ -24,15 +28,14 @@ static uint32_t kCopyBase[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30, |
static uint32_t kCopyExtra[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, |
4, 4, 5, 5, 6, 7, 8, 9, 10, 24 }; |
-static inline uint16_t GetInsertLengthCode(size_t insertlen) { |
+static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) { |
if (insertlen < 6) { |
- return static_cast<uint16_t>(insertlen); |
+ return (uint16_t)insertlen; |
} else if (insertlen < 130) { |
- insertlen -= 2; |
- uint32_t nbits = Log2FloorNonZero(insertlen) - 1u; |
- return static_cast<uint16_t>((nbits << 1) + (insertlen >> nbits) + 2); |
+ uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u; |
+ return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2); |
} else if (insertlen < 2114) { |
- return static_cast<uint16_t>(Log2FloorNonZero(insertlen - 66) + 10); |
+ return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10); |
} else if (insertlen < 6210) { |
return 21u; |
} else if (insertlen < 22594) { |
@@ -42,115 +45,127 @@ static inline uint16_t GetInsertLengthCode(size_t insertlen) { |
} |
} |
-static inline uint16_t GetCopyLengthCode(size_t copylen) { |
+static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) { |
if (copylen < 10) { |
- return static_cast<uint16_t>(copylen - 2); |
+ return (uint16_t)(copylen - 2); |
} else if (copylen < 134) { |
- copylen -= 6; |
- uint32_t nbits = Log2FloorNonZero(copylen) - 1u; |
- return static_cast<uint16_t>((nbits << 1) + (copylen >> nbits) + 4); |
+ uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u; |
+ return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4); |
} else if (copylen < 2118) { |
- return static_cast<uint16_t>(Log2FloorNonZero(copylen - 70) + 12); |
+ return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12); |
} else { |
return 23u; |
} |
} |
-static inline uint16_t CombineLengthCodes( |
- uint16_t inscode, uint16_t copycode, bool use_last_distance) { |
+static BROTLI_INLINE uint16_t CombineLengthCodes( |
+ uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) { |
uint16_t bits64 = |
- static_cast<uint16_t>((copycode & 0x7u) | ((inscode & 0x7u) << 3)); |
+ (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3)); |
if (use_last_distance && inscode < 8 && copycode < 16) { |
return (copycode < 8) ? bits64 : (bits64 | 64); |
} else { |
- // "To convert an insert-and-copy length code to an insert length code and |
- // a copy length code, the following table can be used" |
+ /* "To convert an insert-and-copy length code to an insert length code and |
+ a copy length code, the following table can be used" */ |
static const uint16_t cells[9] = { 128u, 192u, 384u, 256u, 320u, 512u, |
448u, 576u, 640u }; |
return cells[(copycode >> 3) + 3 * (inscode >> 3)] | bits64; |
} |
} |
-static inline void GetLengthCode(size_t insertlen, size_t copylen, |
- bool use_last_distance, |
- uint16_t* code) { |
+static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen, |
+ BROTLI_BOOL use_last_distance, |
+ uint16_t* code) { |
uint16_t inscode = GetInsertLengthCode(insertlen); |
uint16_t copycode = GetCopyLengthCode(copylen); |
*code = CombineLengthCodes(inscode, copycode, use_last_distance); |
} |
-static inline uint32_t GetInsertBase(uint16_t inscode) { |
+static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) { |
return kInsBase[inscode]; |
} |
-static inline uint32_t GetInsertExtra(uint16_t inscode) { |
+static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) { |
return kInsExtra[inscode]; |
} |
-static inline uint32_t GetCopyBase(uint16_t copycode) { |
+static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) { |
return kCopyBase[copycode]; |
} |
-static inline uint32_t GetCopyExtra(uint16_t copycode) { |
+static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) { |
return kCopyExtra[copycode]; |
} |
-struct Command { |
- // distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. |
- Command(size_t insertlen, size_t copylen, size_t copylen_code, |
- size_t distance_code) |
- : insert_len_(static_cast<uint32_t>(insertlen)) { |
- copy_len_ = static_cast<uint32_t>( |
- copylen | ((copylen_code ^ copylen) << 24)); |
- // The distance prefix and extra bits are stored in this Command as if |
- // npostfix and ndirect were 0, they are only recomputed later after the |
- // clustering if needed. |
- PrefixEncodeCopyDistance(distance_code, 0, 0, &dist_prefix_, &dist_extra_); |
- GetLengthCode(insertlen, copylen_code, dist_prefix_ == 0, |
- &cmd_prefix_); |
- } |
- |
- explicit Command(size_t insertlen) |
- : insert_len_(static_cast<uint32_t>(insertlen)) |
- , copy_len_(4 << 24), dist_extra_(0), dist_prefix_(16) { |
- GetLengthCode(insertlen, 4, dist_prefix_ == 0, &cmd_prefix_); |
- } |
+typedef struct Command { |
+ uint32_t insert_len_; |
+ /* Stores copy_len in low 24 bits and copy_len XOR copy_code in high 8 bit. */ |
+ uint32_t copy_len_; |
+ uint32_t dist_extra_; |
+ uint16_t cmd_prefix_; |
+ uint16_t dist_prefix_; |
+} Command; |
+ |
+/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */ |
+static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen, |
+ size_t copylen, size_t copylen_code, size_t distance_code) { |
+ self->insert_len_ = (uint32_t)insertlen; |
+ self->copy_len_ = (uint32_t)(copylen | ((copylen_code ^ copylen) << 24)); |
+ /* The distance prefix and extra bits are stored in this Command as if |
+ npostfix and ndirect were 0, they are only recomputed later after the |
+ clustering if needed. */ |
+ PrefixEncodeCopyDistance( |
+ distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_); |
+ GetLengthCode( |
+ insertlen, copylen_code, TO_BROTLI_BOOL(self->dist_prefix_ == 0), |
+ &self->cmd_prefix_); |
+} |
- uint32_t DistanceCode(void) const { |
- if (dist_prefix_ < 16) { |
- return dist_prefix_; |
- } |
- uint32_t nbits = dist_extra_ >> 24; |
- uint32_t extra = dist_extra_ & 0xffffff; |
- uint32_t prefix = dist_prefix_ - 12 - 2 * nbits; |
- return (prefix << nbits) + extra + 12; |
- } |
+static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) { |
+ self->insert_len_ = (uint32_t)insertlen; |
+ self->copy_len_ = 4 << 24; |
+ self->dist_extra_ = 0; |
+ self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES; |
+ GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_); |
+} |
- uint32_t DistanceContext(void) const { |
- uint32_t r = cmd_prefix_ >> 6; |
- uint32_t c = cmd_prefix_ & 7; |
- if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) { |
- return c; |
- } |
- return 3; |
+static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(const Command* self) { |
+ if (self->dist_prefix_ < BROTLI_NUM_DISTANCE_SHORT_CODES) { |
+ return self->dist_prefix_; |
+ } else { |
+ uint32_t nbits = self->dist_extra_ >> 24; |
+ uint32_t extra = self->dist_extra_ & 0xffffff; |
+ /* It is assumed that the distance was first encoded with NPOSTFIX = 0 and |
+ NDIRECT = 0, so the code itself is of this form: |
+ BROTLI_NUM_DISTANCE_SHORT_CODES + 2 * (nbits - 1) + prefix_bit |
+ Therefore, the following expression results in (2 + prefix_bit). */ |
+ uint32_t prefix = |
+ self->dist_prefix_ + 4u - BROTLI_NUM_DISTANCE_SHORT_CODES - 2u * nbits; |
+ /* Subtract 4 for offset (Chapter 4.) and |
+ increase by BROTLI_NUM_DISTANCE_SHORT_CODES - 1 */ |
+ return (prefix << nbits) + extra + BROTLI_NUM_DISTANCE_SHORT_CODES - 4u; |
} |
+} |
- inline uint32_t copy_len(void) const { |
- return copy_len_ & 0xFFFFFF; |
+static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) { |
+ uint32_t r = self->cmd_prefix_ >> 6; |
+ uint32_t c = self->cmd_prefix_ & 7; |
+ if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) { |
+ return c; |
} |
+ return 3; |
+} |
- inline uint32_t copy_len_code(void) const { |
- return (copy_len_ & 0xFFFFFF) ^ (copy_len_ >> 24); |
- } |
+static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) { |
+ return self->copy_len_ & 0xFFFFFF; |
+} |
- uint32_t insert_len_; |
- /* Stores copy_len in low 24 bits and copy_len XOR copy_code in high 8 bit. */ |
- uint32_t copy_len_; |
- uint32_t dist_extra_; |
- uint16_t cmd_prefix_; |
- uint16_t dist_prefix_; |
-}; |
+static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) { |
+ return (self->copy_len_ & 0xFFFFFF) ^ (self->copy_len_ >> 24); |
+} |
-} // namespace brotli |
+#if defined(__cplusplus) || defined(c_plusplus) |
+} /* extern "C" */ |
+#endif |
-#endif // BROTLI_ENC_COMMAND_H_ |
+#endif /* BROTLI_ENC_COMMAND_H_ */ |