Coverage Report

Created: 2026-02-26 07:09

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libjpeg-turbo.dev/src/jdcol565.c
Line
Count
Source
1
/*
2
 * jdcol565.c
3
 *
4
 * This file was part of the Independent JPEG Group's software:
5
 * Copyright (C) 1991-1997, Thomas G. Lane.
6
 * Modifications:
7
 * Copyright (C) 2013, Linaro Limited.
8
 * Copyright (C) 2014-2015, 2022, D. R. Commander.
9
 * For conditions of distribution and use, see the accompanying README.ijg
10
 * file.
11
 *
12
 * This file contains output colorspace conversion routines.
13
 */
14
15
/* This file is included by jdcolor.c */
16
17
18
INLINE
19
LOCAL(void)
20
ycc_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
21
                            JDIMENSION input_row, _JSAMPARRAY output_buf,
22
                            int num_rows)
23
7.47M
{
24
#if BITS_IN_JSAMPLE != 16
25
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
26
  register int y, cb, cr;
27
  register _JSAMPROW outptr;
28
  register _JSAMPROW inptr0, inptr1, inptr2;
29
  register JDIMENSION col;
30
  JDIMENSION num_cols = cinfo->output_width;
31
  /* copy these pointers into registers if possible */
32
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
33
  register int *Crrtab = cconvert->Cr_r_tab;
34
  register int *Cbbtab = cconvert->Cb_b_tab;
35
  register JLONG *Crgtab = cconvert->Cr_g_tab;
36
  register JLONG *Cbgtab = cconvert->Cb_g_tab;
37
  SHIFT_TEMPS
38
39
14.9M
  while (--num_rows >= 0) {
40
7.47M
    JLONG rgb;
41
7.47M
    unsigned int r, g, b;
42
7.47M
    inptr0 = input_buf[0][input_row];
43
7.47M
    inptr1 = input_buf[1][input_row];
44
7.47M
    inptr2 = input_buf[2][input_row];
45
7.47M
    input_row++;
46
7.47M
    outptr = *output_buf++;
47
48
7.47M
    if (PACK_NEED_ALIGNMENT(outptr)) {
49
0
      y  = *inptr0++;
50
0
      cb = *inptr1++;
51
0
      cr = *inptr2++;
52
0
      r = range_limit[y + Crrtab[cr]];
53
0
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
54
0
                                            SCALEBITS))];
55
0
      b = range_limit[y + Cbbtab[cb]];
56
0
      rgb = PACK_SHORT_565(r, g, b);
57
0
      *(INT16 *)outptr = (INT16)rgb;
58
0
      outptr += 2;
59
0
      num_cols--;
60
0
    }
61
134M
    for (col = 0; col < (num_cols >> 1); col++) {
62
126M
      y  = *inptr0++;
63
126M
      cb = *inptr1++;
64
126M
      cr = *inptr2++;
65
126M
      r = range_limit[y + Crrtab[cr]];
66
126M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
67
126M
                                            SCALEBITS))];
68
126M
      b = range_limit[y + Cbbtab[cb]];
69
126M
      rgb = PACK_SHORT_565(r, g, b);
70
71
126M
      y  = *inptr0++;
72
126M
      cb = *inptr1++;
73
126M
      cr = *inptr2++;
74
126M
      r = range_limit[y + Crrtab[cr]];
75
126M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
76
126M
                                            SCALEBITS))];
77
126M
      b = range_limit[y + Cbbtab[cb]];
78
126M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
79
80
126M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
81
126M
      outptr += 4;
82
126M
    }
83
7.47M
    if (num_cols & 1) {
84
410k
      y  = *inptr0;
85
410k
      cb = *inptr1;
86
410k
      cr = *inptr2;
87
410k
      r = range_limit[y + Crrtab[cr]];
88
410k
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
89
410k
                                            SCALEBITS))];
90
410k
      b = range_limit[y + Cbbtab[cb]];
91
410k
      rgb = PACK_SHORT_565(r, g, b);
92
410k
      *(INT16 *)outptr = (INT16)rgb;
93
410k
    }
94
7.47M
  }
95
#else
96
0
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
97
#endif
98
7.47M
}
Unexecuted instantiation: jdcolor-8.c:ycc_rgb565_convert_be
jdcolor-8.c:ycc_rgb565_convert_le
Line
Count
Source
23
7.47M
{
24
7.47M
#if BITS_IN_JSAMPLE != 16
25
7.47M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
26
7.47M
  register int y, cb, cr;
27
7.47M
  register _JSAMPROW outptr;
28
7.47M
  register _JSAMPROW inptr0, inptr1, inptr2;
29
7.47M
  register JDIMENSION col;
30
7.47M
  JDIMENSION num_cols = cinfo->output_width;
31
  /* copy these pointers into registers if possible */
32
7.47M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
33
7.47M
  register int *Crrtab = cconvert->Cr_r_tab;
34
7.47M
  register int *Cbbtab = cconvert->Cb_b_tab;
35
7.47M
  register JLONG *Crgtab = cconvert->Cr_g_tab;
36
7.47M
  register JLONG *Cbgtab = cconvert->Cb_g_tab;
37
7.47M
  SHIFT_TEMPS
38
39
14.9M
  while (--num_rows >= 0) {
40
7.47M
    JLONG rgb;
41
7.47M
    unsigned int r, g, b;
42
7.47M
    inptr0 = input_buf[0][input_row];
43
7.47M
    inptr1 = input_buf[1][input_row];
44
7.47M
    inptr2 = input_buf[2][input_row];
45
7.47M
    input_row++;
46
7.47M
    outptr = *output_buf++;
47
48
7.47M
    if (PACK_NEED_ALIGNMENT(outptr)) {
49
0
      y  = *inptr0++;
50
0
      cb = *inptr1++;
51
0
      cr = *inptr2++;
52
0
      r = range_limit[y + Crrtab[cr]];
53
0
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
54
0
                                            SCALEBITS))];
55
0
      b = range_limit[y + Cbbtab[cb]];
56
0
      rgb = PACK_SHORT_565(r, g, b);
57
0
      *(INT16 *)outptr = (INT16)rgb;
58
0
      outptr += 2;
59
0
      num_cols--;
60
0
    }
61
134M
    for (col = 0; col < (num_cols >> 1); col++) {
62
126M
      y  = *inptr0++;
63
126M
      cb = *inptr1++;
64
126M
      cr = *inptr2++;
65
126M
      r = range_limit[y + Crrtab[cr]];
66
126M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
67
126M
                                            SCALEBITS))];
68
126M
      b = range_limit[y + Cbbtab[cb]];
69
126M
      rgb = PACK_SHORT_565(r, g, b);
70
71
126M
      y  = *inptr0++;
72
126M
      cb = *inptr1++;
73
126M
      cr = *inptr2++;
74
126M
      r = range_limit[y + Crrtab[cr]];
75
126M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
76
126M
                                            SCALEBITS))];
77
126M
      b = range_limit[y + Cbbtab[cb]];
78
126M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
79
80
126M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
81
126M
      outptr += 4;
82
126M
    }
83
7.47M
    if (num_cols & 1) {
84
410k
      y  = *inptr0;
85
410k
      cb = *inptr1;
86
410k
      cr = *inptr2;
87
410k
      r = range_limit[y + Crrtab[cr]];
88
410k
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
89
410k
                                            SCALEBITS))];
90
410k
      b = range_limit[y + Cbbtab[cb]];
91
410k
      rgb = PACK_SHORT_565(r, g, b);
92
410k
      *(INT16 *)outptr = (INT16)rgb;
93
410k
    }
94
7.47M
  }
95
#else
96
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
97
#endif
98
7.47M
}
Unexecuted instantiation: jdcolor-12.c:ycc_rgb565_convert_be
Unexecuted instantiation: jdcolor-12.c:ycc_rgb565_convert_le
Unexecuted instantiation: jdcolor-16.c:ycc_rgb565_convert_be
Unexecuted instantiation: jdcolor-16.c:ycc_rgb565_convert_le
99
100
101
INLINE
102
LOCAL(void)
103
ycc_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
104
                             JDIMENSION input_row, _JSAMPARRAY output_buf,
105
                             int num_rows)
106
5.64M
{
107
#if BITS_IN_JSAMPLE != 16
108
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
109
  register int y, cb, cr;
110
  register _JSAMPROW outptr;
111
  register _JSAMPROW inptr0, inptr1, inptr2;
112
  register JDIMENSION col;
113
  JDIMENSION num_cols = cinfo->output_width;
114
  /* copy these pointers into registers if possible */
115
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
116
  register int *Crrtab = cconvert->Cr_r_tab;
117
  register int *Cbbtab = cconvert->Cb_b_tab;
118
  register JLONG *Crgtab = cconvert->Cr_g_tab;
119
  register JLONG *Cbgtab = cconvert->Cb_g_tab;
120
5.64M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
121
  SHIFT_TEMPS
122
123
11.2M
  while (--num_rows >= 0) {
124
5.64M
    JLONG rgb;
125
5.64M
    unsigned int r, g, b;
126
127
5.64M
    inptr0 = input_buf[0][input_row];
128
5.64M
    inptr1 = input_buf[1][input_row];
129
5.64M
    inptr2 = input_buf[2][input_row];
130
5.64M
    input_row++;
131
5.64M
    outptr = *output_buf++;
132
5.64M
    if (PACK_NEED_ALIGNMENT(outptr)) {
133
0
      y  = *inptr0++;
134
0
      cb = *inptr1++;
135
0
      cr = *inptr2++;
136
0
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
137
0
      g = range_limit[DITHER_565_G(y +
138
0
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
139
0
                                                     SCALEBITS)), d0)];
140
0
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
141
0
      rgb = PACK_SHORT_565(r, g, b);
142
0
      *(INT16 *)outptr = (INT16)rgb;
143
0
      outptr += 2;
144
0
      num_cols--;
145
0
    }
146
98.2M
    for (col = 0; col < (num_cols >> 1); col++) {
147
92.5M
      y  = *inptr0++;
148
92.5M
      cb = *inptr1++;
149
92.5M
      cr = *inptr2++;
150
92.5M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
151
92.5M
      g = range_limit[DITHER_565_G(y +
152
92.5M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
153
92.5M
                                                     SCALEBITS)), d0)];
154
92.5M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
155
92.5M
      d0 = DITHER_ROTATE(d0);
156
92.5M
      rgb = PACK_SHORT_565(r, g, b);
157
158
92.5M
      y  = *inptr0++;
159
92.5M
      cb = *inptr1++;
160
92.5M
      cr = *inptr2++;
161
92.5M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
162
92.5M
      g = range_limit[DITHER_565_G(y +
163
92.5M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
164
92.5M
                                                     SCALEBITS)), d0)];
165
92.5M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
166
92.5M
      d0 = DITHER_ROTATE(d0);
167
92.5M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
168
169
92.5M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
170
92.5M
      outptr += 4;
171
92.5M
    }
172
5.64M
    if (num_cols & 1) {
173
284k
      y  = *inptr0;
174
284k
      cb = *inptr1;
175
284k
      cr = *inptr2;
176
284k
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
177
284k
      g = range_limit[DITHER_565_G(y +
178
284k
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
179
284k
                                                     SCALEBITS)), d0)];
180
284k
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
181
284k
      rgb = PACK_SHORT_565(r, g, b);
182
284k
      *(INT16 *)outptr = (INT16)rgb;
183
284k
    }
184
5.64M
  }
185
#else
186
0
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
187
#endif
188
5.64M
}
Unexecuted instantiation: jdcolor-8.c:ycc_rgb565D_convert_be
jdcolor-8.c:ycc_rgb565D_convert_le
Line
Count
Source
106
5.64M
{
107
5.64M
#if BITS_IN_JSAMPLE != 16
108
5.64M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
109
5.64M
  register int y, cb, cr;
110
5.64M
  register _JSAMPROW outptr;
111
5.64M
  register _JSAMPROW inptr0, inptr1, inptr2;
112
5.64M
  register JDIMENSION col;
113
5.64M
  JDIMENSION num_cols = cinfo->output_width;
114
  /* copy these pointers into registers if possible */
115
5.64M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
116
5.64M
  register int *Crrtab = cconvert->Cr_r_tab;
117
5.64M
  register int *Cbbtab = cconvert->Cb_b_tab;
118
5.64M
  register JLONG *Crgtab = cconvert->Cr_g_tab;
119
5.64M
  register JLONG *Cbgtab = cconvert->Cb_g_tab;
120
5.64M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
121
5.64M
  SHIFT_TEMPS
122
123
11.2M
  while (--num_rows >= 0) {
124
5.64M
    JLONG rgb;
125
5.64M
    unsigned int r, g, b;
126
127
5.64M
    inptr0 = input_buf[0][input_row];
128
5.64M
    inptr1 = input_buf[1][input_row];
129
5.64M
    inptr2 = input_buf[2][input_row];
130
5.64M
    input_row++;
131
5.64M
    outptr = *output_buf++;
132
5.64M
    if (PACK_NEED_ALIGNMENT(outptr)) {
133
0
      y  = *inptr0++;
134
0
      cb = *inptr1++;
135
0
      cr = *inptr2++;
136
0
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
137
0
      g = range_limit[DITHER_565_G(y +
138
0
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
139
0
                                                     SCALEBITS)), d0)];
140
0
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
141
0
      rgb = PACK_SHORT_565(r, g, b);
142
0
      *(INT16 *)outptr = (INT16)rgb;
143
0
      outptr += 2;
144
0
      num_cols--;
145
0
    }
146
98.2M
    for (col = 0; col < (num_cols >> 1); col++) {
147
92.5M
      y  = *inptr0++;
148
92.5M
      cb = *inptr1++;
149
92.5M
      cr = *inptr2++;
150
92.5M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
151
92.5M
      g = range_limit[DITHER_565_G(y +
152
92.5M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
153
92.5M
                                                     SCALEBITS)), d0)];
154
92.5M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
155
92.5M
      d0 = DITHER_ROTATE(d0);
156
92.5M
      rgb = PACK_SHORT_565(r, g, b);
157
158
92.5M
      y  = *inptr0++;
159
92.5M
      cb = *inptr1++;
160
92.5M
      cr = *inptr2++;
161
92.5M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
162
92.5M
      g = range_limit[DITHER_565_G(y +
163
92.5M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
164
92.5M
                                                     SCALEBITS)), d0)];
165
92.5M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
166
92.5M
      d0 = DITHER_ROTATE(d0);
167
92.5M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
168
169
92.5M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
170
92.5M
      outptr += 4;
171
92.5M
    }
172
5.64M
    if (num_cols & 1) {
173
284k
      y  = *inptr0;
174
284k
      cb = *inptr1;
175
284k
      cr = *inptr2;
176
284k
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
177
284k
      g = range_limit[DITHER_565_G(y +
178
284k
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
179
284k
                                                     SCALEBITS)), d0)];
180
284k
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
181
284k
      rgb = PACK_SHORT_565(r, g, b);
182
284k
      *(INT16 *)outptr = (INT16)rgb;
183
284k
    }
184
5.64M
  }
185
#else
186
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
187
#endif
188
5.64M
}
Unexecuted instantiation: jdcolor-12.c:ycc_rgb565D_convert_be
Unexecuted instantiation: jdcolor-12.c:ycc_rgb565D_convert_le
Unexecuted instantiation: jdcolor-16.c:ycc_rgb565D_convert_be
Unexecuted instantiation: jdcolor-16.c:ycc_rgb565D_convert_le
189
190
191
INLINE
192
LOCAL(void)
193
rgb_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
194
                            JDIMENSION input_row, _JSAMPARRAY output_buf,
195
                            int num_rows)
196
436k
{
197
436k
  register _JSAMPROW outptr;
198
436k
  register _JSAMPROW inptr0, inptr1, inptr2;
199
436k
  register JDIMENSION col;
200
436k
  JDIMENSION num_cols = cinfo->output_width;
201
436k
  SHIFT_TEMPS
202
203
872k
  while (--num_rows >= 0) {
204
436k
    JLONG rgb;
205
436k
    unsigned int r, g, b;
206
207
436k
    inptr0 = input_buf[0][input_row];
208
436k
    inptr1 = input_buf[1][input_row];
209
436k
    inptr2 = input_buf[2][input_row];
210
436k
    input_row++;
211
436k
    outptr = *output_buf++;
212
436k
    if (PACK_NEED_ALIGNMENT(outptr)) {
213
0
      r = *inptr0++;
214
0
      g = *inptr1++;
215
0
      b = *inptr2++;
216
0
      rgb = PACK_SHORT_565(r, g, b);
217
0
      *(INT16 *)outptr = (INT16)rgb;
218
0
      outptr += 2;
219
0
      num_cols--;
220
0
    }
221
13.0M
    for (col = 0; col < (num_cols >> 1); col++) {
222
12.5M
      r = *inptr0++;
223
12.5M
      g = *inptr1++;
224
12.5M
      b = *inptr2++;
225
12.5M
      rgb = PACK_SHORT_565(r, g, b);
226
227
12.5M
      r = *inptr0++;
228
12.5M
      g = *inptr1++;
229
12.5M
      b = *inptr2++;
230
12.5M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
231
232
12.5M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
233
12.5M
      outptr += 4;
234
12.5M
    }
235
436k
    if (num_cols & 1) {
236
50.5k
      r = *inptr0;
237
50.5k
      g = *inptr1;
238
50.5k
      b = *inptr2;
239
50.5k
      rgb = PACK_SHORT_565(r, g, b);
240
50.5k
      *(INT16 *)outptr = (INT16)rgb;
241
50.5k
    }
242
436k
  }
243
436k
}
Unexecuted instantiation: jdcolor-8.c:rgb_rgb565_convert_be
jdcolor-8.c:rgb_rgb565_convert_le
Line
Count
Source
196
436k
{
197
436k
  register _JSAMPROW outptr;
198
436k
  register _JSAMPROW inptr0, inptr1, inptr2;
199
436k
  register JDIMENSION col;
200
436k
  JDIMENSION num_cols = cinfo->output_width;
201
436k
  SHIFT_TEMPS
202
203
872k
  while (--num_rows >= 0) {
204
436k
    JLONG rgb;
205
436k
    unsigned int r, g, b;
206
207
436k
    inptr0 = input_buf[0][input_row];
208
436k
    inptr1 = input_buf[1][input_row];
209
436k
    inptr2 = input_buf[2][input_row];
210
436k
    input_row++;
211
436k
    outptr = *output_buf++;
212
436k
    if (PACK_NEED_ALIGNMENT(outptr)) {
213
0
      r = *inptr0++;
214
0
      g = *inptr1++;
215
0
      b = *inptr2++;
216
0
      rgb = PACK_SHORT_565(r, g, b);
217
0
      *(INT16 *)outptr = (INT16)rgb;
218
0
      outptr += 2;
219
0
      num_cols--;
220
0
    }
221
13.0M
    for (col = 0; col < (num_cols >> 1); col++) {
222
12.5M
      r = *inptr0++;
223
12.5M
      g = *inptr1++;
224
12.5M
      b = *inptr2++;
225
12.5M
      rgb = PACK_SHORT_565(r, g, b);
226
227
12.5M
      r = *inptr0++;
228
12.5M
      g = *inptr1++;
229
12.5M
      b = *inptr2++;
230
12.5M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
231
232
12.5M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
233
12.5M
      outptr += 4;
234
12.5M
    }
235
436k
    if (num_cols & 1) {
236
50.5k
      r = *inptr0;
237
50.5k
      g = *inptr1;
238
50.5k
      b = *inptr2;
239
50.5k
      rgb = PACK_SHORT_565(r, g, b);
240
50.5k
      *(INT16 *)outptr = (INT16)rgb;
241
50.5k
    }
242
436k
  }
243
436k
}
Unexecuted instantiation: jdcolor-12.c:rgb_rgb565_convert_be
Unexecuted instantiation: jdcolor-12.c:rgb_rgb565_convert_le
Unexecuted instantiation: jdcolor-16.c:rgb_rgb565_convert_be
Unexecuted instantiation: jdcolor-16.c:rgb_rgb565_convert_le
244
245
246
INLINE
247
LOCAL(void)
248
rgb_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
249
                             JDIMENSION input_row, _JSAMPARRAY output_buf,
250
                             int num_rows)
251
320k
{
252
320k
  register _JSAMPROW outptr;
253
320k
  register _JSAMPROW inptr0, inptr1, inptr2;
254
320k
  register JDIMENSION col;
255
320k
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
256
320k
  JDIMENSION num_cols = cinfo->output_width;
257
320k
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
258
320k
  SHIFT_TEMPS
259
260
641k
  while (--num_rows >= 0) {
261
320k
    JLONG rgb;
262
320k
    unsigned int r, g, b;
263
264
320k
    inptr0 = input_buf[0][input_row];
265
320k
    inptr1 = input_buf[1][input_row];
266
320k
    inptr2 = input_buf[2][input_row];
267
320k
    input_row++;
268
320k
    outptr = *output_buf++;
269
320k
    if (PACK_NEED_ALIGNMENT(outptr)) {
270
0
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
271
0
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
272
0
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
273
0
      rgb = PACK_SHORT_565(r, g, b);
274
0
      *(INT16 *)outptr = (INT16)rgb;
275
0
      outptr += 2;
276
0
      num_cols--;
277
0
    }
278
8.78M
    for (col = 0; col < (num_cols >> 1); col++) {
279
8.45M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
280
8.45M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
281
8.45M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
282
8.45M
      d0 = DITHER_ROTATE(d0);
283
8.45M
      rgb = PACK_SHORT_565(r, g, b);
284
285
8.45M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
286
8.45M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
287
8.45M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
288
8.45M
      d0 = DITHER_ROTATE(d0);
289
8.45M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
290
291
8.45M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
292
8.45M
      outptr += 4;
293
8.45M
    }
294
320k
    if (num_cols & 1) {
295
22.6k
      r = range_limit[DITHER_565_R(*inptr0, d0)];
296
22.6k
      g = range_limit[DITHER_565_G(*inptr1, d0)];
297
22.6k
      b = range_limit[DITHER_565_B(*inptr2, d0)];
298
22.6k
      rgb = PACK_SHORT_565(r, g, b);
299
22.6k
      *(INT16 *)outptr = (INT16)rgb;
300
22.6k
    }
301
320k
  }
302
320k
}
Unexecuted instantiation: jdcolor-8.c:rgb_rgb565D_convert_be
jdcolor-8.c:rgb_rgb565D_convert_le
Line
Count
Source
251
320k
{
252
320k
  register _JSAMPROW outptr;
253
320k
  register _JSAMPROW inptr0, inptr1, inptr2;
254
320k
  register JDIMENSION col;
255
320k
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
256
320k
  JDIMENSION num_cols = cinfo->output_width;
257
320k
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
258
320k
  SHIFT_TEMPS
259
260
641k
  while (--num_rows >= 0) {
261
320k
    JLONG rgb;
262
320k
    unsigned int r, g, b;
263
264
320k
    inptr0 = input_buf[0][input_row];
265
320k
    inptr1 = input_buf[1][input_row];
266
320k
    inptr2 = input_buf[2][input_row];
267
320k
    input_row++;
268
320k
    outptr = *output_buf++;
269
320k
    if (PACK_NEED_ALIGNMENT(outptr)) {
270
0
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
271
0
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
272
0
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
273
0
      rgb = PACK_SHORT_565(r, g, b);
274
0
      *(INT16 *)outptr = (INT16)rgb;
275
0
      outptr += 2;
276
0
      num_cols--;
277
0
    }
278
8.78M
    for (col = 0; col < (num_cols >> 1); col++) {
279
8.45M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
280
8.45M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
281
8.45M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
282
8.45M
      d0 = DITHER_ROTATE(d0);
283
8.45M
      rgb = PACK_SHORT_565(r, g, b);
284
285
8.45M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
286
8.45M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
287
8.45M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
288
8.45M
      d0 = DITHER_ROTATE(d0);
289
8.45M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
290
291
8.45M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
292
8.45M
      outptr += 4;
293
8.45M
    }
294
320k
    if (num_cols & 1) {
295
22.6k
      r = range_limit[DITHER_565_R(*inptr0, d0)];
296
22.6k
      g = range_limit[DITHER_565_G(*inptr1, d0)];
297
22.6k
      b = range_limit[DITHER_565_B(*inptr2, d0)];
298
22.6k
      rgb = PACK_SHORT_565(r, g, b);
299
22.6k
      *(INT16 *)outptr = (INT16)rgb;
300
22.6k
    }
301
320k
  }
302
320k
}
Unexecuted instantiation: jdcolor-12.c:rgb_rgb565D_convert_be
Unexecuted instantiation: jdcolor-12.c:rgb_rgb565D_convert_le
Unexecuted instantiation: jdcolor-16.c:rgb_rgb565D_convert_be
Unexecuted instantiation: jdcolor-16.c:rgb_rgb565D_convert_le
303
304
305
INLINE
306
LOCAL(void)
307
gray_rgb565_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
308
                             JDIMENSION input_row, _JSAMPARRAY output_buf,
309
                             int num_rows)
310
8.15M
{
311
8.15M
  register _JSAMPROW inptr, outptr;
312
8.15M
  register JDIMENSION col;
313
8.15M
  JDIMENSION num_cols = cinfo->output_width;
314
315
16.3M
  while (--num_rows >= 0) {
316
8.15M
    JLONG rgb;
317
8.15M
    unsigned int g;
318
319
8.15M
    inptr = input_buf[0][input_row++];
320
8.15M
    outptr = *output_buf++;
321
8.15M
    if (PACK_NEED_ALIGNMENT(outptr)) {
322
0
      g = *inptr++;
323
0
      rgb = PACK_SHORT_565(g, g, g);
324
0
      *(INT16 *)outptr = (INT16)rgb;
325
0
      outptr += 2;
326
0
      num_cols--;
327
0
    }
328
93.2M
    for (col = 0; col < (num_cols >> 1); col++) {
329
85.0M
      g = *inptr++;
330
85.0M
      rgb = PACK_SHORT_565(g, g, g);
331
85.0M
      g = *inptr++;
332
85.0M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
333
85.0M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
334
85.0M
      outptr += 4;
335
85.0M
    }
336
8.15M
    if (num_cols & 1) {
337
7.05M
      g = *inptr;
338
7.05M
      rgb = PACK_SHORT_565(g, g, g);
339
7.05M
      *(INT16 *)outptr = (INT16)rgb;
340
7.05M
    }
341
8.15M
  }
342
8.15M
}
Unexecuted instantiation: jdcolor-8.c:gray_rgb565_convert_be
jdcolor-8.c:gray_rgb565_convert_le
Line
Count
Source
310
8.15M
{
311
8.15M
  register _JSAMPROW inptr, outptr;
312
8.15M
  register JDIMENSION col;
313
8.15M
  JDIMENSION num_cols = cinfo->output_width;
314
315
16.3M
  while (--num_rows >= 0) {
316
8.15M
    JLONG rgb;
317
8.15M
    unsigned int g;
318
319
8.15M
    inptr = input_buf[0][input_row++];
320
8.15M
    outptr = *output_buf++;
321
8.15M
    if (PACK_NEED_ALIGNMENT(outptr)) {
322
0
      g = *inptr++;
323
0
      rgb = PACK_SHORT_565(g, g, g);
324
0
      *(INT16 *)outptr = (INT16)rgb;
325
0
      outptr += 2;
326
0
      num_cols--;
327
0
    }
328
93.2M
    for (col = 0; col < (num_cols >> 1); col++) {
329
85.0M
      g = *inptr++;
330
85.0M
      rgb = PACK_SHORT_565(g, g, g);
331
85.0M
      g = *inptr++;
332
85.0M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
333
85.0M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
334
85.0M
      outptr += 4;
335
85.0M
    }
336
8.15M
    if (num_cols & 1) {
337
7.05M
      g = *inptr;
338
7.05M
      rgb = PACK_SHORT_565(g, g, g);
339
7.05M
      *(INT16 *)outptr = (INT16)rgb;
340
7.05M
    }
341
8.15M
  }
342
8.15M
}
Unexecuted instantiation: jdcolor-12.c:gray_rgb565_convert_be
Unexecuted instantiation: jdcolor-12.c:gray_rgb565_convert_le
Unexecuted instantiation: jdcolor-16.c:gray_rgb565_convert_be
Unexecuted instantiation: jdcolor-16.c:gray_rgb565_convert_le
343
344
345
INLINE
346
LOCAL(void)
347
gray_rgb565D_convert_internal(j_decompress_ptr cinfo, _JSAMPIMAGE input_buf,
348
                              JDIMENSION input_row, _JSAMPARRAY output_buf,
349
                              int num_rows)
350
5.26M
{
351
5.26M
  register _JSAMPROW inptr, outptr;
352
5.26M
  register JDIMENSION col;
353
5.26M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
354
5.26M
  JDIMENSION num_cols = cinfo->output_width;
355
5.26M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
356
357
10.5M
  while (--num_rows >= 0) {
358
5.26M
    JLONG rgb;
359
5.26M
    unsigned int g;
360
361
5.26M
    inptr = input_buf[0][input_row++];
362
5.26M
    outptr = *output_buf++;
363
5.26M
    if (PACK_NEED_ALIGNMENT(outptr)) {
364
0
      g = *inptr++;
365
0
      g = range_limit[DITHER_565_R(g, d0)];
366
0
      rgb = PACK_SHORT_565(g, g, g);
367
0
      *(INT16 *)outptr = (INT16)rgb;
368
0
      outptr += 2;
369
0
      num_cols--;
370
0
    }
371
44.9M
    for (col = 0; col < (num_cols >> 1); col++) {
372
39.7M
      g = *inptr++;
373
39.7M
      g = range_limit[DITHER_565_R(g, d0)];
374
39.7M
      rgb = PACK_SHORT_565(g, g, g);
375
39.7M
      d0 = DITHER_ROTATE(d0);
376
377
39.7M
      g = *inptr++;
378
39.7M
      g = range_limit[DITHER_565_R(g, d0)];
379
39.7M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
380
39.7M
      d0 = DITHER_ROTATE(d0);
381
382
39.7M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
383
39.7M
      outptr += 4;
384
39.7M
    }
385
5.26M
    if (num_cols & 1) {
386
4.79M
      g = *inptr;
387
4.79M
      g = range_limit[DITHER_565_R(g, d0)];
388
4.79M
      rgb = PACK_SHORT_565(g, g, g);
389
4.79M
      *(INT16 *)outptr = (INT16)rgb;
390
4.79M
    }
391
5.26M
  }
392
5.26M
}
Unexecuted instantiation: jdcolor-8.c:gray_rgb565D_convert_be
jdcolor-8.c:gray_rgb565D_convert_le
Line
Count
Source
350
5.26M
{
351
5.26M
  register _JSAMPROW inptr, outptr;
352
5.26M
  register JDIMENSION col;
353
5.26M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
354
5.26M
  JDIMENSION num_cols = cinfo->output_width;
355
5.26M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
356
357
10.5M
  while (--num_rows >= 0) {
358
5.26M
    JLONG rgb;
359
5.26M
    unsigned int g;
360
361
5.26M
    inptr = input_buf[0][input_row++];
362
5.26M
    outptr = *output_buf++;
363
5.26M
    if (PACK_NEED_ALIGNMENT(outptr)) {
364
0
      g = *inptr++;
365
0
      g = range_limit[DITHER_565_R(g, d0)];
366
0
      rgb = PACK_SHORT_565(g, g, g);
367
0
      *(INT16 *)outptr = (INT16)rgb;
368
0
      outptr += 2;
369
0
      num_cols--;
370
0
    }
371
44.9M
    for (col = 0; col < (num_cols >> 1); col++) {
372
39.7M
      g = *inptr++;
373
39.7M
      g = range_limit[DITHER_565_R(g, d0)];
374
39.7M
      rgb = PACK_SHORT_565(g, g, g);
375
39.7M
      d0 = DITHER_ROTATE(d0);
376
377
39.7M
      g = *inptr++;
378
39.7M
      g = range_limit[DITHER_565_R(g, d0)];
379
39.7M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
380
39.7M
      d0 = DITHER_ROTATE(d0);
381
382
39.7M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
383
39.7M
      outptr += 4;
384
39.7M
    }
385
5.26M
    if (num_cols & 1) {
386
4.79M
      g = *inptr;
387
4.79M
      g = range_limit[DITHER_565_R(g, d0)];
388
4.79M
      rgb = PACK_SHORT_565(g, g, g);
389
4.79M
      *(INT16 *)outptr = (INT16)rgb;
390
4.79M
    }
391
5.26M
  }
392
5.26M
}
Unexecuted instantiation: jdcolor-12.c:gray_rgb565D_convert_be
Unexecuted instantiation: jdcolor-12.c:gray_rgb565D_convert_le
Unexecuted instantiation: jdcolor-16.c:gray_rgb565D_convert_be
Unexecuted instantiation: jdcolor-16.c:gray_rgb565D_convert_le