Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/brotli/c/enc/hash_longest_match_inc.h @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /* NOLINT(build/header_guard) */
2 /* Copyright 2010 Google Inc. All Rights Reserved.
3
4 Distributed under MIT license.
5 See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
6 */
7
8 /* template parameters: FN */
9
10 /* A (forgetful) hash table to the data seen by the compressor, to
11 help create backward references to previous data.
12
13 This is a hash map of fixed size (bucket_size_) to a ring buffer of
14 fixed size (block_size_). The ring buffer contains the last block_size_
15 index positions of the given hash key in the compressed data. */
16
17 #define HashLongestMatch HASHER()
18
19 static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
20 static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
21
22 /* HashBytes is the function that chooses the bucket to place the address in. */
23 static uint32_t FN(HashBytes)(
24 const uint8_t* BROTLI_RESTRICT data, const int shift) {
25 uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
26 /* The higher bits contain more mixture from the multiplication,
27 so we take our results from there. */
28 return (uint32_t)(h >> shift);
29 }
30
31 typedef struct HashLongestMatch {
32 /* Number of hash buckets. */
33 size_t bucket_size_;
34 /* Only block_size_ newest backward references are kept,
35 and the older are forgotten. */
36 size_t block_size_;
37 /* Left-shift for computing hash bucket index from hash value. */
38 int hash_shift_;
39 /* Mask for accessing entries in a block (in a ring-buffer manner). */
40 uint32_t block_mask_;
41
42 int block_bits_;
43 int num_last_distances_to_check_;
44
45 /* Shortcuts. */
46 HasherCommon* common_;
47
48 /* --- Dynamic size members --- */
49
50 /* Number of entries in a particular bucket. */
51 uint16_t* num_; /* uint16_t[bucket_size]; */
52
53 /* Buckets containing block_size_ of backward references. */
54 uint32_t* buckets_; /* uint32_t[bucket_size * block_size]; */
55 } HashLongestMatch;
56
57 static void FN(Initialize)(
58 HasherCommon* common, HashLongestMatch* BROTLI_RESTRICT self,
59 const BrotliEncoderParams* params) {
60 self->common_ = common;
61
62 BROTLI_UNUSED(params);
63 self->hash_shift_ = 32 - common->params.bucket_bits;
64 self->bucket_size_ = (size_t)1 << common->params.bucket_bits;
65 self->block_size_ = (size_t)1 << common->params.block_bits;
66 self->block_mask_ = (uint32_t)(self->block_size_ - 1);
67 self->num_ = (uint16_t*)common->extra[0];
68 self->buckets_ = (uint32_t*)common->extra[1];
69 self->block_bits_ = common->params.block_bits;
70 self->num_last_distances_to_check_ =
71 common->params.num_last_distances_to_check;
72 }
73
74 static void FN(Prepare)(
75 HashLongestMatch* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
76 size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
77 uint16_t* BROTLI_RESTRICT num = self->num_;
78 /* Partial preparation is 100 times slower (per socket). */
79 size_t partial_prepare_threshold = self->bucket_size_ >> 6;
80 if (one_shot && input_size <= partial_prepare_threshold) {
81 size_t i;
82 for (i = 0; i < input_size; ++i) {
83 const uint32_t key = FN(HashBytes)(&data[i], self->hash_shift_);
84 num[key] = 0;
85 }
86 } else {
87 memset(num, 0, self->bucket_size_ * sizeof(num[0]));
88 }
89 }
90
91 static BROTLI_INLINE void FN(HashMemAllocInBytes)(
92 const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
93 size_t input_size, size_t* alloc_size) {
94 size_t bucket_size = (size_t)1 << params->hasher.bucket_bits;
95 size_t block_size = (size_t)1 << params->hasher.block_bits;
96 BROTLI_UNUSED(one_shot);
97 BROTLI_UNUSED(input_size);
98 alloc_size[0] = sizeof(uint16_t) * bucket_size;
99 alloc_size[1] = sizeof(uint32_t) * bucket_size * block_size;
100 }
101
102 /* Look at 4 bytes at &data[ix & mask].
103 Compute a hash from these, and store the value of ix at that position. */
104 static BROTLI_INLINE void FN(Store)(
105 HashLongestMatch* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
106 const size_t mask, const size_t ix) {
107 uint16_t* BROTLI_RESTRICT num = self->num_;
108 uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
109 const uint32_t key = FN(HashBytes)(&data[ix & mask], self->hash_shift_);
110 const size_t minor_ix = num[key] & self->block_mask_;
111 const size_t offset = minor_ix + (key << self->block_bits_);
112 ++num[key];
113 buckets[offset] = (uint32_t)ix;
114 }
115
116 static BROTLI_INLINE void FN(StoreRange)(HashLongestMatch* BROTLI_RESTRICT self,
117 const uint8_t* BROTLI_RESTRICT data, const size_t mask,
118 const size_t ix_start, const size_t ix_end) {
119 size_t i;
120 for (i = ix_start; i < ix_end; ++i) {
121 FN(Store)(self, data, mask, i);
122 }
123 }
124
125 static BROTLI_INLINE void FN(StitchToPreviousBlock)(
126 HashLongestMatch* BROTLI_RESTRICT self,
127 size_t num_bytes, size_t position, const uint8_t* ringbuffer,
128 size_t ringbuffer_mask) {
129 if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
130 /* Prepare the hashes for three last bytes of the last write.
131 These could not be calculated before, since they require knowledge
132 of both the previous and the current block. */
133 FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
134 FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
135 FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
136 }
137 }
138
139 static BROTLI_INLINE void FN(PrepareDistanceCache)(
140 HashLongestMatch* BROTLI_RESTRICT self,
141 int* BROTLI_RESTRICT distance_cache) {
142 PrepareDistanceCache(distance_cache, self->num_last_distances_to_check_);
143 }
144
145 /* Find a longest backward match of &data[cur_ix] up to the length of
146 max_length and stores the position cur_ix in the hash table.
147
148 REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
149 values; if this method is invoked repeatedly with the same distance
150 cache values, it is enough to invoke FN(PrepareDistanceCache) once.
151
152 Does not look for matches longer than max_length.
153 Does not look for matches further away than max_backward.
154 Writes the best match into |out|.
155 |out|->score is updated only if a better match is found. */
156 static BROTLI_INLINE void FN(FindLongestMatch)(
157 HashLongestMatch* BROTLI_RESTRICT self,
158 const BrotliEncoderDictionary* dictionary,
159 const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
160 const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
161 const size_t max_length, const size_t max_backward,
162 const size_t dictionary_distance, const size_t max_distance,
163 HasherSearchResult* BROTLI_RESTRICT out) {
164 uint16_t* BROTLI_RESTRICT num = self->num_;
165 uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
166 const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
167 /* Don't accept a short copy from far away. */
168 score_t min_score = out->score;
169 score_t best_score = out->score;
170 size_t best_len = out->len;
171 size_t i;
172 /* Precalculate the hash key and prefetch the bucket. */
173 const uint32_t key =
174 FN(HashBytes)(&data[cur_ix_masked], self->hash_shift_);
175 uint32_t* BROTLI_RESTRICT bucket = &buckets[key << self->block_bits_];
176 PREFETCH_L1(bucket);
177 if (self->block_bits_ > 4) PREFETCH_L1(bucket + 16);
178 out->len = 0;
179 out->len_code_delta = 0;
180
181 BROTLI_DCHECK(cur_ix_masked + max_length <= ring_buffer_mask);
182
183 /* Try last distance first. */
184 for (i = 0; i < (size_t)self->num_last_distances_to_check_; ++i) {
185 const size_t backward = (size_t)distance_cache[i];
186 size_t prev_ix = (size_t)(cur_ix - backward);
187 if (prev_ix >= cur_ix) {
188 continue;
189 }
190 if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
191 continue;
192 }
193 prev_ix &= ring_buffer_mask;
194
195 if (cur_ix_masked + best_len > ring_buffer_mask) {
196 break;
197 }
198 if (prev_ix + best_len > ring_buffer_mask ||
199 data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
200 continue;
201 }
202 {
203 const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
204 &data[cur_ix_masked],
205 max_length);
206 if (len >= 3 || (len == 2 && i < 2)) {
207 /* Comparing for >= 2 does not change the semantics, but just saves for
208 a few unnecessary binary logarithms in backward reference score,
209 since we are not interested in such short matches. */
210 score_t score = BackwardReferenceScoreUsingLastDistance(len);
211 if (best_score < score) {
212 if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
213 if (best_score < score) {
214 best_score = score;
215 best_len = len;
216 out->len = best_len;
217 out->distance = backward;
218 out->score = best_score;
219 }
220 }
221 }
222 }
223 }
224 /* we require matches of len >4, so increase best_len to 3, so we can compare
225 * 4 bytes all the time. */
226 if (best_len < 3) {
227 best_len = 3;
228 }
229 {
230 const size_t down =
231 (num[key] > self->block_size_) ? (num[key] - self->block_size_) : 0u;
232 for (i = num[key]; i > down;) {
233 size_t prev_ix = bucket[--i & self->block_mask_];
234 const size_t backward = cur_ix - prev_ix;
235 if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
236 break;
237 }
238 prev_ix &= ring_buffer_mask;
239 if (cur_ix_masked + best_len > ring_buffer_mask) {
240 break;
241 }
242 if (prev_ix + best_len > ring_buffer_mask ||
243 /* compare 4 bytes ending at best_len + 1 */
244 BrotliUnalignedRead32(&data[cur_ix_masked + best_len - 3]) !=
245 BrotliUnalignedRead32(&data[prev_ix + best_len - 3])) {
246 continue;
247 }
248 {
249 const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
250 &data[cur_ix_masked],
251 max_length);
252 if (len >= 4) {
253 /* Comparing for >= 3 does not change the semantics, but just saves
254 for a few unnecessary binary logarithms in backward reference
255 score, since we are not interested in such short matches. */
256 score_t score = BackwardReferenceScore(len, backward);
257 if (best_score < score) {
258 best_score = score;
259 best_len = len;
260 out->len = best_len;
261 out->distance = backward;
262 out->score = best_score;
263 }
264 }
265 }
266 }
267 bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
268 ++num[key];
269 }
270 if (min_score == out->score) {
271 SearchInStaticDictionary(dictionary,
272 self->common_, &data[cur_ix_masked], max_length, dictionary_distance,
273 max_distance, out, BROTLI_FALSE);
274 }
275 }
276
277 #undef HashLongestMatch