Coverage Report

Created: 2026-02-14 07:09

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/ghostpdl/base/gxsamplp.h
Line
Count
Source
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
2.56k
#   define NEXT_MAP map = smap[++smap_index % num_components_per_plane].table.lookup4x1to32
35
395k
#   define NEXT_MAP8 map = smap[++smap_index % num_components_per_plane].table.lookup8
36
1.15k
#   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.40M
{
48
3.40M
    const sample_lookup_t * ptab = &smap->table;
49
3.40M
    const byte *psrc = data + (data_x >> 3);
50
3.40M
    int left = dsize - (data_x >> 3);
51
3.40M
    DEFINE_SMAP_INDEX
52
53
3.40M
#ifdef PACIFY_VALGRIND
54
3.40M
    byte *bend = bptr + left*spread;
55
3.40M
    byte vbits = 0;
56
57
    /* Allow for undefined bits at the end */
58
3.40M
    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.40M
    if ((vbits & 0x80) == 0) {
62
3.40M
        byte zero = 0;
63
3.40M
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
64
3.40M
    }
65
3.40M
#endif
66
67
3.40M
    if (spread == 1) {
68
3.40M
        bits32 *bufp = (bits32 *) bptr;
69
3.40M
        const bits32 *map = &ptab->lookup4x1to32[0];
70
3.40M
        uint b;
71
72
3.40M
        if (left & 1) {
73
62.2k
            b = psrc[0];
74
62.2k
            bufp[0] = map[b >> 4];
75
62.2k
            NEXT_MAP;
76
62.2k
            bufp[1] = map[b & 0xf];
77
62.2k
            NEXT_MAP;
78
62.2k
            psrc++, bufp += 2;
79
62.2k
        }
80
3.40M
        left >>= 1;
81
13.4M
        while (left--) {
82
10.0M
            b = psrc[0];
83
10.0M
            bufp[0] = map[b >> 4];
84
10.0M
            NEXT_MAP;
85
10.0M
            bufp[1] = map[b & 0xf];
86
10.0M
            NEXT_MAP;
87
10.0M
            b = psrc[1];
88
10.0M
            bufp[2] = map[b >> 4];
89
10.0M
            NEXT_MAP;
90
10.0M
            bufp[3] = map[b & 0xf];
91
10.0M
            NEXT_MAP;
92
10.0M
            psrc += 2, bufp += 4;
93
10.0M
        }
94
3.40M
    } 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.40M
#ifdef PACIFY_VALGRIND
128
    /* Put any undefinedness back, and carry it over to the output. */
129
3.40M
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
130
3.40M
    {
131
3.40M
        byte ones = 0xff;
132
3.40M
        if (vbits & 0x40)
133
3.40M
            VALGRIND_SET_VBITS(bend - spread*7, &ones, 1);
134
3.40M
        if (vbits & 0x20)
135
3.40M
            VALGRIND_SET_VBITS(bend - spread*6, &ones, 1);
136
3.40M
        if (vbits & 0x10)
137
3.40M
            VALGRIND_SET_VBITS(bend - spread*5, &ones, 1);
138
3.40M
        if (vbits & 0x08)
139
3.40M
            VALGRIND_SET_VBITS(bend - spread*4, &ones, 1);
140
3.40M
        if (vbits & 0x04)
141
3.40M
            VALGRIND_SET_VBITS(bend - spread*3, &ones, 1);
142
3.40M
        if (vbits & 0x02)
143
3.40M
            VALGRIND_SET_VBITS(bend - spread*2, &ones, 1);
144
3.40M
        if (vbits & 0x01)
145
3.40M
            VALGRIND_SET_VBITS(bend - spread*1, &ones, 1);
146
3.40M
    }
147
3.40M
#endif
148
3.40M
    *pdata_x = data_x & 7;
149
3.40M
    return bptr;
150
3.40M
}
sample_unpack_1
Line
Count
Source
47
3.40M
{
48
3.40M
    const sample_lookup_t * ptab = &smap->table;
49
3.40M
    const byte *psrc = data + (data_x >> 3);
50
3.40M
    int left = dsize - (data_x >> 3);
51
3.40M
    DEFINE_SMAP_INDEX
52
53
3.40M
#ifdef PACIFY_VALGRIND
54
3.40M
    byte *bend = bptr + left*spread;
55
3.40M
    byte vbits = 0;
56
57
    /* Allow for undefined bits at the end */
58
3.40M
    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.40M
    if ((vbits & 0x80) == 0) {
62
3.40M
        byte zero = 0;
63
3.40M
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
64
3.40M
    }
65
3.40M
#endif
66
67
3.40M
    if (spread == 1) {
68
3.40M
        bits32 *bufp = (bits32 *) bptr;
69
3.40M
        const bits32 *map = &ptab->lookup4x1to32[0];
70
3.40M
        uint b;
71
72
3.40M
        if (left & 1) {
73
62.1k
            b = psrc[0];
74
62.1k
            bufp[0] = map[b >> 4];
75
62.1k
            NEXT_MAP;
76
62.1k
            bufp[1] = map[b & 0xf];
77
62.1k
            NEXT_MAP;
78
62.1k
            psrc++, bufp += 2;
79
62.1k
        }
80
3.40M
        left >>= 1;
81
13.4M
        while (left--) {
82
10.0M
            b = psrc[0];
83
10.0M
            bufp[0] = map[b >> 4];
84
10.0M
            NEXT_MAP;
85
10.0M
            bufp[1] = map[b & 0xf];
86
10.0M
            NEXT_MAP;
87
10.0M
            b = psrc[1];
88
10.0M
            bufp[2] = map[b >> 4];
89
10.0M
            NEXT_MAP;
90
10.0M
            bufp[3] = map[b & 0xf];
91
10.0M
            NEXT_MAP;
92
10.0M
            psrc += 2, bufp += 4;
93
10.0M
        }
94
3.40M
    } 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.40M
#ifdef PACIFY_VALGRIND
128
    /* Put any undefinedness back, and carry it over to the output. */
129
3.40M
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
130
3.40M
    {
131
3.40M
        byte ones = 0xff;
132
3.40M
        if (vbits & 0x40)
133
3.40M
            VALGRIND_SET_VBITS(bend - spread*7, &ones, 1);
134
3.40M
        if (vbits & 0x20)
135
3.40M
            VALGRIND_SET_VBITS(bend - spread*6, &ones, 1);
136
3.40M
        if (vbits & 0x10)
137
3.40M
            VALGRIND_SET_VBITS(bend - spread*5, &ones, 1);
138
3.40M
        if (vbits & 0x08)
139
3.40M
            VALGRIND_SET_VBITS(bend - spread*4, &ones, 1);
140
3.40M
        if (vbits & 0x04)
141
3.40M
            VALGRIND_SET_VBITS(bend - spread*3, &ones, 1);
142
3.40M
        if (vbits & 0x02)
143
3.40M
            VALGRIND_SET_VBITS(bend - spread*2, &ones, 1);
144
3.40M
        if (vbits & 0x01)
145
3.40M
            VALGRIND_SET_VBITS(bend - spread*1, &ones, 1);
146
3.40M
    }
147
3.40M
#endif
148
3.40M
    *pdata_x = data_x & 7;
149
3.40M
    return bptr;
150
3.40M
}
sample_unpack_1_interleaved
Line
Count
Source
47
121
{
48
121
    const sample_lookup_t * ptab = &smap->table;
49
121
    const byte *psrc = data + (data_x >> 3);
50
121
    int left = dsize - (data_x >> 3);
51
121
    DEFINE_SMAP_INDEX
52
53
121
#ifdef PACIFY_VALGRIND
54
121
    byte *bend = bptr + left*spread;
55
121
    byte vbits = 0;
56
57
    /* Allow for undefined bits at the end */
58
121
    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
121
    if ((vbits & 0x80) == 0) {
62
121
        byte zero = 0;
63
121
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
64
121
    }
65
121
#endif
66
67
121
    if (spread == 1) {
68
121
        bits32 *bufp = (bits32 *) bptr;
69
121
        const bits32 *map = &ptab->lookup4x1to32[0];
70
121
        uint b;
71
72
121
        if (left & 1) {
73
121
            b = psrc[0];
74
121
            bufp[0] = map[b >> 4];
75
121
            NEXT_MAP;
76
121
            bufp[1] = map[b & 0xf];
77
121
            NEXT_MAP;
78
121
            psrc++, bufp += 2;
79
121
        }
80
121
        left >>= 1;
81
702
        while (left--) {
82
581
            b = psrc[0];
83
581
            bufp[0] = map[b >> 4];
84
581
            NEXT_MAP;
85
581
            bufp[1] = map[b & 0xf];
86
581
            NEXT_MAP;
87
581
            b = psrc[1];
88
581
            bufp[2] = map[b >> 4];
89
581
            NEXT_MAP;
90
581
            bufp[3] = map[b & 0xf];
91
581
            NEXT_MAP;
92
581
            psrc += 2, bufp += 4;
93
581
        }
94
121
    } 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
121
#ifdef PACIFY_VALGRIND
128
    /* Put any undefinedness back, and carry it over to the output. */
129
121
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
130
121
    {
131
121
        byte ones = 0xff;
132
121
        if (vbits & 0x40)
133
121
            VALGRIND_SET_VBITS(bend - spread*7, &ones, 1);
134
121
        if (vbits & 0x20)
135
121
            VALGRIND_SET_VBITS(bend - spread*6, &ones, 1);
136
121
        if (vbits & 0x10)
137
121
            VALGRIND_SET_VBITS(bend - spread*5, &ones, 1);
138
121
        if (vbits & 0x08)
139
121
            VALGRIND_SET_VBITS(bend - spread*4, &ones, 1);
140
121
        if (vbits & 0x04)
141
121
            VALGRIND_SET_VBITS(bend - spread*3, &ones, 1);
142
121
        if (vbits & 0x02)
143
121
            VALGRIND_SET_VBITS(bend - spread*2, &ones, 1);
144
121
        if (vbits & 0x01)
145
121
            VALGRIND_SET_VBITS(bend - spread*1, &ones, 1);
146
121
    }
147
121
#endif
148
121
    *pdata_x = data_x & 7;
149
121
    return bptr;
150
121
}
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
6.85k
{
165
6.85k
    const sample_lookup_t * ptab = &smap->table;
166
6.85k
    const byte *psrc = data + (data_x >> 2);
167
6.85k
    int left = dsize - (data_x >> 2);
168
6.85k
    DEFINE_SMAP_INDEX
169
170
6.85k
#ifdef PACIFY_VALGRIND
171
6.85k
    byte *bend = bptr + left*spread;
172
6.85k
    byte vbits = 0;
173
174
    /* Allow for undefined bits at the end */
175
6.85k
    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
6.85k
    if ((vbits & 0xC0) == 0) {
179
6.85k
        byte zero = 0;
180
6.85k
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
181
6.85k
    }
182
6.85k
#endif
183
184
6.85k
    if (spread == 1) {
185
6.85k
        bits16 *bufp = (bits16 *) bptr;
186
6.85k
        const bits16 *map = &ptab->lookup2x2to16[0];
187
188
614k
        while (left--) {
189
608k
            uint b = *psrc++;
190
191
608k
            *bufp++ = map[b >> 4];
192
608k
            NEXT_MAP;
193
608k
            *bufp++ = map[b & 0xf];
194
608k
            NEXT_MAP;
195
608k
        }
196
6.85k
    } 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
6.85k
    *pdata_x = data_x & 3;
218
6.85k
#ifdef PACIFY_VALGRIND
219
    /* Put any undefinedness back, and carry it over to the output. */
220
6.85k
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
221
6.85k
    {
222
6.85k
        byte ones = 0xff;
223
6.85k
        if (vbits & 0x30)
224
6.85k
            VALGRIND_SET_VBITS(bend - spread*3, &ones, 1);
225
6.85k
        if (vbits & 0x0C)
226
6.85k
            VALGRIND_SET_VBITS(bend - spread*2, &ones, 1);
227
6.85k
        if (vbits & 0x03)
228
6.85k
            VALGRIND_SET_VBITS(bend - spread*1, &ones, 1);
229
6.85k
    }
230
6.85k
#endif
231
6.85k
    return bptr;
232
6.85k
}
sample_unpack_2
Line
Count
Source
164
6.85k
{
165
6.85k
    const sample_lookup_t * ptab = &smap->table;
166
6.85k
    const byte *psrc = data + (data_x >> 2);
167
6.85k
    int left = dsize - (data_x >> 2);
168
6.85k
    DEFINE_SMAP_INDEX
169
170
6.85k
#ifdef PACIFY_VALGRIND
171
6.85k
    byte *bend = bptr + left*spread;
172
6.85k
    byte vbits = 0;
173
174
    /* Allow for undefined bits at the end */
175
6.85k
    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
6.85k
    if ((vbits & 0xC0) == 0) {
179
6.85k
        byte zero = 0;
180
6.85k
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
181
6.85k
    }
182
6.85k
#endif
183
184
6.85k
    if (spread == 1) {
185
6.85k
        bits16 *bufp = (bits16 *) bptr;
186
6.85k
        const bits16 *map = &ptab->lookup2x2to16[0];
187
188
614k
        while (left--) {
189
608k
            uint b = *psrc++;
190
191
608k
            *bufp++ = map[b >> 4];
192
608k
            NEXT_MAP;
193
608k
            *bufp++ = map[b & 0xf];
194
608k
            NEXT_MAP;
195
608k
        }
196
6.85k
    } 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
6.85k
    *pdata_x = data_x & 3;
218
6.85k
#ifdef PACIFY_VALGRIND
219
    /* Put any undefinedness back, and carry it over to the output. */
220
6.85k
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
221
6.85k
    {
222
6.85k
        byte ones = 0xff;
223
6.85k
        if (vbits & 0x30)
224
6.85k
            VALGRIND_SET_VBITS(bend - spread*3, &ones, 1);
225
6.85k
        if (vbits & 0x0C)
226
6.85k
            VALGRIND_SET_VBITS(bend - spread*2, &ones, 1);
227
6.85k
        if (vbits & 0x03)
228
6.85k
            VALGRIND_SET_VBITS(bend - spread*1, &ones, 1);
229
6.85k
    }
230
6.85k
#endif
231
6.85k
    return bptr;
232
6.85k
}
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
19.0k
{
241
19.0k
    const sample_lookup_t * ptab = &smap->table;
242
19.0k
    byte *bufp = bptr;
243
19.0k
    const byte *psrc = data + (data_x >> 1);
244
19.0k
    int left = dsize - (data_x >> 1);
245
19.0k
    const byte *map = &ptab->lookup8[0];
246
19.0k
    DEFINE_SMAP_INDEX
247
248
19.0k
#ifdef PACIFY_VALGRIND
249
19.0k
    byte vbits = 0;
250
251
    /* Allow for undefined bits at the end */
252
19.0k
    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
19.0k
    if ((vbits & 0xf0) == 0) {
256
19.0k
        byte zero = 0;
257
19.0k
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
258
19.0k
    }
259
19.0k
#endif
260
261
3.31M
    while (left--) {
262
3.29M
        uint b = *psrc++;
263
264
3.29M
        *bufp = map[b >> 4];
265
3.29M
        NEXT_MAP8;
266
3.29M
        bufp += spread;
267
3.29M
        *bufp = map[b & 0xf];
268
3.29M
        NEXT_MAP8;
269
3.29M
        bufp += spread;
270
3.29M
    }
271
19.0k
#ifdef PACIFY_VALGRIND
272
    /* Put any undefinedness back, and carry it over to the output. */
273
19.0k
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
274
19.0k
    if ((vbits & 0x0f) != 0) {
275
0
        byte ones = 0xFF;
276
0
        VALGRIND_SET_VBITS(bufp-spread, &ones, 1);
277
0
    }
278
19.0k
#endif
279
19.0k
    *pdata_x = data_x & 1;
280
19.0k
    return bptr;
281
19.0k
}
sample_unpack_4
Line
Count
Source
240
19.0k
{
241
19.0k
    const sample_lookup_t * ptab = &smap->table;
242
19.0k
    byte *bufp = bptr;
243
19.0k
    const byte *psrc = data + (data_x >> 1);
244
19.0k
    int left = dsize - (data_x >> 1);
245
19.0k
    const byte *map = &ptab->lookup8[0];
246
19.0k
    DEFINE_SMAP_INDEX
247
248
19.0k
#ifdef PACIFY_VALGRIND
249
19.0k
    byte vbits = 0;
250
251
    /* Allow for undefined bits at the end */
252
19.0k
    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
19.0k
    if ((vbits & 0xf0) == 0) {
256
19.0k
        byte zero = 0;
257
19.0k
        VALGRIND_SET_VBITS(&psrc[left-1], &zero, 1);
258
19.0k
    }
259
19.0k
#endif
260
261
3.31M
    while (left--) {
262
3.29M
        uint b = *psrc++;
263
264
3.29M
        *bufp = map[b >> 4];
265
3.29M
        NEXT_MAP8;
266
3.29M
        bufp += spread;
267
3.29M
        *bufp = map[b & 0xf];
268
3.29M
        NEXT_MAP8;
269
3.29M
        bufp += spread;
270
3.29M
    }
271
19.0k
#ifdef PACIFY_VALGRIND
272
    /* Put any undefinedness back, and carry it over to the output. */
273
19.0k
    VALGRIND_SET_VBITS(psrc-1, &vbits, 1);
274
19.0k
    if ((vbits & 0x0f) != 0) {
275
0
        byte ones = 0xFF;
276
0
        VALGRIND_SET_VBITS(bufp-spread, &ones, 1);
277
0
    }
278
19.0k
#endif
279
19.0k
    *pdata_x = data_x & 1;
280
19.0k
    return bptr;
281
19.0k
}
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
14.0M
{
288
14.0M
    const sample_lookup_t * ptab = &smap->table;
289
14.0M
    byte *bufp = bptr;
290
14.0M
    const byte *psrc = data + data_x;
291
14.0M
    DEFINE_SMAP_INDEX
292
293
14.0M
    *pdata_x = 0;
294
14.0M
    if (spread == 1) {
295
13.1M
        if (MULTIPLE_MAPS ||
296
13.1M
            ptab->lookup8[0] != 0 ||
297
13.1M
            ptab->lookup8[255] != 255
298
13.1M
            ) {
299
23.6k
            uint left = dsize - data_x;
300
23.6k
            const byte *map = &ptab->lookup8[0];
301
302
12.3M
            while (left--) {
303
12.3M
                *bufp++ = map[*psrc++];
304
12.3M
                NEXT_MAP8;
305
12.3M
            }
306
13.1M
        } else {   /* No copying needed, and we'll use the data right away. */
307
13.1M
            return psrc;
308
13.1M
        }
309
13.1M
    } else {
310
890k
        int left = dsize - data_x;
311
890k
        const byte *map = &ptab->lookup8[0];
312
313
712M
        for (; left--; psrc++, bufp += spread) {
314
711M
            *bufp = map[*psrc];
315
711M
            NEXT_MAP8;
316
711M
        }
317
890k
    }
318
913k
    return bptr;
319
14.0M
}
sample_unpack_8
Line
Count
Source
287
14.0M
{
288
14.0M
    const sample_lookup_t * ptab = &smap->table;
289
14.0M
    byte *bufp = bptr;
290
14.0M
    const byte *psrc = data + data_x;
291
14.0M
    DEFINE_SMAP_INDEX
292
293
14.0M
    *pdata_x = 0;
294
14.0M
    if (spread == 1) {
295
13.1M
        if (MULTIPLE_MAPS ||
296
13.1M
            ptab->lookup8[0] != 0 ||
297
13.1M
            ptab->lookup8[255] != 255
298
13.1M
            ) {
299
22.5k
            uint left = dsize - data_x;
300
22.5k
            const byte *map = &ptab->lookup8[0];
301
302
11.9M
            while (left--) {
303
11.9M
                *bufp++ = map[*psrc++];
304
11.9M
                NEXT_MAP8;
305
11.9M
            }
306
13.1M
        } else {   /* No copying needed, and we'll use the data right away. */
307
13.1M
            return psrc;
308
13.1M
        }
309
13.1M
    } else {
310
890k
        int left = dsize - data_x;
311
890k
        const byte *map = &ptab->lookup8[0];
312
313
712M
        for (; left--; psrc++, bufp += spread) {
314
711M
            *bufp = map[*psrc];
315
711M
            NEXT_MAP8;
316
711M
        }
317
890k
    }
318
912k
    return bptr;
319
14.0M
}
sample_unpack_8_interleaved
Line
Count
Source
287
1.03k
{
288
1.03k
    const sample_lookup_t * ptab = &smap->table;
289
1.03k
    byte *bufp = bptr;
290
1.03k
    const byte *psrc = data + data_x;
291
1.03k
    DEFINE_SMAP_INDEX
292
293
1.03k
    *pdata_x = 0;
294
1.03k
    if (spread == 1) {
295
1.03k
        if (MULTIPLE_MAPS ||
296
0
            ptab->lookup8[0] != 0 ||
297
0
            ptab->lookup8[255] != 255
298
1.03k
            ) {
299
1.03k
            uint left = dsize - data_x;
300
1.03k
            const byte *map = &ptab->lookup8[0];
301
302
396k
            while (left--) {
303
395k
                *bufp++ = map[*psrc++];
304
395k
                NEXT_MAP8;
305
395k
            }
306
1.03k
        } else {   /* No copying needed, and we'll use the data right away. */
307
0
            return psrc;
308
0
        }
309
1.03k
    } 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
1.03k
    return bptr;
319
1.03k
}
320
321
#undef NEXT_MAP
322
#undef NEXT_MAP8
323
#undef DEFINE_SMAP_INDEX
324
325
#else
326
int dummy;
327
#endif