4 * Copyright (C) 1991-1997, Thomas G. Lane.
5 * Modified 2011-2023 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.
9 * This file contains output colorspace conversion routines.
12 #define JPEG_INTERNALS
18 /* Deliberate syntax err */
19 Sorry
, this code requires
2 or more range extension bits
.
23 /* Private subobject */
26 struct jpeg_color_deconverter pub
; /* public fields */
28 /* Private state for YCbCr->RGB and BG_YCC->RGB conversion */
29 int * Cr_r_tab
; /* => table for Cr to R conversion */
30 int * Cb_b_tab
; /* => table for Cb to B conversion */
31 INT32
* Cr_g_tab
; /* => table for Cr to G conversion */
32 INT32
* Cb_g_tab
; /* => table for Cb to G conversion */
34 /* Private state for RGB->Y conversion */
35 INT32
* R_y_tab
; /* => table for R to Y conversion */
36 INT32
* G_y_tab
; /* => table for G to Y conversion */
37 INT32
* B_y_tab
; /* => table for B to Y conversion */
38 } my_color_deconverter
;
40 typedef my_color_deconverter
* my_cconvert_ptr
;
43 /*************** YCbCr -> RGB conversion: most common case **************/
44 /*************** BG_YCC -> RGB conversion: less common case **************/
45 /*************** RGB -> Y conversion: less common case **************/
48 * YCbCr is defined per Recommendation ITU-R BT.601-7 (03/2011),
49 * previously known as Recommendation CCIR 601-1, except that Cb and Cr
50 * are normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
51 * sRGB (standard RGB color space) is defined per IEC 61966-2-1:1999.
52 * sYCC (standard luma-chroma-chroma color space with extended gamut)
53 * is defined per IEC 61966-2-1:1999 Amendment A1:2003 Annex F.
54 * bg-sRGB and bg-sYCC (big gamut standard color spaces)
55 * are defined per IEC 61966-2-1:1999 Amendment A1:2003 Annex G.
56 * Note that the derived conversion coefficients given in some of these
57 * documents are imprecise. The general conversion equations are
59 * R = Y + K * (1 - Kr) * Cr
60 * G = Y - K * (Kb * (1 - Kb) * Cb + Kr * (1 - Kr) * Cr) / (1 - Kr - Kb)
61 * B = Y + K * (1 - Kb) * Cb
63 * Y = Kr * R + (1 - Kr - Kb) * G + Kb * B
65 * With Kr = 0.299 and Kb = 0.114 (derived according to SMPTE RP 177-1993
66 * from the 1953 FCC NTSC primaries and CIE Illuminant C), K = 2 for sYCC,
67 * the conversion equations to be implemented are therefore
70 * G = Y - 0.344136286 * Cb - 0.714136286 * Cr
73 * Y = 0.299 * R + 0.587 * G + 0.114 * B
75 * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
76 * For bg-sYCC, with K = 4, the equations are
79 * G = Y - 0.688272572 * Cb - 1.428272572 * Cr
82 * To avoid floating-point arithmetic, we represent the fractional constants
83 * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
84 * the products by 2^16, with appropriate rounding, to get the correct answer.
85 * Notice that Y, being an integral input, does not contribute any fraction
86 * so it need not participate in the rounding.
88 * For even more speed, we avoid doing any multiplications in the inner loop
89 * by precalculating the constants times Cb and Cr for all possible values.
90 * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
91 * for 9-bit to 12-bit samples it is still acceptable. It's not very
92 * reasonable for 16-bit samples, but if you want lossless storage
93 * you shouldn't be changing colorspace anyway.
94 * The Cr=>R and Cb=>B values can be rounded to integers in advance;
95 * the values for the G calculation are left scaled up,
96 * since we must add them together before rounding.
99 #define SCALEBITS 16 /* speediest right-shift on some machines */
100 #define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
101 #define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
105 * Initialize tables for YCbCr->RGB and BG_YCC->RGB colorspace conversion.
109 build_ycc_rgb_table (j_decompress_ptr cinfo
)
110 /* Normal case, sYCC */
112 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
117 cconvert
->Cr_r_tab
= (int *) (*cinfo
->mem
->alloc_small
)
118 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(int));
119 cconvert
->Cb_b_tab
= (int *) (*cinfo
->mem
->alloc_small
)
120 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(int));
121 cconvert
->Cr_g_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
122 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
123 cconvert
->Cb_g_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
124 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
126 for (i
= 0, x
= -CENTERJSAMPLE
; i
<= MAXJSAMPLE
; i
++, x
++) {
127 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
128 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
129 /* Cr=>R value is nearest int to 1.402 * x */
130 cconvert
->Cr_r_tab
[i
] = (int) DESCALE(FIX(1.402) * x
, SCALEBITS
);
131 /* Cb=>B value is nearest int to 1.772 * x */
132 cconvert
->Cb_b_tab
[i
] = (int) DESCALE(FIX(1.772) * x
, SCALEBITS
);
133 /* Cr=>G value is scaled-up -0.714136286 * x */
134 cconvert
->Cr_g_tab
[i
] = (- FIX(0.714136286)) * x
;
135 /* Cb=>G value is scaled-up -0.344136286 * x */
136 /* We also add in ONE_HALF so that need not do it in inner loop */
137 cconvert
->Cb_g_tab
[i
] = (- FIX(0.344136286)) * x
+ ONE_HALF
;
143 build_bg_ycc_rgb_table (j_decompress_ptr cinfo
)
144 /* Wide gamut case, bg-sYCC */
146 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
151 cconvert
->Cr_r_tab
= (int *) (*cinfo
->mem
->alloc_small
)
152 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(int));
153 cconvert
->Cb_b_tab
= (int *) (*cinfo
->mem
->alloc_small
)
154 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(int));
155 cconvert
->Cr_g_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
156 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
157 cconvert
->Cb_g_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
158 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
160 for (i
= 0, x
= -CENTERJSAMPLE
; i
<= MAXJSAMPLE
; i
++, x
++) {
161 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
162 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
163 /* Cr=>R value is nearest int to 2.804 * x */
164 cconvert
->Cr_r_tab
[i
] = (int) DESCALE(FIX(2.804) * x
, SCALEBITS
);
165 /* Cb=>B value is nearest int to 3.544 * x */
166 cconvert
->Cb_b_tab
[i
] = (int) DESCALE(FIX(3.544) * x
, SCALEBITS
);
167 /* Cr=>G value is scaled-up -1.428272572 * x */
168 cconvert
->Cr_g_tab
[i
] = (- FIX(1.428272572)) * x
;
169 /* Cb=>G value is scaled-up -0.688272572 * x */
170 /* We also add in ONE_HALF so that need not do it in inner loop */
171 cconvert
->Cb_g_tab
[i
] = (- FIX(0.688272572)) * x
+ ONE_HALF
;
177 * Convert some rows of samples to the output colorspace.
179 * Note that we change from noninterleaved, one-plane-per-component format
180 * to interleaved-pixel format. The output buffer is therefore three times
181 * as wide as the input buffer.
183 * A starting row offset is provided only for the input buffer. The caller
184 * can easily adjust the passed output_buf value to accommodate any row
185 * offset required on that side.
189 ycc_rgb_convert (j_decompress_ptr cinfo
,
190 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
191 JSAMPARRAY output_buf
, int num_rows
)
193 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
194 register int y
, cb
, cr
;
195 register JSAMPROW outptr
;
196 register JSAMPROW inptr0
, inptr1
, inptr2
;
197 register JDIMENSION col
;
198 JDIMENSION num_cols
= cinfo
->output_width
;
199 /* copy these pointers into registers if possible */
200 register JSAMPLE
* range_limit
= cinfo
->sample_range_limit
;
201 register int * Crrtab
= cconvert
->Cr_r_tab
;
202 register int * Cbbtab
= cconvert
->Cb_b_tab
;
203 register INT32
* Crgtab
= cconvert
->Cr_g_tab
;
204 register INT32
* Cbgtab
= cconvert
->Cb_g_tab
;
207 while (--num_rows
>= 0) {
208 inptr0
= input_buf
[0][input_row
];
209 inptr1
= input_buf
[1][input_row
];
210 inptr2
= input_buf
[2][input_row
];
212 outptr
= *output_buf
++;
213 for (col
= 0; col
< num_cols
; col
++) {
214 y
= GETJSAMPLE(inptr0
[col
]);
215 cb
= GETJSAMPLE(inptr1
[col
]);
216 cr
= GETJSAMPLE(inptr2
[col
]);
217 /* Range-limiting is essential due to noise introduced by DCT losses,
218 * for extended gamut (sYCC) and wide gamut (bg-sYCC) encodings.
220 outptr
[RGB_RED
] = range_limit
[y
+ Crrtab
[cr
]];
221 outptr
[RGB_GREEN
] = range_limit
[y
+
222 ((int) RIGHT_SHIFT(Cbgtab
[cb
] + Crgtab
[cr
],
224 outptr
[RGB_BLUE
] = range_limit
[y
+ Cbbtab
[cb
]];
225 outptr
+= RGB_PIXELSIZE
;
231 /**************** Cases other than YCC -> RGB ****************/
235 * Initialize for RGB->grayscale colorspace conversion.
239 build_rgb_y_table (j_decompress_ptr cinfo
)
241 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
244 cconvert
->R_y_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
245 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
246 cconvert
->G_y_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
247 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
248 cconvert
->B_y_tab
= (INT32
*) (*cinfo
->mem
->alloc_small
)
249 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, (MAXJSAMPLE
+1) * SIZEOF(INT32
));
251 for (i
= 0; i
<= MAXJSAMPLE
; i
++) {
252 cconvert
->R_y_tab
[i
] = FIX(0.299) * i
;
253 cconvert
->G_y_tab
[i
] = FIX(0.587) * i
;
254 cconvert
->B_y_tab
[i
] = FIX(0.114) * i
+ ONE_HALF
;
260 * Convert RGB to grayscale.
264 rgb_gray_convert (j_decompress_ptr cinfo
,
265 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
266 JSAMPARRAY output_buf
, int num_rows
)
268 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
270 register INT32
* Rytab
= cconvert
->R_y_tab
;
271 register INT32
* Gytab
= cconvert
->G_y_tab
;
272 register INT32
* Bytab
= cconvert
->B_y_tab
;
273 register JSAMPROW outptr
;
274 register JSAMPROW inptr0
, inptr1
, inptr2
;
275 register JDIMENSION col
;
276 JDIMENSION num_cols
= cinfo
->output_width
;
278 while (--num_rows
>= 0) {
279 inptr0
= input_buf
[0][input_row
];
280 inptr1
= input_buf
[1][input_row
];
281 inptr2
= input_buf
[2][input_row
];
283 outptr
= *output_buf
++;
284 for (col
= 0; col
< num_cols
; col
++) {
285 y
= Rytab
[GETJSAMPLE(inptr0
[col
])];
286 y
+= Gytab
[GETJSAMPLE(inptr1
[col
])];
287 y
+= Bytab
[GETJSAMPLE(inptr2
[col
])];
288 outptr
[col
] = (JSAMPLE
) (y
>> SCALEBITS
);
295 * Convert some rows of samples to the output colorspace.
296 * [R-G,G,B-G] to [R,G,B] conversion with modulo calculation
297 * (inverse color transform).
298 * This can be seen as an adaption of the general YCbCr->RGB
299 * conversion equation with Kr = Kb = 0, while replacing the
300 * normalization by modulo calculation.
304 rgb1_rgb_convert (j_decompress_ptr cinfo
,
305 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
306 JSAMPARRAY output_buf
, int num_rows
)
308 register int r
, g
, b
;
309 register JSAMPROW outptr
;
310 register JSAMPROW inptr0
, inptr1
, inptr2
;
311 register JDIMENSION col
;
312 JDIMENSION num_cols
= cinfo
->output_width
;
314 while (--num_rows
>= 0) {
315 inptr0
= input_buf
[0][input_row
];
316 inptr1
= input_buf
[1][input_row
];
317 inptr2
= input_buf
[2][input_row
];
319 outptr
= *output_buf
++;
320 for (col
= 0; col
< num_cols
; col
++) {
321 r
= GETJSAMPLE(inptr0
[col
]);
322 g
= GETJSAMPLE(inptr1
[col
]);
323 b
= GETJSAMPLE(inptr2
[col
]);
324 /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
325 * (modulo) operator is equivalent to the bitmask operator AND.
327 outptr
[RGB_RED
] = (JSAMPLE
) ((r
+ g
- CENTERJSAMPLE
) & MAXJSAMPLE
);
328 outptr
[RGB_GREEN
] = (JSAMPLE
) g
;
329 outptr
[RGB_BLUE
] = (JSAMPLE
) ((b
+ g
- CENTERJSAMPLE
) & MAXJSAMPLE
);
330 outptr
+= RGB_PIXELSIZE
;
337 * [R-G,G,B-G] to grayscale conversion with modulo calculation
338 * (inverse color transform).
342 rgb1_gray_convert (j_decompress_ptr cinfo
,
343 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
344 JSAMPARRAY output_buf
, int num_rows
)
346 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
347 register int r
, g
, b
;
349 register INT32
* Rytab
= cconvert
->R_y_tab
;
350 register INT32
* Gytab
= cconvert
->G_y_tab
;
351 register INT32
* Bytab
= cconvert
->B_y_tab
;
352 register JSAMPROW outptr
;
353 register JSAMPROW inptr0
, inptr1
, inptr2
;
354 register JDIMENSION col
;
355 JDIMENSION num_cols
= cinfo
->output_width
;
357 while (--num_rows
>= 0) {
358 inptr0
= input_buf
[0][input_row
];
359 inptr1
= input_buf
[1][input_row
];
360 inptr2
= input_buf
[2][input_row
];
362 outptr
= *output_buf
++;
363 for (col
= 0; col
< num_cols
; col
++) {
364 r
= GETJSAMPLE(inptr0
[col
]);
365 g
= GETJSAMPLE(inptr1
[col
]);
366 b
= GETJSAMPLE(inptr2
[col
]);
367 /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
368 * (modulo) operator is equivalent to the bitmask operator AND.
370 y
= Rytab
[(r
+ g
- CENTERJSAMPLE
) & MAXJSAMPLE
];
372 y
+= Bytab
[(b
+ g
- CENTERJSAMPLE
) & MAXJSAMPLE
];
373 outptr
[col
] = (JSAMPLE
) (y
>> SCALEBITS
);
380 * Convert some rows of samples to the output colorspace.
381 * No colorspace change, but conversion from separate-planes
382 * to interleaved representation.
386 rgb_convert (j_decompress_ptr cinfo
,
387 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
388 JSAMPARRAY output_buf
, int num_rows
)
390 register JSAMPROW outptr
;
391 register JSAMPROW inptr0
, inptr1
, inptr2
;
392 register JDIMENSION col
;
393 JDIMENSION num_cols
= cinfo
->output_width
;
395 while (--num_rows
>= 0) {
396 inptr0
= input_buf
[0][input_row
];
397 inptr1
= input_buf
[1][input_row
];
398 inptr2
= input_buf
[2][input_row
];
400 outptr
= *output_buf
++;
401 for (col
= 0; col
< num_cols
; col
++) {
402 /* We can dispense with GETJSAMPLE() here */
403 outptr
[RGB_RED
] = inptr0
[col
];
404 outptr
[RGB_GREEN
] = inptr1
[col
];
405 outptr
[RGB_BLUE
] = inptr2
[col
];
406 outptr
+= RGB_PIXELSIZE
;
413 * Color conversion for no colorspace change: just copy the data,
414 * converting from separate-planes to interleaved representation.
415 * Note: Omit uninteresting components in output buffer.
419 null_convert (j_decompress_ptr cinfo
,
420 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
421 JSAMPARRAY output_buf
, int num_rows
)
423 register JSAMPROW outptr
;
424 register JSAMPROW inptr
;
425 register JDIMENSION count
;
426 register int out_comps
= cinfo
->out_color_components
;
427 JDIMENSION num_cols
= cinfo
->output_width
;
430 jpeg_component_info
*compptr
;
432 while (--num_rows
>= 0) {
433 /* It seems fastest to make a separate pass for each component. */
434 startptr
= *output_buf
++;
435 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
437 if (! compptr
->component_needed
)
438 continue; /* skip uninteresting component */
439 inptr
= input_buf
[ci
][input_row
];
441 for (count
= num_cols
; count
> 0; count
--) {
442 *outptr
= *inptr
++; /* don't need GETJSAMPLE() here */
452 * Color conversion for grayscale: just copy the data.
453 * This also works for YCC -> grayscale conversion, in which
454 * we just copy the Y (luminance) component and ignore chrominance.
458 grayscale_convert (j_decompress_ptr cinfo
,
459 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
460 JSAMPARRAY output_buf
, int num_rows
)
462 jcopy_sample_rows(input_buf
[0] + input_row
, output_buf
,
463 num_rows
, cinfo
->output_width
);
468 * Convert grayscale to RGB: just duplicate the graylevel three times.
469 * This is provided to support applications that don't want to cope
470 * with grayscale as a separate case.
474 gray_rgb_convert (j_decompress_ptr cinfo
,
475 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
476 JSAMPARRAY output_buf
, int num_rows
)
478 register JSAMPROW outptr
;
479 register JSAMPROW inptr
;
480 register JDIMENSION col
;
481 JDIMENSION num_cols
= cinfo
->output_width
;
483 while (--num_rows
>= 0) {
484 inptr
= input_buf
[0][input_row
++];
485 outptr
= *output_buf
++;
486 for (col
= 0; col
< num_cols
; col
++) {
487 /* We can dispense with GETJSAMPLE() here */
488 outptr
[RGB_RED
] = outptr
[RGB_GREEN
] = outptr
[RGB_BLUE
] = inptr
[col
];
489 outptr
+= RGB_PIXELSIZE
;
496 * Convert some rows of samples to the output colorspace.
497 * This version handles Adobe-style YCCK->CMYK conversion,
498 * where we convert YCbCr to R=1-C, G=1-M, and B=1-Y using the
499 * same conversion as above, while passing K (black) unchanged.
500 * We assume build_ycc_rgb_table has been called.
504 ycck_cmyk_convert (j_decompress_ptr cinfo
,
505 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
506 JSAMPARRAY output_buf
, int num_rows
)
508 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
509 register int y
, cb
, cr
;
510 register JSAMPROW outptr
;
511 register JSAMPROW inptr0
, inptr1
, inptr2
, inptr3
;
512 register JDIMENSION col
;
513 JDIMENSION num_cols
= cinfo
->output_width
;
514 /* copy these pointers into registers if possible */
515 register JSAMPLE
* range_limit
= cinfo
->sample_range_limit
;
516 register int * Crrtab
= cconvert
->Cr_r_tab
;
517 register int * Cbbtab
= cconvert
->Cb_b_tab
;
518 register INT32
* Crgtab
= cconvert
->Cr_g_tab
;
519 register INT32
* Cbgtab
= cconvert
->Cb_g_tab
;
522 while (--num_rows
>= 0) {
523 inptr0
= input_buf
[0][input_row
];
524 inptr1
= input_buf
[1][input_row
];
525 inptr2
= input_buf
[2][input_row
];
526 inptr3
= input_buf
[3][input_row
];
528 outptr
= *output_buf
++;
529 for (col
= 0; col
< num_cols
; col
++) {
530 y
= GETJSAMPLE(inptr0
[col
]);
531 cb
= GETJSAMPLE(inptr1
[col
]);
532 cr
= GETJSAMPLE(inptr2
[col
]);
533 /* Range-limiting is essential due to noise introduced by DCT losses,
534 * and for extended gamut encodings (sYCC).
536 outptr
[0] = range_limit
[MAXJSAMPLE
- (y
+ Crrtab
[cr
])]; /* red */
537 outptr
[1] = range_limit
[MAXJSAMPLE
- (y
+ /* green */
538 ((int) RIGHT_SHIFT(Cbgtab
[cb
] + Crgtab
[cr
],
540 outptr
[2] = range_limit
[MAXJSAMPLE
- (y
+ Cbbtab
[cb
])]; /* blue */
541 /* K passes through unchanged */
542 outptr
[3] = inptr3
[col
]; /* don't need GETJSAMPLE here */
550 * Convert CMYK to YK part of YCCK for colorless output.
551 * We assume build_rgb_y_table has been called.
555 cmyk_yk_convert (j_decompress_ptr cinfo
,
556 JSAMPIMAGE input_buf
, JDIMENSION input_row
,
557 JSAMPARRAY output_buf
, int num_rows
)
559 my_cconvert_ptr cconvert
= (my_cconvert_ptr
) cinfo
->cconvert
;
561 register INT32
* Rytab
= cconvert
->R_y_tab
;
562 register INT32
* Gytab
= cconvert
->G_y_tab
;
563 register INT32
* Bytab
= cconvert
->B_y_tab
;
564 register JSAMPROW outptr
;
565 register JSAMPROW inptr0
, inptr1
, inptr2
, inptr3
;
566 register JDIMENSION col
;
567 JDIMENSION num_cols
= cinfo
->output_width
;
569 while (--num_rows
>= 0) {
570 inptr0
= input_buf
[0][input_row
];
571 inptr1
= input_buf
[1][input_row
];
572 inptr2
= input_buf
[2][input_row
];
573 inptr3
= input_buf
[3][input_row
];
575 outptr
= *output_buf
++;
576 for (col
= 0; col
< num_cols
; col
++) {
577 y
= Rytab
[MAXJSAMPLE
- GETJSAMPLE(inptr0
[col
])];
578 y
+= Gytab
[MAXJSAMPLE
- GETJSAMPLE(inptr1
[col
])];
579 y
+= Bytab
[MAXJSAMPLE
- GETJSAMPLE(inptr2
[col
])];
580 outptr
[0] = (JSAMPLE
) (y
>> SCALEBITS
);
581 /* K passes through unchanged */
582 outptr
[1] = inptr3
[col
]; /* don't need GETJSAMPLE here */
590 * Empty method for start_pass.
594 start_pass_dcolor (j_decompress_ptr cinfo
)
601 * Module initialization routine for output colorspace conversion.
605 jinit_color_deconverter (j_decompress_ptr cinfo
)
607 my_cconvert_ptr cconvert
;
610 cconvert
= (my_cconvert_ptr
) (*cinfo
->mem
->alloc_small
)
611 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, SIZEOF(my_color_deconverter
));
612 cinfo
->cconvert
= &cconvert
->pub
;
613 cconvert
->pub
.start_pass
= start_pass_dcolor
;
615 /* Make sure num_components agrees with jpeg_color_space */
616 switch (cinfo
->jpeg_color_space
) {
618 if (cinfo
->num_components
!= 1)
619 ERREXIT(cinfo
, JERR_BAD_J_COLORSPACE
);
626 if (cinfo
->num_components
!= 3)
627 ERREXIT(cinfo
, JERR_BAD_J_COLORSPACE
);
632 if (cinfo
->num_components
!= 4)
633 ERREXIT(cinfo
, JERR_BAD_J_COLORSPACE
);
636 default: /* JCS_UNKNOWN can be anything */
637 if (cinfo
->num_components
< 1)
638 ERREXIT(cinfo
, JERR_BAD_J_COLORSPACE
);
641 /* Support color transform only for RGB colorspaces */
642 if (cinfo
->color_transform
&&
643 cinfo
->jpeg_color_space
!= JCS_RGB
&&
644 cinfo
->jpeg_color_space
!= JCS_BG_RGB
)
645 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
647 /* Set out_color_components and conversion method based on requested space.
648 * Also adjust the component_needed flags for any unused components,
649 * so that earlier pipeline stages can avoid useless computation.
652 switch (cinfo
->out_color_space
) {
654 cinfo
->out_color_components
= 1;
655 switch (cinfo
->jpeg_color_space
) {
659 cconvert
->pub
.color_convert
= grayscale_convert
;
660 /* For color->grayscale conversion, only the Y (0) component is needed */
661 for (ci
= 1; ci
< cinfo
->num_components
; ci
++)
662 cinfo
->comp_info
[ci
].component_needed
= FALSE
;
665 switch (cinfo
->color_transform
) {
667 cconvert
->pub
.color_convert
= rgb_gray_convert
;
669 case JCT_SUBTRACT_GREEN
:
670 cconvert
->pub
.color_convert
= rgb1_gray_convert
;
673 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
675 build_rgb_y_table(cinfo
);
678 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
683 cinfo
->out_color_components
= RGB_PIXELSIZE
;
684 switch (cinfo
->jpeg_color_space
) {
686 cconvert
->pub
.color_convert
= gray_rgb_convert
;
689 cconvert
->pub
.color_convert
= ycc_rgb_convert
;
690 build_ycc_rgb_table(cinfo
);
693 cconvert
->pub
.color_convert
= ycc_rgb_convert
;
694 build_bg_ycc_rgb_table(cinfo
);
697 switch (cinfo
->color_transform
) {
699 cconvert
->pub
.color_convert
= rgb_convert
;
701 case JCT_SUBTRACT_GREEN
:
702 cconvert
->pub
.color_convert
= rgb1_rgb_convert
;
705 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
709 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
714 if (cinfo
->jpeg_color_space
!= JCS_BG_RGB
)
715 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
716 cinfo
->out_color_components
= RGB_PIXELSIZE
;
717 switch (cinfo
->color_transform
) {
719 cconvert
->pub
.color_convert
= rgb_convert
;
721 case JCT_SUBTRACT_GREEN
:
722 cconvert
->pub
.color_convert
= rgb1_rgb_convert
;
725 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
730 if (cinfo
->jpeg_color_space
!= JCS_YCCK
)
732 cinfo
->out_color_components
= 4;
733 cconvert
->pub
.color_convert
= ycck_cmyk_convert
;
734 build_ycc_rgb_table(cinfo
);
738 if (cinfo
->jpeg_color_space
!= JCS_CMYK
||
739 /* Support only YK part of YCCK for colorless output */
740 ! cinfo
->comp_info
[0].component_needed
||
741 cinfo
->comp_info
[1].component_needed
||
742 cinfo
->comp_info
[2].component_needed
||
743 ! cinfo
->comp_info
[3].component_needed
)
745 cinfo
->out_color_components
= 2;
746 /* Need all components on input side */
747 cinfo
->comp_info
[1].component_needed
= TRUE
;
748 cinfo
->comp_info
[2].component_needed
= TRUE
;
749 cconvert
->pub
.color_convert
= cmyk_yk_convert
;
750 build_rgb_y_table(cinfo
);
753 default: def_label
: /* permit null conversion to same output space */
754 if (cinfo
->out_color_space
!= cinfo
->jpeg_color_space
)
755 /* unsupported non-null conversion */
756 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
758 for (ci
= 0; ci
< cinfo
->num_components
; ci
++)
759 if (cinfo
->comp_info
[ci
].component_needed
)
760 i
++; /* count output color components */
761 cinfo
->out_color_components
= i
;
762 cconvert
->pub
.color_convert
= null_convert
;
765 if (cinfo
->quantize_colors
)
766 cinfo
->output_components
= 1; /* single colormapped output component */
768 cinfo
->output_components
= cinfo
->out_color_components
;