Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/brotli/c/enc/hash_composite_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 2018 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, HASHER_A, HASHER_B */
9
10 /* Composite hasher: This hasher allows to combine two other hashers, HASHER_A
11 and HASHER_B. */
12
13 #define HashComposite HASHER()
14
15 #define FN_A(X) EXPAND_CAT(X, HASHER_A)
16 #define FN_B(X) EXPAND_CAT(X, HASHER_B)
17
18 static BROTLI_INLINE size_t FN(HashTypeLength)(void) {
19 size_t a = FN_A(HashTypeLength)();
20 size_t b = FN_B(HashTypeLength)();
21 return a > b ? a : b;
22 }
23
24 static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
25 size_t a = FN_A(StoreLookahead)();
26 size_t b = FN_B(StoreLookahead)();
27 return a > b ? a : b;
28 }
29
30 typedef struct HashComposite {
31 HASHER_A ha;
32 HASHER_B hb;
33 HasherCommon ha_common;
34 HasherCommon hb_common;
35
36 /* Shortcuts. */
37 HasherCommon* common;
38
39 BROTLI_BOOL fresh;
40 const BrotliEncoderParams* params;
41 } HashComposite;
42
43 static void FN(Initialize)(HasherCommon* common,
44 HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
45 self->common = common;
46
47 self->ha_common = *self->common;
48 self->hb_common = *self->common;
49 self->fresh = BROTLI_TRUE;
50 self->params = params;
51 /* TODO(lode): Initialize of the hashers is deferred to Prepare (and params
52 remembered here) because we don't get the one_shot and input_size params
53 here that are needed to know the memory size of them. Instead provide
54 those params to all hashers FN(Initialize) */
55 }
56
57 static void FN(Prepare)(
58 HashComposite* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
59 size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
60 if (self->fresh) {
61 self->fresh = BROTLI_FALSE;
62 self->ha_common.extra[0] = self->common->extra[0];
63 self->ha_common.extra[1] = self->common->extra[1];
64 self->ha_common.extra[2] = NULL;
65 self->ha_common.extra[3] = NULL;
66 self->hb_common.extra[0] = self->common->extra[2];
67 self->hb_common.extra[1] = self->common->extra[3];
68 self->hb_common.extra[2] = NULL;
69 self->hb_common.extra[3] = NULL;
70
71 FN_A(Initialize)(&self->ha_common, &self->ha, self->params);
72 FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
73 }
74 FN_A(Prepare)(&self->ha, one_shot, input_size, data);
75 FN_B(Prepare)(&self->hb, one_shot, input_size, data);
76 }
77
78 static BROTLI_INLINE void FN(HashMemAllocInBytes)(
79 const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
80 size_t input_size, size_t* alloc_size) {
81 size_t alloc_size_a[4] = {0};
82 size_t alloc_size_b[4] = {0};
83 FN_A(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_a);
84 FN_B(HashMemAllocInBytes)(params, one_shot, input_size, alloc_size_b);
85 /* Should never happen. */
86 if (alloc_size_a[2] != 0 || alloc_size_a[3] != 0) exit(EXIT_FAILURE);
87 if (alloc_size_b[2] != 0 || alloc_size_b[3] != 0) exit(EXIT_FAILURE);
88 alloc_size[0] = alloc_size_a[0];
89 alloc_size[1] = alloc_size_a[1];
90 alloc_size[2] = alloc_size_b[0];
91 alloc_size[3] = alloc_size_b[1];
92 }
93
94 static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
95 const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
96 FN_A(Store)(&self->ha, data, mask, ix);
97 FN_B(Store)(&self->hb, data, mask, ix);
98 }
99
100 static BROTLI_INLINE void FN(StoreRange)(
101 HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
102 const size_t mask, const size_t ix_start,
103 const size_t ix_end) {
104 FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
105 FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
106 }
107
108 static BROTLI_INLINE void FN(StitchToPreviousBlock)(
109 HashComposite* BROTLI_RESTRICT self,
110 size_t num_bytes, size_t position, const uint8_t* ringbuffer,
111 size_t ring_buffer_mask) {
112 FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
113 ringbuffer, ring_buffer_mask);
114 FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
115 ringbuffer, ring_buffer_mask);
116 }
117
118 static BROTLI_INLINE void FN(PrepareDistanceCache)(
119 HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
120 FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
121 FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
122 }
123
124 static BROTLI_INLINE void FN(FindLongestMatch)(
125 HashComposite* BROTLI_RESTRICT self,
126 const BrotliEncoderDictionary* dictionary,
127 const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
128 const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
129 const size_t max_length, const size_t max_backward,
130 const size_t dictionary_distance, const size_t max_distance,
131 HasherSearchResult* BROTLI_RESTRICT out) {
132 FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
133 distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
134 max_distance, out);
135 FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
136 distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
137 max_distance, out);
138 }
139
140 #undef HashComposite