Coverage Report

Created: 2026-05-30 06:17

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