Coverage Report

Created: 2026-08-08 08:00

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