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
FN(HashTypeLength)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
FN(StoreLookahead)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 hb_common;
34
35 /* Shortcuts. */
36 void* extra;
37 HasherCommon* common;
38
39 BROTLI_BOOL fresh;
40 const BrotliEncoderParams* params;
41 } HashComposite;
42
FN(Initialize)43 static void FN(Initialize)(HasherCommon* common,
44 HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
45 self->common = common;
46 self->extra = common->extra;
47
48 self->hb_common = *self->common;
49 self->fresh = BROTLI_TRUE;
50 self->params = params;
51 /* TODO: Initialize of the hashers is defered 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
FN(Prepare)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->hb_common.extra = (uint8_t*)self->extra +
63 FN_A(HashMemAllocInBytes)(self->params, one_shot, input_size);
64
65 FN_A(Initialize)(self->common, &self->ha, self->params);
66 FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
67 }
68 FN_A(Prepare)(&self->ha, one_shot, input_size, data);
69 FN_B(Prepare)(&self->hb, one_shot, input_size, data);
70 }
71
FN(HashMemAllocInBytes)72 static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
73 const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
74 size_t input_size) {
75 return FN_A(HashMemAllocInBytes)(params, one_shot, input_size) +
76 FN_B(HashMemAllocInBytes)(params, one_shot, input_size);
77 }
78
FN(Store)79 static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
80 const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
81 FN_A(Store)(&self->ha, data, mask, ix);
82 FN_B(Store)(&self->hb, data, mask, ix);
83 }
84
FN(StoreRange)85 static BROTLI_INLINE void FN(StoreRange)(
86 HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
87 const size_t mask, const size_t ix_start,
88 const size_t ix_end) {
89 FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
90 FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
91 }
92
FN(StitchToPreviousBlock)93 static BROTLI_INLINE void FN(StitchToPreviousBlock)(
94 HashComposite* BROTLI_RESTRICT self,
95 size_t num_bytes, size_t position, const uint8_t* ringbuffer,
96 size_t ring_buffer_mask) {
97 FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
98 ringbuffer, ring_buffer_mask);
99 FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
100 ringbuffer, ring_buffer_mask);
101 }
102
FN(PrepareDistanceCache)103 static BROTLI_INLINE void FN(PrepareDistanceCache)(
104 HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
105 FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
106 FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
107 }
108
FN(FindLongestMatch)109 static BROTLI_INLINE void FN(FindLongestMatch)(
110 HashComposite* BROTLI_RESTRICT self,
111 const BrotliEncoderDictionary* dictionary,
112 const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
113 const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
114 const size_t max_length, const size_t max_backward,
115 const size_t dictionary_distance, const size_t max_distance,
116 HasherSearchResult* BROTLI_RESTRICT out) {
117 FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
118 distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
119 max_distance, out);
120 FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
121 distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
122 max_distance, out);
123 }
124
125 #undef HashComposite
126