Line data    Source code

       1             : /*
       2             :  * jdcolext.c
       3             :  *
       4             :  * This file was part of the Independent JPEG Group's software:
       5             :  * Copyright (C) 1991-1997, Thomas G. Lane.
       6             :  * libjpeg-turbo Modifications:
       7             :  * Copyright (C) 2009, 2011, 2015, D. R. Commander.
       8             :  * For conditions of distribution and use, see the accompanying README.ijg
       9             :  * file.
      10             :  *
      11             :  * This file contains output colorspace conversion routines.
      12             :  */
      13             : 
      14             : 
      15             : /* This file is included by jdcolor.c */
      16             : 
      17             : 
      18             : /*
      19             :  * Convert some rows of samples to the output colorspace.
      20             :  *
      21             :  * Note that we change from noninterleaved, one-plane-per-component format
      22             :  * to interleaved-pixel format.  The output buffer is therefore three times
      23             :  * as wide as the input buffer.
      24             :  * A starting row offset is provided only for the input buffer.  The caller
      25             :  * can easily adjust the passed output_buf value to accommodate any row
      26             :  * offset required on that side.
      27             :  */
      28             : 
      29             : INLINE
      30             : LOCAL(void)
      31           0 : ycc_rgb_convert_internal (j_decompress_ptr cinfo,
      32             :                           JSAMPIMAGE input_buf, JDIMENSION input_row,
      33             :                           JSAMPARRAY output_buf, int num_rows)
      34             : {
      35           0 :   my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
      36             :   register int y, cb, cr;
      37             :   register JSAMPROW outptr;
      38             :   register JSAMPROW inptr0, inptr1, inptr2;
      39             :   register JDIMENSION col;
      40           0 :   JDIMENSION num_cols = cinfo->output_width;
      41             :   /* copy these pointers into registers if possible */
      42           0 :   register JSAMPLE * range_limit = cinfo->sample_range_limit;
      43           0 :   register int * Crrtab = cconvert->Cr_r_tab;
      44           0 :   register int * Cbbtab = cconvert->Cb_b_tab;
      45           0 :   register JLONG * Crgtab = cconvert->Cr_g_tab;
      46           0 :   register JLONG * Cbgtab = cconvert->Cb_g_tab;
      47             :   SHIFT_TEMPS
      48             : 
      49           0 :   while (--num_rows >= 0) {
      50           0 :     inptr0 = input_buf[0][input_row];
      51           0 :     inptr1 = input_buf[1][input_row];
      52           0 :     inptr2 = input_buf[2][input_row];
      53           0 :     input_row++;
      54           0 :     outptr = *output_buf++;
      55           0 :     for (col = 0; col < num_cols; col++) {
      56           0 :       y  = GETJSAMPLE(inptr0[col]);
      57           0 :       cb = GETJSAMPLE(inptr1[col]);
      58           0 :       cr = GETJSAMPLE(inptr2[col]);
      59             :       /* Range-limiting is essential due to noise introduced by DCT losses. */
      60           0 :       outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
      61           0 :       outptr[RGB_GREEN] = range_limit[y +
      62           0 :                               ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
      63             :                                                  SCALEBITS))];
      64           0 :       outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
      65             :       /* Set unused byte to 0xFF so it can be interpreted as an opaque */
      66             :       /* alpha channel value */
      67             : #ifdef RGB_ALPHA
      68           0 :       outptr[RGB_ALPHA] = 0xFF;
      69             : #endif
      70           0 :       outptr += RGB_PIXELSIZE;
      71             :     }
      72             :   }
      73           0 : }
      74             : 
      75             : 
      76             : /*
      77             :  * Convert grayscale to RGB: just duplicate the graylevel three times.
      78             :  * This is provided to support applications that don't want to cope
      79             :  * with grayscale as a separate case.
      80             :  */
      81             : 
      82             : INLINE
      83             : LOCAL(void)
      84           0 : gray_rgb_convert_internal (j_decompress_ptr cinfo,
      85             :                            JSAMPIMAGE input_buf, JDIMENSION input_row,
      86             :                            JSAMPARRAY output_buf, int num_rows)
      87             : {
      88             :   register JSAMPROW inptr, outptr;
      89             :   register JDIMENSION col;
      90           0 :   JDIMENSION num_cols = cinfo->output_width;
      91             : 
      92           0 :   while (--num_rows >= 0) {
      93           0 :     inptr = input_buf[0][input_row++];
      94           0 :     outptr = *output_buf++;
      95           0 :     for (col = 0; col < num_cols; col++) {
      96             :       /* We can dispense with GETJSAMPLE() here */
      97           0 :       outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
      98             :       /* Set unused byte to 0xFF so it can be interpreted as an opaque */
      99             :       /* alpha channel value */
     100             : #ifdef RGB_ALPHA
     101           0 :       outptr[RGB_ALPHA] = 0xFF;
     102             : #endif
     103           0 :       outptr += RGB_PIXELSIZE;
     104             :     }
     105             :   }
     106           0 : }
     107             : 
     108             : 
     109             : /*
     110             :  * Convert RGB to extended RGB: just swap the order of source pixels
     111             :  */
     112             : 
     113             : INLINE
     114             : LOCAL(void)
     115           0 : rgb_rgb_convert_internal (j_decompress_ptr cinfo,
     116             :                           JSAMPIMAGE input_buf, JDIMENSION input_row,
     117             :                           JSAMPARRAY output_buf, int num_rows)
     118             : {
     119             :   register JSAMPROW inptr0, inptr1, inptr2;
     120             :   register JSAMPROW outptr;
     121             :   register JDIMENSION col;
     122           0 :   JDIMENSION num_cols = cinfo->output_width;
     123             : 
     124           0 :   while (--num_rows >= 0) {
     125           0 :     inptr0 = input_buf[0][input_row];
     126           0 :     inptr1 = input_buf[1][input_row];
     127           0 :     inptr2 = input_buf[2][input_row];
     128           0 :     input_row++;
     129           0 :     outptr = *output_buf++;
     130           0 :     for (col = 0; col < num_cols; col++) {
     131             :       /* We can dispense with GETJSAMPLE() here */
     132           0 :       outptr[RGB_RED] = inptr0[col];
     133           0 :       outptr[RGB_GREEN] = inptr1[col];
     134           0 :       outptr[RGB_BLUE] = inptr2[col];
     135             :       /* Set unused byte to 0xFF so it can be interpreted as an opaque */
     136             :       /* alpha channel value */
     137             : #ifdef RGB_ALPHA
     138           0 :       outptr[RGB_ALPHA] = 0xFF;
     139             : #endif
     140           0 :       outptr += RGB_PIXELSIZE;
     141             :     }
     142             :   }
     143           0 : }