Coverage Report

Created: 2026-08-31 07:19

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libjpeg-turbo.main/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
23.9M
{
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
47.8M
  while (--num_rows >= 0) {
40
23.9M
    JLONG rgb;
41
23.9M
    unsigned int r, g, b;
42
23.9M
    inptr0 = input_buf[0][input_row];
43
23.9M
    inptr1 = input_buf[1][input_row];
44
23.9M
    inptr2 = input_buf[2][input_row];
45
23.9M
    input_row++;
46
23.9M
    outptr = *output_buf++;
47
48
23.9M
    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
454M
    for (col = 0; col < (num_cols >> 1); col++) {
62
430M
      y  = *inptr0++;
63
430M
      cb = *inptr1++;
64
430M
      cr = *inptr2++;
65
430M
      r = range_limit[y + Crrtab[cr]];
66
430M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
67
430M
                                            SCALEBITS))];
68
430M
      b = range_limit[y + Cbbtab[cb]];
69
430M
      rgb = PACK_SHORT_565(r, g, b);
70
71
430M
      y  = *inptr0++;
72
430M
      cb = *inptr1++;
73
430M
      cr = *inptr2++;
74
430M
      r = range_limit[y + Crrtab[cr]];
75
430M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
76
430M
                                            SCALEBITS))];
77
430M
      b = range_limit[y + Cbbtab[cb]];
78
430M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
79
80
430M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
81
430M
      outptr += 4;
82
430M
    }
83
23.9M
    if (num_cols & 1) {
84
4.91M
      y  = *inptr0;
85
4.91M
      cb = *inptr1;
86
4.91M
      cr = *inptr2;
87
4.91M
      r = range_limit[y + Crrtab[cr]];
88
4.91M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
89
4.91M
                                            SCALEBITS))];
90
4.91M
      b = range_limit[y + Cbbtab[cb]];
91
4.91M
      rgb = PACK_SHORT_565(r, g, b);
92
4.91M
      *(INT16 *)outptr = (INT16)rgb;
93
4.91M
    }
94
23.9M
  }
95
#else
96
0
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
97
#endif
98
23.9M
}
Unexecuted instantiation: jdcolor-8.c:ycc_rgb565_convert_be
jdcolor-8.c:ycc_rgb565_convert_le
Line
Count
Source
23
23.9M
{
24
23.9M
#if BITS_IN_JSAMPLE != 16
25
23.9M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
26
23.9M
  register int y, cb, cr;
27
23.9M
  register _JSAMPROW outptr;
28
23.9M
  register _JSAMPROW inptr0, inptr1, inptr2;
29
23.9M
  register JDIMENSION col;
30
23.9M
  JDIMENSION num_cols = cinfo->output_width;
31
  /* copy these pointers into registers if possible */
32
23.9M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
33
23.9M
  register int *Crrtab = cconvert->Cr_r_tab;
34
23.9M
  register int *Cbbtab = cconvert->Cb_b_tab;
35
23.9M
  register JLONG *Crgtab = cconvert->Cr_g_tab;
36
23.9M
  register JLONG *Cbgtab = cconvert->Cb_g_tab;
37
23.9M
  SHIFT_TEMPS
38
39
47.8M
  while (--num_rows >= 0) {
40
23.9M
    JLONG rgb;
41
23.9M
    unsigned int r, g, b;
42
23.9M
    inptr0 = input_buf[0][input_row];
43
23.9M
    inptr1 = input_buf[1][input_row];
44
23.9M
    inptr2 = input_buf[2][input_row];
45
23.9M
    input_row++;
46
23.9M
    outptr = *output_buf++;
47
48
23.9M
    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
454M
    for (col = 0; col < (num_cols >> 1); col++) {
62
430M
      y  = *inptr0++;
63
430M
      cb = *inptr1++;
64
430M
      cr = *inptr2++;
65
430M
      r = range_limit[y + Crrtab[cr]];
66
430M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
67
430M
                                            SCALEBITS))];
68
430M
      b = range_limit[y + Cbbtab[cb]];
69
430M
      rgb = PACK_SHORT_565(r, g, b);
70
71
430M
      y  = *inptr0++;
72
430M
      cb = *inptr1++;
73
430M
      cr = *inptr2++;
74
430M
      r = range_limit[y + Crrtab[cr]];
75
430M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
76
430M
                                            SCALEBITS))];
77
430M
      b = range_limit[y + Cbbtab[cb]];
78
430M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
79
80
430M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
81
430M
      outptr += 4;
82
430M
    }
83
23.9M
    if (num_cols & 1) {
84
4.91M
      y  = *inptr0;
85
4.91M
      cb = *inptr1;
86
4.91M
      cr = *inptr2;
87
4.91M
      r = range_limit[y + Crrtab[cr]];
88
4.91M
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
89
4.91M
                                            SCALEBITS))];
90
4.91M
      b = range_limit[y + Cbbtab[cb]];
91
4.91M
      rgb = PACK_SHORT_565(r, g, b);
92
4.91M
      *(INT16 *)outptr = (INT16)rgb;
93
4.91M
    }
94
23.9M
  }
95
#else
96
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
97
#endif
98
23.9M
}
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
21.4M
{
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
21.4M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
121
  SHIFT_TEMPS
122
123
42.8M
  while (--num_rows >= 0) {
124
21.4M
    JLONG rgb;
125
21.4M
    unsigned int r, g, b;
126
127
21.4M
    inptr0 = input_buf[0][input_row];
128
21.4M
    inptr1 = input_buf[1][input_row];
129
21.4M
    inptr2 = input_buf[2][input_row];
130
21.4M
    input_row++;
131
21.4M
    outptr = *output_buf++;
132
21.4M
    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
310M
    for (col = 0; col < (num_cols >> 1); col++) {
147
288M
      y  = *inptr0++;
148
288M
      cb = *inptr1++;
149
288M
      cr = *inptr2++;
150
288M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
151
288M
      g = range_limit[DITHER_565_G(y +
152
288M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
153
288M
                                                     SCALEBITS)), d0)];
154
288M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
155
288M
      d0 = DITHER_ROTATE(d0);
156
288M
      rgb = PACK_SHORT_565(r, g, b);
157
158
288M
      y  = *inptr0++;
159
288M
      cb = *inptr1++;
160
288M
      cr = *inptr2++;
161
288M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
162
288M
      g = range_limit[DITHER_565_G(y +
163
288M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
164
288M
                                                     SCALEBITS)), d0)];
165
288M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
166
288M
      d0 = DITHER_ROTATE(d0);
167
288M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
168
169
288M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
170
288M
      outptr += 4;
171
288M
    }
172
21.4M
    if (num_cols & 1) {
173
4.47M
      y  = *inptr0;
174
4.47M
      cb = *inptr1;
175
4.47M
      cr = *inptr2;
176
4.47M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
177
4.47M
      g = range_limit[DITHER_565_G(y +
178
4.47M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
179
4.47M
                                                     SCALEBITS)), d0)];
180
4.47M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
181
4.47M
      rgb = PACK_SHORT_565(r, g, b);
182
4.47M
      *(INT16 *)outptr = (INT16)rgb;
183
4.47M
    }
184
21.4M
  }
185
#else
186
0
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
187
#endif
188
21.4M
}
Unexecuted instantiation: jdcolor-8.c:ycc_rgb565D_convert_be
jdcolor-8.c:ycc_rgb565D_convert_le
Line
Count
Source
106
21.4M
{
107
21.4M
#if BITS_IN_JSAMPLE != 16
108
21.4M
  my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
109
21.4M
  register int y, cb, cr;
110
21.4M
  register _JSAMPROW outptr;
111
21.4M
  register _JSAMPROW inptr0, inptr1, inptr2;
112
21.4M
  register JDIMENSION col;
113
21.4M
  JDIMENSION num_cols = cinfo->output_width;
114
  /* copy these pointers into registers if possible */
115
21.4M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
116
21.4M
  register int *Crrtab = cconvert->Cr_r_tab;
117
21.4M
  register int *Cbbtab = cconvert->Cb_b_tab;
118
21.4M
  register JLONG *Crgtab = cconvert->Cr_g_tab;
119
21.4M
  register JLONG *Cbgtab = cconvert->Cb_g_tab;
120
21.4M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
121
21.4M
  SHIFT_TEMPS
122
123
42.8M
  while (--num_rows >= 0) {
124
21.4M
    JLONG rgb;
125
21.4M
    unsigned int r, g, b;
126
127
21.4M
    inptr0 = input_buf[0][input_row];
128
21.4M
    inptr1 = input_buf[1][input_row];
129
21.4M
    inptr2 = input_buf[2][input_row];
130
21.4M
    input_row++;
131
21.4M
    outptr = *output_buf++;
132
21.4M
    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
310M
    for (col = 0; col < (num_cols >> 1); col++) {
147
288M
      y  = *inptr0++;
148
288M
      cb = *inptr1++;
149
288M
      cr = *inptr2++;
150
288M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
151
288M
      g = range_limit[DITHER_565_G(y +
152
288M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
153
288M
                                                     SCALEBITS)), d0)];
154
288M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
155
288M
      d0 = DITHER_ROTATE(d0);
156
288M
      rgb = PACK_SHORT_565(r, g, b);
157
158
288M
      y  = *inptr0++;
159
288M
      cb = *inptr1++;
160
288M
      cr = *inptr2++;
161
288M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
162
288M
      g = range_limit[DITHER_565_G(y +
163
288M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
164
288M
                                                     SCALEBITS)), d0)];
165
288M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
166
288M
      d0 = DITHER_ROTATE(d0);
167
288M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
168
169
288M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
170
288M
      outptr += 4;
171
288M
    }
172
21.4M
    if (num_cols & 1) {
173
4.47M
      y  = *inptr0;
174
4.47M
      cb = *inptr1;
175
4.47M
      cr = *inptr2;
176
4.47M
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
177
4.47M
      g = range_limit[DITHER_565_G(y +
178
4.47M
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
179
4.47M
                                                     SCALEBITS)), d0)];
180
4.47M
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
181
4.47M
      rgb = PACK_SHORT_565(r, g, b);
182
4.47M
      *(INT16 *)outptr = (INT16)rgb;
183
4.47M
    }
184
21.4M
  }
185
#else
186
  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
187
#endif
188
21.4M
}
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
1.03M
{
197
1.03M
  register _JSAMPROW outptr;
198
1.03M
  register _JSAMPROW inptr0, inptr1, inptr2;
199
1.03M
  register JDIMENSION col;
200
1.03M
  JDIMENSION num_cols = cinfo->output_width;
201
1.03M
  SHIFT_TEMPS
202
203
2.06M
  while (--num_rows >= 0) {
204
1.03M
    JLONG rgb;
205
1.03M
    unsigned int r, g, b;
206
207
1.03M
    inptr0 = input_buf[0][input_row];
208
1.03M
    inptr1 = input_buf[1][input_row];
209
1.03M
    inptr2 = input_buf[2][input_row];
210
1.03M
    input_row++;
211
1.03M
    outptr = *output_buf++;
212
1.03M
    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
27.3M
    for (col = 0; col < (num_cols >> 1); col++) {
222
26.2M
      r = *inptr0++;
223
26.2M
      g = *inptr1++;
224
26.2M
      b = *inptr2++;
225
26.2M
      rgb = PACK_SHORT_565(r, g, b);
226
227
26.2M
      r = *inptr0++;
228
26.2M
      g = *inptr1++;
229
26.2M
      b = *inptr2++;
230
26.2M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
231
232
26.2M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
233
26.2M
      outptr += 4;
234
26.2M
    }
235
1.03M
    if (num_cols & 1) {
236
581k
      r = *inptr0;
237
581k
      g = *inptr1;
238
581k
      b = *inptr2;
239
581k
      rgb = PACK_SHORT_565(r, g, b);
240
581k
      *(INT16 *)outptr = (INT16)rgb;
241
581k
    }
242
1.03M
  }
243
1.03M
}
Unexecuted instantiation: jdcolor-8.c:rgb_rgb565_convert_be
jdcolor-8.c:rgb_rgb565_convert_le
Line
Count
Source
196
1.03M
{
197
1.03M
  register _JSAMPROW outptr;
198
1.03M
  register _JSAMPROW inptr0, inptr1, inptr2;
199
1.03M
  register JDIMENSION col;
200
1.03M
  JDIMENSION num_cols = cinfo->output_width;
201
1.03M
  SHIFT_TEMPS
202
203
2.06M
  while (--num_rows >= 0) {
204
1.03M
    JLONG rgb;
205
1.03M
    unsigned int r, g, b;
206
207
1.03M
    inptr0 = input_buf[0][input_row];
208
1.03M
    inptr1 = input_buf[1][input_row];
209
1.03M
    inptr2 = input_buf[2][input_row];
210
1.03M
    input_row++;
211
1.03M
    outptr = *output_buf++;
212
1.03M
    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
27.3M
    for (col = 0; col < (num_cols >> 1); col++) {
222
26.2M
      r = *inptr0++;
223
26.2M
      g = *inptr1++;
224
26.2M
      b = *inptr2++;
225
26.2M
      rgb = PACK_SHORT_565(r, g, b);
226
227
26.2M
      r = *inptr0++;
228
26.2M
      g = *inptr1++;
229
26.2M
      b = *inptr2++;
230
26.2M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
231
232
26.2M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
233
26.2M
      outptr += 4;
234
26.2M
    }
235
1.03M
    if (num_cols & 1) {
236
581k
      r = *inptr0;
237
581k
      g = *inptr1;
238
581k
      b = *inptr2;
239
581k
      rgb = PACK_SHORT_565(r, g, b);
240
581k
      *(INT16 *)outptr = (INT16)rgb;
241
581k
    }
242
1.03M
  }
243
1.03M
}
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
939k
{
252
939k
  register _JSAMPROW outptr;
253
939k
  register _JSAMPROW inptr0, inptr1, inptr2;
254
939k
  register JDIMENSION col;
255
939k
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
256
939k
  JDIMENSION num_cols = cinfo->output_width;
257
939k
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
258
939k
  SHIFT_TEMPS
259
260
1.87M
  while (--num_rows >= 0) {
261
939k
    JLONG rgb;
262
939k
    unsigned int r, g, b;
263
264
939k
    inptr0 = input_buf[0][input_row];
265
939k
    inptr1 = input_buf[1][input_row];
266
939k
    inptr2 = input_buf[2][input_row];
267
939k
    input_row++;
268
939k
    outptr = *output_buf++;
269
939k
    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
25.2M
    for (col = 0; col < (num_cols >> 1); col++) {
279
24.3M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
280
24.3M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
281
24.3M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
282
24.3M
      d0 = DITHER_ROTATE(d0);
283
24.3M
      rgb = PACK_SHORT_565(r, g, b);
284
285
24.3M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
286
24.3M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
287
24.3M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
288
24.3M
      d0 = DITHER_ROTATE(d0);
289
24.3M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
290
291
24.3M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
292
24.3M
      outptr += 4;
293
24.3M
    }
294
939k
    if (num_cols & 1) {
295
512k
      r = range_limit[DITHER_565_R(*inptr0, d0)];
296
512k
      g = range_limit[DITHER_565_G(*inptr1, d0)];
297
512k
      b = range_limit[DITHER_565_B(*inptr2, d0)];
298
512k
      rgb = PACK_SHORT_565(r, g, b);
299
512k
      *(INT16 *)outptr = (INT16)rgb;
300
512k
    }
301
939k
  }
302
939k
}
Unexecuted instantiation: jdcolor-8.c:rgb_rgb565D_convert_be
jdcolor-8.c:rgb_rgb565D_convert_le
Line
Count
Source
251
939k
{
252
939k
  register _JSAMPROW outptr;
253
939k
  register _JSAMPROW inptr0, inptr1, inptr2;
254
939k
  register JDIMENSION col;
255
939k
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
256
939k
  JDIMENSION num_cols = cinfo->output_width;
257
939k
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
258
939k
  SHIFT_TEMPS
259
260
1.87M
  while (--num_rows >= 0) {
261
939k
    JLONG rgb;
262
939k
    unsigned int r, g, b;
263
264
939k
    inptr0 = input_buf[0][input_row];
265
939k
    inptr1 = input_buf[1][input_row];
266
939k
    inptr2 = input_buf[2][input_row];
267
939k
    input_row++;
268
939k
    outptr = *output_buf++;
269
939k
    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
25.2M
    for (col = 0; col < (num_cols >> 1); col++) {
279
24.3M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
280
24.3M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
281
24.3M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
282
24.3M
      d0 = DITHER_ROTATE(d0);
283
24.3M
      rgb = PACK_SHORT_565(r, g, b);
284
285
24.3M
      r = range_limit[DITHER_565_R(*inptr0++, d0)];
286
24.3M
      g = range_limit[DITHER_565_G(*inptr1++, d0)];
287
24.3M
      b = range_limit[DITHER_565_B(*inptr2++, d0)];
288
24.3M
      d0 = DITHER_ROTATE(d0);
289
24.3M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
290
291
24.3M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
292
24.3M
      outptr += 4;
293
24.3M
    }
294
939k
    if (num_cols & 1) {
295
512k
      r = range_limit[DITHER_565_R(*inptr0, d0)];
296
512k
      g = range_limit[DITHER_565_G(*inptr1, d0)];
297
512k
      b = range_limit[DITHER_565_B(*inptr2, d0)];
298
512k
      rgb = PACK_SHORT_565(r, g, b);
299
512k
      *(INT16 *)outptr = (INT16)rgb;
300
512k
    }
301
939k
  }
302
939k
}
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
18.8M
{
311
18.8M
  register _JSAMPROW inptr, outptr;
312
18.8M
  register JDIMENSION col;
313
18.8M
  JDIMENSION num_cols = cinfo->output_width;
314
315
37.7M
  while (--num_rows >= 0) {
316
18.8M
    JLONG rgb;
317
18.8M
    unsigned int g;
318
319
18.8M
    inptr = input_buf[0][input_row++];
320
18.8M
    outptr = *output_buf++;
321
18.8M
    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
378M
    for (col = 0; col < (num_cols >> 1); col++) {
329
359M
      g = *inptr++;
330
359M
      rgb = PACK_SHORT_565(g, g, g);
331
359M
      g = *inptr++;
332
359M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
333
359M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
334
359M
      outptr += 4;
335
359M
    }
336
18.8M
    if (num_cols & 1) {
337
11.5M
      g = *inptr;
338
11.5M
      rgb = PACK_SHORT_565(g, g, g);
339
11.5M
      *(INT16 *)outptr = (INT16)rgb;
340
11.5M
    }
341
18.8M
  }
342
18.8M
}
Unexecuted instantiation: jdcolor-8.c:gray_rgb565_convert_be
jdcolor-8.c:gray_rgb565_convert_le
Line
Count
Source
310
18.8M
{
311
18.8M
  register _JSAMPROW inptr, outptr;
312
18.8M
  register JDIMENSION col;
313
18.8M
  JDIMENSION num_cols = cinfo->output_width;
314
315
37.7M
  while (--num_rows >= 0) {
316
18.8M
    JLONG rgb;
317
18.8M
    unsigned int g;
318
319
18.8M
    inptr = input_buf[0][input_row++];
320
18.8M
    outptr = *output_buf++;
321
18.8M
    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
378M
    for (col = 0; col < (num_cols >> 1); col++) {
329
359M
      g = *inptr++;
330
359M
      rgb = PACK_SHORT_565(g, g, g);
331
359M
      g = *inptr++;
332
359M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
333
359M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
334
359M
      outptr += 4;
335
359M
    }
336
18.8M
    if (num_cols & 1) {
337
11.5M
      g = *inptr;
338
11.5M
      rgb = PACK_SHORT_565(g, g, g);
339
11.5M
      *(INT16 *)outptr = (INT16)rgb;
340
11.5M
    }
341
18.8M
  }
342
18.8M
}
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
10.8M
{
351
10.8M
  register _JSAMPROW inptr, outptr;
352
10.8M
  register JDIMENSION col;
353
10.8M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
354
10.8M
  JDIMENSION num_cols = cinfo->output_width;
355
10.8M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
356
357
21.6M
  while (--num_rows >= 0) {
358
10.8M
    JLONG rgb;
359
10.8M
    unsigned int g;
360
361
10.8M
    inptr = input_buf[0][input_row++];
362
10.8M
    outptr = *output_buf++;
363
10.8M
    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
234M
    for (col = 0; col < (num_cols >> 1); col++) {
372
224M
      g = *inptr++;
373
224M
      g = range_limit[DITHER_565_R(g, d0)];
374
224M
      rgb = PACK_SHORT_565(g, g, g);
375
224M
      d0 = DITHER_ROTATE(d0);
376
377
224M
      g = *inptr++;
378
224M
      g = range_limit[DITHER_565_R(g, d0)];
379
224M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
380
224M
      d0 = DITHER_ROTATE(d0);
381
382
224M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
383
224M
      outptr += 4;
384
224M
    }
385
10.8M
    if (num_cols & 1) {
386
6.96M
      g = *inptr;
387
6.96M
      g = range_limit[DITHER_565_R(g, d0)];
388
6.96M
      rgb = PACK_SHORT_565(g, g, g);
389
6.96M
      *(INT16 *)outptr = (INT16)rgb;
390
6.96M
    }
391
10.8M
  }
392
10.8M
}
Unexecuted instantiation: jdcolor-8.c:gray_rgb565D_convert_be
jdcolor-8.c:gray_rgb565D_convert_le
Line
Count
Source
350
10.8M
{
351
10.8M
  register _JSAMPROW inptr, outptr;
352
10.8M
  register JDIMENSION col;
353
10.8M
  register _JSAMPLE *range_limit = (_JSAMPLE *)cinfo->sample_range_limit;
354
10.8M
  JDIMENSION num_cols = cinfo->output_width;
355
10.8M
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
356
357
21.6M
  while (--num_rows >= 0) {
358
10.8M
    JLONG rgb;
359
10.8M
    unsigned int g;
360
361
10.8M
    inptr = input_buf[0][input_row++];
362
10.8M
    outptr = *output_buf++;
363
10.8M
    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
234M
    for (col = 0; col < (num_cols >> 1); col++) {
372
224M
      g = *inptr++;
373
224M
      g = range_limit[DITHER_565_R(g, d0)];
374
224M
      rgb = PACK_SHORT_565(g, g, g);
375
224M
      d0 = DITHER_ROTATE(d0);
376
377
224M
      g = *inptr++;
378
224M
      g = range_limit[DITHER_565_R(g, d0)];
379
224M
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
380
224M
      d0 = DITHER_ROTATE(d0);
381
382
224M
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
383
224M
      outptr += 4;
384
224M
    }
385
10.8M
    if (num_cols & 1) {
386
6.96M
      g = *inptr;
387
6.96M
      g = range_limit[DITHER_565_R(g, d0)];
388
6.96M
      rgb = PACK_SHORT_565(g, g, g);
389
6.96M
      *(INT16 *)outptr = (INT16)rgb;
390
6.96M
    }
391
10.8M
  }
392
10.8M
}
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