dll/3rdparty/libjpeg/jdcolor.c

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