ReactOS  0.4.14-dev-342-gdc047f9
jccolor.c
Go to the documentation of this file.
1 /*
2  * jccolor.c
3  *
4  * Copyright (C) 1991-1996, Thomas G. Lane.
5  * Modified 2011-2013 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 input colorspace conversion routines.
10  */
11 
12 #define JPEG_INTERNALS
13 #include "jinclude.h"
14 #include "jpeglib.h"
15 
16 
17 /* Private subobject */
18 
19 typedef struct {
20  struct jpeg_color_converter pub; /* public fields */
21 
22  /* Private state for RGB->YCC conversion */
23  INT32 * rgb_ycc_tab; /* => table for RGB to YCbCr conversion */
25 
27 
28 
29 /**************** RGB -> YCbCr conversion: most common case **************/
30 
31 /*
32  * YCbCr is defined per Recommendation ITU-R BT.601-7 (03/2011),
33  * previously known as Recommendation CCIR 601-1, except that Cb and Cr
34  * are normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
35  * sRGB (standard RGB color space) is defined per IEC 61966-2-1:1999.
36  * sYCC (standard luma-chroma-chroma color space with extended gamut)
37  * is defined per IEC 61966-2-1:1999 Amendment A1:2003 Annex F.
38  * bg-sRGB and bg-sYCC (big gamut standard color spaces)
39  * are defined per IEC 61966-2-1:1999 Amendment A1:2003 Annex G.
40  * Note that the derived conversion coefficients given in some of these
41  * documents are imprecise. The general conversion equations are
42  * Y = Kr * R + (1 - Kr - Kb) * G + Kb * B
43  * Cb = 0.5 * (B - Y) / (1 - Kb)
44  * Cr = 0.5 * (R - Y) / (1 - Kr)
45  * With Kr = 0.299 and Kb = 0.114 (derived according to SMPTE RP 177-1993
46  * from the 1953 FCC NTSC primaries and CIE Illuminant C),
47  * the conversion equations to be implemented are therefore
48  * Y = 0.299 * R + 0.587 * G + 0.114 * B
49  * Cb = -0.168735892 * R - 0.331264108 * G + 0.5 * B + CENTERJSAMPLE
50  * Cr = 0.5 * R - 0.418687589 * G - 0.081312411 * B + CENTERJSAMPLE
51  * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
52  * rather than CENTERJSAMPLE, for Cb and Cr. This gave equal positive and
53  * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
54  * were not represented exactly. Now we sacrifice exact representation of
55  * maximum red and maximum blue in order to get exact grayscales.
56  *
57  * To avoid floating-point arithmetic, we represent the fractional constants
58  * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
59  * the products by 2^16, with appropriate rounding, to get the correct answer.
60  *
61  * For even more speed, we avoid doing any multiplications in the inner loop
62  * by precalculating the constants times R,G,B for all possible values.
63  * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
64  * for 9-bit to 12-bit samples it is still acceptable. It's not very
65  * reasonable for 16-bit samples, but if you want lossless storage you
66  * shouldn't be changing colorspace anyway.
67  * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
68  * in the tables to save adding them separately in the inner loop.
69  */
70 
71 #define SCALEBITS 16 /* speediest right-shift on some machines */
72 #define CBCR_OFFSET ((INT32) CENTERJSAMPLE << SCALEBITS)
73 #define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
74 #define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
75 
76 /* We allocate one big table and divide it up into eight parts, instead of
77  * doing eight alloc_small requests. This lets us use a single table base
78  * address, which can be held in a register in the inner loops on many
79  * machines (more than can hold all eight addresses, anyway).
80  */
81 
82 #define R_Y_OFF 0 /* offset to R => Y section */
83 #define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */
84 #define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */
85 #define R_CB_OFF (3*(MAXJSAMPLE+1))
86 #define G_CB_OFF (4*(MAXJSAMPLE+1))
87 #define B_CB_OFF (5*(MAXJSAMPLE+1))
88 #define R_CR_OFF B_CB_OFF /* B=>Cb, R=>Cr are the same */
89 #define G_CR_OFF (6*(MAXJSAMPLE+1))
90 #define B_CR_OFF (7*(MAXJSAMPLE+1))
91 #define TABLE_SIZE (8*(MAXJSAMPLE+1))
92 
93 
94 /*
95  * Initialize for RGB->YCC colorspace conversion.
96  */
97 
98 METHODDEF(void)
100 {
101  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
102  INT32 * rgb_ycc_tab;
103  INT32 i;
104 
105  /* Allocate and fill in the conversion tables. */
106  cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
107  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
108  (TABLE_SIZE * SIZEOF(INT32)));
109 
110  for (i = 0; i <= MAXJSAMPLE; i++) {
111  rgb_ycc_tab[i+R_Y_OFF] = FIX(0.299) * i;
112  rgb_ycc_tab[i+G_Y_OFF] = FIX(0.587) * i;
113  rgb_ycc_tab[i+B_Y_OFF] = FIX(0.114) * i + ONE_HALF;
114  rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.168735892)) * i;
115  rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.331264108)) * i;
116  /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
117  * This ensures that the maximum output will round to MAXJSAMPLE
118  * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
119  */
120  rgb_ycc_tab[i+B_CB_OFF] = FIX(0.5) * i + CBCR_OFFSET + ONE_HALF-1;
121 /* B=>Cb and R=>Cr tables are the same
122  rgb_ycc_tab[i+R_CR_OFF] = FIX(0.5) * i + CBCR_OFFSET + ONE_HALF-1;
123 */
124  rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.418687589)) * i;
125  rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.081312411)) * i;
126  }
127 }
128 
129 
130 /*
131  * Convert some rows of samples to the JPEG colorspace.
132  *
133  * Note that we change from the application's interleaved-pixel format
134  * to our internal noninterleaved, one-plane-per-component format.
135  * The input buffer is therefore three times as wide as the output buffer.
136  *
137  * A starting row offset is provided only for the output buffer. The caller
138  * can easily adjust the passed input_buf value to accommodate any row
139  * offset required on that side.
140  */
141 
142 METHODDEF(void)
144  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
146 {
147  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
148  register INT32 * ctab = cconvert->rgb_ycc_tab;
149  register int r, g, b;
150  register JSAMPROW inptr;
151  register JSAMPROW outptr0, outptr1, outptr2;
152  register JDIMENSION col;
153  JDIMENSION num_cols = cinfo->image_width;
154 
155  while (--num_rows >= 0) {
156  inptr = *input_buf++;
157  outptr0 = output_buf[0][output_row];
158  outptr1 = output_buf[1][output_row];
159  outptr2 = output_buf[2][output_row];
160  output_row++;
161  for (col = 0; col < num_cols; col++) {
162  r = GETJSAMPLE(inptr[RGB_RED]);
163  g = GETJSAMPLE(inptr[RGB_GREEN]);
164  b = GETJSAMPLE(inptr[RGB_BLUE]);
165  /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
166  * must be too; we do not need an explicit range-limiting operation.
167  * Hence the value being shifted is never negative, and we don't
168  * need the general RIGHT_SHIFT macro.
169  */
170  /* Y */
171  outptr0[col] = (JSAMPLE)
172  ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
173  >> SCALEBITS);
174  /* Cb */
175  outptr1[col] = (JSAMPLE)
176  ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
177  >> SCALEBITS);
178  /* Cr */
179  outptr2[col] = (JSAMPLE)
180  ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
181  >> SCALEBITS);
182  inptr += RGB_PIXELSIZE;
183  }
184  }
185 }
186 
187 
188 /**************** Cases other than RGB -> YCbCr **************/
189 
190 
191 /*
192  * Convert some rows of samples to the JPEG colorspace.
193  * This version handles RGB->grayscale conversion, which is the same
194  * as the RGB->Y portion of RGB->YCbCr.
195  * We assume rgb_ycc_start has been called (we only use the Y tables).
196  */
197 
198 METHODDEF(void)
200  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
202 {
203  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
204  register INT32 * ctab = cconvert->rgb_ycc_tab;
205  register int r, g, b;
206  register JSAMPROW inptr;
207  register JSAMPROW outptr;
208  register JDIMENSION col;
209  JDIMENSION num_cols = cinfo->image_width;
210 
211  while (--num_rows >= 0) {
212  inptr = *input_buf++;
213  outptr = output_buf[0][output_row++];
214  for (col = 0; col < num_cols; col++) {
215  r = GETJSAMPLE(inptr[RGB_RED]);
216  g = GETJSAMPLE(inptr[RGB_GREEN]);
217  b = GETJSAMPLE(inptr[RGB_BLUE]);
218  /* Y */
219  outptr[col] = (JSAMPLE)
220  ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
221  >> SCALEBITS);
222  inptr += RGB_PIXELSIZE;
223  }
224  }
225 }
226 
227 
228 /*
229  * Convert some rows of samples to the JPEG colorspace.
230  * This version handles Adobe-style CMYK->YCCK conversion,
231  * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
232  * conversion as above, while passing K (black) unchanged.
233  * We assume rgb_ycc_start has been called.
234  */
235 
236 METHODDEF(void)
238  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
240 {
241  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
242  register INT32 * ctab = cconvert->rgb_ycc_tab;
243  register int r, g, b;
244  register JSAMPROW inptr;
245  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
246  register JDIMENSION col;
247  JDIMENSION num_cols = cinfo->image_width;
248 
249  while (--num_rows >= 0) {
250  inptr = *input_buf++;
251  outptr0 = output_buf[0][output_row];
252  outptr1 = output_buf[1][output_row];
253  outptr2 = output_buf[2][output_row];
254  outptr3 = output_buf[3][output_row];
255  output_row++;
256  for (col = 0; col < num_cols; col++) {
257  r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
258  g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
259  b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
260  /* K passes through as-is */
261  outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */
262  /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
263  * must be too; we do not need an explicit range-limiting operation.
264  * Hence the value being shifted is never negative, and we don't
265  * need the general RIGHT_SHIFT macro.
266  */
267  /* Y */
268  outptr0[col] = (JSAMPLE)
269  ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
270  >> SCALEBITS);
271  /* Cb */
272  outptr1[col] = (JSAMPLE)
273  ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
274  >> SCALEBITS);
275  /* Cr */
276  outptr2[col] = (JSAMPLE)
277  ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
278  >> SCALEBITS);
279  inptr += 4;
280  }
281  }
282 }
283 
284 
285 /*
286  * Convert some rows of samples to the JPEG colorspace.
287  * [R,G,B] to [R-G,G,B-G] conversion with modulo calculation
288  * (forward reversible color transform).
289  * This can be seen as an adaption of the general RGB->YCbCr
290  * conversion equation with Kr = Kb = 0, while replacing the
291  * normalization by modulo calculation.
292  */
293 
294 METHODDEF(void)
296  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
298 {
299  register int r, g, b;
300  register JSAMPROW inptr;
301  register JSAMPROW outptr0, outptr1, outptr2;
302  register JDIMENSION col;
303  JDIMENSION num_cols = cinfo->image_width;
304 
305  while (--num_rows >= 0) {
306  inptr = *input_buf++;
307  outptr0 = output_buf[0][output_row];
308  outptr1 = output_buf[1][output_row];
309  outptr2 = output_buf[2][output_row];
310  output_row++;
311  for (col = 0; col < num_cols; col++) {
312  r = GETJSAMPLE(inptr[RGB_RED]);
313  g = GETJSAMPLE(inptr[RGB_GREEN]);
314  b = GETJSAMPLE(inptr[RGB_BLUE]);
315  /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
316  * (modulo) operator is equivalent to the bitmask operator AND.
317  */
318  outptr0[col] = (JSAMPLE) ((r - g + CENTERJSAMPLE) & MAXJSAMPLE);
319  outptr1[col] = (JSAMPLE) g;
320  outptr2[col] = (JSAMPLE) ((b - g + CENTERJSAMPLE) & MAXJSAMPLE);
321  inptr += RGB_PIXELSIZE;
322  }
323  }
324 }
325 
326 
327 /*
328  * Convert some rows of samples to the JPEG colorspace.
329  * This version handles grayscale output with no conversion.
330  * The source can be either plain grayscale or YCC (since Y == gray).
331  */
332 
333 METHODDEF(void)
335  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
337 {
338  int instride = cinfo->input_components;
339  register JSAMPROW inptr;
340  register JSAMPROW outptr;
341  register JDIMENSION col;
342  JDIMENSION num_cols = cinfo->image_width;
343 
344  while (--num_rows >= 0) {
345  inptr = *input_buf++;
346  outptr = output_buf[0][output_row++];
347  for (col = 0; col < num_cols; col++) {
348  outptr[col] = inptr[0]; /* don't need GETJSAMPLE() here */
349  inptr += instride;
350  }
351  }
352 }
353 
354 
355 /*
356  * Convert some rows of samples to the JPEG colorspace.
357  * No colorspace conversion, but change from interleaved
358  * to separate-planes representation.
359  */
360 
361 METHODDEF(void)
363  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
365 {
366  register JSAMPROW inptr;
367  register JSAMPROW outptr0, outptr1, outptr2;
368  register JDIMENSION col;
369  JDIMENSION num_cols = cinfo->image_width;
370 
371  while (--num_rows >= 0) {
372  inptr = *input_buf++;
373  outptr0 = output_buf[0][output_row];
374  outptr1 = output_buf[1][output_row];
375  outptr2 = output_buf[2][output_row];
376  output_row++;
377  for (col = 0; col < num_cols; col++) {
378  /* We can dispense with GETJSAMPLE() here */
379  outptr0[col] = inptr[RGB_RED];
380  outptr1[col] = inptr[RGB_GREEN];
381  outptr2[col] = inptr[RGB_BLUE];
382  inptr += RGB_PIXELSIZE;
383  }
384  }
385 }
386 
387 
388 /*
389  * Convert some rows of samples to the JPEG colorspace.
390  * This version handles multi-component colorspaces without conversion.
391  * We assume input_components == num_components.
392  */
393 
394 METHODDEF(void)
396  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
398 {
399  int ci;
400  register int nc = cinfo->num_components;
401  register JSAMPROW inptr;
402  register JSAMPROW outptr;
403  register JDIMENSION col;
404  JDIMENSION num_cols = cinfo->image_width;
405 
406  while (--num_rows >= 0) {
407  /* It seems fastest to make a separate pass for each component. */
408  for (ci = 0; ci < nc; ci++) {
409  inptr = input_buf[0] + ci;
410  outptr = output_buf[ci][output_row];
411  for (col = 0; col < num_cols; col++) {
412  *outptr++ = *inptr; /* don't need GETJSAMPLE() here */
413  inptr += nc;
414  }
415  }
416  input_buf++;
417  output_row++;
418  }
419 }
420 
421 
422 /*
423  * Empty method for start_pass.
424  */
425 
426 METHODDEF(void)
428 {
429  /* no work needed */
430 }
431 
432 
433 /*
434  * Module initialization routine for input colorspace conversion.
435  */
436 
437 GLOBAL(void)
439 {
440  my_cconvert_ptr cconvert;
441 
442  cconvert = (my_cconvert_ptr)
443  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
445  cinfo->cconvert = &cconvert->pub;
446  /* set start_pass to null method until we find out differently */
447  cconvert->pub.start_pass = null_method;
448 
449  /* Make sure input_components agrees with in_color_space */
450  switch (cinfo->in_color_space) {
451  case JCS_GRAYSCALE:
452  if (cinfo->input_components != 1)
453  ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
454  break;
455 
456  case JCS_RGB:
457  case JCS_BG_RGB:
458  if (cinfo->input_components != RGB_PIXELSIZE)
459  ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
460  break;
461 
462  case JCS_YCbCr:
463  case JCS_BG_YCC:
464  if (cinfo->input_components != 3)
465  ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
466  break;
467 
468  case JCS_CMYK:
469  case JCS_YCCK:
470  if (cinfo->input_components != 4)
471  ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
472  break;
473 
474  default: /* JCS_UNKNOWN can be anything */
475  if (cinfo->input_components < 1)
476  ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
477  break;
478  }
479 
480  /* Support color transform only for RGB colorspaces */
481  if (cinfo->color_transform &&
482  cinfo->jpeg_color_space != JCS_RGB &&
483  cinfo->jpeg_color_space != JCS_BG_RGB)
484  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
485 
486  /* Check num_components, set conversion method based on requested space */
487  switch (cinfo->jpeg_color_space) {
488  case JCS_GRAYSCALE:
489  if (cinfo->num_components != 1)
490  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
491  switch (cinfo->in_color_space) {
492  case JCS_GRAYSCALE:
493  case JCS_YCbCr:
494  case JCS_BG_YCC:
495  cconvert->pub.color_convert = grayscale_convert;
496  break;
497  case JCS_RGB:
498  cconvert->pub.start_pass = rgb_ycc_start;
499  cconvert->pub.color_convert = rgb_gray_convert;
500  break;
501  default:
502  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
503  }
504  break;
505 
506  case JCS_RGB:
507  case JCS_BG_RGB:
508  if (cinfo->num_components != 3)
509  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
510  if (cinfo->in_color_space == cinfo->jpeg_color_space) {
511  switch (cinfo->color_transform) {
512  case JCT_NONE:
513  cconvert->pub.color_convert = rgb_convert;
514  break;
515  case JCT_SUBTRACT_GREEN:
516  cconvert->pub.color_convert = rgb_rgb1_convert;
517  break;
518  default:
519  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
520  }
521  } else
522  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
523  break;
524 
525  case JCS_YCbCr:
526  if (cinfo->num_components != 3)
527  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
528  switch (cinfo->in_color_space) {
529  case JCS_RGB:
530  cconvert->pub.start_pass = rgb_ycc_start;
531  cconvert->pub.color_convert = rgb_ycc_convert;
532  break;
533  case JCS_YCbCr:
534  cconvert->pub.color_convert = null_convert;
535  break;
536  default:
537  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
538  }
539  break;
540 
541  case JCS_BG_YCC:
542  if (cinfo->num_components != 3)
543  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
544  switch (cinfo->in_color_space) {
545  case JCS_RGB:
546  /* For conversion from normal RGB input to BG_YCC representation,
547  * the Cb/Cr values are first computed as usual, and then
548  * quantized further after DCT processing by a factor of
549  * 2 in reference to the nominal quantization factor.
550  */
551  /* need quantization scale by factor of 2 after DCT */
552  cinfo->comp_info[1].component_needed = TRUE;
553  cinfo->comp_info[2].component_needed = TRUE;
554  /* compute normal YCC first */
555  cconvert->pub.start_pass = rgb_ycc_start;
556  cconvert->pub.color_convert = rgb_ycc_convert;
557  break;
558  case JCS_YCbCr:
559  /* need quantization scale by factor of 2 after DCT */
560  cinfo->comp_info[1].component_needed = TRUE;
561  cinfo->comp_info[2].component_needed = TRUE;
562  /*FALLTHROUGH*/
563  case JCS_BG_YCC:
564  /* Pass through for BG_YCC input */
565  cconvert->pub.color_convert = null_convert;
566  break;
567  default:
568  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
569  }
570  break;
571 
572  case JCS_CMYK:
573  if (cinfo->num_components != 4)
574  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
575  if (cinfo->in_color_space == JCS_CMYK)
576  cconvert->pub.color_convert = null_convert;
577  else
578  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
579  break;
580 
581  case JCS_YCCK:
582  if (cinfo->num_components != 4)
583  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
584  switch (cinfo->in_color_space) {
585  case JCS_CMYK:
586  cconvert->pub.start_pass = rgb_ycc_start;
587  cconvert->pub.color_convert = cmyk_ycck_convert;
588  break;
589  case JCS_YCCK:
590  cconvert->pub.color_convert = null_convert;
591  break;
592  default:
593  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
594  }
595  break;
596 
597  default: /* allow null conversion of JCS_UNKNOWN */
598  if (cinfo->jpeg_color_space != cinfo->in_color_space ||
599  cinfo->num_components != cinfo->input_components)
600  ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
601  cconvert->pub.color_convert = null_convert;
602  break;
603  }
604 }
#define CENTERJSAMPLE
Definition: jmorecfg.h:84
cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:237
#define R_Y_OFF
Definition: jccolor.c:82
#define TRUE
Definition: types.h:120
char JSAMPLE
Definition: jmorecfg.h:74
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:75
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define SCALEBITS
Definition: jccolor.c:71
null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:395
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
INT32 * rgb_ycc_tab
Definition: jccolor.c:23
my_color_converter * my_cconvert_ptr
Definition: jccolor.c:26
#define GETJSAMPLE(value)
Definition: jmorecfg.h:78
#define G_CB_OFF
Definition: jccolor.c:86
#define MAXJSAMPLE
Definition: jmorecfg.h:83
#define B_CB_OFF
Definition: jccolor.c:87
rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:143
#define R_CR_OFF
Definition: jccolor.c:88
while(1)
Definition: macro.lex.yy.c:740
#define CBCR_OFFSET
Definition: jccolor.c:72
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 G_CR_OFF
Definition: jccolor.c:89
grayscale_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:334
#define ONE_HALF
Definition: jccolor.c:73
jinit_color_converter(j_compress_ptr cinfo)
Definition: jccolor.c:438
#define b
Definition: ke_i.h:79
#define G_Y_OFF
Definition: jccolor.c:83
rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:199
null_method(j_compress_ptr cinfo)
Definition: jccolor.c:427
GLboolean GLboolean g
Definition: glext.h:6204
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
rgb_ycc_start(j_compress_ptr cinfo)
Definition: jccolor.c:99
JBLOCKROW output_row
Definition: jpegint.h:415
#define R_CB_OFF
Definition: jccolor.c:85
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
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
#define B_Y_OFF
Definition: jccolor.c:84
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:76
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define METHODDEF(type)
Definition: jmorecfg.h:287
#define FIX(x)
Definition: jccolor.c:74
#define B_CR_OFF
Definition: jccolor.c:90
#define TABLE_SIZE
Definition: jccolor.c:91
rgb_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:362
jpeg_component_info JCOEFPTR JSAMPARRAY output_buf
Definition: jdct.h:238
unsigned int JDIMENSION
Definition: jmorecfg.h:229
signed int INT32
rgb_rgb1_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf, JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
Definition: jccolor.c:295