reactos/dll/3rdparty/libjpeg/jdcolor.c

   1 /*
   2  * jdcolor.c
   3  *
   4  * Copyright (C) 1991-1997, Thomas G. Lane.
   5  * Modified 2011-2012 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 /* Private subobject */
  18
  19 typedef struct {
  20   struct jpeg_color_deconverter pub; /* public fields */
  21
  22   /* Private state for YCC->RGB conversion */
  23   int * Cr_r_tab;               /* => table for Cr to R conversion */
  24   int * Cb_b_tab;               /* => table for Cb to B conversion */
  25   INT32 * Cr_g_tab;             /* => table for Cr to G conversion */
  26   INT32 * Cb_g_tab;             /* => table for Cb to G conversion */
  27
  28   /* Private state for RGB->Y conversion */
  29   INT32 * rgb_y_tab;            /* => table for RGB to Y conversion */
  30 } my_color_deconverter;
  31
  32 typedef my_color_deconverter * my_cconvert_ptr;
  33
  34
  35 /**************** YCbCr -> RGB conversion: most common case **************/
  36 /****************   RGB -> Y   conversion: less common case **************/
  37
  38 /*
  39  * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
  40  * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
  41  * The conversion equations to be implemented are therefore
  42  *
  43  *      R = Y                + 1.40200 * Cr
  44  *      G = Y - 0.34414 * Cb - 0.71414 * Cr
  45  *      B = Y + 1.77200 * Cb
  46  *
  47  *      Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
  48  *
  49  * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
  50  * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
  51  *
  52  * To avoid floating-point arithmetic, we represent the fractional constants
  53  * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
  54  * the products by 2^16, with appropriate rounding, to get the correct answer.
  55  * Notice that Y, being an integral input, does not contribute any fraction
  56  * so it need not participate in the rounding.
  57  *
  58  * For even more speed, we avoid doing any multiplications in the inner loop
  59  * by precalculating the constants times Cb and Cr for all possible values.
  60  * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
  61  * for 12-bit samples it is still acceptable.  It's not very reasonable for
  62  * 16-bit samples, but if you want lossless storage you shouldn't be changing
  63  * colorspace anyway.
  64  * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
  65  * values for the G calculation are left scaled up, since we must add them
  66  * together before rounding.
  67  */
  68
  69 #define SCALEBITS       16      /* speediest right-shift on some machines */
  70 #define ONE_HALF        ((INT32) 1 << (SCALEBITS-1))
  71 #define FIX(x)          ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
  72
  73 /* We allocate one big table for RGB->Y conversion and divide it up into
  74  * three parts, instead of doing three alloc_small requests.  This lets us
  75  * use a single table base address, which can be held in a register in the
  76  * inner loops on many machines (more than can hold all three addresses,
  77  * anyway).
  78  */
  79
  80 #define R_Y_OFF         0                       /* offset to R => Y section */
  81 #define G_Y_OFF         (1*(MAXJSAMPLE+1))      /* offset to G => Y section */
  82 #define B_Y_OFF         (2*(MAXJSAMPLE+1))      /* etc. */
  83 #define TABLE_SIZE      (3*(MAXJSAMPLE+1))
  84
  85
  86 /*
  87  * Initialize tables for YCC->RGB colorspace conversion.
  88  */
  89
  90 LOCAL(void)
  91 build_ycc_rgb_table (j_decompress_ptr cinfo)
  92 {
  93   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
  94   int i;
  95   INT32 x;
  96   SHIFT_TEMPS
  97
  98   cconvert->Cr_r_tab = (int *)
  99     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 100                                 (MAXJSAMPLE+1) * SIZEOF(int));
 101   cconvert->Cb_b_tab = (int *)
 102     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 103                                 (MAXJSAMPLE+1) * SIZEOF(int));
 104   cconvert->Cr_g_tab = (INT32 *)
 105     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 106                                 (MAXJSAMPLE+1) * SIZEOF(INT32));
 107   cconvert->Cb_g_tab = (INT32 *)
 108     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 109                                 (MAXJSAMPLE+1) * SIZEOF(INT32));
 110
 111   for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
 112     /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
 113     /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
 114     /* Cr=>R value is nearest int to 1.40200 * x */
 115     cconvert->Cr_r_tab[i] = (int)
 116                     RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
 117     /* Cb=>B value is nearest int to 1.77200 * x */
 118     cconvert->Cb_b_tab[i] = (int)
 119                     RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
 120     /* Cr=>G value is scaled-up -0.71414 * x */
 121     cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
 122     /* Cb=>G value is scaled-up -0.34414 * x */
 123     /* We also add in ONE_HALF so that need not do it in inner loop */
 124     cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
 125   }
 126 }
 127
 128
 129 /*
 130  * Convert some rows of samples to the output colorspace.
 131  *
 132  * Note that we change from noninterleaved, one-plane-per-component format
 133  * to interleaved-pixel format.  The output buffer is therefore three times
 134  * as wide as the input buffer.
 135  * A starting row offset is provided only for the input buffer.  The caller
 136  * can easily adjust the passed output_buf value to accommodate any row
 137  * offset required on that side.
 138  */
 139
 140 METHODDEF(void)
 141 ycc_rgb_convert (j_decompress_ptr cinfo,
 142                  JSAMPIMAGE input_buf, JDIMENSION input_row,
 143                  JSAMPARRAY output_buf, int num_rows)
 144 {
 145   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
 146   register int y, cb, cr;
 147   register JSAMPROW outptr;
 148   register JSAMPROW inptr0, inptr1, inptr2;
 149   register JDIMENSION col;
 150   JDIMENSION num_cols = cinfo->output_width;
 151   /* copy these pointers into registers if possible */
 152   register JSAMPLE * range_limit = cinfo->sample_range_limit;
 153   register int * Crrtab = cconvert->Cr_r_tab;
 154   register int * Cbbtab = cconvert->Cb_b_tab;
 155   register INT32 * Crgtab = cconvert->Cr_g_tab;
 156   register INT32 * Cbgtab = cconvert->Cb_g_tab;
 157   SHIFT_TEMPS
 158
 159   while (--num_rows >= 0) {
 160     inptr0 = input_buf[0][input_row];
 161     inptr1 = input_buf[1][input_row];
 162     inptr2 = input_buf[2][input_row];
 163     input_row++;
 164     outptr = *output_buf++;
 165     for (col = 0; col < num_cols; col++) {
 166       y  = GETJSAMPLE(inptr0[col]);
 167       cb = GETJSAMPLE(inptr1[col]);
 168       cr = GETJSAMPLE(inptr2[col]);
 169       /* Range-limiting is essential due to noise introduced by DCT losses. */
 170       outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
 171       outptr[RGB_GREEN] = range_limit[y +
 172                               ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
 173                                                  SCALEBITS))];
 174       outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
 175       outptr += RGB_PIXELSIZE;
 176     }
 177   }
 178 }
 179
 180
 181 /**************** Cases other than YCbCr -> RGB **************/
 182
 183
 184 /*
 185  * Initialize for RGB->grayscale colorspace conversion.
 186  */
 187
 188 LOCAL(void)
 189 build_rgb_y_table (j_decompress_ptr cinfo)
 190 {
 191   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
 192   INT32 * rgb_y_tab;
 193   INT32 i;
 194
 195   /* Allocate and fill in the conversion tables. */
 196   cconvert->rgb_y_tab = rgb_y_tab = (INT32 *)
 197     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 198                                 (TABLE_SIZE * SIZEOF(INT32)));
 199
 200   for (i = 0; i <= MAXJSAMPLE; i++) {
 201     rgb_y_tab[i+R_Y_OFF] = FIX(0.29900) * i;
 202     rgb_y_tab[i+G_Y_OFF] = FIX(0.58700) * i;
 203     rgb_y_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
 204   }
 205 }
 206
 207
 208 /*
 209  * Convert RGB to grayscale.
 210  */
 211
 212 METHODDEF(void)
 213 rgb_gray_convert (j_decompress_ptr cinfo,
 214                   JSAMPIMAGE input_buf, JDIMENSION input_row,
 215                   JSAMPARRAY output_buf, int num_rows)
 216 {
 217   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
 218   register INT32 * ctab = cconvert->rgb_y_tab;
 219   register int r, g, b;
 220   register JSAMPROW outptr;
 221   register JSAMPROW inptr0, inptr1, inptr2;
 222   register JDIMENSION col;
 223   JDIMENSION num_cols = cinfo->output_width;
 224
 225   while (--num_rows >= 0) {
 226     inptr0 = input_buf[0][input_row];
 227     inptr1 = input_buf[1][input_row];
 228     inptr2 = input_buf[2][input_row];
 229     input_row++;
 230     outptr = *output_buf++;
 231     for (col = 0; col < num_cols; col++) {
 232       r = GETJSAMPLE(inptr0[col]);
 233       g = GETJSAMPLE(inptr1[col]);
 234       b = GETJSAMPLE(inptr2[col]);
 235       /* Y */
 236       outptr[col] = (JSAMPLE)
 237                 ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
 238                  >> SCALEBITS);
 239     }
 240   }
 241 }
 242
 243
 244 /*
 245  * [R-G,G,B-G] to [R,G,B] conversion with modulo calculation
 246  * (inverse color transform).
 247  */
 248
 249 METHODDEF(void)
 250 rgb1_rgb_convert (j_decompress_ptr cinfo,
 251                   JSAMPIMAGE input_buf, JDIMENSION input_row,
 252                   JSAMPARRAY output_buf, int num_rows)
 253 {
 254   register int r, g, b;
 255   register JSAMPROW outptr;
 256   register JSAMPROW inptr0, inptr1, inptr2;
 257   register JDIMENSION col;
 258   JDIMENSION num_cols = cinfo->output_width;
 259
 260   while (--num_rows >= 0) {
 261     inptr0 = input_buf[0][input_row];
 262     inptr1 = input_buf[1][input_row];
 263     inptr2 = input_buf[2][input_row];
 264     input_row++;
 265     outptr = *output_buf++;
 266     for (col = 0; col < num_cols; col++) {
 267       r = GETJSAMPLE(inptr0[col]);
 268       g = GETJSAMPLE(inptr1[col]);
 269       b = GETJSAMPLE(inptr2[col]);
 270       /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
 271        * (modulo) operator is equivalent to the bitmask operator AND.
 272        */
 273       outptr[RGB_RED]   = (JSAMPLE) ((r + g - CENTERJSAMPLE) & MAXJSAMPLE);
 274       outptr[RGB_GREEN] = (JSAMPLE) g;
 275       outptr[RGB_BLUE]  = (JSAMPLE) ((b + g - CENTERJSAMPLE) & MAXJSAMPLE);
 276       outptr += RGB_PIXELSIZE;
 277     }
 278   }
 279 }
 280
 281
 282 /*
 283  * [R-G,G,B-G] to grayscale conversion with modulo calculation
 284  * (inverse color transform).
 285  */
 286
 287 METHODDEF(void)
 288 rgb1_gray_convert (j_decompress_ptr cinfo,
 289                    JSAMPIMAGE input_buf, JDIMENSION input_row,
 290                    JSAMPARRAY output_buf, int num_rows)
 291 {
 292   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
 293   register INT32 * ctab = cconvert->rgb_y_tab;
 294   register int r, g, b;
 295   register JSAMPROW outptr;
 296   register JSAMPROW inptr0, inptr1, inptr2;
 297   register JDIMENSION col;
 298   JDIMENSION num_cols = cinfo->output_width;
 299
 300   while (--num_rows >= 0) {
 301     inptr0 = input_buf[0][input_row];
 302     inptr1 = input_buf[1][input_row];
 303     inptr2 = input_buf[2][input_row];
 304     input_row++;
 305     outptr = *output_buf++;
 306     for (col = 0; col < num_cols; col++) {
 307       r = GETJSAMPLE(inptr0[col]);
 308       g = GETJSAMPLE(inptr1[col]);
 309       b = GETJSAMPLE(inptr2[col]);
 310       /* Assume that MAXJSAMPLE+1 is a power of 2, so that the MOD
 311        * (modulo) operator is equivalent to the bitmask operator AND.
 312        */
 313       r = (r + g - CENTERJSAMPLE) & MAXJSAMPLE;
 314       b = (b + g - CENTERJSAMPLE) & MAXJSAMPLE;
 315       /* Y */
 316       outptr[col] = (JSAMPLE)
 317                 ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
 318                  >> SCALEBITS);
 319     }
 320   }
 321 }
 322
 323
 324 /*
 325  * No colorspace change, but conversion from separate-planes
 326  * to interleaved representation.
 327  */
 328
 329 METHODDEF(void)
 330 rgb_convert (j_decompress_ptr cinfo,
 331              JSAMPIMAGE input_buf, JDIMENSION input_row,
 332              JSAMPARRAY output_buf, int num_rows)
 333 {
 334   register JSAMPROW outptr;
 335   register JSAMPROW inptr0, inptr1, inptr2;
 336   register JDIMENSION col;
 337   JDIMENSION num_cols = cinfo->output_width;
 338
 339   while (--num_rows >= 0) {
 340     inptr0 = input_buf[0][input_row];
 341     inptr1 = input_buf[1][input_row];
 342     inptr2 = input_buf[2][input_row];
 343     input_row++;
 344     outptr = *output_buf++;
 345     for (col = 0; col < num_cols; col++) {
 346       /* We can dispense with GETJSAMPLE() here */
 347       outptr[RGB_RED]   = inptr0[col];
 348       outptr[RGB_GREEN] = inptr1[col];
 349       outptr[RGB_BLUE]  = inptr2[col];
 350       outptr += RGB_PIXELSIZE;
 351     }
 352   }
 353 }
 354
 355
 356 /*
 357  * Color conversion for no colorspace change: just copy the data,
 358  * converting from separate-planes to interleaved representation.
 359  */
 360
 361 METHODDEF(void)
 362 null_convert (j_decompress_ptr cinfo,
 363               JSAMPIMAGE input_buf, JDIMENSION input_row,
 364               JSAMPARRAY output_buf, int num_rows)
 365 {
 366   int ci;
 367   register int nc = cinfo->num_components;
 368   register JSAMPROW outptr;
 369   register JSAMPROW inptr;
 370   register JDIMENSION col;
 371   JDIMENSION num_cols = cinfo->output_width;
 372
 373   while (--num_rows >= 0) {
 374     for (ci = 0; ci < nc; ci++) {
 375       inptr = input_buf[ci][input_row];
 376       outptr = output_buf[0] + ci;
 377       for (col = 0; col < num_cols; col++) {
 378         *outptr = *inptr++;     /* needn't bother with GETJSAMPLE() here */
 379         outptr += nc;
 380       }
 381     }
 382     input_row++;
 383     output_buf++;
 384   }
 385 }
 386
 387
 388 /*
 389  * Color conversion for grayscale: just copy the data.
 390  * This also works for YCbCr -> grayscale conversion, in which
 391  * we just copy the Y (luminance) component and ignore chrominance.
 392  */
 393
 394 METHODDEF(void)
 395 grayscale_convert (j_decompress_ptr cinfo,
 396                    JSAMPIMAGE input_buf, JDIMENSION input_row,
 397                    JSAMPARRAY output_buf, int num_rows)
 398 {
 399   jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
 400                     num_rows, cinfo->output_width);
 401 }
 402
 403
 404 /*
 405  * Convert grayscale to RGB: just duplicate the graylevel three times.
 406  * This is provided to support applications that don't want to cope
 407  * with grayscale as a separate case.
 408  */
 409
 410 METHODDEF(void)
 411 gray_rgb_convert (j_decompress_ptr cinfo,
 412                   JSAMPIMAGE input_buf, JDIMENSION input_row,
 413                   JSAMPARRAY output_buf, int num_rows)
 414 {
 415   register JSAMPROW outptr;
 416   register JSAMPROW inptr;
 417   register JDIMENSION col;
 418   JDIMENSION num_cols = cinfo->output_width;
 419
 420   while (--num_rows >= 0) {
 421     inptr = input_buf[0][input_row++];
 422     outptr = *output_buf++;
 423     for (col = 0; col < num_cols; col++) {
 424       /* We can dispense with GETJSAMPLE() here */
 425       outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
 426       outptr += RGB_PIXELSIZE;
 427     }
 428   }
 429 }
 430
 431
 432 /*
 433  * Adobe-style YCCK->CMYK conversion.
 434  * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
 435  * conversion as above, while passing K (black) unchanged.
 436  * We assume build_ycc_rgb_table has been called.
 437  */
 438
 439 METHODDEF(void)
 440 ycck_cmyk_convert (j_decompress_ptr cinfo,
 441                    JSAMPIMAGE input_buf, JDIMENSION input_row,
 442                    JSAMPARRAY output_buf, int num_rows)
 443 {
 444   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
 445   register int y, cb, cr;
 446   register JSAMPROW outptr;
 447   register JSAMPROW inptr0, inptr1, inptr2, inptr3;
 448   register JDIMENSION col;
 449   JDIMENSION num_cols = cinfo->output_width;
 450   /* copy these pointers into registers if possible */
 451   register JSAMPLE * range_limit = cinfo->sample_range_limit;
 452   register int * Crrtab = cconvert->Cr_r_tab;
 453   register int * Cbbtab = cconvert->Cb_b_tab;
 454   register INT32 * Crgtab = cconvert->Cr_g_tab;
 455   register INT32 * Cbgtab = cconvert->Cb_g_tab;
 456   SHIFT_TEMPS
 457
 458   while (--num_rows >= 0) {
 459     inptr0 = input_buf[0][input_row];
 460     inptr1 = input_buf[1][input_row];
 461     inptr2 = input_buf[2][input_row];
 462     inptr3 = input_buf[3][input_row];
 463     input_row++;
 464     outptr = *output_buf++;
 465     for (col = 0; col < num_cols; col++) {
 466       y  = GETJSAMPLE(inptr0[col]);
 467       cb = GETJSAMPLE(inptr1[col]);
 468       cr = GETJSAMPLE(inptr2[col]);
 469       /* Range-limiting is essential due to noise introduced by DCT losses. */
 470       outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];   /* red */
 471       outptr[1] = range_limit[MAXJSAMPLE - (y +                 /* green */
 472                               ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
 473                                                  SCALEBITS)))];
 474       outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];   /* blue */
 475       /* K passes through unchanged */
 476       outptr[3] = inptr3[col];  /* don't need GETJSAMPLE here */
 477       outptr += 4;
 478     }
 479   }
 480 }
 481
 482
 483 /*
 484  * Empty method for start_pass.
 485  */
 486
 487 METHODDEF(void)
 488 start_pass_dcolor (j_decompress_ptr cinfo)
 489 {
 490   /* no work needed */
 491 }
 492
 493
 494 /*
 495  * Module initialization routine for output colorspace conversion.
 496  */
 497
 498 GLOBAL(void)
 499 jinit_color_deconverter (j_decompress_ptr cinfo)
 500 {
 501   my_cconvert_ptr cconvert;
 502   int ci;
 503
 504   cconvert = (my_cconvert_ptr)
 505     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 506                                 SIZEOF(my_color_deconverter));
 507   cinfo->cconvert = &cconvert->pub;
 508   cconvert->pub.start_pass = start_pass_dcolor;
 509
 510   /* Make sure num_components agrees with jpeg_color_space */
 511   switch (cinfo->jpeg_color_space) {
 512   case JCS_GRAYSCALE:
 513     if (cinfo->num_components != 1)
 514       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
 515     break;
 516
 517   case JCS_RGB:
 518   case JCS_YCbCr:
 519     if (cinfo->num_components != 3)
 520       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
 521     break;
 522
 523   case JCS_CMYK:
 524   case JCS_YCCK:
 525     if (cinfo->num_components != 4)
 526       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
 527     break;
 528
 529   default:                      /* JCS_UNKNOWN can be anything */
 530     if (cinfo->num_components < 1)
 531       ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
 532     break;
 533   }
 534
 535   /* Support color transform only for RGB colorspace */
 536   if (cinfo->color_transform && cinfo->jpeg_color_space != JCS_RGB)
 537     ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 538
 539   /* Set out_color_components and conversion method based on requested space.
 540    * Also clear the component_needed flags for any unused components,
 541    * so that earlier pipeline stages can avoid useless computation.
 542    */
 543
 544   switch (cinfo->out_color_space) {
 545   case JCS_GRAYSCALE:
 546     cinfo->out_color_components = 1;
 547     if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
 548         cinfo->jpeg_color_space == JCS_YCbCr) {
 549       cconvert->pub.color_convert = grayscale_convert;
 550       /* For color->grayscale conversion, only the Y (0) component is needed */
 551       for (ci = 1; ci < cinfo->num_components; ci++)
 552         cinfo->comp_info[ci].component_needed = FALSE;
 553     } else if (cinfo->jpeg_color_space == JCS_RGB) {
 554       switch (cinfo->color_transform) {
 555       case JCT_NONE:
 556         cconvert->pub.color_convert = rgb_gray_convert;
 557         break;
 558       case JCT_SUBTRACT_GREEN:
 559         cconvert->pub.color_convert = rgb1_gray_convert;
 560         break;
 561       default:
 562         ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 563         break;
 564       }
 565       build_rgb_y_table(cinfo);
 566     } else
 567       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 568     break;
 569
 570   case JCS_RGB:
 571     cinfo->out_color_components = RGB_PIXELSIZE;
 572     if (cinfo->jpeg_color_space == JCS_YCbCr) {
 573       cconvert->pub.color_convert = ycc_rgb_convert;
 574       build_ycc_rgb_table(cinfo);
 575     } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
 576       cconvert->pub.color_convert = gray_rgb_convert;
 577     } else if (cinfo->jpeg_color_space == JCS_RGB) {
 578       switch (cinfo->color_transform) {
 579       case JCT_NONE:
 580         cconvert->pub.color_convert = rgb_convert;
 581         break;
 582       case JCT_SUBTRACT_GREEN:
 583         cconvert->pub.color_convert = rgb1_rgb_convert;
 584         break;
 585       default:
 586         ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 587         break;
 588       }
 589     } else
 590       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 591     break;
 592
 593   case JCS_CMYK:
 594     cinfo->out_color_components = 4;
 595     if (cinfo->jpeg_color_space == JCS_YCCK) {
 596       cconvert->pub.color_convert = ycck_cmyk_convert;
 597       build_ycc_rgb_table(cinfo);
 598     } else if (cinfo->jpeg_color_space == JCS_CMYK) {
 599       cconvert->pub.color_convert = null_convert;
 600     } else
 601       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 602     break;
 603
 604   default:
 605     /* Permit null conversion to same output space */
 606     if (cinfo->out_color_space == cinfo->jpeg_color_space) {
 607       cinfo->out_color_components = cinfo->num_components;
 608       cconvert->pub.color_convert = null_convert;
 609     } else                      /* unsupported non-null conversion */
 610       ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 611     break;
 612   }
 613
 614   if (cinfo->quantize_colors)
 615     cinfo->output_components = 1; /* single colormapped output component */
 616   else
 617     cinfo->output_components = cinfo->out_color_components;
 618 }