[LIBJPEG]
[reactos.git] / reactos / dll / 3rdparty / libjpeg / jdcolor.c
1 /*
2 * jdcolor.c
3 *
4 * Copyright (C) 1991-1997, Thomas G. Lane.
5 * Modified 2011-2015 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
8 *
9 * This file contains output colorspace conversion routines.
10 */
11
12 #define JPEG_INTERNALS
13 #include "jinclude.h"
14 #include "jpeglib.h"
15
16
17 /* Private subobject */
18
19 typedef struct {
20 struct jpeg_color_deconverter pub; /* public fields */
21
22 /* Private state for YCbCr->RGB and BG_YCC->RGB conversion */
23 int * Cr_r_tab; /* => table for Cr to R conversion */
24 int * Cb_b_tab; /* => table for Cb to B conversion */
25 INT32 * Cr_g_tab; /* => table for Cr to G conversion */
26 INT32 * Cb_g_tab; /* => table for Cb to G conversion */
27
28 /* Private state for RGB->Y conversion */
29 INT32 * rgb_y_tab; /* => table for RGB to Y conversion */
30 } my_color_deconverter;
31
32 typedef my_color_deconverter * my_cconvert_ptr;
33
34
35 /*************** YCbCr -> RGB conversion: most common case **************/
36 /*************** BG_YCC -> RGB conversion: less common case **************/
37 /*************** RGB -> Y conversion: less common case **************/
38
39 /*
40 * YCbCr is defined per Recommendation ITU-R BT.601-7 (03/2011),
41 * previously known as Recommendation CCIR 601-1, except that Cb and Cr
42 * are normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
43 * sRGB (standard RGB color space) is defined per IEC 61966-2-1:1999.
44 * sYCC (standard luma-chroma-chroma color space with extended gamut)
45 * is defined per IEC 61966-2-1:1999 Amendment A1:2003 Annex F.
46 * bg-sRGB and bg-sYCC (big gamut standard color spaces)
47 * are defined per IEC 61966-2-1:1999 Amendment A1:2003 Annex G.
48 * Note that the derived conversion coefficients given in some of these
49 * documents are imprecise. The general conversion equations are
50 *
51 * R = Y + K * (1 - Kr) * Cr
52 * G = Y - K * (Kb * (1 - Kb) * Cb + Kr * (1 - Kr) * Cr) / (1 - Kr - Kb)
53 * B = Y + K * (1 - Kb) * Cb
54 *
55 * Y = Kr * R + (1 - Kr - Kb) * G + Kb * B
56 *
57 * With Kr = 0.299 and Kb = 0.114 (derived according to SMPTE RP 177-1993
58 * from the 1953 FCC NTSC primaries and CIE Illuminant C), K = 2 for sYCC,
59 * the conversion equations to be implemented are therefore
60 *
61 * R = Y + 1.402 * Cr
62 * G = Y - 0.344136286 * Cb - 0.714136286 * Cr
63 * B = Y + 1.772 * Cb
64 *
65 * Y = 0.299 * R + 0.587 * G + 0.114 * B
66 *
67 * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
68 * For bg-sYCC, with K = 4, the equations are
69 *
70 * R = Y + 2.804 * Cr
71 * G = Y - 0.688272572 * Cb - 1.428272572 * Cr
72 * B = Y + 3.544 * Cb
73 *
74 * To avoid floating-point arithmetic, we represent the fractional constants
75 * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
76 * the products by 2^16, with appropriate rounding, to get the correct answer.
77 * Notice that Y, being an integral input, does not contribute any fraction
78 * so it need not participate in the rounding.
79 *
80 * For even more speed, we avoid doing any multiplications in the inner loop
81 * by precalculating the constants times Cb and Cr for all possible values.
82 * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
83 * for 9-bit to 12-bit samples it is still acceptable. It's not very
84 * reasonable for 16-bit samples, but if you want lossless storage you
85 * shouldn't be changing colorspace anyway.
86 * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
87 * values for the G calculation are left scaled up, since we must add them
88 * together before rounding.
89 */
90
91 #define SCALEBITS 16 /* speediest right-shift on some machines */
92 #define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
93 #define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
94
95 /* We allocate one big table for RGB->Y conversion and divide it up into
96 * three parts, instead of doing three alloc_small requests. This lets us
97 * use a single table base address, which can be held in a register in the
98 * inner loops on many machines (more than can hold all three addresses,
99 * anyway).
100 */
101
102 #define R_Y_OFF 0 /* offset to R => Y section */
103 #define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */
104 #define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */
105 #define TABLE_SIZE (3*(MAXJSAMPLE+1))
106
107
108 /*
109 * Initialize tables for YCbCr->RGB and BG_YCC->RGB colorspace conversion.
110 */
111
112 LOCAL(void)
113 build_ycc_rgb_table (j_decompress_ptr cinfo)
114 /* Normal case, sYCC */
115 {
116 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
117 int i;
118 INT32 x;
119 SHIFT_TEMPS
120
121 cconvert->Cr_r_tab = (int *)
122 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
123 (MAXJSAMPLE+1) * SIZEOF(int));
124 cconvert->Cb_b_tab = (int *)
125 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
126 (MAXJSAMPLE+1) * SIZEOF(int));
127 cconvert->Cr_g_tab = (INT32 *)
128 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
129 (MAXJSAMPLE+1) * SIZEOF(INT32));
130 cconvert->Cb_g_tab = (INT32 *)
131 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
132 (MAXJSAMPLE+1) * SIZEOF(INT32));
133
134 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
135 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
136 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
137 /* Cr=>R value is nearest int to 1.402 * x */
138 cconvert->Cr_r_tab[i] = (int)
139 RIGHT_SHIFT(FIX(1.402) * x + ONE_HALF, SCALEBITS);
140 /* Cb=>B value is nearest int to 1.772 * x */
141 cconvert->Cb_b_tab[i] = (int)
142 RIGHT_SHIFT(FIX(1.772) * x + ONE_HALF, SCALEBITS);
143 /* Cr=>G value is scaled-up -0.714136286 * x */
144 cconvert->Cr_g_tab[i] = (- FIX(0.714136286)) * x;
145 /* Cb=>G value is scaled-up -0.344136286 * x */
146 /* We also add in ONE_HALF so that need not do it in inner loop */
147 cconvert->Cb_g_tab[i] = (- FIX(0.344136286)) * x + ONE_HALF;
148 }
149 }
150
151
152 LOCAL(void)
153 build_bg_ycc_rgb_table (j_decompress_ptr cinfo)
154 /* Wide gamut case, bg-sYCC */
155 {
156 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
157 int i;
158 INT32 x;
159 SHIFT_TEMPS
160
161 cconvert->Cr_r_tab = (int *)
162 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
163 (MAXJSAMPLE+1) * SIZEOF(int));
164 cconvert->Cb_b_tab = (int *)
165 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
166 (MAXJSAMPLE+1) * SIZEOF(int));
167 cconvert->Cr_g_tab = (INT32 *)
168 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
169 (MAXJSAMPLE+1) * SIZEOF(INT32));
170 cconvert->Cb_g_tab = (INT32 *)
171 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
172 (MAXJSAMPLE+1) * SIZEOF(INT32));
173
174 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
175 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
176 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
177 /* Cr=>R value is nearest int to 2.804 * x */
178 cconvert->Cr_r_tab[i] = (int)
179 RIGHT_SHIFT(FIX(2.804) * x + ONE_HALF, SCALEBITS);
180 /* Cb=>B value is nearest int to 3.544 * x */
181 cconvert->Cb_b_tab[i] = (int)
182 RIGHT_SHIFT(FIX(3.544) * x + ONE_HALF, SCALEBITS);
183 /* Cr=>G value is scaled-up -1.428272572 * x */
184 cconvert->Cr_g_tab[i] = (- FIX(1.428272572)) * x;
185 /* Cb=>G value is scaled-up -0.688272572 * x */
186 /* We also add in ONE_HALF so that need not do it in inner loop */
187 cconvert->Cb_g_tab[i] = (- FIX(0.688272572)) * x + ONE_HALF;
188 }
189 }
190
191
192 /*
193 * Convert some rows of samples to the output colorspace.
194 *
195 * Note that we change from noninterleaved, one-plane-per-component format
196 * to interleaved-pixel format. The output buffer is therefore three times
197 * as wide as the input buffer.
198 * A starting row offset is provided only for the input buffer. The caller
199 * can easily adjust the passed output_buf value to accommodate any row
200 * offset required on that side.
201 */
202
203 METHODDEF(void)
204 ycc_rgb_convert (j_decompress_ptr cinfo,
205 JSAMPIMAGE input_buf, JDIMENSION input_row,
206 JSAMPARRAY output_buf, int num_rows)
207 {
208 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
209 register int y, cb, cr;
210 register JSAMPROW outptr;
211 register JSAMPROW inptr0, inptr1, inptr2;
212 register JDIMENSION col;
213 JDIMENSION num_cols = cinfo->output_width;
214 /* copy these pointers into registers if possible */
215 register JSAMPLE * range_limit = cinfo->sample_range_limit;
216 register int * Crrtab = cconvert->Cr_r_tab;
217 register int * Cbbtab = cconvert->Cb_b_tab;
218 register INT32 * Crgtab = cconvert->Cr_g_tab;
219 register INT32 * Cbgtab = cconvert->Cb_g_tab;
220 SHIFT_TEMPS
221
222 while (--num_rows >= 0) {
223 inptr0 = input_buf[0][input_row];
224 inptr1 = input_buf[1][input_row];
225 inptr2 = input_buf[2][input_row];
226 input_row++;
227 outptr = *output_buf++;
228 for (col = 0; col < num_cols; col++) {
229 y = GETJSAMPLE(inptr0[col]);
230 cb = GETJSAMPLE(inptr1[col]);
231 cr = GETJSAMPLE(inptr2[col]);
232 /* Range-limiting is essential due to noise introduced by DCT losses,
233 * for extended gamut (sYCC) and wide gamut (bg-sYCC) encodings.
234 */
235 outptr[RGB_RED] = range_limit[y + Crrtab[cr]];
236 outptr[RGB_GREEN] = range_limit[y +
237 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
238 SCALEBITS))];
239 outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]];
240 outptr += RGB_PIXELSIZE;
241 }
242 }
243 }
244
245
246 /**************** Cases other than YCC -> RGB ****************/
247
248
249 /*
250 * Initialize for RGB->grayscale colorspace conversion.
251 */
252
253 LOCAL(void)
254 build_rgb_y_table (j_decompress_ptr cinfo)
255 {
256 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
257 INT32 * rgb_y_tab;
258 INT32 i;
259
260 /* Allocate and fill in the conversion tables. */
261 cconvert->rgb_y_tab = rgb_y_tab = (INT32 *)
262 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
263 (TABLE_SIZE * SIZEOF(INT32)));
264
265 for (i = 0; i <= MAXJSAMPLE; i++) {
266 rgb_y_tab[i+R_Y_OFF] = FIX(0.299) * i;
267 rgb_y_tab[i+G_Y_OFF] = FIX(0.587) * i;
268 rgb_y_tab[i+B_Y_OFF] = FIX(0.114) * i + ONE_HALF;
269 }
270 }
271
272
273 /*
274 * Convert RGB to grayscale.
275 */
276
277 METHODDEF(void)
278 rgb_gray_convert (j_decompress_ptr cinfo,
279 JSAMPIMAGE input_buf, JDIMENSION input_row,
280 JSAMPARRAY output_buf, int num_rows)
281 {
282 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
283 register INT32 * ctab = cconvert->rgb_y_tab;
284 register int r, g, b;
285 register JSAMPROW outptr;
286 register JSAMPROW inptr0, inptr1, inptr2;
287 register JDIMENSION col;
288 JDIMENSION num_cols = cinfo->output_width;
289
290 while (--num_rows >= 0) {
291 inptr0 = input_buf[0][input_row];
292 inptr1 = input_buf[1][input_row];
293 inptr2 = input_buf[2][input_row];
294 input_row++;
295 outptr = *output_buf++;
296 for (col = 0; col < num_cols; col++) {
297 r = GETJSAMPLE(inptr0[col]);
298 g = GETJSAMPLE(inptr1[col]);
299 b = GETJSAMPLE(inptr2[col]);
300 /* Y */
301 outptr[col] = (JSAMPLE)
302 ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
303 >> SCALEBITS);
304 }
305 }
306 }
307
308
309 /*
310 * [R-G,G,B-G] to [R,G,B] conversion with modulo calculation
311 * (inverse color transform).
312 * This can be seen as an adaption of the general YCbCr->RGB
313 * conversion equation with Kr = Kb = 0, while replacing the
314 * normalization by modulo calculation.
315 */
316
317 METHODDEF(void)
318 rgb1_rgb_convert (j_decompress_ptr cinfo,
319 JSAMPIMAGE input_buf, JDIMENSION input_row,
320 JSAMPARRAY output_buf, int num_rows)
321 {
322 register int r, g, b;
323 register JSAMPROW outptr;
324 register JSAMPROW inptr0, inptr1, inptr2;
325 register JDIMENSION col;
326 JDIMENSION num_cols = cinfo->output_width;
327
328 while (--num_rows >= 0) {
329 inptr0 = input_buf[0][input_row];
330 inptr1 = input_buf[1][input_row];
331 inptr2 = input_buf[2][input_row];
332 input_row++;
333 outptr = *output_buf++;
334 for (col = 0; col < num_cols; col++) {
335 r = GETJSAMPLE(inptr0[col]);
336 g = GETJSAMPLE(inptr1[col]);
337 b = GETJSAMPLE(inptr2[col]);
338 /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
339 * (modulo) operator is equivalent to the bitmask operator AND.
340 */
341 outptr[RGB_RED] = (JSAMPLE) ((r + g - CENTERJSAMPLE) & MAXJSAMPLE);
342 outptr[RGB_GREEN] = (JSAMPLE) g;
343 outptr[RGB_BLUE] = (JSAMPLE) ((b + g - CENTERJSAMPLE) & MAXJSAMPLE);
344 outptr += RGB_PIXELSIZE;
345 }
346 }
347 }
348
349
350 /*
351 * [R-G,G,B-G] to grayscale conversion with modulo calculation
352 * (inverse color transform).
353 */
354
355 METHODDEF(void)
356 rgb1_gray_convert (j_decompress_ptr cinfo,
357 JSAMPIMAGE input_buf, JDIMENSION input_row,
358 JSAMPARRAY output_buf, int num_rows)
359 {
360 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
361 register INT32 * ctab = cconvert->rgb_y_tab;
362 register int r, g, b;
363 register JSAMPROW outptr;
364 register JSAMPROW inptr0, inptr1, inptr2;
365 register JDIMENSION col;
366 JDIMENSION num_cols = cinfo->output_width;
367
368 while (--num_rows >= 0) {
369 inptr0 = input_buf[0][input_row];
370 inptr1 = input_buf[1][input_row];
371 inptr2 = input_buf[2][input_row];
372 input_row++;
373 outptr = *output_buf++;
374 for (col = 0; col < num_cols; col++) {
375 r = GETJSAMPLE(inptr0[col]);
376 g = GETJSAMPLE(inptr1[col]);
377 b = GETJSAMPLE(inptr2[col]);
378 /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
379 * (modulo) operator is equivalent to the bitmask operator AND.
380 */
381 r = (r + g - CENTERJSAMPLE) & MAXJSAMPLE;
382 b = (b + g - CENTERJSAMPLE) & MAXJSAMPLE;
383 /* Y */
384 outptr[col] = (JSAMPLE)
385 ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
386 >> SCALEBITS);
387 }
388 }
389 }
390
391
392 /*
393 * No colorspace change, but conversion from separate-planes
394 * to interleaved representation.
395 */
396
397 METHODDEF(void)
398 rgb_convert (j_decompress_ptr cinfo,
399 JSAMPIMAGE input_buf, JDIMENSION input_row,
400 JSAMPARRAY output_buf, int num_rows)
401 {
402 register JSAMPROW outptr;
403 register JSAMPROW inptr0, inptr1, inptr2;
404 register JDIMENSION col;
405 JDIMENSION num_cols = cinfo->output_width;
406
407 while (--num_rows >= 0) {
408 inptr0 = input_buf[0][input_row];
409 inptr1 = input_buf[1][input_row];
410 inptr2 = input_buf[2][input_row];
411 input_row++;
412 outptr = *output_buf++;
413 for (col = 0; col < num_cols; col++) {
414 /* We can dispense with GETJSAMPLE() here */
415 outptr[RGB_RED] = inptr0[col];
416 outptr[RGB_GREEN] = inptr1[col];
417 outptr[RGB_BLUE] = inptr2[col];
418 outptr += RGB_PIXELSIZE;
419 }
420 }
421 }
422
423
424 /*
425 * Color conversion for no colorspace change: just copy the data,
426 * converting from separate-planes to interleaved representation.
427 */
428
429 METHODDEF(void)
430 null_convert (j_decompress_ptr cinfo,
431 JSAMPIMAGE input_buf, JDIMENSION input_row,
432 JSAMPARRAY output_buf, int num_rows)
433 {
434 int ci;
435 register int nc = cinfo->num_components;
436 register JSAMPROW outptr;
437 register JSAMPROW inptr;
438 register JDIMENSION col;
439 JDIMENSION num_cols = cinfo->output_width;
440
441 while (--num_rows >= 0) {
442 for (ci = 0; ci < nc; ci++) {
443 inptr = input_buf[ci][input_row];
444 outptr = output_buf[0] + ci;
445 for (col = 0; col < num_cols; col++) {
446 *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */
447 outptr += nc;
448 }
449 }
450 input_row++;
451 output_buf++;
452 }
453 }
454
455
456 /*
457 * Color conversion for grayscale: just copy the data.
458 * This also works for YCC -> grayscale conversion, in which
459 * we just copy the Y (luminance) component and ignore chrominance.
460 */
461
462 METHODDEF(void)
463 grayscale_convert (j_decompress_ptr cinfo,
464 JSAMPIMAGE input_buf, JDIMENSION input_row,
465 JSAMPARRAY output_buf, int num_rows)
466 {
467 jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
468 num_rows, cinfo->output_width);
469 }
470
471
472 /*
473 * Convert grayscale to RGB: just duplicate the graylevel three times.
474 * This is provided to support applications that don't want to cope
475 * with grayscale as a separate case.
476 */
477
478 METHODDEF(void)
479 gray_rgb_convert (j_decompress_ptr cinfo,
480 JSAMPIMAGE input_buf, JDIMENSION input_row,
481 JSAMPARRAY output_buf, int num_rows)
482 {
483 register JSAMPROW outptr;
484 register JSAMPROW inptr;
485 register JDIMENSION col;
486 JDIMENSION num_cols = cinfo->output_width;
487
488 while (--num_rows >= 0) {
489 inptr = input_buf[0][input_row++];
490 outptr = *output_buf++;
491 for (col = 0; col < num_cols; col++) {
492 /* We can dispense with GETJSAMPLE() here */
493 outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
494 outptr += RGB_PIXELSIZE;
495 }
496 }
497 }
498
499
500 /*
501 * Adobe-style YCCK->CMYK conversion.
502 * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
503 * conversion as above, while passing K (black) unchanged.
504 * We assume build_ycc_rgb_table has been called.
505 */
506
507 METHODDEF(void)
508 ycck_cmyk_convert (j_decompress_ptr cinfo,
509 JSAMPIMAGE input_buf, JDIMENSION input_row,
510 JSAMPARRAY output_buf, int num_rows)
511 {
512 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
513 register int y, cb, cr;
514 register JSAMPROW outptr;
515 register JSAMPROW inptr0, inptr1, inptr2, inptr3;
516 register JDIMENSION col;
517 JDIMENSION num_cols = cinfo->output_width;
518 /* copy these pointers into registers if possible */
519 register JSAMPLE * range_limit = cinfo->sample_range_limit;
520 register int * Crrtab = cconvert->Cr_r_tab;
521 register int * Cbbtab = cconvert->Cb_b_tab;
522 register INT32 * Crgtab = cconvert->Cr_g_tab;
523 register INT32 * Cbgtab = cconvert->Cb_g_tab;
524 SHIFT_TEMPS
525
526 while (--num_rows >= 0) {
527 inptr0 = input_buf[0][input_row];
528 inptr1 = input_buf[1][input_row];
529 inptr2 = input_buf[2][input_row];
530 inptr3 = input_buf[3][input_row];
531 input_row++;
532 outptr = *output_buf++;
533 for (col = 0; col < num_cols; col++) {
534 y = GETJSAMPLE(inptr0[col]);
535 cb = GETJSAMPLE(inptr1[col]);
536 cr = GETJSAMPLE(inptr2[col]);
537 /* Range-limiting is essential due to noise introduced by DCT losses,
538 * and for extended gamut encodings (sYCC).
539 */
540 outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */
541 outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */
542 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
543 SCALEBITS)))];
544 outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */
545 /* K passes through unchanged */
546 outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
547 outptr += 4;
548 }
549 }
550 }
551
552
553 /*
554 * Empty method for start_pass.
555 */
556
557 METHODDEF(void)
558 start_pass_dcolor (j_decompress_ptr cinfo)
559 {
560 /* no work needed */
561 }
562
563
564 /*
565 * Module initialization routine for output colorspace conversion.
566 */
567
568 GLOBAL(void)
569 jinit_color_deconverter (j_decompress_ptr cinfo)
570 {
571 my_cconvert_ptr cconvert;
572 int ci;
573
574 cconvert = (my_cconvert_ptr)
575 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
576 SIZEOF(my_color_deconverter));
577 cinfo->cconvert = &cconvert->pub;
578 cconvert->pub.start_pass = start_pass_dcolor;
579
580 /* Make sure num_components agrees with jpeg_color_space */
581 switch (cinfo->jpeg_color_space) {
582 case JCS_GRAYSCALE:
583 if (cinfo->num_components != 1)
584 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
585 break;
586
587 case JCS_RGB:
588 case JCS_YCbCr:
589 case JCS_BG_RGB:
590 case JCS_BG_YCC:
591 if (cinfo->num_components != 3)
592 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
593 break;
594
595 case JCS_CMYK:
596 case JCS_YCCK:
597 if (cinfo->num_components != 4)
598 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
599 break;
600
601 default: /* JCS_UNKNOWN can be anything */
602 if (cinfo->num_components < 1)
603 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
604 break;
605 }
606
607 /* Support color transform only for RGB colorspaces */
608 if (cinfo->color_transform &&
609 cinfo->jpeg_color_space != JCS_RGB &&
610 cinfo->jpeg_color_space != JCS_BG_RGB)
611 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
612
613 /* Set out_color_components and conversion method based on requested space.
614 * Also clear the component_needed flags for any unused components,
615 * so that earlier pipeline stages can avoid useless computation.
616 */
617
618 switch (cinfo->out_color_space) {
619 case JCS_GRAYSCALE:
620 cinfo->out_color_components = 1;
621 switch (cinfo->jpeg_color_space) {
622 case JCS_GRAYSCALE:
623 case JCS_YCbCr:
624 case JCS_BG_YCC:
625 cconvert->pub.color_convert = grayscale_convert;
626 /* For color->grayscale conversion, only the Y (0) component is needed */
627 for (ci = 1; ci < cinfo->num_components; ci++)
628 cinfo->comp_info[ci].component_needed = FALSE;
629 break;
630 case JCS_RGB:
631 switch (cinfo->color_transform) {
632 case JCT_NONE:
633 cconvert->pub.color_convert = rgb_gray_convert;
634 break;
635 case JCT_SUBTRACT_GREEN:
636 cconvert->pub.color_convert = rgb1_gray_convert;
637 break;
638 default:
639 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
640 }
641 build_rgb_y_table(cinfo);
642 break;
643 default:
644 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
645 }
646 break;
647
648 case JCS_RGB:
649 cinfo->out_color_components = RGB_PIXELSIZE;
650 switch (cinfo->jpeg_color_space) {
651 case JCS_GRAYSCALE:
652 cconvert->pub.color_convert = gray_rgb_convert;
653 break;
654 case JCS_YCbCr:
655 cconvert->pub.color_convert = ycc_rgb_convert;
656 build_ycc_rgb_table(cinfo);
657 break;
658 case JCS_BG_YCC:
659 cconvert->pub.color_convert = ycc_rgb_convert;
660 build_bg_ycc_rgb_table(cinfo);
661 break;
662 case JCS_RGB:
663 switch (cinfo->color_transform) {
664 case JCT_NONE:
665 cconvert->pub.color_convert = rgb_convert;
666 break;
667 case JCT_SUBTRACT_GREEN:
668 cconvert->pub.color_convert = rgb1_rgb_convert;
669 break;
670 default:
671 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
672 }
673 break;
674 default:
675 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
676 }
677 break;
678
679 case JCS_BG_RGB:
680 cinfo->out_color_components = RGB_PIXELSIZE;
681 if (cinfo->jpeg_color_space == JCS_BG_RGB) {
682 switch (cinfo->color_transform) {
683 case JCT_NONE:
684 cconvert->pub.color_convert = rgb_convert;
685 break;
686 case JCT_SUBTRACT_GREEN:
687 cconvert->pub.color_convert = rgb1_rgb_convert;
688 break;
689 default:
690 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
691 }
692 } else
693 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
694 break;
695
696 case JCS_CMYK:
697 cinfo->out_color_components = 4;
698 switch (cinfo->jpeg_color_space) {
699 case JCS_YCCK:
700 cconvert->pub.color_convert = ycck_cmyk_convert;
701 build_ycc_rgb_table(cinfo);
702 break;
703 case JCS_CMYK:
704 cconvert->pub.color_convert = null_convert;
705 break;
706 default:
707 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
708 }
709 break;
710
711 default:
712 /* Permit null conversion to same output space */
713 if (cinfo->out_color_space == cinfo->jpeg_color_space) {
714 cinfo->out_color_components = cinfo->num_components;
715 cconvert->pub.color_convert = null_convert;
716 } else /* unsupported non-null conversion */
717 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
718 break;
719 }
720
721 if (cinfo->quantize_colors)
722 cinfo->output_components = 1; /* single colormapped output component */
723 else
724 cinfo->output_components = cinfo->out_color_components;
725 }