CoCalc -- jdcol565.c

GitHub Repository: Tetragramm/opencv
Path: blob/master/3rdparty/libjpeg-turbo/src/jdcol565.c
¹⁶³³⁷ views
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, 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,
21
                             JSAMPIMAGE input_buf, JDIMENSION input_row,
22
                             JSAMPARRAY output_buf, int num_rows)
23
{
24
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
25
  register int y, cb, cr;
26
  register JSAMPROW outptr;
27
  register JSAMPROW inptr0, inptr1, inptr2;
28
  register JDIMENSION col;
29
  JDIMENSION num_cols = cinfo->output_width;
30
  /* copy these pointers into registers if possible */
31
  register JSAMPLE * range_limit = cinfo->sample_range_limit;
32
  register int * Crrtab = cconvert->Cr_r_tab;
33
  register int * Cbbtab = cconvert->Cb_b_tab;
34
  register JLONG * Crgtab = cconvert->Cr_g_tab;
35
  register JLONG * Cbgtab = cconvert->Cb_g_tab;
36
  SHIFT_TEMPS
37

38
  while (--num_rows >= 0) {
39
    JLONG rgb;
40
    unsigned int r, g, b;
41
    inptr0 = input_buf[0][input_row];
42
    inptr1 = input_buf[1][input_row];
43
    inptr2 = input_buf[2][input_row];
44
    input_row++;
45
    outptr = *output_buf++;
46

47
    if (PACK_NEED_ALIGNMENT(outptr)) {
48
      y  = GETJSAMPLE(*inptr0++);
49
      cb = GETJSAMPLE(*inptr1++);
50
      cr = GETJSAMPLE(*inptr2++);
51
      r = range_limit[y + Crrtab[cr]];
52
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
53
                                            SCALEBITS))];
54
      b = range_limit[y + Cbbtab[cb]];
55
      rgb = PACK_SHORT_565(r, g, b);
56
      *(INT16*)outptr = (INT16)rgb;
57
      outptr += 2;
58
      num_cols--;
59
    }
60
    for (col = 0; col < (num_cols >> 1); col++) {
61
      y  = GETJSAMPLE(*inptr0++);
62
      cb = GETJSAMPLE(*inptr1++);
63
      cr = GETJSAMPLE(*inptr2++);
64
      r = range_limit[y + Crrtab[cr]];
65
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
66
                                            SCALEBITS))];
67
      b = range_limit[y + Cbbtab[cb]];
68
      rgb = PACK_SHORT_565(r, g, b);
69

70
      y  = GETJSAMPLE(*inptr0++);
71
      cb = GETJSAMPLE(*inptr1++);
72
      cr = GETJSAMPLE(*inptr2++);
73
      r = range_limit[y + Crrtab[cr]];
74
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
75
                                            SCALEBITS))];
76
      b = range_limit[y + Cbbtab[cb]];
77
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
78

79
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
80
      outptr += 4;
81
    }
82
    if (num_cols & 1) {
83
      y  = GETJSAMPLE(*inptr0);
84
      cb = GETJSAMPLE(*inptr1);
85
      cr = GETJSAMPLE(*inptr2);
86
      r = range_limit[y + Crrtab[cr]];
87
      g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
88
                                            SCALEBITS))];
89
      b = range_limit[y + Cbbtab[cb]];
90
      rgb = PACK_SHORT_565(r, g, b);
91
      *(INT16*)outptr = (INT16)rgb;
92
    }
93
  }
94
}
95

96

97
INLINE
98
LOCAL(void)
99
ycc_rgb565D_convert_internal (j_decompress_ptr cinfo,
100
                              JSAMPIMAGE input_buf, JDIMENSION input_row,
101
                              JSAMPARRAY output_buf, int num_rows)
102
{
103
  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
104
  register int y, cb, cr;
105
  register JSAMPROW outptr;
106
  register JSAMPROW inptr0, inptr1, inptr2;
107
  register JDIMENSION col;
108
  JDIMENSION num_cols = cinfo->output_width;
109
  /* copy these pointers into registers if possible */
110
  register JSAMPLE * range_limit = cinfo->sample_range_limit;
111
  register int * Crrtab = cconvert->Cr_r_tab;
112
  register int * Cbbtab = cconvert->Cb_b_tab;
113
  register JLONG * Crgtab = cconvert->Cr_g_tab;
114
  register JLONG * Cbgtab = cconvert->Cb_g_tab;
115
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
116
  SHIFT_TEMPS
117

118
  while (--num_rows >= 0) {
119
    JLONG rgb;
120
    unsigned int r, g, b;
121

122
    inptr0 = input_buf[0][input_row];
123
    inptr1 = input_buf[1][input_row];
124
    inptr2 = input_buf[2][input_row];
125
    input_row++;
126
    outptr = *output_buf++;
127
    if (PACK_NEED_ALIGNMENT(outptr)) {
128
      y  = GETJSAMPLE(*inptr0++);
129
      cb = GETJSAMPLE(*inptr1++);
130
      cr = GETJSAMPLE(*inptr2++);
131
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
132
      g = range_limit[DITHER_565_G(y +
133
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
134
                                                     SCALEBITS)), d0)];
135
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
136
      rgb = PACK_SHORT_565(r, g, b);
137
      *(INT16*)outptr = (INT16)rgb;
138
      outptr += 2;
139
      num_cols--;
140
    }
141
    for (col = 0; col < (num_cols >> 1); col++) {
142
      y  = GETJSAMPLE(*inptr0++);
143
      cb = GETJSAMPLE(*inptr1++);
144
      cr = GETJSAMPLE(*inptr2++);
145
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
146
      g = range_limit[DITHER_565_G(y +
147
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
148
                                                     SCALEBITS)), d0)];
149
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
150
      d0 = DITHER_ROTATE(d0);
151
      rgb = PACK_SHORT_565(r, g, b);
152

153
      y  = GETJSAMPLE(*inptr0++);
154
      cb = GETJSAMPLE(*inptr1++);
155
      cr = GETJSAMPLE(*inptr2++);
156
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
157
      g = range_limit[DITHER_565_G(y +
158
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
159
                                                     SCALEBITS)), d0)];
160
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
161
      d0 = DITHER_ROTATE(d0);
162
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
163

164
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
165
      outptr += 4;
166
    }
167
    if (num_cols & 1) {
168
      y  = GETJSAMPLE(*inptr0);
169
      cb = GETJSAMPLE(*inptr1);
170
      cr = GETJSAMPLE(*inptr2);
171
      r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)];
172
      g = range_limit[DITHER_565_G(y +
173
                                   ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
174
                                                     SCALEBITS)), d0)];
175
      b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)];
176
      rgb = PACK_SHORT_565(r, g, b);
177
      *(INT16*)outptr = (INT16)rgb;
178
    }
179
  }
180
}
181

182

183
INLINE
184
LOCAL(void)
185
rgb_rgb565_convert_internal (j_decompress_ptr cinfo,
186
                             JSAMPIMAGE input_buf, JDIMENSION input_row,
187
                             JSAMPARRAY output_buf, int num_rows)
188
{
189
  register JSAMPROW outptr;
190
  register JSAMPROW inptr0, inptr1, inptr2;
191
  register JDIMENSION col;
192
  JDIMENSION num_cols = cinfo->output_width;
193
  SHIFT_TEMPS
194

195
  while (--num_rows >= 0) {
196
    JLONG rgb;
197
    unsigned int r, g, b;
198

199
    inptr0 = input_buf[0][input_row];
200
    inptr1 = input_buf[1][input_row];
201
    inptr2 = input_buf[2][input_row];
202
    input_row++;
203
    outptr = *output_buf++;
204
    if (PACK_NEED_ALIGNMENT(outptr)) {
205
      r = GETJSAMPLE(*inptr0++);
206
      g = GETJSAMPLE(*inptr1++);
207
      b = GETJSAMPLE(*inptr2++);
208
      rgb = PACK_SHORT_565(r, g, b);
209
      *(INT16*)outptr = (INT16)rgb;
210
      outptr += 2;
211
      num_cols--;
212
    }
213
    for (col = 0; col < (num_cols >> 1); col++) {
214
      r = GETJSAMPLE(*inptr0++);
215
      g = GETJSAMPLE(*inptr1++);
216
      b = GETJSAMPLE(*inptr2++);
217
      rgb = PACK_SHORT_565(r, g, b);
218

219
      r = GETJSAMPLE(*inptr0++);
220
      g = GETJSAMPLE(*inptr1++);
221
      b = GETJSAMPLE(*inptr2++);
222
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
223

224
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
225
      outptr += 4;
226
    }
227
    if (num_cols & 1) {
228
      r = GETJSAMPLE(*inptr0);
229
      g = GETJSAMPLE(*inptr1);
230
      b = GETJSAMPLE(*inptr2);
231
      rgb = PACK_SHORT_565(r, g, b);
232
      *(INT16*)outptr = (INT16)rgb;
233
    }
234
  }
235
}
236

237

238
INLINE
239
LOCAL(void)
240
rgb_rgb565D_convert_internal (j_decompress_ptr cinfo,
241
                              JSAMPIMAGE input_buf, JDIMENSION input_row,
242
                              JSAMPARRAY output_buf, int num_rows)
243
{
244
  register JSAMPROW outptr;
245
  register JSAMPROW inptr0, inptr1, inptr2;
246
  register JDIMENSION col;
247
  register JSAMPLE * range_limit = cinfo->sample_range_limit;
248
  JDIMENSION num_cols = cinfo->output_width;
249
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
250
  SHIFT_TEMPS
251

252
  while (--num_rows >= 0) {
253
    JLONG rgb;
254
    unsigned int r, g, b;
255

256
    inptr0 = input_buf[0][input_row];
257
    inptr1 = input_buf[1][input_row];
258
    inptr2 = input_buf[2][input_row];
259
    input_row++;
260
    outptr = *output_buf++;
261
    if (PACK_NEED_ALIGNMENT(outptr)) {
262
      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)];
263
      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)];
264
      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)];
265
      rgb = PACK_SHORT_565(r, g, b);
266
      *(INT16*)outptr = (INT16)rgb;
267
      outptr += 2;
268
      num_cols--;
269
    }
270
    for (col = 0; col < (num_cols >> 1); col++) {
271
      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)];
272
      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)];
273
      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)];
274
      d0 = DITHER_ROTATE(d0);
275
      rgb = PACK_SHORT_565(r, g, b);
276

277
      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)];
278
      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)];
279
      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)];
280
      d0 = DITHER_ROTATE(d0);
281
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b));
282

283
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
284
      outptr += 4;
285
    }
286
    if (num_cols & 1) {
287
      r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0), d0)];
288
      g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1), d0)];
289
      b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2), d0)];
290
      rgb = PACK_SHORT_565(r, g, b);
291
      *(INT16*)outptr = (INT16)rgb;
292
    }
293
  }
294
}
295

296

297
INLINE
298
LOCAL(void)
299
gray_rgb565_convert_internal (j_decompress_ptr cinfo,
300
                              JSAMPIMAGE input_buf, JDIMENSION input_row,
301
                              JSAMPARRAY output_buf, int num_rows)
302
{
303
  register JSAMPROW inptr, outptr;
304
  register JDIMENSION col;
305
  JDIMENSION num_cols = cinfo->output_width;
306

307
  while (--num_rows >= 0) {
308
    JLONG rgb;
309
    unsigned int g;
310

311
    inptr = input_buf[0][input_row++];
312
    outptr = *output_buf++;
313
    if (PACK_NEED_ALIGNMENT(outptr)) {
314
      g = *inptr++;
315
      rgb = PACK_SHORT_565(g, g, g);
316
      *(INT16*)outptr = (INT16)rgb;
317
      outptr += 2;
318
      num_cols--;
319
    }
320
    for (col = 0; col < (num_cols >> 1); col++) {
321
      g = *inptr++;
322
      rgb = PACK_SHORT_565(g, g, g);
323
      g = *inptr++;
324
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
325
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
326
      outptr += 4;
327
    }
328
    if (num_cols & 1) {
329
      g = *inptr;
330
      rgb = PACK_SHORT_565(g, g, g);
331
      *(INT16*)outptr = (INT16)rgb;
332
    }
333
  }
334
}
335

336

337
INLINE
338
LOCAL(void)
339
gray_rgb565D_convert_internal (j_decompress_ptr cinfo,
340
                               JSAMPIMAGE input_buf, JDIMENSION input_row,
341
                               JSAMPARRAY output_buf, int num_rows)
342
{
343
  register JSAMPROW inptr, outptr;
344
  register JDIMENSION col;
345
  register JSAMPLE * range_limit = cinfo->sample_range_limit;
346
  JDIMENSION num_cols = cinfo->output_width;
347
  JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK];
348

349
  while (--num_rows >= 0) {
350
    JLONG rgb;
351
    unsigned int g;
352

353
    inptr = input_buf[0][input_row++];
354
    outptr = *output_buf++;
355
    if (PACK_NEED_ALIGNMENT(outptr)) {
356
      g = *inptr++;
357
      g = range_limit[DITHER_565_R(g, d0)];
358
      rgb = PACK_SHORT_565(g, g, g);
359
      *(INT16*)outptr = (INT16)rgb;
360
      outptr += 2;
361
      num_cols--;
362
    }
363
    for (col = 0; col < (num_cols >> 1); col++) {
364
      g = *inptr++;
365
      g = range_limit[DITHER_565_R(g, d0)];
366
      rgb = PACK_SHORT_565(g, g, g);
367
      d0 = DITHER_ROTATE(d0);
368

369
      g = *inptr++;
370
      g = range_limit[DITHER_565_R(g, d0)];
371
      rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g));
372
      d0 = DITHER_ROTATE(d0);
373

374
      WRITE_TWO_ALIGNED_PIXELS(outptr, rgb);
375
      outptr += 4;
376
    }
377
    if (num_cols & 1) {
378
      g = *inptr;
379
      g = range_limit[DITHER_565_R(g, d0)];
380
      rgb = PACK_SHORT_565(g, g, g);
381
      *(INT16*)outptr = (INT16)rgb;
382
    }
383
  }
384
}
385

386
Product

Resources

Company
