ReactOS  0.4.14-dev-342-gdc047f9
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-2017 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 *)
128  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
129  (MAXJSAMPLE+1) * SIZEOF(int));
130  cconvert->Cb_b_tab = (int *)
131  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
132  (MAXJSAMPLE+1) * SIZEOF(int));
133  cconvert->Cr_g_tab = (INT32 *)
134  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
135  (MAXJSAMPLE+1) * SIZEOF(INT32));
136  cconvert->Cb_g_tab = (INT32 *)
137  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
138  (MAXJSAMPLE+1) * SIZEOF(INT32));
139 
140  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
141  /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
142  /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
143  /* Cr=>R value is nearest int to 1.402 * x */
144  cconvert->Cr_r_tab[i] = (int)
145  RIGHT_SHIFT(FIX(1.402) * x + ONE_HALF, SCALEBITS);
146  /* Cb=>B value is nearest int to 1.772 * x */
147  cconvert->Cb_b_tab[i] = (int)
148  RIGHT_SHIFT(FIX(1.772) * x + ONE_HALF, SCALEBITS);
149  /* Cr=>G value is scaled-up -0.714136286 * x */
150  cconvert->Cr_g_tab[i] = (- FIX(0.714136286)) * x;
151  /* Cb=>G value is scaled-up -0.344136286 * x */
152  /* We also add in ONE_HALF so that need not do it in inner loop */
153  cconvert->Cb_g_tab[i] = (- FIX(0.344136286)) * x + ONE_HALF;
154  }
155 }
156 
157 
158 LOCAL(void)
160 /* Wide gamut case, bg-sYCC */
161 {
162  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
163  int i;
164  INT32 x;
166 
167  cconvert->Cr_r_tab = (int *)
168  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
169  (MAXJSAMPLE+1) * SIZEOF(int));
170  cconvert->Cb_b_tab = (int *)
171  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
172  (MAXJSAMPLE+1) * SIZEOF(int));
173  cconvert->Cr_g_tab = (INT32 *)
174  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
175  (MAXJSAMPLE+1) * SIZEOF(INT32));
176  cconvert->Cb_g_tab = (INT32 *)
177  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
178  (MAXJSAMPLE+1) * SIZEOF(INT32));
179 
180  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
181  /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
182  /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
183  /* Cr=>R value is nearest int to 2.804 * x */
184  cconvert->Cr_r_tab[i] = (int)
185  RIGHT_SHIFT(FIX(2.804) * x + ONE_HALF, SCALEBITS);
186  /* Cb=>B value is nearest int to 3.544 * x */
187  cconvert->Cb_b_tab[i] = (int)
188  RIGHT_SHIFT(FIX(3.544) * x + ONE_HALF, SCALEBITS);
189  /* Cr=>G value is scaled-up -1.428272572 * x */
190  cconvert->Cr_g_tab[i] = (- FIX(1.428272572)) * x;
191  /* Cb=>G value is scaled-up -0.688272572 * x */
192  /* We also add in ONE_HALF so that need not do it in inner loop */
193  cconvert->Cb_g_tab[i] = (- FIX(0.688272572)) * x + ONE_HALF;
194  }
195 }
196 
197 
198 /*
199  * Convert some rows of samples to the output colorspace.
200  *
201  * Note that we change from noninterleaved, one-plane-per-component format
202  * to interleaved-pixel format. The output buffer is therefore three times
203  * as wide as the input buffer.
204  * A starting row offset is provided only for the input buffer. The caller
205  * can easily adjust the passed output_buf value to accommodate any row
206  * offset required on that side.
207  */
208 
209 METHODDEF(void)
211  JSAMPIMAGE input_buf, JDIMENSION input_row,
213 {
214  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
215  register int y, cb, cr;
216  register JSAMPROW outptr;
217  register JSAMPROW inptr0, inptr1, inptr2;
218  register JDIMENSION col;
219  JDIMENSION num_cols = cinfo->output_width;
220  /* copy these pointers into registers if possible */
221  register JSAMPLE * range_limit = cinfo->sample_range_limit;
222  register int * Crrtab = cconvert->Cr_r_tab;
223  register int * Cbbtab = cconvert->Cb_b_tab;
224  register INT32 * Crgtab = cconvert->Cr_g_tab;
225  register INT32 * Cbgtab = cconvert->Cb_g_tab;
227 
228  while (--num_rows >= 0) {
229  inptr0 = input_buf[0][input_row];
230  inptr1 = input_buf[1][input_row];
231  inptr2 = input_buf[2][input_row];
232  input_row++;
233  outptr = *output_buf++;
234  for (col = 0; col < num_cols; col++) {
235  y = GETJSAMPLE(inptr0[col]);
236  cb = GETJSAMPLE(inptr1[col]);
237  cr = GETJSAMPLE(inptr2[col]);
238  /* Range-limiting is essential due to noise introduced by DCT losses,
239  * for extended gamut (sYCC) and wide gamut (bg-sYCC) encodings.
240  */
241  outptr[RGB_RED] = range_limit[y + Crrtab[cr]];
242  outptr[RGB_GREEN] = range_limit[y +
243  ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
244  SCALEBITS))];
245  outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]];
246  outptr += RGB_PIXELSIZE;
247  }
248  }
249 }
250 
251 
252 /**************** Cases other than YCC -> RGB ****************/
253 
254 
255 /*
256  * Initialize for RGB->grayscale colorspace conversion.
257  */
258 
259 LOCAL(void)
261 {
262  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
263  INT32 * rgb_y_tab;
264  INT32 i;
265 
266  /* Allocate and fill in the conversion tables. */
267  cconvert->rgb_y_tab = rgb_y_tab = (INT32 *)
268  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
269  (TABLE_SIZE * SIZEOF(INT32)));
270 
271  for (i = 0; i <= MAXJSAMPLE; i++) {
272  rgb_y_tab[i+R_Y_OFF] = FIX(0.299) * i;
273  rgb_y_tab[i+G_Y_OFF] = FIX(0.587) * i;
274  rgb_y_tab[i+B_Y_OFF] = FIX(0.114) * i + ONE_HALF;
275  }
276 }
277 
278 
279 /*
280  * Convert RGB to grayscale.
281  */
282 
283 METHODDEF(void)
285  JSAMPIMAGE input_buf, JDIMENSION input_row,
287 {
288  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
289  register INT32 * ctab = cconvert->rgb_y_tab;
290  register int r, g, b;
291  register JSAMPROW outptr;
292  register JSAMPROW inptr0, inptr1, inptr2;
293  register JDIMENSION col;
294  JDIMENSION num_cols = cinfo->output_width;
295 
296  while (--num_rows >= 0) {
297  inptr0 = input_buf[0][input_row];
298  inptr1 = input_buf[1][input_row];
299  inptr2 = input_buf[2][input_row];
300  input_row++;
301  outptr = *output_buf++;
302  for (col = 0; col < num_cols; col++) {
303  r = GETJSAMPLE(inptr0[col]);
304  g = GETJSAMPLE(inptr1[col]);
305  b = GETJSAMPLE(inptr2[col]);
306  /* Y */
307  outptr[col] = (JSAMPLE)
308  ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
309  >> SCALEBITS);
310  }
311  }
312 }
313 
314 
315 /*
316  * [R-G,G,B-G] to [R,G,B] conversion with modulo calculation
317  * (inverse color transform).
318  * This can be seen as an adaption of the general YCbCr->RGB
319  * conversion equation with Kr = Kb = 0, while replacing the
320  * normalization by modulo calculation.
321  */
322 
323 METHODDEF(void)
325  JSAMPIMAGE input_buf, JDIMENSION input_row,
327 {
328  register int r, g, b;
329  register JSAMPROW outptr;
330  register JSAMPROW inptr0, inptr1, inptr2;
331  register JDIMENSION col;
332  JDIMENSION num_cols = cinfo->output_width;
333 
334  while (--num_rows >= 0) {
335  inptr0 = input_buf[0][input_row];
336  inptr1 = input_buf[1][input_row];
337  inptr2 = input_buf[2][input_row];
338  input_row++;
339  outptr = *output_buf++;
340  for (col = 0; col < num_cols; col++) {
341  r = GETJSAMPLE(inptr0[col]);
342  g = GETJSAMPLE(inptr1[col]);
343  b = GETJSAMPLE(inptr2[col]);
344  /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
345  * (modulo) operator is equivalent to the bitmask operator AND.
346  */
347  outptr[RGB_RED] = (JSAMPLE) ((r + g - CENTERJSAMPLE) & MAXJSAMPLE);
348  outptr[RGB_GREEN] = (JSAMPLE) g;
349  outptr[RGB_BLUE] = (JSAMPLE) ((b + g - CENTERJSAMPLE) & MAXJSAMPLE);
350  outptr += RGB_PIXELSIZE;
351  }
352  }
353 }
354 
355 
356 /*
357  * [R-G,G,B-G] to grayscale conversion with modulo calculation
358  * (inverse color transform).
359  */
360 
361 METHODDEF(void)
363  JSAMPIMAGE input_buf, JDIMENSION input_row,
365 {
366  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
367  register INT32 * ctab = cconvert->rgb_y_tab;
368  register int r, g, b;
369  register JSAMPROW outptr;
370  register JSAMPROW inptr0, inptr1, inptr2;
371  register JDIMENSION col;
372  JDIMENSION num_cols = cinfo->output_width;
373 
374  while (--num_rows >= 0) {
375  inptr0 = input_buf[0][input_row];
376  inptr1 = input_buf[1][input_row];
377  inptr2 = input_buf[2][input_row];
378  input_row++;
379  outptr = *output_buf++;
380  for (col = 0; col < num_cols; col++) {
381  r = GETJSAMPLE(inptr0[col]);
382  g = GETJSAMPLE(inptr1[col]);
383  b = GETJSAMPLE(inptr2[col]);
384  /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
385  * (modulo) operator is equivalent to the bitmask operator AND.
386  */
387  r = (r + g - CENTERJSAMPLE) & MAXJSAMPLE;
388  b = (b + g - CENTERJSAMPLE) & MAXJSAMPLE;
389  /* Y */
390  outptr[col] = (JSAMPLE)
391  ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
392  >> SCALEBITS);
393  }
394  }
395 }
396 
397 
398 /*
399  * No colorspace change, but conversion from separate-planes
400  * to interleaved representation.
401  */
402 
403 METHODDEF(void)
405  JSAMPIMAGE input_buf, JDIMENSION input_row,
407 {
408  register JSAMPROW outptr;
409  register JSAMPROW inptr0, inptr1, inptr2;
410  register JDIMENSION col;
411  JDIMENSION num_cols = cinfo->output_width;
412 
413  while (--num_rows >= 0) {
414  inptr0 = input_buf[0][input_row];
415  inptr1 = input_buf[1][input_row];
416  inptr2 = input_buf[2][input_row];
417  input_row++;
418  outptr = *output_buf++;
419  for (col = 0; col < num_cols; col++) {
420  /* We can dispense with GETJSAMPLE() here */
421  outptr[RGB_RED] = inptr0[col];
422  outptr[RGB_GREEN] = inptr1[col];
423  outptr[RGB_BLUE] = inptr2[col];
424  outptr += RGB_PIXELSIZE;
425  }
426  }
427 }
428 
429 
430 /*
431  * Color conversion for no colorspace change: just copy the data,
432  * converting from separate-planes to interleaved representation.
433  */
434 
435 METHODDEF(void)
437  JSAMPIMAGE input_buf, JDIMENSION input_row,
439 {
440  int ci;
441  register int nc = cinfo->num_components;
442  register JSAMPROW outptr;
443  register JSAMPROW inptr;
444  register JDIMENSION col;
445  JDIMENSION num_cols = cinfo->output_width;
446 
447  while (--num_rows >= 0) {
448  for (ci = 0; ci < nc; ci++) {
449  inptr = input_buf[ci][input_row];
450  outptr = output_buf[0] + ci;
451  for (col = 0; col < num_cols; col++) {
452  *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */
453  outptr += nc;
454  }
455  }
456  input_row++;
457  output_buf++;
458  }
459 }
460 
461 
462 /*
463  * Color conversion for grayscale: just copy the data.
464  * This also works for YCC -> grayscale conversion, in which
465  * we just copy the Y (luminance) component and ignore chrominance.
466  */
467 
468 METHODDEF(void)
470  JSAMPIMAGE input_buf, JDIMENSION input_row,
472 {
473  jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
474  num_rows, cinfo->output_width);
475 }
476 
477 
478 /*
479  * Convert grayscale to RGB: just duplicate the graylevel three times.
480  * This is provided to support applications that don't want to cope
481  * with grayscale as a separate case.
482  */
483 
484 METHODDEF(void)
486  JSAMPIMAGE input_buf, JDIMENSION input_row,
488 {
489  register JSAMPROW outptr;
490  register JSAMPROW inptr;
491  register JDIMENSION col;
492  JDIMENSION num_cols = cinfo->output_width;
493 
494  while (--num_rows >= 0) {
495  inptr = input_buf[0][input_row++];
496  outptr = *output_buf++;
497  for (col = 0; col < num_cols; col++) {
498  /* We can dispense with GETJSAMPLE() here */
499  outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
500  outptr += RGB_PIXELSIZE;
501  }
502  }
503 }
504 
505 
506 /*
507  * Adobe-style YCCK->CMYK conversion.
508  * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
509  * conversion as above, while passing K (black) unchanged.
510  * We assume build_ycc_rgb_table has been called.
511  */
512 
513 METHODDEF(void)
515  JSAMPIMAGE input_buf, JDIMENSION input_row,
517 {
518  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
519  register int y, cb, cr;
520  register JSAMPROW outptr;
521  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
522  register JDIMENSION col;
523  JDIMENSION num_cols = cinfo->output_width;
524  /* copy these pointers into registers if possible */
525  register JSAMPLE * range_limit = cinfo->sample_range_limit;
526  register int * Crrtab = cconvert->Cr_r_tab;
527  register int * Cbbtab = cconvert->Cb_b_tab;
528  register INT32 * Crgtab = cconvert->Cr_g_tab;
529  register INT32 * Cbgtab = cconvert->Cb_g_tab;
531 
532  while (--num_rows >= 0) {
533  inptr0 = input_buf[0][input_row];
534  inptr1 = input_buf[1][input_row];
535  inptr2 = input_buf[2][input_row];
536  inptr3 = input_buf[3][input_row];
537  input_row++;
538  outptr = *output_buf++;
539  for (col = 0; col < num_cols; col++) {
540  y = GETJSAMPLE(inptr0[col]);
541  cb = GETJSAMPLE(inptr1[col]);
542  cr = GETJSAMPLE(inptr2[col]);
543  /* Range-limiting is essential due to noise introduced by DCT losses,
544  * and for extended gamut encodings (sYCC).
545  */
546  outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */
547  outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */
548  ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
549  SCALEBITS)))];
550  outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */
551  /* K passes through unchanged */
552  outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
553  outptr += 4;
554  }
555  }
556 }
557 
558 
559 /*
560  * Empty method for start_pass.
561  */
562 
563 METHODDEF(void)
565 {
566  /* no work needed */
567 }
568 
569 
570 /*
571  * Module initialization routine for output colorspace conversion.
572  */
573 
574 GLOBAL(void)
576 {
577  my_cconvert_ptr cconvert;
578  int ci;
579 
580  cconvert = (my_cconvert_ptr)
581  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
583  cinfo->cconvert = &cconvert->pub;
584  cconvert->pub.start_pass = start_pass_dcolor;
585 
586  /* Make sure num_components agrees with jpeg_color_space */
587  switch (cinfo->jpeg_color_space) {
588  case JCS_GRAYSCALE:
589  if (cinfo->num_components != 1)
590  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
591  break;
592 
593  case JCS_RGB:
594  case JCS_YCbCr:
595  case JCS_BG_RGB:
596  case JCS_BG_YCC:
597  if (cinfo->num_components != 3)
598  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
599  break;
600 
601  case JCS_CMYK:
602  case JCS_YCCK:
603  if (cinfo->num_components != 4)
604  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
605  break;
606 
607  default: /* JCS_UNKNOWN can be anything */
608  if (cinfo->num_components < 1)
609  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
610  break;
611  }
612 
613  /* Support color transform only for RGB colorspaces */
614  if (cinfo->color_transform &&
615  cinfo->jpeg_color_space != JCS_RGB &&
616  cinfo->jpeg_color_space != JCS_BG_RGB)
617  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
618 
619  /* Set out_color_components and conversion method based on requested space.
620  * Also clear the component_needed flags for any unused components,
621  * so that earlier pipeline stages can avoid useless computation.
622  */
623 
624  switch (cinfo->out_color_space) {
625  case JCS_GRAYSCALE:
626  cinfo->out_color_components = 1;
627  switch (cinfo->jpeg_color_space) {
628  case JCS_GRAYSCALE:
629  case JCS_YCbCr:
630  case JCS_BG_YCC:
631  cconvert->pub.color_convert = grayscale_convert;
632  /* For color->grayscale conversion, only the Y (0) component is needed */
633  for (ci = 1; ci < cinfo->num_components; ci++)
634  cinfo->comp_info[ci].component_needed = FALSE;
635  break;
636  case JCS_RGB:
637  switch (cinfo->color_transform) {
638  case JCT_NONE:
639  cconvert->pub.color_convert = rgb_gray_convert;
640  break;
641  case JCT_SUBTRACT_GREEN:
642  cconvert->pub.color_convert = rgb1_gray_convert;
643  break;
644  default:
645  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
646  }
647  build_rgb_y_table(cinfo);
648  break;
649  default:
650  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
651  }
652  break;
653 
654  case JCS_RGB:
655  cinfo->out_color_components = RGB_PIXELSIZE;
656  switch (cinfo->jpeg_color_space) {
657  case JCS_GRAYSCALE:
658  cconvert->pub.color_convert = gray_rgb_convert;
659  break;
660  case JCS_YCbCr:
661  cconvert->pub.color_convert = ycc_rgb_convert;
662  build_ycc_rgb_table(cinfo);
663  break;
664  case JCS_BG_YCC:
665  cconvert->pub.color_convert = ycc_rgb_convert;
666  build_bg_ycc_rgb_table(cinfo);
667  break;
668  case JCS_RGB:
669  switch (cinfo->color_transform) {
670  case JCT_NONE:
671  cconvert->pub.color_convert = rgb_convert;
672  break;
673  case JCT_SUBTRACT_GREEN:
674  cconvert->pub.color_convert = rgb1_rgb_convert;
675  break;
676  default:
677  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
678  }
679  break;
680  default:
681  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
682  }
683  break;
684 
685  case JCS_BG_RGB:
686  cinfo->out_color_components = RGB_PIXELSIZE;
687  if (cinfo->jpeg_color_space == JCS_BG_RGB) {
688  switch (cinfo->color_transform) {
689  case JCT_NONE:
690  cconvert->pub.color_convert = rgb_convert;
691  break;
692  case JCT_SUBTRACT_GREEN:
693  cconvert->pub.color_convert = rgb1_rgb_convert;
694  break;
695  default:
696  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
697  }
698  } else
699  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
700  break;
701 
702  case JCS_CMYK:
703  cinfo->out_color_components = 4;
704  switch (cinfo->jpeg_color_space) {
705  case JCS_YCCK:
706  cconvert->pub.color_convert = ycck_cmyk_convert;
707  build_ycc_rgb_table(cinfo);
708  break;
709  case JCS_CMYK:
710  cconvert->pub.color_convert = null_convert;
711  break;
712  default:
713  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
714  }
715  break;
716 
717  default:
718  /* Permit null conversion to same output space */
719  if (cinfo->out_color_space == cinfo->jpeg_color_space) {
720  cinfo->out_color_components = cinfo->num_components;
721  cconvert->pub.color_convert = null_convert;
722  } else /* unsupported non-null conversion */
723  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
724  break;
725  }
726 
727  if (cinfo->quantize_colors)
728  cinfo->output_components = 1; /* single colormapped output component */
729  else
730  cinfo->output_components = cinfo->out_color_components;
731 }
#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:324
#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:284
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
rgb1_gray_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
Definition: jdcolor.c:362
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
build_rgb_y_table(j_decompress_ptr cinfo)
Definition: jdcolor.c:260
#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:575
rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
Definition: jdcolor.c:404
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:514
#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:436
struct jpeg_color_converter pub
Definition: jccolor.c:20
int JSAMPARRAY int int num_rows
Definition: jpegint.h:412
int JSAMPARRAY int int JDIMENSION num_cols
Definition: jpegint.h:412
INT32 * Cb_g_tab
Definition: jdcolor.c:32
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
start_pass_dcolor(j_decompress_ptr cinfo)
Definition: jdcolor.c:564
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:159
#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:210
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
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:485
grayscale_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION input_row, JSAMPARRAY output_buf, int num_rows)
Definition: jdcolor.c:469
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31