/src/c-blosc2/blosc/delta.c
Line | Count | Source |
1 | | /********************************************************************* |
2 | | Blosc - Blocked Shuffling and Compression Library |
3 | | |
4 | | Copyright (c) 2021 Blosc Development Team <blosc@blosc.org> |
5 | | https://blosc.org |
6 | | License: BSD 3-Clause (see LICENSE.txt) |
7 | | |
8 | | See LICENSE.txt for details about copyright and rights to use. |
9 | | **********************************************************************/ |
10 | | |
11 | | #include "delta.h" |
12 | | |
13 | | #include <stdio.h> |
14 | | #include <stdint.h> |
15 | | |
16 | | |
17 | | /* Apply the delta filters to src. This can never fail. */ |
18 | | void delta_encoder(const uint8_t* dref, int32_t offset, int32_t nbytes, int32_t typesize, |
19 | 0 | const uint8_t* src, uint8_t* dest) { |
20 | 0 | int32_t i; |
21 | 0 | if (offset == 0) { |
22 | | /* This is the reference block, use delta coding in elements */ |
23 | 0 | switch (typesize) { |
24 | 0 | case 1: |
25 | 0 | dest[0] = dref[0]; |
26 | 0 | for (i = 1; i < nbytes; i++) { |
27 | 0 | dest[i] = src[i] ^ dref[i-1]; |
28 | 0 | } |
29 | 0 | break; |
30 | 0 | case 2: |
31 | 0 | ((uint16_t *)dest)[0] = ((uint16_t *)dref)[0]; |
32 | 0 | for (i = 1; i < nbytes / 2; i++) { |
33 | 0 | ((uint16_t *)dest)[i] = |
34 | 0 | ((uint16_t *)src)[i] ^ ((uint16_t *)dref)[i-1]; |
35 | 0 | } |
36 | 0 | break; |
37 | 0 | case 4: |
38 | 0 | ((uint32_t *)dest)[0] = ((uint32_t *)dref)[0]; |
39 | 0 | for (i = 1; i < nbytes / 4; i++) { |
40 | 0 | ((uint32_t *)dest)[i] = |
41 | 0 | ((uint32_t *)src)[i] ^ ((uint32_t *)dref)[i-1]; |
42 | 0 | } |
43 | 0 | break; |
44 | 0 | case 8: |
45 | 0 | ((uint64_t *)dest)[0] = ((uint64_t *)dref)[0]; |
46 | 0 | for (i = 1; i < nbytes / 8; i++) { |
47 | 0 | ((uint64_t *)dest)[i] = |
48 | 0 | ((uint64_t *)src)[i] ^ ((uint64_t *)dref)[i-1]; |
49 | 0 | } |
50 | 0 | break; |
51 | 0 | default: |
52 | 0 | if ((typesize % 8) == 0) { |
53 | 0 | delta_encoder(dref, offset, nbytes, 8, src, dest); |
54 | 0 | } else { |
55 | 0 | delta_encoder(dref, offset, nbytes, 1, src, dest); |
56 | 0 | } |
57 | 0 | } |
58 | 0 | } else { |
59 | | /* Use delta coding wrt reference block */ |
60 | 0 | switch (typesize) { |
61 | 0 | case 1: |
62 | 0 | for (i = 0; i < nbytes; i++) { |
63 | 0 | dest[i] = src[i] ^ dref[i]; |
64 | 0 | } |
65 | 0 | break; |
66 | 0 | case 2: |
67 | 0 | for (i = 0; i < nbytes / 2; i++) { |
68 | 0 | ((uint16_t *) dest)[i] = |
69 | 0 | ((uint16_t *) src)[i] ^ ((uint16_t *) dref)[i]; |
70 | 0 | } |
71 | 0 | break; |
72 | 0 | case 4: |
73 | 0 | for (i = 0; i < nbytes / 4; i++) { |
74 | 0 | ((uint32_t *) dest)[i] = |
75 | 0 | ((uint32_t *) src)[i] ^ ((uint32_t *) dref)[i]; |
76 | 0 | } |
77 | 0 | break; |
78 | 0 | case 8: |
79 | 0 | for (i = 0; i < nbytes / 8; i++) { |
80 | 0 | ((uint64_t *) dest)[i] = |
81 | 0 | ((uint64_t *) src)[i] ^ ((uint64_t *) dref)[i]; |
82 | 0 | } |
83 | 0 | break; |
84 | 0 | default: |
85 | 0 | if ((typesize % 8) == 0) { |
86 | 0 | delta_encoder(dref, offset, nbytes, 8, src, dest); |
87 | 0 | } else { |
88 | 0 | delta_encoder(dref, offset, nbytes, 1, src, dest); |
89 | 0 | } |
90 | 0 | } |
91 | 0 | } |
92 | 0 | } |
93 | | |
94 | | |
95 | | /* Undo the delta filter in dest. This can never fail. */ |
96 | | void delta_decoder(const uint8_t* dref, int32_t offset, int32_t nbytes, |
97 | 43.4k | int32_t typesize, uint8_t* dest) { |
98 | 43.4k | int32_t i; |
99 | | |
100 | 43.4k | if (offset == 0) { |
101 | | /* Decode delta for the reference block */ |
102 | 22.1k | switch (typesize) { |
103 | 9.04k | case 1: |
104 | 931M | for (i = 1; i < nbytes; i++) { |
105 | 931M | dest[i] ^= dref[i-1]; |
106 | 931M | } |
107 | 9.04k | break; |
108 | 375 | case 2: |
109 | 6.03M | for (i = 1; i < nbytes / 2; i++) { |
110 | 6.03M | ((uint16_t *)dest)[i] ^= ((uint16_t *)dref)[i-1]; |
111 | 6.03M | } |
112 | 375 | break; |
113 | 278 | case 4: |
114 | 169M | for (i = 1; i < nbytes / 4; i++) { |
115 | 169M | ((uint32_t *)dest)[i] ^= ((uint32_t *)dref)[i-1]; |
116 | 169M | } |
117 | 278 | break; |
118 | 3.41k | case 8: |
119 | 249M | for (i = 1; i < nbytes / 8; i++) { |
120 | 249M | ((uint64_t *)dest)[i] ^= ((uint64_t *)dref)[i-1]; |
121 | 249M | } |
122 | 3.41k | break; |
123 | 9.02k | default: |
124 | 9.02k | if ((typesize % 8) == 0) { |
125 | 348 | delta_decoder(dref, offset, nbytes, 8, dest); |
126 | 8.67k | } else { |
127 | 8.67k | delta_decoder(dref, offset, nbytes, 1, dest); |
128 | 8.67k | } |
129 | 22.1k | } |
130 | 22.1k | } else { |
131 | | /* Decode delta for the non-reference blocks */ |
132 | 21.3k | switch (typesize) { |
133 | 7.56k | case 1: |
134 | 72.2M | for (i = 0; i < nbytes; i++) { |
135 | 72.2M | dest[i] ^= dref[i]; |
136 | 72.2M | } |
137 | 7.56k | break; |
138 | 978 | case 2: |
139 | 4.31M | for (i = 0; i < nbytes / 2; i++) { |
140 | 4.31M | ((uint16_t *)dest)[i] ^= ((uint16_t *)dref)[i]; |
141 | 4.31M | } |
142 | 978 | break; |
143 | 1.39k | case 4: |
144 | 67.2M | for (i = 0; i < nbytes / 4; i++) { |
145 | 67.2M | ((uint32_t *)dest)[i] ^= ((uint32_t *)dref)[i]; |
146 | 67.2M | } |
147 | 1.39k | break; |
148 | 3.83k | case 8: |
149 | 108M | for (i = 0; i < nbytes / 8; i++) { |
150 | 108M | ((uint64_t *)dest)[i] ^= ((uint64_t *)dref)[i]; |
151 | 108M | } |
152 | 3.83k | break; |
153 | 7.59k | default: |
154 | 7.59k | if ((typesize % 8) == 0) { |
155 | 1.27k | delta_decoder(dref, offset, nbytes, 8, dest); |
156 | 6.32k | } else { |
157 | 6.32k | delta_decoder(dref, offset, nbytes, 1, dest); |
158 | 6.32k | } |
159 | 21.3k | } |
160 | 21.3k | } |
161 | 43.4k | } |