jccolext.c

   1 /*
   2  * jccolext.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1991-1996, Thomas G. Lane.
   6  * libjpeg-turbo Modifications:
   7  * Copyright (C) 2009-2012, 2015, 2022, D. R. Commander.
   8  * For conditions of distribution and use, see the accompanying README.ijg
   9  * file.
  10  *
  11  * This file contains input colorspace conversion routines.
  12  */
  13
  14
  15 /* This file is included by jccolor.c */
  16
  17
  18 /*
  19  * Convert some rows of samples to the JPEG colorspace.
  20  *
  21  * Note that we change from the application's interleaved-pixel format
  22  * to our internal noninterleaved, one-plane-per-component format.
  23  * The input buffer is therefore three times as wide as the output buffer.
  24  *
  25  * A starting row offset is provided only for the output buffer.  The caller
  26  * can easily adjust the passed input_buf value to accommodate any row
  27  * offset required on that side.
  28  */
  29
  30 INLINE
  31 LOCAL(void)
  32 rgb_ycc_convert_internal(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
  33                          _JSAMPIMAGE output_buf, JDIMENSION output_row,
  34                          int num_rows)
  35 {
  36 #if BITS_IN_JSAMPLE != 16
  37   my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
  38   register int r, g, b;
  39   register JLONG *ctab = cconvert->rgb_ycc_tab;
  40   register _JSAMPROW inptr;
  41   register _JSAMPROW outptr0, outptr1, outptr2;
  42   register JDIMENSION col;
  43   JDIMENSION num_cols = cinfo->image_width;
  44
  45   while (--num_rows >= 0) {
  46     inptr = *input_buf++;
  47     outptr0 = output_buf[0][output_row];
  48     outptr1 = output_buf[1][output_row];
  49     outptr2 = output_buf[2][output_row];
  50     output_row++;
  51     for (col = 0; col < num_cols; col++) {
  52       r = RANGE_LIMIT(inptr[RGB_RED]);
  53       g = RANGE_LIMIT(inptr[RGB_GREEN]);
  54       b = RANGE_LIMIT(inptr[RGB_BLUE]);
  55       inptr += RGB_PIXELSIZE;
  56       /* If the inputs are 0.._MAXJSAMPLE, the outputs of these equations
  57        * must be too; we do not need an explicit range-limiting operation.
  58        * Hence the value being shifted is never negative, and we don't
  59        * need the general RIGHT_SHIFT macro.
  60        */
  61       /* Y */
  62       outptr0[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
  63                                  ctab[b + B_Y_OFF]) >> SCALEBITS);
  64       /* Cb */
  65       outptr1[col] = (_JSAMPLE)((ctab[r + R_CB_OFF] + ctab[g + G_CB_OFF] +
  66                                  ctab[b + B_CB_OFF]) >> SCALEBITS);
  67       /* Cr */
  68       outptr2[col] = (_JSAMPLE)((ctab[r + R_CR_OFF] + ctab[g + G_CR_OFF] +
  69                                  ctab[b + B_CR_OFF]) >> SCALEBITS);
  70     }
  71   }
  72 #else
  73   ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
  74 #endif
  75 }
  76
  77
  78 /**************** Cases other than RGB -> YCbCr **************/
  79
  80
  81 /*
  82  * Convert some rows of samples to the JPEG colorspace.
  83  * This version handles RGB->grayscale conversion, which is the same
  84  * as the RGB->Y portion of RGB->YCbCr.
  85  * We assume rgb_ycc_start has been called (we only use the Y tables).
  86  */
  87
  88 INLINE
  89 LOCAL(void)
  90 rgb_gray_convert_internal(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
  91                           _JSAMPIMAGE output_buf, JDIMENSION output_row,
  92                           int num_rows)
  93 {
  94 #if BITS_IN_JSAMPLE != 16
  95   my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
  96   register int r, g, b;
  97   register JLONG *ctab = cconvert->rgb_ycc_tab;
  98   register _JSAMPROW inptr;
  99   register _JSAMPROW outptr;
 100   register JDIMENSION col;
 101   JDIMENSION num_cols = cinfo->image_width;
 102
 103   while (--num_rows >= 0) {
 104     inptr = *input_buf++;
 105     outptr = output_buf[0][output_row];
 106     output_row++;
 107     for (col = 0; col < num_cols; col++) {
 108       r = RANGE_LIMIT(inptr[RGB_RED]);
 109       g = RANGE_LIMIT(inptr[RGB_GREEN]);
 110       b = RANGE_LIMIT(inptr[RGB_BLUE]);
 111       inptr += RGB_PIXELSIZE;
 112       /* Y */
 113       outptr[col] = (_JSAMPLE)((ctab[r + R_Y_OFF] + ctab[g + G_Y_OFF] +
 114                                 ctab[b + B_Y_OFF]) >> SCALEBITS);
 115     }
 116   }
 117 #else
 118   ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
 119 #endif
 120 }
 121
 122
 123 /*
 124  * Convert some rows of samples to the JPEG colorspace.
 125  * This version handles extended RGB->plain RGB conversion
 126  */
 127
 128 INLINE
 129 LOCAL(void)
 130 rgb_rgb_convert_internal(j_compress_ptr cinfo, _JSAMPARRAY input_buf,
 131                          _JSAMPIMAGE output_buf, JDIMENSION output_row,
 132                          int num_rows)
 133 {
 134   register _JSAMPROW inptr;
 135   register _JSAMPROW outptr0, outptr1, outptr2;
 136   register JDIMENSION col;
 137   JDIMENSION num_cols = cinfo->image_width;
 138
 139   while (--num_rows >= 0) {
 140     inptr = *input_buf++;
 141     outptr0 = output_buf[0][output_row];
 142     outptr1 = output_buf[1][output_row];
 143     outptr2 = output_buf[2][output_row];
 144     output_row++;
 145     for (col = 0; col < num_cols; col++) {
 146       outptr0[col] = inptr[RGB_RED];
 147       outptr1[col] = inptr[RGB_GREEN];
 148       outptr2[col] = inptr[RGB_BLUE];
 149       inptr += RGB_PIXELSIZE;
 150     }
 151   }
 152 }