src/third_party/libjpeg_turbo/jdmrgext.c

   1 /*
   2  * jdmrgext.c
   3  *
   4  * Copyright (C) 1994-1996, Thomas G. Lane.
   5  * Copyright (C) 2011, D. R. Commander.
   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 code for merged upsampling/color conversion.
  10  */
  11
  12
  13 /* This file is included by jdmerge.c */
  14
  15
  16 /*
  17  * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
  18  */
  19
  20 INLINE
  21 LOCAL(void)
  22 h2v1_merged_upsample_internal (j_decompress_ptr cinfo,
  23                                JSAMPIMAGE input_buf,
  24                                JDIMENSION in_row_group_ctr,
  25                                JSAMPARRAY output_buf)
  26 {
  27   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
  28   register int y, cred, cgreen, cblue;
  29   int cb, cr;
  30   register JSAMPROW outptr;
  31   JSAMPROW inptr0, inptr1, inptr2;
  32   JDIMENSION col;
  33   /* copy these pointers into registers if possible */
  34   register JSAMPLE * range_limit = cinfo->sample_range_limit;
  35   int * Crrtab = upsample->Cr_r_tab;
  36   int * Cbbtab = upsample->Cb_b_tab;
  37   INT32 * Crgtab = upsample->Cr_g_tab;
  38   INT32 * Cbgtab = upsample->Cb_g_tab;
  39   SHIFT_TEMPS
  40
  41   inptr0 = input_buf[0][in_row_group_ctr];
  42   inptr1 = input_buf[1][in_row_group_ctr];
  43   inptr2 = input_buf[2][in_row_group_ctr];
  44   outptr = output_buf[0];
  45   /* Loop for each pair of output pixels */
  46   for (col = cinfo->output_width >> 1; col > 0; col--) {
  47     /* Do the chroma part of the calculation */
  48     cb = GETJSAMPLE(*inptr1++);
  49     cr = GETJSAMPLE(*inptr2++);
  50     cred = Crrtab[cr];
  51     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
  52     cblue = Cbbtab[cb];
  53     /* Fetch 2 Y values and emit 2 pixels */
  54     y  = GETJSAMPLE(*inptr0++);
  55     outptr[RGB_RED] =   range_limit[y + cred];
  56     outptr[RGB_GREEN] = range_limit[y + cgreen];
  57     outptr[RGB_BLUE] =  range_limit[y + cblue];
  58 #ifdef RGB_ALPHA
  59     outptr[RGB_ALPHA] = 0xFF;
  60 #endif
  61     outptr += RGB_PIXELSIZE;
  62     y  = GETJSAMPLE(*inptr0++);
  63     outptr[RGB_RED] =   range_limit[y + cred];
  64     outptr[RGB_GREEN] = range_limit[y + cgreen];
  65     outptr[RGB_BLUE] =  range_limit[y + cblue];
  66 #ifdef RGB_ALPHA
  67     outptr[RGB_ALPHA] = 0xFF;
  68 #endif
  69     outptr += RGB_PIXELSIZE;
  70   }
  71   /* If image width is odd, do the last output column separately */
  72   if (cinfo->output_width & 1) {
  73     cb = GETJSAMPLE(*inptr1);
  74     cr = GETJSAMPLE(*inptr2);
  75     cred = Crrtab[cr];
  76     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
  77     cblue = Cbbtab[cb];
  78     y  = GETJSAMPLE(*inptr0);
  79     outptr[RGB_RED] =   range_limit[y + cred];
  80     outptr[RGB_GREEN] = range_limit[y + cgreen];
  81     outptr[RGB_BLUE] =  range_limit[y + cblue];
  82 #ifdef RGB_ALPHA
  83     outptr[RGB_ALPHA] = 0xFF;
  84 #endif
  85   }
  86 }
  87
  88
  89 /*
  90  * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
  91  */
  92
  93 INLINE
  94 LOCAL(void)
  95 h2v2_merged_upsample_internal (j_decompress_ptr cinfo,
  96                                JSAMPIMAGE input_buf,
  97                                JDIMENSION in_row_group_ctr,
  98                                JSAMPARRAY output_buf)
  99 {
 100   my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
 101   register int y, cred, cgreen, cblue;
 102   int cb, cr;
 103   register JSAMPROW outptr0, outptr1;
 104   JSAMPROW inptr00, inptr01, inptr1, inptr2;
 105   JDIMENSION col;
 106   /* copy these pointers into registers if possible */
 107   register JSAMPLE * range_limit = cinfo->sample_range_limit;
 108   int * Crrtab = upsample->Cr_r_tab;
 109   int * Cbbtab = upsample->Cb_b_tab;
 110   INT32 * Crgtab = upsample->Cr_g_tab;
 111   INT32 * Cbgtab = upsample->Cb_g_tab;
 112   SHIFT_TEMPS
 113
 114   inptr00 = input_buf[0][in_row_group_ctr*2];
 115   inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
 116   inptr1 = input_buf[1][in_row_group_ctr];
 117   inptr2 = input_buf[2][in_row_group_ctr];
 118   outptr0 = output_buf[0];
 119   outptr1 = output_buf[1];
 120   /* Loop for each group of output pixels */
 121   for (col = cinfo->output_width >> 1; col > 0; col--) {
 122     /* Do the chroma part of the calculation */
 123     cb = GETJSAMPLE(*inptr1++);
 124     cr = GETJSAMPLE(*inptr2++);
 125     cred = Crrtab[cr];
 126     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
 127     cblue = Cbbtab[cb];
 128     /* Fetch 4 Y values and emit 4 pixels */
 129     y  = GETJSAMPLE(*inptr00++);
 130     outptr0[RGB_RED] =   range_limit[y + cred];
 131     outptr0[RGB_GREEN] = range_limit[y + cgreen];
 132     outptr0[RGB_BLUE] =  range_limit[y + cblue];
 133 #ifdef RGB_ALPHA
 134     outptr0[RGB_ALPHA] = 0xFF;
 135 #endif
 136     outptr0 += RGB_PIXELSIZE;
 137     y  = GETJSAMPLE(*inptr00++);
 138     outptr0[RGB_RED] =   range_limit[y + cred];
 139     outptr0[RGB_GREEN] = range_limit[y + cgreen];
 140     outptr0[RGB_BLUE] =  range_limit[y + cblue];
 141 #ifdef RGB_ALPHA
 142     outptr0[RGB_ALPHA] = 0xFF;
 143 #endif
 144     outptr0 += RGB_PIXELSIZE;
 145     y  = GETJSAMPLE(*inptr01++);
 146     outptr1[RGB_RED] =   range_limit[y + cred];
 147     outptr1[RGB_GREEN] = range_limit[y + cgreen];
 148     outptr1[RGB_BLUE] =  range_limit[y + cblue];
 149 #ifdef RGB_ALPHA
 150     outptr1[RGB_ALPHA] = 0xFF;
 151 #endif
 152     outptr1 += RGB_PIXELSIZE;
 153     y  = GETJSAMPLE(*inptr01++);
 154     outptr1[RGB_RED] =   range_limit[y + cred];
 155     outptr1[RGB_GREEN] = range_limit[y + cgreen];
 156     outptr1[RGB_BLUE] =  range_limit[y + cblue];
 157 #ifdef RGB_ALPHA
 158     outptr1[RGB_ALPHA] = 0xFF;
 159 #endif
 160     outptr1 += RGB_PIXELSIZE;
 161   }
 162   /* If image width is odd, do the last output column separately */
 163   if (cinfo->output_width & 1) {
 164     cb = GETJSAMPLE(*inptr1);
 165     cr = GETJSAMPLE(*inptr2);
 166     cred = Crrtab[cr];
 167     cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
 168     cblue = Cbbtab[cb];
 169     y  = GETJSAMPLE(*inptr00);
 170     outptr0[RGB_RED] =   range_limit[y + cred];
 171     outptr0[RGB_GREEN] = range_limit[y + cgreen];
 172     outptr0[RGB_BLUE] =  range_limit[y + cblue];
 173 #ifdef RGB_ALPHA
 174     outptr0[RGB_ALPHA] = 0xFF;
 175 #endif
 176     y  = GETJSAMPLE(*inptr01);
 177     outptr1[RGB_RED] =   range_limit[y + cred];
 178     outptr1[RGB_GREEN] = range_limit[y + cgreen];
 179     outptr1[RGB_BLUE] =  range_limit[y + cblue];
 180 #ifdef RGB_ALPHA
 181     outptr1[RGB_ALPHA] = 0xFF;
 182 #endif
 183   }
 184 }