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