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 <brotli/port.h>
14 #include <brotli/types.h>
15 #include "./fast_log.h"
16 #include "./prefix.h"
17
18 #if defined(__cplusplus) || defined(c_plusplus)
19 extern "C" {
20 #endif
21
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 };
30
GetInsertLengthCode(size_t insertlen)31 static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
32 if (insertlen < 6) {
33 return (uint16_t)insertlen;
34 } else if (insertlen < 130) {
35 uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
36 return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
37 } else if (insertlen < 2114) {
38 return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
39 } else if (insertlen < 6210) {
40 return 21u;
41 } else if (insertlen < 22594) {
42 return 22u;
43 } else {
44 return 23u;
45 }
46 }
47
GetCopyLengthCode(size_t copylen)48 static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
49 if (copylen < 10) {
50 return (uint16_t)(copylen - 2);
51 } else if (copylen < 134) {
52 uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
53 return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
54 } else if (copylen < 2118) {
55 return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
56 } else {
57 return 23u;
58 }
59 }
60
CombineLengthCodes(uint16_t inscode,uint16_t copycode,BROTLI_BOOL use_last_distance)61 static BROTLI_INLINE uint16_t CombineLengthCodes(
62 uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
63 uint16_t bits64 =
64 (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3));
65 if (use_last_distance && inscode < 8 && copycode < 16) {
66 return (copycode < 8) ? bits64 : (bits64 | 64);
67 } else {
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;
79 }
80 }
81
GetLengthCode(size_t insertlen,size_t copylen,BROTLI_BOOL use_last_distance,uint16_t * code)82 static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
83 BROTLI_BOOL use_last_distance,
84 uint16_t* code) {
85 uint16_t inscode = GetInsertLengthCode(insertlen);
86 uint16_t copycode = GetCopyLengthCode(copylen);
87 *code = CombineLengthCodes(inscode, copycode, use_last_distance);
88 }
89
GetInsertBase(uint16_t inscode)90 static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
91 return kInsBase[inscode];
92 }
93
GetInsertExtra(uint16_t inscode)94 static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
95 return kInsExtra[inscode];
96 }
97
GetCopyBase(uint16_t copycode)98 static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
99 return kCopyBase[copycode];
100 }
101
GetCopyExtra(uint16_t copycode)102 static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
103 return kCopyExtra[copycode];
104 }
105
106 typedef struct Command {
107 uint32_t insert_len_;
108 /* Stores copy_len in low 24 bits and copy_len XOR copy_code in high 8 bit. */
109 uint32_t copy_len_;
110 uint32_t dist_extra_;
111 uint16_t cmd_prefix_;
112 uint16_t dist_prefix_;
113 } Command;
114
115 /* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
InitCommand(Command * self,size_t insertlen,size_t copylen,int copylen_code_delta,size_t distance_code)116 static BROTLI_INLINE void InitCommand(Command* self, size_t insertlen,
117 size_t copylen, int copylen_code_delta, size_t distance_code) {
118 /* Don't rely on signed int representation, use honest casts. */
119 uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
120 self->insert_len_ = (uint32_t)insertlen;
121 self->copy_len_ = (uint32_t)(copylen | (delta << 24));
122 /* The distance prefix and extra bits are stored in this Command as if
123 npostfix and ndirect were 0, they are only recomputed later after the
124 clustering if needed. */
125 PrefixEncodeCopyDistance(
126 distance_code, 0, 0, &self->dist_prefix_, &self->dist_extra_);
127 GetLengthCode(
128 insertlen, (size_t)((int)copylen + copylen_code_delta),
129 TO_BROTLI_BOOL(self->dist_prefix_ == 0), &self->cmd_prefix_);
130 }
131
InitInsertCommand(Command * self,size_t insertlen)132 static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
133 self->insert_len_ = (uint32_t)insertlen;
134 self->copy_len_ = 4 << 24;
135 self->dist_extra_ = 0;
136 self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
137 GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
138 }
139
CommandRestoreDistanceCode(const Command * self)140 static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(const Command* self) {
141 if (self->dist_prefix_ < BROTLI_NUM_DISTANCE_SHORT_CODES) {
142 return self->dist_prefix_;
143 } else {
144 uint32_t nbits = self->dist_extra_ >> 24;
145 uint32_t extra = self->dist_extra_ & 0xffffff;
146 /* It is assumed that the distance was first encoded with NPOSTFIX = 0 and
147 NDIRECT = 0, so the code itself is of this form:
148 BROTLI_NUM_DISTANCE_SHORT_CODES + 2 * (nbits - 1) + prefix_bit
149 Therefore, the following expression results in (2 + prefix_bit). */
150 uint32_t prefix =
151 self->dist_prefix_ + 4u - BROTLI_NUM_DISTANCE_SHORT_CODES - 2u * nbits;
152 /* Subtract 4 for offset (Chapter 4.) and
153 increase by BROTLI_NUM_DISTANCE_SHORT_CODES - 1 */
154 return (prefix << nbits) + extra + BROTLI_NUM_DISTANCE_SHORT_CODES - 4u;
155 }
156 }
157
CommandDistanceContext(const Command * self)158 static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
159 uint32_t r = self->cmd_prefix_ >> 6;
160 uint32_t c = self->cmd_prefix_ & 7;
161 if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
162 return c;
163 }
164 return 3;
165 }
166
CommandCopyLen(const Command * self)167 static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
168 return self->copy_len_ & 0xFFFFFF;
169 }
170
CommandCopyLenCode(const Command * self)171 static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
172 int32_t delta = (int8_t)((uint8_t)(self->copy_len_ >> 24));
173 return (uint32_t)((int32_t)(self->copy_len_ & 0xFFFFFF) + delta);
174 }
175
176 #if defined(__cplusplus) || defined(c_plusplus)
177 } /* extern "C" */
178 #endif
179
180 #endif /* BROTLI_ENC_COMMAND_H_ */
181