Eugene Klyuchnikov | 771eb10 | 2015-11-27 11:27:11 +0100 | [diff] [blame] | 1 | /* Copyright 2013 Google Inc. All Rights Reserved. |
| 2 | |
Eugene Klyuchnikov | 24ffa78 | 2015-12-11 11:11:51 +0100 | [diff] [blame] | 3 | Distributed under MIT license. |
Eugene Klyuchnikov | 771eb10 | 2015-11-27 11:27:11 +0100 | [diff] [blame] | 4 | See file LICENSE for detail or copy at https://opensource.org/licenses/MIT |
| 5 | */ |
| 6 | |
Eugene Kliuchnikov | 352b0b2 | 2016-06-03 11:19:23 +0200 | [diff] [blame] | 7 | /* This class models a sequence of literals and a backward reference copy. */ |
Zoltan Szabadka | c66e4e3 | 2013-10-23 13:06:13 +0200 | [diff] [blame] | 8 | |
| 9 | #ifndef BROTLI_ENC_COMMAND_H_ |
| 10 | #define BROTLI_ENC_COMMAND_H_ |
| 11 | |
Eugene Kliuchnikov | 0a63f99 | 2016-09-21 17:20:36 +0200 | [diff] [blame] | 12 | #include "../common/constants.h" |
| 13 | #include <brotli/port.h> |
Eugene Kliuchnikov | 8148001 | 2016-08-23 14:40:33 +0200 | [diff] [blame] | 14 | #include <brotli/types.h> |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 15 | #include "./fast_log.h" |
Lode Vandevenne | 6511d6b | 2015-08-28 16:09:23 +0200 | [diff] [blame] | 16 | #include "./prefix.h" |
Zoltan Szabadka | c66e4e3 | 2013-10-23 13:06:13 +0200 | [diff] [blame] | 17 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 18 | #if defined(__cplusplus) || defined(c_plusplus) |
| 19 | extern "C" { |
| 20 | #endif |
Zoltan Szabadka | c66e4e3 | 2013-10-23 13:06:13 +0200 | [diff] [blame] | 21 | |
Zoltan Szabadka | 8844b7f | 2016-01-07 16:27:49 +0100 | [diff] [blame] | 22 | static uint32_t kInsBase[] = { 0, 1, 2, 3, 4, 5, 6, 8, 10, 14, 18, 26, 34, 50, |
| 23 | 66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594 }; |
| 24 | static uint32_t kInsExtra[] = { 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, |
| 25 | 5, 5, 6, 7, 8, 9, 10, 12, 14, 24 }; |
| 26 | static uint32_t kCopyBase[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 18, 22, 30, |
| 27 | 38, 54, 70, 102, 134, 198, 326, 582, 1094, 2118 }; |
| 28 | static uint32_t kCopyExtra[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, |
| 29 | 4, 4, 5, 5, 6, 7, 8, 9, 10, 24 }; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 30 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 31 | static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) { |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 32 | if (insertlen < 6) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 33 | return (uint16_t)insertlen; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 34 | } else if (insertlen < 130) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 35 | uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u; |
| 36 | return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2); |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 37 | } else if (insertlen < 2114) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 38 | return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10); |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 39 | } else if (insertlen < 6210) { |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 40 | return 21u; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 41 | } else if (insertlen < 22594) { |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 42 | return 22u; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 43 | } else { |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 44 | return 23u; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 45 | } |
| 46 | } |
| 47 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 48 | static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) { |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 49 | if (copylen < 10) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 50 | return (uint16_t)(copylen - 2); |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 51 | } else if (copylen < 134) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 52 | uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u; |
| 53 | return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4); |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 54 | } else if (copylen < 2118) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 55 | return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12); |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 56 | } else { |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 57 | return 23u; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 58 | } |
| 59 | } |
| 60 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 61 | static BROTLI_INLINE uint16_t CombineLengthCodes( |
Eugene Kliuchnikov | 2048189 | 2016-07-26 14:41:59 +0200 | [diff] [blame] | 62 | uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) { |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 63 | uint16_t bits64 = |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 64 | (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3)); |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 65 | if (use_last_distance && inscode < 8 && copycode < 16) { |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 66 | return (copycode < 8) ? bits64 : (bits64 | 64); |
| 67 | } else { |
Eugene Kliuchnikov | cdca91b | 2017-03-06 14:22:45 +0100 | [diff] [blame^] | 68 | /* Specification: 5 Encoding of ... (last table) */ |
| 69 | /* offset = 2 * index, where index is in range [0..8] */ |
| 70 | int offset = 2 * ((copycode >> 3) + 3 * (inscode >> 3)); |
| 71 | /* All values in specification are K * 64, |
| 72 | where K = [2, 3, 6, 4, 5, 8, 7, 9, 10], |
| 73 | i + 1 = [1, 2, 3, 4, 5, 6, 7, 8, 9], |
| 74 | K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1, 2] = D. |
| 75 | All values in D require only 2 bits to encode. |
| 76 | Magic constant is shifted 6 bits left, to avoid final multiplication. */ |
| 77 | offset = (offset << 5) + 0x40 + ((0x520D40 >> offset) & 0xC0); |
| 78 | return (uint16_t)offset | bits64; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 79 | } |
| 80 | } |
| 81 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 82 | static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen, |
Eugene Kliuchnikov | 2048189 | 2016-07-26 14:41:59 +0200 | [diff] [blame] | 83 | BROTLI_BOOL use_last_distance, |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 84 | uint16_t* code) { |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 85 | uint16_t inscode = GetInsertLengthCode(insertlen); |
| 86 | uint16_t copycode = GetCopyLengthCode(copylen); |
Zoltan Szabadka | ea48ce5 | 2015-10-28 17:44:47 +0100 | [diff] [blame] | 87 | *code = CombineLengthCodes(inscode, copycode, use_last_distance); |
Zoltan Szabadka | b820c39 | 2016-03-15 10:50:16 +0100 | [diff] [blame] | 88 | } |
| 89 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 90 | static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) { |
Zoltan Szabadka | b820c39 | 2016-03-15 10:50:16 +0100 | [diff] [blame] | 91 | return kInsBase[inscode]; |
| 92 | } |
| 93 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 94 | static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) { |
Zoltan Szabadka | b820c39 | 2016-03-15 10:50:16 +0100 | [diff] [blame] | 95 | return kInsExtra[inscode]; |
| 96 | } |
| 97 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 98 | static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) { |
Zoltan Szabadka | b820c39 | 2016-03-15 10:50:16 +0100 | [diff] [blame] | 99 | return kCopyBase[copycode]; |
| 100 | } |
| 101 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 102 | static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) { |
Zoltan Szabadka | b820c39 | 2016-03-15 10:50:16 +0100 | [diff] [blame] | 103 | return kCopyExtra[copycode]; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 104 | } |
| 105 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 106 | typedef struct Command { |
Zoltan Szabadka | 8844b7f | 2016-01-07 16:27:49 +0100 | [diff] [blame] | 107 | uint32_t insert_len_; |
Zoltan Szabadka | b820c39 | 2016-03-15 10:50:16 +0100 | [diff] [blame] | 108 | /* Stores copy_len in low 24 bits and copy_len XOR copy_code in high 8 bit. */ |
Zoltan Szabadka | 8844b7f | 2016-01-07 16:27:49 +0100 | [diff] [blame] | 109 | uint32_t copy_len_; |
Zoltan Szabadka | b4f39bf | 2014-10-28 13:25:22 +0100 | [diff] [blame] | 110 | uint32_t dist_extra_; |
Zoltan Szabadka | 14d6ae7 | 2016-01-26 11:25:53 +0100 | [diff] [blame] | 111 | uint16_t cmd_prefix_; |
| 112 | uint16_t dist_prefix_; |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 113 | } Command; |
Zoltan Szabadka | c66e4e3 | 2013-10-23 13:06:13 +0200 | [diff] [blame] | 114 | |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 115 | /* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */ |
| 116 | static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen, |
| 117 | size_t copylen, size_t copylen_code, size_t distance_code) { |
| 118 | self->insert_len_ = (uint32_t)insertlen; |
| 119 | self->copy_len_ = (uint32_t)(copylen | ((copylen_code ^ copylen) << 24)); |
| 120 | /* The distance prefix and extra bits are stored in this Command as if |
| 121 | npostfix and ndirect were 0, they are only recomputed later after the |
| 122 | clustering if needed. */ |
| 123 | PrefixEncodeCopyDistance( |
| 124 | distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_); |
| 125 | GetLengthCode( |
Eugene Kliuchnikov | 2048189 | 2016-07-26 14:41:59 +0200 | [diff] [blame] | 126 | insertlen, copylen_code, TO_BROTLI_BOOL(self->dist_prefix_ == 0), |
| 127 | &self->cmd_prefix_); |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) { |
| 131 | self->insert_len_ = (uint32_t)insertlen; |
| 132 | self->copy_len_ = 4 << 24; |
| 133 | self->dist_extra_ = 0; |
Eugene Kliuchnikov | 0a63f99 | 2016-09-21 17:20:36 +0200 | [diff] [blame] | 134 | self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES; |
Eugene Kliuchnikov | 2048189 | 2016-07-26 14:41:59 +0200 | [diff] [blame] | 135 | GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_); |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 136 | } |
| 137 | |
Eugene Kliuchnikov | 0a63f99 | 2016-09-21 17:20:36 +0200 | [diff] [blame] | 138 | static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(const Command* self) { |
| 139 | if (self->dist_prefix_ < BROTLI_NUM_DISTANCE_SHORT_CODES) { |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 140 | return self->dist_prefix_; |
| 141 | } else { |
| 142 | uint32_t nbits = self->dist_extra_ >> 24; |
| 143 | uint32_t extra = self->dist_extra_ & 0xffffff; |
Eugene Kliuchnikov | 0a63f99 | 2016-09-21 17:20:36 +0200 | [diff] [blame] | 144 | /* It is assumed that the distance was first encoded with NPOSTFIX = 0 and |
| 145 | NDIRECT = 0, so the code itself is of this form: |
| 146 | BROTLI_NUM_DISTANCE_SHORT_CODES + 2 * (nbits - 1) + prefix_bit |
| 147 | Therefore, the following expression results in (2 + prefix_bit). */ |
| 148 | uint32_t prefix = |
| 149 | self->dist_prefix_ + 4u - BROTLI_NUM_DISTANCE_SHORT_CODES - 2u * nbits; |
| 150 | /* Subtract 4 for offset (Chapter 4.) and |
| 151 | increase by BROTLI_NUM_DISTANCE_SHORT_CODES - 1 */ |
| 152 | return (prefix << nbits) + extra + BROTLI_NUM_DISTANCE_SHORT_CODES - 4u; |
Eugene Kliuchnikov | b972c67 | 2016-06-13 11:01:04 +0200 | [diff] [blame] | 153 | } |
| 154 | } |
| 155 | |
| 156 | static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) { |
| 157 | uint32_t r = self->cmd_prefix_ >> 6; |
| 158 | uint32_t c = self->cmd_prefix_ & 7; |
| 159 | if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) { |
| 160 | return c; |
| 161 | } |
| 162 | return 3; |
| 163 | } |
| 164 | |
| 165 | static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) { |
| 166 | return self->copy_len_ & 0xFFFFFF; |
| 167 | } |
| 168 | |
| 169 | static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) { |
| 170 | return (self->copy_len_ & 0xFFFFFF) ^ (self->copy_len_ >> 24); |
| 171 | } |
| 172 | |
| 173 | #if defined(__cplusplus) || defined(c_plusplus) |
| 174 | } /* extern "C" */ |
| 175 | #endif |
Zoltan Szabadka | c66e4e3 | 2013-10-23 13:06:13 +0200 | [diff] [blame] | 176 | |
Eugene Kliuchnikov | 352b0b2 | 2016-06-03 11:19:23 +0200 | [diff] [blame] | 177 | #endif /* BROTLI_ENC_COMMAND_H_ */ |