1 | /* |
2 | * jdcolor.c |
3 | * |
4 | * This file was part of the Independent JPEG Group's software: |
5 | * Copyright (C) 1991-1997, Thomas G. Lane. |
6 | * Modified 2011 by Guido Vollbeding. |
7 | * libjpeg-turbo Modifications: |
8 | * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB |
9 | * Copyright (C) 2009, 2011-2012, 2014-2015, D. R. Commander. |
10 | * Copyright (C) 2013, Linaro Limited. |
11 | * For conditions of distribution and use, see the accompanying README.ijg |
12 | * file. |
13 | * |
14 | * This file contains output colorspace conversion routines. |
15 | */ |
16 | |
17 | #define JPEG_INTERNALS |
18 | #include "jinclude.h" |
19 | #include "jpeglib.h" |
20 | #include "jsimd.h" |
21 | #include "jconfigint.h" |
22 | |
23 | |
24 | /* Private subobject */ |
25 | |
26 | typedef struct { |
27 | struct jpeg_color_deconverter pub; /* public fields */ |
28 | |
29 | /* Private state for YCC->RGB conversion */ |
30 | int *Cr_r_tab; /* => table for Cr to R conversion */ |
31 | int *Cb_b_tab; /* => table for Cb to B conversion */ |
32 | JLONG *Cr_g_tab; /* => table for Cr to G conversion */ |
33 | JLONG *Cb_g_tab; /* => table for Cb to G conversion */ |
34 | |
35 | /* Private state for RGB->Y conversion */ |
36 | JLONG *rgb_y_tab; /* => table for RGB to Y conversion */ |
37 | } my_color_deconverter; |
38 | |
39 | typedef my_color_deconverter *my_cconvert_ptr; |
40 | |
41 | |
42 | /**************** YCbCr -> RGB conversion: most common case **************/ |
43 | /**************** RGB -> Y conversion: less common case **************/ |
44 | |
45 | /* |
46 | * YCbCr is defined per CCIR 601-1, except that Cb and Cr are |
47 | * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. |
48 | * The conversion equations to be implemented are therefore |
49 | * |
50 | * R = Y + 1.40200 * Cr |
51 | * G = Y - 0.34414 * Cb - 0.71414 * Cr |
52 | * B = Y + 1.77200 * Cb |
53 | * |
54 | * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B |
55 | * |
56 | * where Cb and Cr represent the incoming values less CENTERJSAMPLE. |
57 | * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) |
58 | * |
59 | * To avoid floating-point arithmetic, we represent the fractional constants |
60 | * as integers scaled up by 2^16 (about 4 digits precision); we have to divide |
61 | * the products by 2^16, with appropriate rounding, to get the correct answer. |
62 | * Notice that Y, being an integral input, does not contribute any fraction |
63 | * so it need not participate in the rounding. |
64 | * |
65 | * For even more speed, we avoid doing any multiplications in the inner loop |
66 | * by precalculating the constants times Cb and Cr for all possible values. |
67 | * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); |
68 | * for 12-bit samples it is still acceptable. It's not very reasonable for |
69 | * 16-bit samples, but if you want lossless storage you shouldn't be changing |
70 | * colorspace anyway. |
71 | * The Cr=>R and Cb=>B values can be rounded to integers in advance; the |
72 | * values for the G calculation are left scaled up, since we must add them |
73 | * together before rounding. |
74 | */ |
75 | |
76 | #define SCALEBITS 16 /* speediest right-shift on some machines */ |
77 | #define ONE_HALF ((JLONG) 1 << (SCALEBITS-1)) |
78 | #define FIX(x) ((JLONG) ((x) * (1L<<SCALEBITS) + 0.5)) |
79 | |
80 | /* We allocate one big table for RGB->Y conversion and divide it up into |
81 | * three parts, instead of doing three alloc_small requests. This lets us |
82 | * use a single table base address, which can be held in a register in the |
83 | * inner loops on many machines (more than can hold all three addresses, |
84 | * anyway). |
85 | */ |
86 | |
87 | #define R_Y_OFF 0 /* offset to R => Y section */ |
88 | #define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */ |
89 | #define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */ |
90 | #define TABLE_SIZE (3*(MAXJSAMPLE+1)) |
91 | |
92 | |
93 | /* Include inline routines for colorspace extensions */ |
94 | |
95 | #include "jdcolext.c" |
96 | #undef RGB_RED |
97 | #undef RGB_GREEN |
98 | #undef RGB_BLUE |
99 | #undef RGB_PIXELSIZE |
100 | |
101 | #define RGB_RED EXT_RGB_RED |
102 | #define RGB_GREEN EXT_RGB_GREEN |
103 | #define RGB_BLUE EXT_RGB_BLUE |
104 | #define RGB_PIXELSIZE EXT_RGB_PIXELSIZE |
105 | #define ycc_rgb_convert_internal ycc_extrgb_convert_internal |
106 | #define gray_rgb_convert_internal gray_extrgb_convert_internal |
107 | #define rgb_rgb_convert_internal rgb_extrgb_convert_internal |
108 | #include "jdcolext.c" |
109 | #undef RGB_RED |
110 | #undef RGB_GREEN |
111 | #undef RGB_BLUE |
112 | #undef RGB_PIXELSIZE |
113 | #undef ycc_rgb_convert_internal |
114 | #undef gray_rgb_convert_internal |
115 | #undef rgb_rgb_convert_internal |
116 | |
117 | #define RGB_RED EXT_RGBX_RED |
118 | #define RGB_GREEN EXT_RGBX_GREEN |
119 | #define RGB_BLUE EXT_RGBX_BLUE |
120 | #define RGB_ALPHA 3 |
121 | #define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE |
122 | #define ycc_rgb_convert_internal ycc_extrgbx_convert_internal |
123 | #define gray_rgb_convert_internal gray_extrgbx_convert_internal |
124 | #define rgb_rgb_convert_internal rgb_extrgbx_convert_internal |
125 | #include "jdcolext.c" |
126 | #undef RGB_RED |
127 | #undef RGB_GREEN |
128 | #undef RGB_BLUE |
129 | #undef RGB_ALPHA |
130 | #undef RGB_PIXELSIZE |
131 | #undef ycc_rgb_convert_internal |
132 | #undef gray_rgb_convert_internal |
133 | #undef rgb_rgb_convert_internal |
134 | |
135 | #define RGB_RED EXT_BGR_RED |
136 | #define RGB_GREEN EXT_BGR_GREEN |
137 | #define RGB_BLUE EXT_BGR_BLUE |
138 | #define RGB_PIXELSIZE EXT_BGR_PIXELSIZE |
139 | #define ycc_rgb_convert_internal ycc_extbgr_convert_internal |
140 | #define gray_rgb_convert_internal gray_extbgr_convert_internal |
141 | #define rgb_rgb_convert_internal rgb_extbgr_convert_internal |
142 | #include "jdcolext.c" |
143 | #undef RGB_RED |
144 | #undef RGB_GREEN |
145 | #undef RGB_BLUE |
146 | #undef RGB_PIXELSIZE |
147 | #undef ycc_rgb_convert_internal |
148 | #undef gray_rgb_convert_internal |
149 | #undef rgb_rgb_convert_internal |
150 | |
151 | #define RGB_RED EXT_BGRX_RED |
152 | #define RGB_GREEN EXT_BGRX_GREEN |
153 | #define RGB_BLUE EXT_BGRX_BLUE |
154 | #define RGB_ALPHA 3 |
155 | #define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE |
156 | #define ycc_rgb_convert_internal ycc_extbgrx_convert_internal |
157 | #define gray_rgb_convert_internal gray_extbgrx_convert_internal |
158 | #define rgb_rgb_convert_internal rgb_extbgrx_convert_internal |
159 | #include "jdcolext.c" |
160 | #undef RGB_RED |
161 | #undef RGB_GREEN |
162 | #undef RGB_BLUE |
163 | #undef RGB_ALPHA |
164 | #undef RGB_PIXELSIZE |
165 | #undef ycc_rgb_convert_internal |
166 | #undef gray_rgb_convert_internal |
167 | #undef rgb_rgb_convert_internal |
168 | |
169 | #define RGB_RED EXT_XBGR_RED |
170 | #define RGB_GREEN EXT_XBGR_GREEN |
171 | #define RGB_BLUE EXT_XBGR_BLUE |
172 | #define RGB_ALPHA 0 |
173 | #define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE |
174 | #define ycc_rgb_convert_internal ycc_extxbgr_convert_internal |
175 | #define gray_rgb_convert_internal gray_extxbgr_convert_internal |
176 | #define rgb_rgb_convert_internal rgb_extxbgr_convert_internal |
177 | #include "jdcolext.c" |
178 | #undef RGB_RED |
179 | #undef RGB_GREEN |
180 | #undef RGB_BLUE |
181 | #undef RGB_ALPHA |
182 | #undef RGB_PIXELSIZE |
183 | #undef ycc_rgb_convert_internal |
184 | #undef gray_rgb_convert_internal |
185 | #undef rgb_rgb_convert_internal |
186 | |
187 | #define RGB_RED EXT_XRGB_RED |
188 | #define RGB_GREEN EXT_XRGB_GREEN |
189 | #define RGB_BLUE EXT_XRGB_BLUE |
190 | #define RGB_ALPHA 0 |
191 | #define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE |
192 | #define ycc_rgb_convert_internal ycc_extxrgb_convert_internal |
193 | #define gray_rgb_convert_internal gray_extxrgb_convert_internal |
194 | #define rgb_rgb_convert_internal rgb_extxrgb_convert_internal |
195 | #include "jdcolext.c" |
196 | #undef RGB_RED |
197 | #undef RGB_GREEN |
198 | #undef RGB_BLUE |
199 | #undef RGB_ALPHA |
200 | #undef RGB_PIXELSIZE |
201 | #undef ycc_rgb_convert_internal |
202 | #undef gray_rgb_convert_internal |
203 | #undef rgb_rgb_convert_internal |
204 | |
205 | |
206 | /* |
207 | * Initialize tables for YCC->RGB colorspace conversion. |
208 | */ |
209 | |
210 | LOCAL(void) |
211 | build_ycc_rgb_table (j_decompress_ptr cinfo) |
212 | { |
213 | my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; |
214 | int i; |
215 | JLONG x; |
216 | SHIFT_TEMPS |
217 | |
218 | cconvert->Cr_r_tab = (int *) |
219 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
220 | (MAXJSAMPLE+1) * sizeof(int)); |
221 | cconvert->Cb_b_tab = (int *) |
222 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
223 | (MAXJSAMPLE+1) * sizeof(int)); |
224 | cconvert->Cr_g_tab = (JLONG *) |
225 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
226 | (MAXJSAMPLE+1) * sizeof(JLONG)); |
227 | cconvert->Cb_g_tab = (JLONG *) |
228 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
229 | (MAXJSAMPLE+1) * sizeof(JLONG)); |
230 | |
231 | for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { |
232 | /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ |
233 | /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ |
234 | /* Cr=>R value is nearest int to 1.40200 * x */ |
235 | cconvert->Cr_r_tab[i] = (int) |
236 | RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); |
237 | /* Cb=>B value is nearest int to 1.77200 * x */ |
238 | cconvert->Cb_b_tab[i] = (int) |
239 | RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); |
240 | /* Cr=>G value is scaled-up -0.71414 * x */ |
241 | cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x; |
242 | /* Cb=>G value is scaled-up -0.34414 * x */ |
243 | /* We also add in ONE_HALF so that need not do it in inner loop */ |
244 | cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; |
245 | } |
246 | } |
247 | |
248 | |
249 | /* |
250 | * Convert some rows of samples to the output colorspace. |
251 | */ |
252 | |
253 | METHODDEF(void) |
254 | ycc_rgb_convert (j_decompress_ptr cinfo, |
255 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
256 | JSAMPARRAY output_buf, int num_rows) |
257 | { |
258 | switch (cinfo->out_color_space) { |
259 | case JCS_EXT_RGB: |
260 | ycc_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
261 | num_rows); |
262 | break; |
263 | case JCS_EXT_RGBX: |
264 | case JCS_EXT_RGBA: |
265 | ycc_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf, |
266 | num_rows); |
267 | break; |
268 | case JCS_EXT_BGR: |
269 | ycc_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf, |
270 | num_rows); |
271 | break; |
272 | case JCS_EXT_BGRX: |
273 | case JCS_EXT_BGRA: |
274 | ycc_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf, |
275 | num_rows); |
276 | break; |
277 | case JCS_EXT_XBGR: |
278 | case JCS_EXT_ABGR: |
279 | ycc_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf, |
280 | num_rows); |
281 | break; |
282 | case JCS_EXT_XRGB: |
283 | case JCS_EXT_ARGB: |
284 | ycc_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
285 | num_rows); |
286 | break; |
287 | default: |
288 | ycc_rgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
289 | num_rows); |
290 | break; |
291 | } |
292 | } |
293 | |
294 | |
295 | /**************** Cases other than YCbCr -> RGB **************/ |
296 | |
297 | |
298 | /* |
299 | * Initialize for RGB->grayscale colorspace conversion. |
300 | */ |
301 | |
302 | LOCAL(void) |
303 | build_rgb_y_table (j_decompress_ptr cinfo) |
304 | { |
305 | my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; |
306 | JLONG *rgb_y_tab; |
307 | JLONG i; |
308 | |
309 | /* Allocate and fill in the conversion tables. */ |
310 | cconvert->rgb_y_tab = rgb_y_tab = (JLONG *) |
311 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
312 | (TABLE_SIZE * sizeof(JLONG))); |
313 | |
314 | for (i = 0; i <= MAXJSAMPLE; i++) { |
315 | rgb_y_tab[i+R_Y_OFF] = FIX(0.29900) * i; |
316 | rgb_y_tab[i+G_Y_OFF] = FIX(0.58700) * i; |
317 | rgb_y_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF; |
318 | } |
319 | } |
320 | |
321 | |
322 | /* |
323 | * Convert RGB to grayscale. |
324 | */ |
325 | |
326 | METHODDEF(void) |
327 | rgb_gray_convert (j_decompress_ptr cinfo, |
328 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
329 | JSAMPARRAY output_buf, int num_rows) |
330 | { |
331 | my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; |
332 | register int r, g, b; |
333 | register JLONG *ctab = cconvert->rgb_y_tab; |
334 | register JSAMPROW outptr; |
335 | register JSAMPROW inptr0, inptr1, inptr2; |
336 | register JDIMENSION col; |
337 | JDIMENSION num_cols = cinfo->output_width; |
338 | |
339 | while (--num_rows >= 0) { |
340 | inptr0 = input_buf[0][input_row]; |
341 | inptr1 = input_buf[1][input_row]; |
342 | inptr2 = input_buf[2][input_row]; |
343 | input_row++; |
344 | outptr = *output_buf++; |
345 | for (col = 0; col < num_cols; col++) { |
346 | r = GETJSAMPLE(inptr0[col]); |
347 | g = GETJSAMPLE(inptr1[col]); |
348 | b = GETJSAMPLE(inptr2[col]); |
349 | /* Y */ |
350 | outptr[col] = (JSAMPLE) |
351 | ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) |
352 | >> SCALEBITS); |
353 | } |
354 | } |
355 | } |
356 | |
357 | |
358 | /* |
359 | * Color conversion for no colorspace change: just copy the data, |
360 | * converting from separate-planes to interleaved representation. |
361 | */ |
362 | |
363 | METHODDEF(void) |
364 | null_convert (j_decompress_ptr cinfo, |
365 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
366 | JSAMPARRAY output_buf, int num_rows) |
367 | { |
368 | register JSAMPROW inptr, inptr0, inptr1, inptr2, inptr3, outptr; |
369 | register JDIMENSION col; |
370 | register int num_components = cinfo->num_components; |
371 | JDIMENSION num_cols = cinfo->output_width; |
372 | int ci; |
373 | |
374 | if (num_components == 3) { |
375 | while (--num_rows >= 0) { |
376 | inptr0 = input_buf[0][input_row]; |
377 | inptr1 = input_buf[1][input_row]; |
378 | inptr2 = input_buf[2][input_row]; |
379 | input_row++; |
380 | outptr = *output_buf++; |
381 | for (col = 0; col < num_cols; col++) { |
382 | *outptr++ = inptr0[col]; |
383 | *outptr++ = inptr1[col]; |
384 | *outptr++ = inptr2[col]; |
385 | } |
386 | } |
387 | } else if (num_components == 4) { |
388 | while (--num_rows >= 0) { |
389 | inptr0 = input_buf[0][input_row]; |
390 | inptr1 = input_buf[1][input_row]; |
391 | inptr2 = input_buf[2][input_row]; |
392 | inptr3 = input_buf[3][input_row]; |
393 | input_row++; |
394 | outptr = *output_buf++; |
395 | for (col = 0; col < num_cols; col++) { |
396 | *outptr++ = inptr0[col]; |
397 | *outptr++ = inptr1[col]; |
398 | *outptr++ = inptr2[col]; |
399 | *outptr++ = inptr3[col]; |
400 | } |
401 | } |
402 | } else { |
403 | while (--num_rows >= 0) { |
404 | for (ci = 0; ci < num_components; ci++) { |
405 | inptr = input_buf[ci][input_row]; |
406 | outptr = *output_buf; |
407 | for (col = 0; col < num_cols; col++) { |
408 | outptr[ci] = inptr[col]; |
409 | outptr += num_components; |
410 | } |
411 | } |
412 | output_buf++; |
413 | input_row++; |
414 | } |
415 | } |
416 | } |
417 | |
418 | |
419 | /* |
420 | * Color conversion for grayscale: just copy the data. |
421 | * This also works for YCbCr -> grayscale conversion, in which |
422 | * we just copy the Y (luminance) component and ignore chrominance. |
423 | */ |
424 | |
425 | METHODDEF(void) |
426 | grayscale_convert (j_decompress_ptr cinfo, |
427 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
428 | JSAMPARRAY output_buf, int num_rows) |
429 | { |
430 | jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0, |
431 | num_rows, cinfo->output_width); |
432 | } |
433 | |
434 | |
435 | /* |
436 | * Convert grayscale to RGB |
437 | */ |
438 | |
439 | METHODDEF(void) |
440 | gray_rgb_convert (j_decompress_ptr cinfo, |
441 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
442 | JSAMPARRAY output_buf, int num_rows) |
443 | { |
444 | switch (cinfo->out_color_space) { |
445 | case JCS_EXT_RGB: |
446 | gray_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
447 | num_rows); |
448 | break; |
449 | case JCS_EXT_RGBX: |
450 | case JCS_EXT_RGBA: |
451 | gray_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf, |
452 | num_rows); |
453 | break; |
454 | case JCS_EXT_BGR: |
455 | gray_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf, |
456 | num_rows); |
457 | break; |
458 | case JCS_EXT_BGRX: |
459 | case JCS_EXT_BGRA: |
460 | gray_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf, |
461 | num_rows); |
462 | break; |
463 | case JCS_EXT_XBGR: |
464 | case JCS_EXT_ABGR: |
465 | gray_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf, |
466 | num_rows); |
467 | break; |
468 | case JCS_EXT_XRGB: |
469 | case JCS_EXT_ARGB: |
470 | gray_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
471 | num_rows); |
472 | break; |
473 | default: |
474 | gray_rgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
475 | num_rows); |
476 | break; |
477 | } |
478 | } |
479 | |
480 | |
481 | /* |
482 | * Convert plain RGB to extended RGB |
483 | */ |
484 | |
485 | METHODDEF(void) |
486 | rgb_rgb_convert (j_decompress_ptr cinfo, |
487 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
488 | JSAMPARRAY output_buf, int num_rows) |
489 | { |
490 | switch (cinfo->out_color_space) { |
491 | case JCS_EXT_RGB: |
492 | rgb_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
493 | num_rows); |
494 | break; |
495 | case JCS_EXT_RGBX: |
496 | case JCS_EXT_RGBA: |
497 | rgb_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf, |
498 | num_rows); |
499 | break; |
500 | case JCS_EXT_BGR: |
501 | rgb_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf, |
502 | num_rows); |
503 | break; |
504 | case JCS_EXT_BGRX: |
505 | case JCS_EXT_BGRA: |
506 | rgb_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf, |
507 | num_rows); |
508 | break; |
509 | case JCS_EXT_XBGR: |
510 | case JCS_EXT_ABGR: |
511 | rgb_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf, |
512 | num_rows); |
513 | break; |
514 | case JCS_EXT_XRGB: |
515 | case JCS_EXT_ARGB: |
516 | rgb_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
517 | num_rows); |
518 | break; |
519 | default: |
520 | rgb_rgb_convert_internal(cinfo, input_buf, input_row, output_buf, |
521 | num_rows); |
522 | break; |
523 | } |
524 | } |
525 | |
526 | |
527 | /* |
528 | * Adobe-style YCCK->CMYK conversion. |
529 | * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same |
530 | * conversion as above, while passing K (black) unchanged. |
531 | * We assume build_ycc_rgb_table has been called. |
532 | */ |
533 | |
534 | METHODDEF(void) |
535 | ycck_cmyk_convert (j_decompress_ptr cinfo, |
536 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
537 | JSAMPARRAY output_buf, int num_rows) |
538 | { |
539 | my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; |
540 | register int y, cb, cr; |
541 | register JSAMPROW outptr; |
542 | register JSAMPROW inptr0, inptr1, inptr2, inptr3; |
543 | register JDIMENSION col; |
544 | JDIMENSION num_cols = cinfo->output_width; |
545 | /* copy these pointers into registers if possible */ |
546 | register JSAMPLE *range_limit = cinfo->sample_range_limit; |
547 | register int *Crrtab = cconvert->Cr_r_tab; |
548 | register int *Cbbtab = cconvert->Cb_b_tab; |
549 | register JLONG *Crgtab = cconvert->Cr_g_tab; |
550 | register JLONG *Cbgtab = cconvert->Cb_g_tab; |
551 | SHIFT_TEMPS |
552 | |
553 | while (--num_rows >= 0) { |
554 | inptr0 = input_buf[0][input_row]; |
555 | inptr1 = input_buf[1][input_row]; |
556 | inptr2 = input_buf[2][input_row]; |
557 | inptr3 = input_buf[3][input_row]; |
558 | input_row++; |
559 | outptr = *output_buf++; |
560 | for (col = 0; col < num_cols; col++) { |
561 | y = GETJSAMPLE(inptr0[col]); |
562 | cb = GETJSAMPLE(inptr1[col]); |
563 | cr = GETJSAMPLE(inptr2[col]); |
564 | /* Range-limiting is essential due to noise introduced by DCT losses. */ |
565 | outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */ |
566 | outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */ |
567 | ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], |
568 | SCALEBITS)))]; |
569 | outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */ |
570 | /* K passes through unchanged */ |
571 | outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */ |
572 | outptr += 4; |
573 | } |
574 | } |
575 | } |
576 | |
577 | |
578 | /* |
579 | * RGB565 conversion |
580 | */ |
581 | |
582 | #define PACK_SHORT_565_LE(r, g, b) ((((r) << 8) & 0xF800) | \ |
583 | (((g) << 3) & 0x7E0) | ((b) >> 3)) |
584 | #define PACK_SHORT_565_BE(r, g, b) (((r) & 0xF8) | ((g) >> 5) | \ |
585 | (((g) << 11) & 0xE000) | \ |
586 | (((b) << 5) & 0x1F00)) |
587 | |
588 | #define PACK_TWO_PIXELS_LE(l, r) ((r << 16) | l) |
589 | #define PACK_TWO_PIXELS_BE(l, r) ((l << 16) | r) |
590 | |
591 | #define PACK_NEED_ALIGNMENT(ptr) (((size_t)(ptr)) & 3) |
592 | |
593 | #define WRITE_TWO_ALIGNED_PIXELS(addr, pixels) ((*(int *)(addr)) = pixels) |
594 | |
595 | #define DITHER_565_R(r, dither) ((r) + ((dither) & 0xFF)) |
596 | #define DITHER_565_G(g, dither) ((g) + (((dither) & 0xFF) >> 1)) |
597 | #define DITHER_565_B(b, dither) ((b) + ((dither) & 0xFF)) |
598 | |
599 | |
600 | /* Declarations for ordered dithering |
601 | * |
602 | * We use a 4x4 ordered dither array packed into 32 bits. This array is |
603 | * sufficent for dithering RGB888 to RGB565. |
604 | */ |
605 | |
606 | #define DITHER_MASK 0x3 |
607 | #define DITHER_ROTATE(x) ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF)) |
608 | static const JLONG dither_matrix[4] = { |
609 | 0x0008020A, |
610 | 0x0C040E06, |
611 | 0x030B0109, |
612 | 0x0F070D05 |
613 | }; |
614 | |
615 | |
616 | static INLINE boolean is_big_endian(void) |
617 | { |
618 | int test_value = 1; |
619 | if(*(char *)&test_value != 1) |
620 | return TRUE; |
621 | return FALSE; |
622 | } |
623 | |
624 | |
625 | /* Include inline routines for RGB565 conversion */ |
626 | |
627 | #define PACK_SHORT_565 PACK_SHORT_565_LE |
628 | #define PACK_TWO_PIXELS PACK_TWO_PIXELS_LE |
629 | #define ycc_rgb565_convert_internal ycc_rgb565_convert_le |
630 | #define ycc_rgb565D_convert_internal ycc_rgb565D_convert_le |
631 | #define rgb_rgb565_convert_internal rgb_rgb565_convert_le |
632 | #define rgb_rgb565D_convert_internal rgb_rgb565D_convert_le |
633 | #define gray_rgb565_convert_internal gray_rgb565_convert_le |
634 | #define gray_rgb565D_convert_internal gray_rgb565D_convert_le |
635 | #include "jdcol565.c" |
636 | #undef PACK_SHORT_565 |
637 | #undef PACK_TWO_PIXELS |
638 | #undef ycc_rgb565_convert_internal |
639 | #undef ycc_rgb565D_convert_internal |
640 | #undef rgb_rgb565_convert_internal |
641 | #undef rgb_rgb565D_convert_internal |
642 | #undef gray_rgb565_convert_internal |
643 | #undef gray_rgb565D_convert_internal |
644 | |
645 | #define PACK_SHORT_565 PACK_SHORT_565_BE |
646 | #define PACK_TWO_PIXELS PACK_TWO_PIXELS_BE |
647 | #define ycc_rgb565_convert_internal ycc_rgb565_convert_be |
648 | #define ycc_rgb565D_convert_internal ycc_rgb565D_convert_be |
649 | #define rgb_rgb565_convert_internal rgb_rgb565_convert_be |
650 | #define rgb_rgb565D_convert_internal rgb_rgb565D_convert_be |
651 | #define gray_rgb565_convert_internal gray_rgb565_convert_be |
652 | #define gray_rgb565D_convert_internal gray_rgb565D_convert_be |
653 | #include "jdcol565.c" |
654 | #undef PACK_SHORT_565 |
655 | #undef PACK_TWO_PIXELS |
656 | #undef ycc_rgb565_convert_internal |
657 | #undef ycc_rgb565D_convert_internal |
658 | #undef rgb_rgb565_convert_internal |
659 | #undef rgb_rgb565D_convert_internal |
660 | #undef gray_rgb565_convert_internal |
661 | #undef gray_rgb565D_convert_internal |
662 | |
663 | |
664 | METHODDEF(void) |
665 | ycc_rgb565_convert (j_decompress_ptr cinfo, |
666 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
667 | JSAMPARRAY output_buf, int num_rows) |
668 | { |
669 | if (is_big_endian()) |
670 | ycc_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); |
671 | else |
672 | ycc_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); |
673 | } |
674 | |
675 | |
676 | METHODDEF(void) |
677 | ycc_rgb565D_convert (j_decompress_ptr cinfo, |
678 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
679 | JSAMPARRAY output_buf, int num_rows) |
680 | { |
681 | if (is_big_endian()) |
682 | ycc_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); |
683 | else |
684 | ycc_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); |
685 | } |
686 | |
687 | |
688 | METHODDEF(void) |
689 | rgb_rgb565_convert (j_decompress_ptr cinfo, |
690 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
691 | JSAMPARRAY output_buf, int num_rows) |
692 | { |
693 | if (is_big_endian()) |
694 | rgb_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); |
695 | else |
696 | rgb_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); |
697 | } |
698 | |
699 | |
700 | METHODDEF(void) |
701 | rgb_rgb565D_convert (j_decompress_ptr cinfo, |
702 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
703 | JSAMPARRAY output_buf, int num_rows) |
704 | { |
705 | if (is_big_endian()) |
706 | rgb_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); |
707 | else |
708 | rgb_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); |
709 | } |
710 | |
711 | |
712 | METHODDEF(void) |
713 | gray_rgb565_convert (j_decompress_ptr cinfo, |
714 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
715 | JSAMPARRAY output_buf, int num_rows) |
716 | { |
717 | if (is_big_endian()) |
718 | gray_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); |
719 | else |
720 | gray_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); |
721 | } |
722 | |
723 | |
724 | METHODDEF(void) |
725 | gray_rgb565D_convert (j_decompress_ptr cinfo, |
726 | JSAMPIMAGE input_buf, JDIMENSION input_row, |
727 | JSAMPARRAY output_buf, int num_rows) |
728 | { |
729 | if (is_big_endian()) |
730 | gray_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); |
731 | else |
732 | gray_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); |
733 | } |
734 | |
735 | |
736 | /* |
737 | * Empty method for start_pass. |
738 | */ |
739 | |
740 | METHODDEF(void) |
741 | start_pass_dcolor (j_decompress_ptr cinfo) |
742 | { |
743 | /* no work needed */ |
744 | } |
745 | |
746 | |
747 | /* |
748 | * Module initialization routine for output colorspace conversion. |
749 | */ |
750 | |
751 | GLOBAL(void) |
752 | jinit_color_deconverter (j_decompress_ptr cinfo) |
753 | { |
754 | my_cconvert_ptr cconvert; |
755 | int ci; |
756 | |
757 | cconvert = (my_cconvert_ptr) |
758 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
759 | sizeof(my_color_deconverter)); |
760 | cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert; |
761 | cconvert->pub.start_pass = start_pass_dcolor; |
762 | |
763 | /* Make sure num_components agrees with jpeg_color_space */ |
764 | switch (cinfo->jpeg_color_space) { |
765 | case JCS_GRAYSCALE: |
766 | if (cinfo->num_components != 1) |
767 | ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); |
768 | break; |
769 | |
770 | case JCS_RGB: |
771 | case JCS_YCbCr: |
772 | if (cinfo->num_components != 3) |
773 | ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); |
774 | break; |
775 | |
776 | case JCS_CMYK: |
777 | case JCS_YCCK: |
778 | if (cinfo->num_components != 4) |
779 | ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); |
780 | break; |
781 | |
782 | default: /* JCS_UNKNOWN can be anything */ |
783 | if (cinfo->num_components < 1) |
784 | ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); |
785 | break; |
786 | } |
787 | |
788 | /* Set out_color_components and conversion method based on requested space. |
789 | * Also clear the component_needed flags for any unused components, |
790 | * so that earlier pipeline stages can avoid useless computation. |
791 | */ |
792 | |
793 | switch (cinfo->out_color_space) { |
794 | case JCS_GRAYSCALE: |
795 | cinfo->out_color_components = 1; |
796 | if (cinfo->jpeg_color_space == JCS_GRAYSCALE || |
797 | cinfo->jpeg_color_space == JCS_YCbCr) { |
798 | cconvert->pub.color_convert = grayscale_convert; |
799 | /* For color->grayscale conversion, only the Y (0) component is needed */ |
800 | for (ci = 1; ci < cinfo->num_components; ci++) |
801 | cinfo->comp_info[ci].component_needed = FALSE; |
802 | } else if (cinfo->jpeg_color_space == JCS_RGB) { |
803 | cconvert->pub.color_convert = rgb_gray_convert; |
804 | build_rgb_y_table(cinfo); |
805 | } else |
806 | ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); |
807 | break; |
808 | |
809 | case JCS_RGB: |
810 | case JCS_EXT_RGB: |
811 | case JCS_EXT_RGBX: |
812 | case JCS_EXT_BGR: |
813 | case JCS_EXT_BGRX: |
814 | case JCS_EXT_XBGR: |
815 | case JCS_EXT_XRGB: |
816 | case JCS_EXT_RGBA: |
817 | case JCS_EXT_BGRA: |
818 | case JCS_EXT_ABGR: |
819 | case JCS_EXT_ARGB: |
820 | cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space]; |
821 | if (cinfo->jpeg_color_space == JCS_YCbCr) { |
822 | if (jsimd_can_ycc_rgb()) |
823 | cconvert->pub.color_convert = jsimd_ycc_rgb_convert; |
824 | else { |
825 | cconvert->pub.color_convert = ycc_rgb_convert; |
826 | build_ycc_rgb_table(cinfo); |
827 | } |
828 | } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { |
829 | cconvert->pub.color_convert = gray_rgb_convert; |
830 | } else if (cinfo->jpeg_color_space == JCS_RGB) { |
831 | if (rgb_red[cinfo->out_color_space] == 0 && |
832 | rgb_green[cinfo->out_color_space] == 1 && |
833 | rgb_blue[cinfo->out_color_space] == 2 && |
834 | rgb_pixelsize[cinfo->out_color_space] == 3) |
835 | cconvert->pub.color_convert = null_convert; |
836 | else |
837 | cconvert->pub.color_convert = rgb_rgb_convert; |
838 | } else |
839 | ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); |
840 | break; |
841 | |
842 | case JCS_RGB565: |
843 | cinfo->out_color_components = 3; |
844 | if (cinfo->dither_mode == JDITHER_NONE) { |
845 | if (cinfo->jpeg_color_space == JCS_YCbCr) { |
846 | if (jsimd_can_ycc_rgb565()) |
847 | cconvert->pub.color_convert = jsimd_ycc_rgb565_convert; |
848 | else { |
849 | cconvert->pub.color_convert = ycc_rgb565_convert; |
850 | build_ycc_rgb_table(cinfo); |
851 | } |
852 | } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { |
853 | cconvert->pub.color_convert = gray_rgb565_convert; |
854 | } else if (cinfo->jpeg_color_space == JCS_RGB) { |
855 | cconvert->pub.color_convert = rgb_rgb565_convert; |
856 | } else |
857 | ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); |
858 | } else { |
859 | /* only ordered dithering is supported */ |
860 | if (cinfo->jpeg_color_space == JCS_YCbCr) { |
861 | cconvert->pub.color_convert = ycc_rgb565D_convert; |
862 | build_ycc_rgb_table(cinfo); |
863 | } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { |
864 | cconvert->pub.color_convert = gray_rgb565D_convert; |
865 | } else if (cinfo->jpeg_color_space == JCS_RGB) { |
866 | cconvert->pub.color_convert = rgb_rgb565D_convert; |
867 | } else |
868 | ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); |
869 | } |
870 | break; |
871 | |
872 | case JCS_CMYK: |
873 | cinfo->out_color_components = 4; |
874 | if (cinfo->jpeg_color_space == JCS_YCCK) { |
875 | cconvert->pub.color_convert = ycck_cmyk_convert; |
876 | build_ycc_rgb_table(cinfo); |
877 | } else if (cinfo->jpeg_color_space == JCS_CMYK) { |
878 | cconvert->pub.color_convert = null_convert; |
879 | } else |
880 | ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); |
881 | break; |
882 | |
883 | default: |
884 | /* Permit null conversion to same output space */ |
885 | if (cinfo->out_color_space == cinfo->jpeg_color_space) { |
886 | cinfo->out_color_components = cinfo->num_components; |
887 | cconvert->pub.color_convert = null_convert; |
888 | } else /* unsupported non-null conversion */ |
889 | ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); |
890 | break; |
891 | } |
892 | |
893 | if (cinfo->quantize_colors) |
894 | cinfo->output_components = 1; /* single colormapped output component */ |
895 | else |
896 | cinfo->output_components = cinfo->out_color_components; |
897 | } |
898 | |