1 /*
2 * jdcolor.c
3 *
4 * Copyright (C) 1991-1994, Thomas G. Lane.
5 * This file is part of the Independent JPEG Group's software.
6 * For conditions of distribution and use, see the accompanying README file.
7 *
8 * This file contains output colorspace conversion routines.
9 */
10
11 #define JPEG_INTERNALS
12 #include "jinclude.h"
13 #include "jpeglib.h"
14
15
16 /* Private subobject */
17
18 typedef struct {
19 struct jpeg_color_deconverter pub; /* public fields */
20
21 /* Private state for YCC->RGB conversion */
22 int * Cr_r_tab; /* => table for Cr to R conversion */
23 int * Cb_b_tab; /* => table for Cb to B conversion */
24 INT32 * Cr_g_tab; /* => table for Cr to G conversion */
25 INT32 * Cb_g_tab; /* => table for Cb to G conversion */
26 } my_color_deconverter;
27
28 typedef my_color_deconverter * my_cconvert_ptr;
29
30
31 /**************** YCbCr -> RGB conversion: most common case **************/
32
33 /*
34 * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
35 * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
36 * The conversion equations to be implemented are therefore
37 * R = Y + 1.40200 * Cr
38 * G = Y - 0.34414 * Cb - 0.71414 * Cr
39 * B = Y + 1.77200 * Cb
40 * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
41 * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
42 *
43 * To avoid floating-point arithmetic, we represent the fractional constants
44 * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
45 * the products by 2^16, with appropriate rounding, to get the correct answer.
46 * Notice that Y, being an integral input, does not contribute any fraction
47 * so it need not participate in the rounding.
48 *
49 * For even more speed, we avoid doing any multiplications in the inner loop
50 * by precalculating the constants times Cb and Cr for all possible values.
51 * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
52 * for 12-bit samples it is still acceptable. It's not very reasonable for
53 * 16-bit samples, but if you want lossless storage you shouldn't be changing
54 * colorspace anyway.
55 * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
56 * values for the G calculation are left scaled up, since we must add them
57 * together before rounding.
58 */
59
60 #define SCALEBITS 16 /* speediest right-shift on some machines */
61 #define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
62 #define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
63
64
65 /*
66 * Initialize for YCC->RGB colorspace conversion.
67 */
68
69 METHODDEF void
ycc_rgb_start(j_decompress_ptr cinfo)70 ycc_rgb_start (j_decompress_ptr cinfo)
71 {
72 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
73 INT32 i, x;
74 SHIFT_TEMPS
75
76 cconvert->Cr_r_tab = (int *)
77 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
78 (MAXJSAMPLE+1) * SIZEOF(int));
79 cconvert->Cb_b_tab = (int *)
80 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
81 (MAXJSAMPLE+1) * SIZEOF(int));
82 cconvert->Cr_g_tab = (INT32 *)
83 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
84 (MAXJSAMPLE+1) * SIZEOF(INT32));
85 cconvert->Cb_g_tab = (INT32 *)
86 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
87 (MAXJSAMPLE+1) * SIZEOF(INT32));
88
89 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
90 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
91 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
92 /* Cr=>R value is nearest int to 1.40200 * x */
93 cconvert->Cr_r_tab[i] = (int)
94 RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
95 /* Cb=>B value is nearest int to 1.77200 * x */
96 cconvert->Cb_b_tab[i] = (int)
97 RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
98 /* Cr=>G value is scaled-up -0.71414 * x */
99 cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
100 /* Cb=>G value is scaled-up -0.34414 * x */
101 /* We also add in ONE_HALF so that need not do it in inner loop */
102 cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
103 }
104 }
105
106
107 /*
108 * Convert some rows of samples to the output colorspace.
109 *
110 * Note that we change from noninterleaved, one-plane-per-component format
111 * to interleaved-pixel format. The output buffer is therefore three times
112 * as wide as the input buffer.
113 * A starting row offset is provided only for the input buffer. The caller
114 * can easily adjust the passed output_buf value to accommodate any row
115 * offset required on that side.
116 */
117
118 METHODDEF void
ycc_rgb_convert(j_decompress_ptr cinfo,JSAMPIMAGE input_buf,JDIMENSION input_row,JSAMPARRAY output_buf,int num_rows)119 ycc_rgb_convert (j_decompress_ptr cinfo,
120 JSAMPIMAGE input_buf, JDIMENSION input_row,
121 JSAMPARRAY output_buf, int num_rows)
122 {
123 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
124 register int y, cb, cr;
125 register JSAMPROW outptr;
126 register JSAMPROW inptr0, inptr1, inptr2;
127 register JDIMENSION col;
128 JDIMENSION num_cols = cinfo->output_width;
129 /* copy these pointers into registers if possible */
130 register JSAMPLE * range_limit = cinfo->sample_range_limit;
131 register int * Crrtab = cconvert->Cr_r_tab;
132 register int * Cbbtab = cconvert->Cb_b_tab;
133 register INT32 * Crgtab = cconvert->Cr_g_tab;
134 register INT32 * Cbgtab = cconvert->Cb_g_tab;
135 SHIFT_TEMPS
136
137 while (--num_rows >= 0) {
138 inptr0 = input_buf[0][input_row];
139 inptr1 = input_buf[1][input_row];
140 inptr2 = input_buf[2][input_row];
141 input_row++;
142 outptr = *output_buf++;
143 for (col = 0; col < num_cols; col++) {
144 y = GETJSAMPLE(inptr0[col]);
145 cb = GETJSAMPLE(inptr1[col]);
146 cr = GETJSAMPLE(inptr2[col]);
147 /* Range-limiting is essential due to noise introduced by DCT losses. */
148 outptr[RGB_RED] = range_limit[y + Crrtab[cr]];
149 outptr[RGB_GREEN] = range_limit[y +
150 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
151 SCALEBITS))];
152 outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]];
153 outptr += RGB_PIXELSIZE;
154 }
155 }
156 }
157
158
159 /**************** Cases other than YCbCr -> RGB **************/
160
161
162 /*
163 * Color conversion for no colorspace change: just copy the data,
164 * converting from separate-planes to interleaved representation.
165 */
166
167 METHODDEF void
null_convert(j_decompress_ptr cinfo,JSAMPIMAGE input_buf,JDIMENSION input_row,JSAMPARRAY output_buf,int num_rows)168 null_convert (j_decompress_ptr cinfo,
169 JSAMPIMAGE input_buf, JDIMENSION input_row,
170 JSAMPARRAY output_buf, int num_rows)
171 {
172 register JSAMPROW inptr, outptr;
173 register JDIMENSION count;
174 register int num_components = cinfo->output_components;
175 JDIMENSION num_cols = cinfo->output_width;
176 int ci;
177
178 while (--num_rows >= 0) {
179 for (ci = 0; ci < num_components; ci++) {
180 inptr = input_buf[ci][input_row];
181 outptr = output_buf[0] + ci;
182 for (count = num_cols; count > 0; count--) {
183 *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */
184 outptr += num_components;
185 }
186 }
187 input_row++;
188 output_buf++;
189 }
190 }
191
192
193 /*
194 * Color conversion for grayscale: just copy the data.
195 * This also works for YCbCr -> grayscale conversion, in which
196 * we just copy the Y (luminance) component and ignore chrominance.
197 */
198
199 METHODDEF void
grayscale_convert(j_decompress_ptr cinfo,JSAMPIMAGE input_buf,JDIMENSION input_row,JSAMPARRAY output_buf,int num_rows)200 grayscale_convert (j_decompress_ptr cinfo,
201 JSAMPIMAGE input_buf, JDIMENSION input_row,
202 JSAMPARRAY output_buf, int num_rows)
203 {
204 jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
205 num_rows, cinfo->output_width);
206 }
207
208
209 /*
210 * Adobe-style YCCK->CMYK conversion.
211 * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
212 * conversion as above, while passing K (black) unchanged.
213 * We assume ycc_rgb_start has been called.
214 */
215
216 METHODDEF void
ycck_cmyk_convert(j_decompress_ptr cinfo,JSAMPIMAGE input_buf,JDIMENSION input_row,JSAMPARRAY output_buf,int num_rows)217 ycck_cmyk_convert (j_decompress_ptr cinfo,
218 JSAMPIMAGE input_buf, JDIMENSION input_row,
219 JSAMPARRAY output_buf, int num_rows)
220 {
221 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
222 register int y, cb, cr;
223 register JSAMPROW outptr;
224 register JSAMPROW inptr0, inptr1, inptr2, inptr3;
225 register JDIMENSION col;
226 JDIMENSION num_cols = cinfo->output_width;
227 /* copy these pointers into registers if possible */
228 register JSAMPLE * range_limit = cinfo->sample_range_limit;
229 register int * Crrtab = cconvert->Cr_r_tab;
230 register int * Cbbtab = cconvert->Cb_b_tab;
231 register INT32 * Crgtab = cconvert->Cr_g_tab;
232 register INT32 * Cbgtab = cconvert->Cb_g_tab;
233 SHIFT_TEMPS
234
235 while (--num_rows >= 0) {
236 inptr0 = input_buf[0][input_row];
237 inptr1 = input_buf[1][input_row];
238 inptr2 = input_buf[2][input_row];
239 inptr3 = input_buf[3][input_row];
240 input_row++;
241 outptr = *output_buf++;
242 for (col = 0; col < num_cols; col++) {
243 y = GETJSAMPLE(inptr0[col]);
244 cb = GETJSAMPLE(inptr1[col]);
245 cr = GETJSAMPLE(inptr2[col]);
246 /* Range-limiting is essential due to noise introduced by DCT losses. */
247 outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */
248 outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */
249 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
250 SCALEBITS)))];
251 outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */
252 /* K passes through unchanged */
253 outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
254 outptr += 4;
255 }
256 }
257 }
258
259
260 /*
261 * Empty method for start_pass.
262 */
263
264 METHODDEF void
null_method(j_decompress_ptr cinfo)265 null_method (j_decompress_ptr cinfo)
266 {
267 /* no work needed */
268 }
269
270
271 /*
272 * Module initialization routine for output colorspace conversion.
273 */
274
275 GLOBAL void
jinit_color_deconverter(j_decompress_ptr cinfo)276 jinit_color_deconverter (j_decompress_ptr cinfo)
277 {
278 my_cconvert_ptr cconvert;
279 int ci;
280
281 cconvert = (my_cconvert_ptr)
282 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
283 SIZEOF(my_color_deconverter));
284 cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
285 /* set start_pass to null method until we find out differently */
286 cconvert->pub.start_pass = null_method;
287
288 /* Make sure num_components agrees with jpeg_color_space */
289 switch (cinfo->jpeg_color_space) {
290 case JCS_GRAYSCALE:
291 if (cinfo->num_components != 1)
292 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
293 break;
294
295 case JCS_RGB:
296 case JCS_YCbCr:
297 if (cinfo->num_components != 3)
298 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
299 break;
300
301 case JCS_CMYK:
302 case JCS_YCCK:
303 if (cinfo->num_components != 4)
304 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
305 break;
306
307 default: /* JCS_UNKNOWN can be anything */
308 if (cinfo->num_components < 1)
309 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
310 break;
311 }
312
313 /* Set out_color_components and conversion method based on requested space.
314 * Also clear the component_needed flags for any unused components,
315 * so that earlier pipeline stages can avoid useless computation.
316 */
317
318 switch (cinfo->out_color_space) {
319 case JCS_GRAYSCALE:
320 cinfo->out_color_components = 1;
321 if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
322 cinfo->jpeg_color_space == JCS_YCbCr) {
323 cconvert->pub.color_convert = grayscale_convert;
324 /* For color->grayscale conversion, only the Y (0) component is needed */
325 for (ci = 1; ci < cinfo->num_components; ci++)
326 cinfo->comp_info[ci].component_needed = FALSE;
327 } else
328 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
329 break;
330
331 case JCS_RGB:
332 cinfo->out_color_components = RGB_PIXELSIZE;
333 if (cinfo->jpeg_color_space == JCS_YCbCr) {
334 cconvert->pub.start_pass = ycc_rgb_start;
335 cconvert->pub.color_convert = ycc_rgb_convert;
336 } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) {
337 cconvert->pub.color_convert = null_convert;
338 } else
339 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
340 break;
341
342 case JCS_CMYK:
343 cinfo->out_color_components = 4;
344 if (cinfo->jpeg_color_space == JCS_YCCK) {
345 cconvert->pub.start_pass = ycc_rgb_start;
346 cconvert->pub.color_convert = ycck_cmyk_convert;
347 } else if (cinfo->jpeg_color_space == JCS_CMYK) {
348 cconvert->pub.color_convert = null_convert;
349 } else
350 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
351 break;
352
353 default:
354 /* Permit null conversion to same output space */
355 if (cinfo->out_color_space == cinfo->jpeg_color_space) {
356 cinfo->out_color_components = cinfo->num_components;
357 cconvert->pub.color_convert = null_convert;
358 } else /* unsupported non-null conversion */
359 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
360 break;
361 }
362
363 if (cinfo->quantize_colors)
364 cinfo->output_components = 1; /* single colormapped output component */
365 else
366 cinfo->output_components = cinfo->out_color_components;
367 }
368