/src/ghostpdl/base/gxsamplp.h
Line | Count | Source (jump to first uncovered line) |
1 | | /* Copyright (C) 2001-2023 Artifex Software, Inc. |
2 | | All Rights Reserved. |
3 | | |
4 | | This software is provided AS-IS with no warranty, either express or |
5 | | implied. |
6 | | |
7 | | This software is distributed under license and may not be copied, |
8 | | modified or distributed except as expressly authorized under the terms |
9 | | of the license contained in the file LICENSE in this distribution. |
10 | | |
11 | | Refer to licensing information at http://www.artifex.com or contact |
12 | | Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco, |
13 | | CA 94129, USA, for further information. |
14 | | */ |
15 | | |
16 | | |
17 | | /* Templates for sample lookup and expansion */ |
18 | | |
19 | | /* This module is allowed to include several times into a single .c file. |
20 | | The following macros to be defined in advance : |
21 | | MULTIPLE_MAPS - 1 if num_components_per_plane > 0 and |
22 | | components use different maps, 0 otherwise. |
23 | | TEMPLATE_sample_unpack_1 - a name for the function |
24 | | TEMPLATE_sample_unpack_2 - a name for the function |
25 | | TEMPLATE_sample_unpack_4 - a name for the function |
26 | | TEMPLATE_sample_unpack_8 - a name for the function |
27 | | */ |
28 | | |
29 | | #if defined(TEMPLATE_sample_unpack_1) && defined(TEMPLATE_sample_unpack_2) && defined(TEMPLATE_sample_unpack_4) && defined(TEMPLATE_sample_unpack_8) |
30 | | |
31 | | #include "valgrind.h" |
32 | | |
33 | | #if MULTIPLE_MAPS |
34 | 60 | # define NEXT_MAP map = smap[++smap_index % num_components_per_plane].table.lookup4x1to32 |
35 | 68.3k | # define NEXT_MAP8 map = smap[++smap_index % num_components_per_plane].table.lookup8 |
36 | 189 | # define DEFINE_SMAP_INDEX int smap_index = 0; |
37 | | #else |
38 | | # define NEXT_MAP |
39 | | # define NEXT_MAP8 |
40 | | # define DEFINE_SMAP_INDEX |
41 | | #endif |
42 | | |
43 | | const byte * |
44 | | TEMPLATE_sample_unpack_1(byte * bptr, int *pdata_x, const byte * data, int data_x, |
45 | | uint dsize, const sample_map *smap, int spread, |
46 | | int num_components_per_plane) |
47 | 3.71M | { |
48 | 3.71M | const sample_lookup_t * ptab = &smap->table; |
49 | 3.71M | const byte *psrc = data + (data_x >> 3); |
50 | 3.71M | int left = dsize - (data_x >> 3); |
51 | 3.71M | DEFINE_SMAP_INDEX |
52 | | |
53 | 3.71M | #ifdef PACIFY_VALGRIND |
54 | 3.71M | byte *bend = bptr + left*spread; |
55 | 3.71M | byte vbits = 0; |
56 | | |
57 | | /* Allow for undefined bits at the end */ |
58 | 3.71M | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); |
59 | | /* At least the top bit must be defined. If not, |
60 | | * don't change anything, and let valgrind complain. */ |
61 | 3.71M | if ((vbits & 0x80) == 0) { |
62 | 3.71M | byte zero = 0; |
63 | 3.71M | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); |
64 | 3.71M | } |
65 | 3.71M | #endif |
66 | | |
67 | 3.71M | if (spread == 1) { |
68 | 3.71M | bits32 *bufp = (bits32 *) bptr; |
69 | 3.71M | const bits32 *map = &ptab->lookup4x1to32[0]; |
70 | 3.71M | uint b; |
71 | | |
72 | 3.71M | if (left & 1) { |
73 | 43.4k | b = psrc[0]; |
74 | 43.4k | bufp[0] = map[b >> 4]; |
75 | 43.4k | NEXT_MAP; |
76 | 43.4k | bufp[1] = map[b & 0xf]; |
77 | 43.4k | NEXT_MAP; |
78 | 43.4k | psrc++, bufp += 2; |
79 | 43.4k | } |
80 | 3.71M | left >>= 1; |
81 | 18.6M | while (left--) { |
82 | 14.9M | b = psrc[0]; |
83 | 14.9M | bufp[0] = map[b >> 4]; |
84 | 14.9M | NEXT_MAP; |
85 | 14.9M | bufp[1] = map[b & 0xf]; |
86 | 14.9M | NEXT_MAP; |
87 | 14.9M | b = psrc[1]; |
88 | 14.9M | bufp[2] = map[b >> 4]; |
89 | 14.9M | NEXT_MAP; |
90 | 14.9M | bufp[3] = map[b & 0xf]; |
91 | 14.9M | NEXT_MAP; |
92 | 14.9M | psrc += 2, bufp += 4; |
93 | 14.9M | } |
94 | 3.71M | } else { |
95 | 0 | byte *bufp = bptr; |
96 | 0 | const byte *map = &ptab->lookup8[0]; |
97 | |
|
98 | 0 | while (left--) { |
99 | 0 | uint b = *psrc++; |
100 | |
|
101 | 0 | *bufp = map[b >> 7]; |
102 | 0 | NEXT_MAP8; |
103 | 0 | bufp += spread; |
104 | 0 | *bufp = map[(b >> 6) & 1]; |
105 | 0 | NEXT_MAP8; |
106 | 0 | bufp += spread; |
107 | 0 | *bufp = map[(b >> 5) & 1]; |
108 | 0 | NEXT_MAP8; |
109 | 0 | bufp += spread; |
110 | 0 | *bufp = map[(b >> 4) & 1]; |
111 | 0 | NEXT_MAP8; |
112 | 0 | bufp += spread; |
113 | 0 | *bufp = map[(b >> 3) & 1]; |
114 | 0 | NEXT_MAP8; |
115 | 0 | bufp += spread; |
116 | 0 | *bufp = map[(b >> 2) & 1]; |
117 | 0 | NEXT_MAP8; |
118 | 0 | bufp += spread; |
119 | 0 | *bufp = map[(b >> 1) & 1]; |
120 | 0 | NEXT_MAP8; |
121 | 0 | bufp += spread; |
122 | 0 | *bufp = map[b & 1]; |
123 | 0 | NEXT_MAP8; |
124 | 0 | bufp += spread; |
125 | 0 | } |
126 | 0 | } |
127 | 3.71M | #ifdef PACIFY_VALGRIND |
128 | | /* Put any undefinedness back, and carry it over to the output. */ |
129 | 3.71M | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); |
130 | 3.71M | { |
131 | 3.71M | byte ones = 0xff; |
132 | 3.71M | if (vbits & 0x40) |
133 | 3.71M | VALGRIND_SET_VBITS(bend - spread*7, &ones, 1); |
134 | 3.71M | if (vbits & 0x20) |
135 | 3.71M | VALGRIND_SET_VBITS(bend - spread*6, &ones, 1); |
136 | 3.71M | if (vbits & 0x10) |
137 | 3.71M | VALGRIND_SET_VBITS(bend - spread*5, &ones, 1); |
138 | 3.71M | if (vbits & 0x08) |
139 | 3.71M | VALGRIND_SET_VBITS(bend - spread*4, &ones, 1); |
140 | 3.71M | if (vbits & 0x04) |
141 | 3.71M | VALGRIND_SET_VBITS(bend - spread*3, &ones, 1); |
142 | 3.71M | if (vbits & 0x02) |
143 | 3.71M | VALGRIND_SET_VBITS(bend - spread*2, &ones, 1); |
144 | 3.71M | if (vbits & 0x01) |
145 | 3.71M | VALGRIND_SET_VBITS(bend - spread*1, &ones, 1); |
146 | 3.71M | } |
147 | 3.71M | #endif |
148 | 3.71M | *pdata_x = data_x & 7; |
149 | 3.71M | return bptr; |
150 | 3.71M | } Line | Count | Source | 47 | 3.71M | { | 48 | 3.71M | const sample_lookup_t * ptab = &smap->table; | 49 | 3.71M | const byte *psrc = data + (data_x >> 3); | 50 | 3.71M | int left = dsize - (data_x >> 3); | 51 | 3.71M | DEFINE_SMAP_INDEX | 52 | | | 53 | 3.71M | #ifdef PACIFY_VALGRIND | 54 | 3.71M | byte *bend = bptr + left*spread; | 55 | 3.71M | byte vbits = 0; | 56 | | | 57 | | /* Allow for undefined bits at the end */ | 58 | 3.71M | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); | 59 | | /* At least the top bit must be defined. If not, | 60 | | * don't change anything, and let valgrind complain. */ | 61 | 3.71M | if ((vbits & 0x80) == 0) { | 62 | 3.71M | byte zero = 0; | 63 | 3.71M | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); | 64 | 3.71M | } | 65 | 3.71M | #endif | 66 | | | 67 | 3.71M | if (spread == 1) { | 68 | 3.71M | bits32 *bufp = (bits32 *) bptr; | 69 | 3.71M | const bits32 *map = &ptab->lookup4x1to32[0]; | 70 | 3.71M | uint b; | 71 | | | 72 | 3.71M | if (left & 1) { | 73 | 43.4k | b = psrc[0]; | 74 | 43.4k | bufp[0] = map[b >> 4]; | 75 | 43.4k | NEXT_MAP; | 76 | 43.4k | bufp[1] = map[b & 0xf]; | 77 | 43.4k | NEXT_MAP; | 78 | 43.4k | psrc++, bufp += 2; | 79 | 43.4k | } | 80 | 3.71M | left >>= 1; | 81 | 18.6M | while (left--) { | 82 | 14.9M | b = psrc[0]; | 83 | 14.9M | bufp[0] = map[b >> 4]; | 84 | 14.9M | NEXT_MAP; | 85 | 14.9M | bufp[1] = map[b & 0xf]; | 86 | 14.9M | NEXT_MAP; | 87 | 14.9M | b = psrc[1]; | 88 | 14.9M | bufp[2] = map[b >> 4]; | 89 | 14.9M | NEXT_MAP; | 90 | 14.9M | bufp[3] = map[b & 0xf]; | 91 | 14.9M | NEXT_MAP; | 92 | 14.9M | psrc += 2, bufp += 4; | 93 | 14.9M | } | 94 | 3.71M | } else { | 95 | 0 | byte *bufp = bptr; | 96 | 0 | const byte *map = &ptab->lookup8[0]; | 97 | |
| 98 | 0 | while (left--) { | 99 | 0 | uint b = *psrc++; | 100 | |
| 101 | 0 | *bufp = map[b >> 7]; | 102 | 0 | NEXT_MAP8; | 103 | 0 | bufp += spread; | 104 | 0 | *bufp = map[(b >> 6) & 1]; | 105 | 0 | NEXT_MAP8; | 106 | 0 | bufp += spread; | 107 | 0 | *bufp = map[(b >> 5) & 1]; | 108 | 0 | NEXT_MAP8; | 109 | 0 | bufp += spread; | 110 | 0 | *bufp = map[(b >> 4) & 1]; | 111 | 0 | NEXT_MAP8; | 112 | 0 | bufp += spread; | 113 | 0 | *bufp = map[(b >> 3) & 1]; | 114 | 0 | NEXT_MAP8; | 115 | 0 | bufp += spread; | 116 | 0 | *bufp = map[(b >> 2) & 1]; | 117 | 0 | NEXT_MAP8; | 118 | 0 | bufp += spread; | 119 | 0 | *bufp = map[(b >> 1) & 1]; | 120 | 0 | NEXT_MAP8; | 121 | 0 | bufp += spread; | 122 | 0 | *bufp = map[b & 1]; | 123 | 0 | NEXT_MAP8; | 124 | 0 | bufp += spread; | 125 | 0 | } | 126 | 0 | } | 127 | 3.71M | #ifdef PACIFY_VALGRIND | 128 | | /* Put any undefinedness back, and carry it over to the output. */ | 129 | 3.71M | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); | 130 | 3.71M | { | 131 | 3.71M | byte ones = 0xff; | 132 | 3.71M | if (vbits & 0x40) | 133 | 3.71M | VALGRIND_SET_VBITS(bend - spread*7, &ones, 1); | 134 | 3.71M | if (vbits & 0x20) | 135 | 3.71M | VALGRIND_SET_VBITS(bend - spread*6, &ones, 1); | 136 | 3.71M | if (vbits & 0x10) | 137 | 3.71M | VALGRIND_SET_VBITS(bend - spread*5, &ones, 1); | 138 | 3.71M | if (vbits & 0x08) | 139 | 3.71M | VALGRIND_SET_VBITS(bend - spread*4, &ones, 1); | 140 | 3.71M | if (vbits & 0x04) | 141 | 3.71M | VALGRIND_SET_VBITS(bend - spread*3, &ones, 1); | 142 | 3.71M | if (vbits & 0x02) | 143 | 3.71M | VALGRIND_SET_VBITS(bend - spread*2, &ones, 1); | 144 | 3.71M | if (vbits & 0x01) | 145 | 3.71M | VALGRIND_SET_VBITS(bend - spread*1, &ones, 1); | 146 | 3.71M | } | 147 | 3.71M | #endif | 148 | 3.71M | *pdata_x = data_x & 7; | 149 | 3.71M | return bptr; | 150 | 3.71M | } |
sample_unpack_1_interleaved Line | Count | Source | 47 | 10 | { | 48 | 10 | const sample_lookup_t * ptab = &smap->table; | 49 | 10 | const byte *psrc = data + (data_x >> 3); | 50 | 10 | int left = dsize - (data_x >> 3); | 51 | 10 | DEFINE_SMAP_INDEX | 52 | | | 53 | 10 | #ifdef PACIFY_VALGRIND | 54 | 10 | byte *bend = bptr + left*spread; | 55 | 10 | byte vbits = 0; | 56 | | | 57 | | /* Allow for undefined bits at the end */ | 58 | 10 | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); | 59 | | /* At least the top bit must be defined. If not, | 60 | | * don't change anything, and let valgrind complain. */ | 61 | 10 | if ((vbits & 0x80) == 0) { | 62 | 10 | byte zero = 0; | 63 | 10 | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); | 64 | 10 | } | 65 | 10 | #endif | 66 | | | 67 | 10 | if (spread == 1) { | 68 | 10 | bits32 *bufp = (bits32 *) bptr; | 69 | 10 | const bits32 *map = &ptab->lookup4x1to32[0]; | 70 | 10 | uint b; | 71 | | | 72 | 10 | if (left & 1) { | 73 | 10 | b = psrc[0]; | 74 | 10 | bufp[0] = map[b >> 4]; | 75 | 10 | NEXT_MAP; | 76 | 10 | bufp[1] = map[b & 0xf]; | 77 | 10 | NEXT_MAP; | 78 | 10 | psrc++, bufp += 2; | 79 | 10 | } | 80 | 10 | left >>= 1; | 81 | 20 | while (left--) { | 82 | 10 | b = psrc[0]; | 83 | 10 | bufp[0] = map[b >> 4]; | 84 | 10 | NEXT_MAP; | 85 | 10 | bufp[1] = map[b & 0xf]; | 86 | 10 | NEXT_MAP; | 87 | 10 | b = psrc[1]; | 88 | 10 | bufp[2] = map[b >> 4]; | 89 | 10 | NEXT_MAP; | 90 | 10 | bufp[3] = map[b & 0xf]; | 91 | 10 | NEXT_MAP; | 92 | 10 | psrc += 2, bufp += 4; | 93 | 10 | } | 94 | 10 | } else { | 95 | 0 | byte *bufp = bptr; | 96 | 0 | const byte *map = &ptab->lookup8[0]; | 97 | |
| 98 | 0 | while (left--) { | 99 | 0 | uint b = *psrc++; | 100 | |
| 101 | 0 | *bufp = map[b >> 7]; | 102 | 0 | NEXT_MAP8; | 103 | 0 | bufp += spread; | 104 | 0 | *bufp = map[(b >> 6) & 1]; | 105 | 0 | NEXT_MAP8; | 106 | 0 | bufp += spread; | 107 | 0 | *bufp = map[(b >> 5) & 1]; | 108 | 0 | NEXT_MAP8; | 109 | 0 | bufp += spread; | 110 | 0 | *bufp = map[(b >> 4) & 1]; | 111 | 0 | NEXT_MAP8; | 112 | 0 | bufp += spread; | 113 | 0 | *bufp = map[(b >> 3) & 1]; | 114 | 0 | NEXT_MAP8; | 115 | 0 | bufp += spread; | 116 | 0 | *bufp = map[(b >> 2) & 1]; | 117 | 0 | NEXT_MAP8; | 118 | 0 | bufp += spread; | 119 | 0 | *bufp = map[(b >> 1) & 1]; | 120 | 0 | NEXT_MAP8; | 121 | 0 | bufp += spread; | 122 | 0 | *bufp = map[b & 1]; | 123 | 0 | NEXT_MAP8; | 124 | 0 | bufp += spread; | 125 | 0 | } | 126 | 0 | } | 127 | 10 | #ifdef PACIFY_VALGRIND | 128 | | /* Put any undefinedness back, and carry it over to the output. */ | 129 | 10 | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); | 130 | 10 | { | 131 | 10 | byte ones = 0xff; | 132 | 10 | if (vbits & 0x40) | 133 | 10 | VALGRIND_SET_VBITS(bend - spread*7, &ones, 1); | 134 | 10 | if (vbits & 0x20) | 135 | 10 | VALGRIND_SET_VBITS(bend - spread*6, &ones, 1); | 136 | 10 | if (vbits & 0x10) | 137 | 10 | VALGRIND_SET_VBITS(bend - spread*5, &ones, 1); | 138 | 10 | if (vbits & 0x08) | 139 | 10 | VALGRIND_SET_VBITS(bend - spread*4, &ones, 1); | 140 | 10 | if (vbits & 0x04) | 141 | 10 | VALGRIND_SET_VBITS(bend - spread*3, &ones, 1); | 142 | 10 | if (vbits & 0x02) | 143 | 10 | VALGRIND_SET_VBITS(bend - spread*2, &ones, 1); | 144 | 10 | if (vbits & 0x01) | 145 | 10 | VALGRIND_SET_VBITS(bend - spread*1, &ones, 1); | 146 | 10 | } | 147 | 10 | #endif | 148 | 10 | *pdata_x = data_x & 7; | 149 | 10 | return bptr; | 150 | 10 | } |
|
151 | | |
152 | | #undef NEXT_MAP |
153 | | |
154 | | #if MULTIPLE_MAPS |
155 | 48 | # define NEXT_MAP map = smap[++smap_index % num_components_per_plane].table.lookup2x2to16 |
156 | | #else |
157 | | # define NEXT_MAP |
158 | | #endif |
159 | | |
160 | | const byte * |
161 | | TEMPLATE_sample_unpack_2(byte * bptr, int *pdata_x, const byte * data, int data_x, |
162 | | uint dsize, const sample_map *smap, int spread, |
163 | | int num_components_per_plane) |
164 | 7.02k | { |
165 | 7.02k | const sample_lookup_t * ptab = &smap->table; |
166 | 7.02k | const byte *psrc = data + (data_x >> 2); |
167 | 7.02k | int left = dsize - (data_x >> 2); |
168 | 7.02k | DEFINE_SMAP_INDEX |
169 | | |
170 | 7.02k | #ifdef PACIFY_VALGRIND |
171 | 7.02k | byte *bend = bptr + left*spread; |
172 | 7.02k | byte vbits = 0; |
173 | | |
174 | | /* Allow for undefined bits at the end */ |
175 | 7.02k | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); |
176 | | /* At least the top 2 bits must be defined. If not, |
177 | | * don't change anything, and let valgrind complain. */ |
178 | 7.02k | if ((vbits & 0xC0) == 0) { |
179 | 7.02k | byte zero = 0; |
180 | 7.02k | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); |
181 | 7.02k | } |
182 | 7.02k | #endif |
183 | | |
184 | 7.02k | if (spread == 1) { |
185 | 7.02k | bits16 *bufp = (bits16 *) bptr; |
186 | 7.02k | const bits16 *map = &ptab->lookup2x2to16[0]; |
187 | | |
188 | 635k | while (left--) { |
189 | 628k | uint b = *psrc++; |
190 | | |
191 | 628k | *bufp++ = map[b >> 4]; |
192 | 628k | NEXT_MAP; |
193 | 628k | *bufp++ = map[b & 0xf]; |
194 | 628k | NEXT_MAP; |
195 | 628k | } |
196 | 7.02k | } else { |
197 | 0 | byte *bufp = bptr; |
198 | 0 | const byte *map = &ptab->lookup8[0]; |
199 | |
|
200 | 0 | while (left--) { |
201 | 0 | unsigned b = *psrc++; |
202 | |
|
203 | 0 | *bufp = map[b >> 6]; |
204 | 0 | NEXT_MAP8; |
205 | 0 | bufp += spread; |
206 | 0 | *bufp = map[(b >> 4) & 3]; |
207 | 0 | NEXT_MAP8; |
208 | 0 | bufp += spread; |
209 | 0 | *bufp = map[(b >> 2) & 3]; |
210 | 0 | NEXT_MAP8; |
211 | 0 | bufp += spread; |
212 | 0 | *bufp = map[b & 3]; |
213 | 0 | NEXT_MAP8; |
214 | 0 | bufp += spread; |
215 | 0 | } |
216 | 0 | } |
217 | 7.02k | *pdata_x = data_x & 3; |
218 | 7.02k | #ifdef PACIFY_VALGRIND |
219 | | /* Put any undefinedness back, and carry it over to the output. */ |
220 | 7.02k | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); |
221 | 7.02k | { |
222 | 7.02k | byte ones = 0xff; |
223 | 7.02k | if (vbits & 0x30) |
224 | 7.02k | VALGRIND_SET_VBITS(bend - spread*3, &ones, 1); |
225 | 7.02k | if (vbits & 0x0C) |
226 | 7.02k | VALGRIND_SET_VBITS(bend - spread*2, &ones, 1); |
227 | 7.02k | if (vbits & 0x03) |
228 | 7.02k | VALGRIND_SET_VBITS(bend - spread*1, &ones, 1); |
229 | 7.02k | } |
230 | 7.02k | #endif |
231 | 7.02k | return bptr; |
232 | 7.02k | } Line | Count | Source | 164 | 7.02k | { | 165 | 7.02k | const sample_lookup_t * ptab = &smap->table; | 166 | 7.02k | const byte *psrc = data + (data_x >> 2); | 167 | 7.02k | int left = dsize - (data_x >> 2); | 168 | 7.02k | DEFINE_SMAP_INDEX | 169 | | | 170 | 7.02k | #ifdef PACIFY_VALGRIND | 171 | 7.02k | byte *bend = bptr + left*spread; | 172 | 7.02k | byte vbits = 0; | 173 | | | 174 | | /* Allow for undefined bits at the end */ | 175 | 7.02k | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); | 176 | | /* At least the top 2 bits must be defined. If not, | 177 | | * don't change anything, and let valgrind complain. */ | 178 | 7.02k | if ((vbits & 0xC0) == 0) { | 179 | 7.02k | byte zero = 0; | 180 | 7.02k | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); | 181 | 7.02k | } | 182 | 7.02k | #endif | 183 | | | 184 | 7.02k | if (spread == 1) { | 185 | 7.02k | bits16 *bufp = (bits16 *) bptr; | 186 | 7.02k | const bits16 *map = &ptab->lookup2x2to16[0]; | 187 | | | 188 | 635k | while (left--) { | 189 | 628k | uint b = *psrc++; | 190 | | | 191 | 628k | *bufp++ = map[b >> 4]; | 192 | 628k | NEXT_MAP; | 193 | 628k | *bufp++ = map[b & 0xf]; | 194 | 628k | NEXT_MAP; | 195 | 628k | } | 196 | 7.02k | } else { | 197 | 0 | byte *bufp = bptr; | 198 | 0 | const byte *map = &ptab->lookup8[0]; | 199 | |
| 200 | 0 | while (left--) { | 201 | 0 | unsigned b = *psrc++; | 202 | |
| 203 | 0 | *bufp = map[b >> 6]; | 204 | 0 | NEXT_MAP8; | 205 | 0 | bufp += spread; | 206 | 0 | *bufp = map[(b >> 4) & 3]; | 207 | 0 | NEXT_MAP8; | 208 | 0 | bufp += spread; | 209 | 0 | *bufp = map[(b >> 2) & 3]; | 210 | 0 | NEXT_MAP8; | 211 | 0 | bufp += spread; | 212 | 0 | *bufp = map[b & 3]; | 213 | 0 | NEXT_MAP8; | 214 | 0 | bufp += spread; | 215 | 0 | } | 216 | 0 | } | 217 | 7.02k | *pdata_x = data_x & 3; | 218 | 7.02k | #ifdef PACIFY_VALGRIND | 219 | | /* Put any undefinedness back, and carry it over to the output. */ | 220 | 7.02k | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); | 221 | 7.02k | { | 222 | 7.02k | byte ones = 0xff; | 223 | 7.02k | if (vbits & 0x30) | 224 | 7.02k | VALGRIND_SET_VBITS(bend - spread*3, &ones, 1); | 225 | 7.02k | if (vbits & 0x0C) | 226 | 7.02k | VALGRIND_SET_VBITS(bend - spread*2, &ones, 1); | 227 | 7.02k | if (vbits & 0x03) | 228 | 7.02k | VALGRIND_SET_VBITS(bend - spread*1, &ones, 1); | 229 | 7.02k | } | 230 | 7.02k | #endif | 231 | 7.02k | return bptr; | 232 | 7.02k | } |
sample_unpack_2_interleaved Line | Count | Source | 164 | 1 | { | 165 | 1 | const sample_lookup_t * ptab = &smap->table; | 166 | 1 | const byte *psrc = data + (data_x >> 2); | 167 | 1 | int left = dsize - (data_x >> 2); | 168 | 1 | DEFINE_SMAP_INDEX | 169 | | | 170 | 1 | #ifdef PACIFY_VALGRIND | 171 | 1 | byte *bend = bptr + left*spread; | 172 | 1 | byte vbits = 0; | 173 | | | 174 | | /* Allow for undefined bits at the end */ | 175 | 1 | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); | 176 | | /* At least the top 2 bits must be defined. If not, | 177 | | * don't change anything, and let valgrind complain. */ | 178 | 1 | if ((vbits & 0xC0) == 0) { | 179 | 1 | byte zero = 0; | 180 | 1 | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); | 181 | 1 | } | 182 | 1 | #endif | 183 | | | 184 | 1 | if (spread == 1) { | 185 | 1 | bits16 *bufp = (bits16 *) bptr; | 186 | 1 | const bits16 *map = &ptab->lookup2x2to16[0]; | 187 | | | 188 | 25 | while (left--) { | 189 | 24 | uint b = *psrc++; | 190 | | | 191 | 24 | *bufp++ = map[b >> 4]; | 192 | 24 | NEXT_MAP; | 193 | 24 | *bufp++ = map[b & 0xf]; | 194 | 24 | NEXT_MAP; | 195 | 24 | } | 196 | 1 | } else { | 197 | 0 | byte *bufp = bptr; | 198 | 0 | const byte *map = &ptab->lookup8[0]; | 199 | |
| 200 | 0 | while (left--) { | 201 | 0 | unsigned b = *psrc++; | 202 | |
| 203 | 0 | *bufp = map[b >> 6]; | 204 | 0 | NEXT_MAP8; | 205 | 0 | bufp += spread; | 206 | 0 | *bufp = map[(b >> 4) & 3]; | 207 | 0 | NEXT_MAP8; | 208 | 0 | bufp += spread; | 209 | 0 | *bufp = map[(b >> 2) & 3]; | 210 | 0 | NEXT_MAP8; | 211 | 0 | bufp += spread; | 212 | 0 | *bufp = map[b & 3]; | 213 | 0 | NEXT_MAP8; | 214 | 0 | bufp += spread; | 215 | 0 | } | 216 | 0 | } | 217 | 1 | *pdata_x = data_x & 3; | 218 | 1 | #ifdef PACIFY_VALGRIND | 219 | | /* Put any undefinedness back, and carry it over to the output. */ | 220 | 1 | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); | 221 | 1 | { | 222 | 1 | byte ones = 0xff; | 223 | 1 | if (vbits & 0x30) | 224 | 1 | VALGRIND_SET_VBITS(bend - spread*3, &ones, 1); | 225 | 1 | if (vbits & 0x0C) | 226 | 1 | VALGRIND_SET_VBITS(bend - spread*2, &ones, 1); | 227 | 1 | if (vbits & 0x03) | 228 | 1 | VALGRIND_SET_VBITS(bend - spread*1, &ones, 1); | 229 | 1 | } | 230 | 1 | #endif | 231 | 1 | return bptr; | 232 | 1 | } |
|
233 | | |
234 | | #undef NEXT_MAP |
235 | | |
236 | | const byte * |
237 | | TEMPLATE_sample_unpack_4(byte * bptr, int *pdata_x, const byte * data, int data_x, |
238 | | uint dsize, const sample_map *smap, int spread, |
239 | | int num_components_per_plane) |
240 | 20.6k | { |
241 | 20.6k | const sample_lookup_t * ptab = &smap->table; |
242 | 20.6k | byte *bufp = bptr; |
243 | 20.6k | const byte *psrc = data + (data_x >> 1); |
244 | 20.6k | int left = dsize - (data_x >> 1); |
245 | 20.6k | const byte *map = &ptab->lookup8[0]; |
246 | 20.6k | DEFINE_SMAP_INDEX |
247 | | |
248 | 20.6k | #ifdef PACIFY_VALGRIND |
249 | 20.6k | byte vbits = 0; |
250 | | |
251 | | /* Allow for undefined bits at the end */ |
252 | 20.6k | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); |
253 | | /* At least the top 4 bits must be defined. If not, |
254 | | * don't change anything, and let valgrind complain. */ |
255 | 20.6k | if ((vbits & 0xf0) == 0) { |
256 | 20.6k | byte zero = 0; |
257 | 20.6k | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); |
258 | 20.6k | } |
259 | 20.6k | #endif |
260 | | |
261 | 3.11M | while (left--) { |
262 | 3.09M | uint b = *psrc++; |
263 | | |
264 | 3.09M | *bufp = map[b >> 4]; |
265 | 3.09M | NEXT_MAP8; |
266 | 3.09M | bufp += spread; |
267 | 3.09M | *bufp = map[b & 0xf]; |
268 | 3.09M | NEXT_MAP8; |
269 | 3.09M | bufp += spread; |
270 | 3.09M | } |
271 | 20.6k | #ifdef PACIFY_VALGRIND |
272 | | /* Put any undefinedness back, and carry it over to the output. */ |
273 | 20.6k | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); |
274 | 20.6k | if ((vbits & 0x0f) != 0) { |
275 | 0 | byte ones = 0xFF; |
276 | 0 | VALGRIND_SET_VBITS(bufp-spread, &ones, 1); |
277 | 0 | } |
278 | 20.6k | #endif |
279 | 20.6k | *pdata_x = data_x & 1; |
280 | 20.6k | return bptr; |
281 | 20.6k | } Line | Count | Source | 240 | 20.6k | { | 241 | 20.6k | const sample_lookup_t * ptab = &smap->table; | 242 | 20.6k | byte *bufp = bptr; | 243 | 20.6k | const byte *psrc = data + (data_x >> 1); | 244 | 20.6k | int left = dsize - (data_x >> 1); | 245 | 20.6k | const byte *map = &ptab->lookup8[0]; | 246 | 20.6k | DEFINE_SMAP_INDEX | 247 | | | 248 | 20.6k | #ifdef PACIFY_VALGRIND | 249 | 20.6k | byte vbits = 0; | 250 | | | 251 | | /* Allow for undefined bits at the end */ | 252 | 20.6k | VALGRIND_GET_VBITS(&psrc[left-1], &vbits, 1); | 253 | | /* At least the top 4 bits must be defined. If not, | 254 | | * don't change anything, and let valgrind complain. */ | 255 | 20.6k | if ((vbits & 0xf0) == 0) { | 256 | 20.6k | byte zero = 0; | 257 | 20.6k | VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1); | 258 | 20.6k | } | 259 | 20.6k | #endif | 260 | | | 261 | 3.11M | while (left--) { | 262 | 3.09M | uint b = *psrc++; | 263 | | | 264 | 3.09M | *bufp = map[b >> 4]; | 265 | 3.09M | NEXT_MAP8; | 266 | 3.09M | bufp += spread; | 267 | 3.09M | *bufp = map[b & 0xf]; | 268 | 3.09M | NEXT_MAP8; | 269 | 3.09M | bufp += spread; | 270 | 3.09M | } | 271 | 20.6k | #ifdef PACIFY_VALGRIND | 272 | | /* Put any undefinedness back, and carry it over to the output. */ | 273 | 20.6k | VALGRIND_SET_VBITS(psrc-1, &vbits, 1); | 274 | 20.6k | if ((vbits & 0x0f) != 0) { | 275 | 0 | byte ones = 0xFF; | 276 | 0 | VALGRIND_SET_VBITS(bufp-spread, &ones, 1); | 277 | 0 | } | 278 | 20.6k | #endif | 279 | 20.6k | *pdata_x = data_x & 1; | 280 | 20.6k | return bptr; | 281 | 20.6k | } |
Unexecuted instantiation: sample_unpack_4_interleaved |
282 | | |
283 | | const byte * |
284 | | TEMPLATE_sample_unpack_8(byte * bptr, int *pdata_x, const byte * data, int data_x, |
285 | | uint dsize, const sample_map *smap, int spread, |
286 | | int num_components_per_plane) |
287 | 23.9M | { |
288 | 23.9M | const sample_lookup_t * ptab = &smap->table; |
289 | 23.9M | byte *bufp = bptr; |
290 | 23.9M | const byte *psrc = data + data_x; |
291 | 23.9M | DEFINE_SMAP_INDEX |
292 | | |
293 | 23.9M | *pdata_x = 0; |
294 | 23.9M | if (spread == 1) { |
295 | 20.8M | if (MULTIPLE_MAPS || |
296 | 20.8M | ptab->lookup8[0] != 0 || |
297 | 20.8M | ptab->lookup8[255] != 255 |
298 | 20.8M | ) { |
299 | 24.2k | uint left = dsize - data_x; |
300 | 24.2k | const byte *map = &ptab->lookup8[0]; |
301 | | |
302 | 17.3M | while (left--) { |
303 | 17.3M | *bufp++ = map[*psrc++]; |
304 | 17.3M | NEXT_MAP8; |
305 | 17.3M | } |
306 | 20.7M | } else { /* No copying needed, and we'll use the data right away. */ |
307 | 20.7M | return psrc; |
308 | 20.7M | } |
309 | 20.8M | } else { |
310 | 3.10M | int left = dsize - data_x; |
311 | 3.10M | const byte *map = &ptab->lookup8[0]; |
312 | | |
313 | 3.04G | for (; left--; psrc++, bufp += spread) { |
314 | 3.04G | *bufp = map[*psrc]; |
315 | 3.04G | NEXT_MAP8; |
316 | 3.04G | } |
317 | 3.10M | } |
318 | 3.13M | return bptr; |
319 | 23.9M | } Line | Count | Source | 287 | 23.9M | { | 288 | 23.9M | const sample_lookup_t * ptab = &smap->table; | 289 | 23.9M | byte *bufp = bptr; | 290 | 23.9M | const byte *psrc = data + data_x; | 291 | 23.9M | DEFINE_SMAP_INDEX | 292 | | | 293 | 23.9M | *pdata_x = 0; | 294 | 23.9M | if (spread == 1) { | 295 | 20.8M | if (MULTIPLE_MAPS || | 296 | 20.8M | ptab->lookup8[0] != 0 || | 297 | 20.8M | ptab->lookup8[255] != 255 | 298 | 20.8M | ) { | 299 | 24.0k | uint left = dsize - data_x; | 300 | 24.0k | const byte *map = &ptab->lookup8[0]; | 301 | | | 302 | 17.3M | while (left--) { | 303 | 17.2M | *bufp++ = map[*psrc++]; | 304 | 17.2M | NEXT_MAP8; | 305 | 17.2M | } | 306 | 20.7M | } else { /* No copying needed, and we'll use the data right away. */ | 307 | 20.7M | return psrc; | 308 | 20.7M | } | 309 | 20.8M | } else { | 310 | 3.10M | int left = dsize - data_x; | 311 | 3.10M | const byte *map = &ptab->lookup8[0]; | 312 | | | 313 | 3.04G | for (; left--; psrc++, bufp += spread) { | 314 | 3.04G | *bufp = map[*psrc]; | 315 | 3.04G | NEXT_MAP8; | 316 | 3.04G | } | 317 | 3.10M | } | 318 | 3.13M | return bptr; | 319 | 23.9M | } |
sample_unpack_8_interleaved Line | Count | Source | 287 | 178 | { | 288 | 178 | const sample_lookup_t * ptab = &smap->table; | 289 | 178 | byte *bufp = bptr; | 290 | 178 | const byte *psrc = data + data_x; | 291 | 178 | DEFINE_SMAP_INDEX | 292 | | | 293 | 178 | *pdata_x = 0; | 294 | 178 | if (spread == 1) { | 295 | 178 | if (MULTIPLE_MAPS || | 296 | 178 | ptab->lookup8[0] != 0 || | 297 | 178 | ptab->lookup8[255] != 255 | 298 | 178 | ) { | 299 | 178 | uint left = dsize - data_x; | 300 | 178 | const byte *map = &ptab->lookup8[0]; | 301 | | | 302 | 68.5k | while (left--) { | 303 | 68.3k | *bufp++ = map[*psrc++]; | 304 | 68.3k | NEXT_MAP8; | 305 | 68.3k | } | 306 | 178 | } else { /* No copying needed, and we'll use the data right away. */ | 307 | 0 | return psrc; | 308 | 0 | } | 309 | 178 | } else { | 310 | 0 | int left = dsize - data_x; | 311 | 0 | const byte *map = &ptab->lookup8[0]; | 312 | |
| 313 | 0 | for (; left--; psrc++, bufp += spread) { | 314 | 0 | *bufp = map[*psrc]; | 315 | 0 | NEXT_MAP8; | 316 | 0 | } | 317 | 0 | } | 318 | 178 | return bptr; | 319 | 178 | } |
|
320 | | |
321 | | #undef NEXT_MAP |
322 | | #undef NEXT_MAP8 |
323 | | #undef DEFINE_SMAP_INDEX |
324 | | |
325 | | #else |
326 | | int dummy; |
327 | | #endif |