/src/c-blosc2/blosc/delta.c
Line | Count | Source (jump to first uncovered line) |
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 | 14.1k | int32_t typesize, uint8_t* dest) { |
98 | 14.1k | int32_t i; |
99 | | |
100 | 14.1k | if (offset == 0) { |
101 | | /* Decode delta for the reference block */ |
102 | 1.75k | switch (typesize) { |
103 | 535 | case 1: |
104 | 10.6M | for (i = 1; i < nbytes; i++) { |
105 | 10.5M | dest[i] ^= dref[i-1]; |
106 | 10.5M | } |
107 | 535 | break; |
108 | 138 | case 2: |
109 | 1.94M | for (i = 1; i < nbytes / 2; i++) { |
110 | 1.94M | ((uint16_t *)dest)[i] ^= ((uint16_t *)dref)[i-1]; |
111 | 1.94M | } |
112 | 138 | break; |
113 | 162 | case 4: |
114 | 2.30M | for (i = 1; i < nbytes / 4; i++) { |
115 | 2.30M | ((uint32_t *)dest)[i] ^= ((uint32_t *)dref)[i-1]; |
116 | 2.30M | } |
117 | 162 | break; |
118 | 380 | case 8: |
119 | 1.87M | for (i = 1; i < nbytes / 8; i++) { |
120 | 1.87M | ((uint64_t *)dest)[i] ^= ((uint64_t *)dref)[i-1]; |
121 | 1.87M | } |
122 | 380 | break; |
123 | 540 | default: |
124 | 540 | if ((typesize % 8) == 0) { |
125 | 197 | delta_decoder(dref, offset, nbytes, 8, dest); |
126 | 343 | } else { |
127 | 343 | delta_decoder(dref, offset, nbytes, 1, dest); |
128 | 343 | } |
129 | 1.75k | } |
130 | 12.4k | } else { |
131 | | /* Decode delta for the non-reference blocks */ |
132 | 12.4k | switch (typesize) { |
133 | 4.38k | case 1: |
134 | 3.54M | for (i = 0; i < nbytes; i++) { |
135 | 3.53M | dest[i] ^= dref[i]; |
136 | 3.53M | } |
137 | 4.38k | break; |
138 | 929 | case 2: |
139 | 950k | for (i = 0; i < nbytes / 2; i++) { |
140 | 949k | ((uint16_t *)dest)[i] ^= ((uint16_t *)dref)[i]; |
141 | 949k | } |
142 | 929 | break; |
143 | 852 | case 4: |
144 | 1.13M | for (i = 0; i < nbytes / 4; i++) { |
145 | 1.13M | ((uint32_t *)dest)[i] ^= ((uint32_t *)dref)[i]; |
146 | 1.13M | } |
147 | 852 | break; |
148 | 2.16k | case 8: |
149 | 576k | for (i = 0; i < nbytes / 8; i++) { |
150 | 574k | ((uint64_t *)dest)[i] ^= ((uint64_t *)dref)[i]; |
151 | 574k | } |
152 | 2.16k | break; |
153 | 4.11k | default: |
154 | 4.11k | if ((typesize % 8) == 0) { |
155 | 1.18k | delta_decoder(dref, offset, nbytes, 8, dest); |
156 | 2.93k | } else { |
157 | 2.93k | delta_decoder(dref, offset, nbytes, 1, dest); |
158 | 2.93k | } |
159 | 12.4k | } |
160 | 12.4k | } |
161 | 14.1k | } |