libs/jpeg/jdcolor.c

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