1 /* 2 * jdmrg565.c 3 * 4 * This file was part of the Independent JPEG Group's software: 5 * Copyright (C) 1994-1996, Thomas G. Lane. 6 * libjpeg-turbo Modifications: 7 * Copyright (C) 2013, Linaro Limited. 8 * Copyright (C) 2014-2015, D. R. Commander. 9 * For conditions of distribution and use, see the accompanying README.ijg 10 * file. 11 * 12 * This file contains code for merged upsampling/color conversion. 13 */ 14 15 16 INLINE 17 LOCAL(void) 18 h2v1_merged_upsample_565_internal (j_decompress_ptr cinfo, 19 JSAMPIMAGE input_buf, 20 JDIMENSION in_row_group_ctr, 21 JSAMPARRAY output_buf) 22 { 23 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; 24 register int y, cred, cgreen, cblue; 25 int cb, cr; 26 register JSAMPROW outptr; 27 JSAMPROW inptr0, inptr1, inptr2; 28 JDIMENSION col; 29 /* copy these pointers into registers if possible */ 30 register JSAMPLE * range_limit = cinfo->sample_range_limit; 31 int * Crrtab = upsample->Cr_r_tab; 32 int * Cbbtab = upsample->Cb_b_tab; 33 JLONG * Crgtab = upsample->Cr_g_tab; 34 JLONG * Cbgtab = upsample->Cb_g_tab; 35 unsigned int r, g, b; 36 JLONG rgb; 37 SHIFT_TEMPS 38 39 inptr0 = input_buf[0][in_row_group_ctr]; 40 inptr1 = input_buf[1][in_row_group_ctr]; 41 inptr2 = input_buf[2][in_row_group_ctr]; 42 outptr = output_buf[0]; 43 44 /* Loop for each pair of output pixels */ 45 for (col = cinfo->output_width >> 1; col > 0; col--) { 46 /* Do the chroma part of the calculation */ 47 cb = GETJSAMPLE(*inptr1++); 48 cr = GETJSAMPLE(*inptr2++); 49 cred = Crrtab[cr]; 50 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 51 cblue = Cbbtab[cb]; 52 53 /* Fetch 2 Y values and emit 2 pixels */ 54 y = GETJSAMPLE(*inptr0++); 55 r = range_limit[y + cred]; 56 g = range_limit[y + cgreen]; 57 b = range_limit[y + cblue]; 58 rgb = PACK_SHORT_565(r, g, b); 59 60 y = GETJSAMPLE(*inptr0++); 61 r = range_limit[y + cred]; 62 g = range_limit[y + cgreen]; 63 b = range_limit[y + cblue]; 64 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); 65 66 WRITE_TWO_PIXELS(outptr, rgb); 67 outptr += 4; 68 } 69 70 /* If image width is odd, do the last output column separately */ 71 if (cinfo->output_width & 1) { 72 cb = GETJSAMPLE(*inptr1); 73 cr = GETJSAMPLE(*inptr2); 74 cred = Crrtab[cr]; 75 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 76 cblue = Cbbtab[cb]; 77 y = GETJSAMPLE(*inptr0); 78 r = range_limit[y + cred]; 79 g = range_limit[y + cgreen]; 80 b = range_limit[y + cblue]; 81 rgb = PACK_SHORT_565(r, g, b); 82 *(INT16*)outptr = (INT16)rgb; 83 } 84 } 85 86 87 INLINE 88 LOCAL(void) 89 h2v1_merged_upsample_565D_internal (j_decompress_ptr cinfo, 90 JSAMPIMAGE input_buf, 91 JDIMENSION in_row_group_ctr, 92 JSAMPARRAY output_buf) 93 { 94 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; 95 register int y, cred, cgreen, cblue; 96 int cb, cr; 97 register JSAMPROW outptr; 98 JSAMPROW inptr0, inptr1, inptr2; 99 JDIMENSION col; 100 /* copy these pointers into registers if possible */ 101 register JSAMPLE * range_limit = cinfo->sample_range_limit; 102 int * Crrtab = upsample->Cr_r_tab; 103 int * Cbbtab = upsample->Cb_b_tab; 104 JLONG * Crgtab = upsample->Cr_g_tab; 105 JLONG * Cbgtab = upsample->Cb_g_tab; 106 JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; 107 unsigned int r, g, b; 108 JLONG rgb; 109 SHIFT_TEMPS 110 111 inptr0 = input_buf[0][in_row_group_ctr]; 112 inptr1 = input_buf[1][in_row_group_ctr]; 113 inptr2 = input_buf[2][in_row_group_ctr]; 114 outptr = output_buf[0]; 115 116 /* Loop for each pair of output pixels */ 117 for (col = cinfo->output_width >> 1; col > 0; col--) { 118 /* Do the chroma part of the calculation */ 119 cb = GETJSAMPLE(*inptr1++); 120 cr = GETJSAMPLE(*inptr2++); 121 cred = Crrtab[cr]; 122 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 123 cblue = Cbbtab[cb]; 124 125 /* Fetch 2 Y values and emit 2 pixels */ 126 y = GETJSAMPLE(*inptr0++); 127 r = range_limit[DITHER_565_R(y + cred, d0)]; 128 g = range_limit[DITHER_565_G(y + cgreen, d0)]; 129 b = range_limit[DITHER_565_B(y + cblue, d0)]; 130 d0 = DITHER_ROTATE(d0); 131 rgb = PACK_SHORT_565(r, g, b); 132 133 y = GETJSAMPLE(*inptr0++); 134 r = range_limit[DITHER_565_R(y + cred, d0)]; 135 g = range_limit[DITHER_565_G(y + cgreen, d0)]; 136 b = range_limit[DITHER_565_B(y + cblue, d0)]; 137 d0 = DITHER_ROTATE(d0); 138 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); 139 140 WRITE_TWO_PIXELS(outptr, rgb); 141 outptr += 4; 142 } 143 144 /* If image width is odd, do the last output column separately */ 145 if (cinfo->output_width & 1) { 146 cb = GETJSAMPLE(*inptr1); 147 cr = GETJSAMPLE(*inptr2); 148 cred = Crrtab[cr]; 149 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 150 cblue = Cbbtab[cb]; 151 y = GETJSAMPLE(*inptr0); 152 r = range_limit[DITHER_565_R(y + cred, d0)]; 153 g = range_limit[DITHER_565_G(y + cgreen, d0)]; 154 b = range_limit[DITHER_565_B(y + cblue, d0)]; 155 rgb = PACK_SHORT_565(r, g, b); 156 *(INT16*)outptr = (INT16)rgb; 157 } 158 } 159 160 161 INLINE 162 LOCAL(void) 163 h2v2_merged_upsample_565_internal (j_decompress_ptr cinfo, 164 JSAMPIMAGE input_buf, 165 JDIMENSION in_row_group_ctr, 166 JSAMPARRAY output_buf) 167 { 168 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; 169 register int y, cred, cgreen, cblue; 170 int cb, cr; 171 register JSAMPROW outptr0, outptr1; 172 JSAMPROW inptr00, inptr01, inptr1, inptr2; 173 JDIMENSION col; 174 /* copy these pointers into registers if possible */ 175 register JSAMPLE * range_limit = cinfo->sample_range_limit; 176 int * Crrtab = upsample->Cr_r_tab; 177 int * Cbbtab = upsample->Cb_b_tab; 178 JLONG * Crgtab = upsample->Cr_g_tab; 179 JLONG * Cbgtab = upsample->Cb_g_tab; 180 unsigned int r, g, b; 181 JLONG rgb; 182 SHIFT_TEMPS 183 184 inptr00 = input_buf[0][in_row_group_ctr * 2]; 185 inptr01 = input_buf[0][in_row_group_ctr * 2 + 1]; 186 inptr1 = input_buf[1][in_row_group_ctr]; 187 inptr2 = input_buf[2][in_row_group_ctr]; 188 outptr0 = output_buf[0]; 189 outptr1 = output_buf[1]; 190 191 /* Loop for each group of output pixels */ 192 for (col = cinfo->output_width >> 1; col > 0; col--) { 193 /* Do the chroma part of the calculation */ 194 cb = GETJSAMPLE(*inptr1++); 195 cr = GETJSAMPLE(*inptr2++); 196 cred = Crrtab[cr]; 197 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 198 cblue = Cbbtab[cb]; 199 200 /* Fetch 4 Y values and emit 4 pixels */ 201 y = GETJSAMPLE(*inptr00++); 202 r = range_limit[y + cred]; 203 g = range_limit[y + cgreen]; 204 b = range_limit[y + cblue]; 205 rgb = PACK_SHORT_565(r, g, b); 206 207 y = GETJSAMPLE(*inptr00++); 208 r = range_limit[y + cred]; 209 g = range_limit[y + cgreen]; 210 b = range_limit[y + cblue]; 211 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); 212 213 WRITE_TWO_PIXELS(outptr0, rgb); 214 outptr0 += 4; 215 216 y = GETJSAMPLE(*inptr01++); 217 r = range_limit[y + cred]; 218 g = range_limit[y + cgreen]; 219 b = range_limit[y + cblue]; 220 rgb = PACK_SHORT_565(r, g, b); 221 222 y = GETJSAMPLE(*inptr01++); 223 r = range_limit[y + cred]; 224 g = range_limit[y + cgreen]; 225 b = range_limit[y + cblue]; 226 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); 227 228 WRITE_TWO_PIXELS(outptr1, rgb); 229 outptr1 += 4; 230 } 231 232 /* If image width is odd, do the last output column separately */ 233 if (cinfo->output_width & 1) { 234 cb = GETJSAMPLE(*inptr1); 235 cr = GETJSAMPLE(*inptr2); 236 cred = Crrtab[cr]; 237 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 238 cblue = Cbbtab[cb]; 239 240 y = GETJSAMPLE(*inptr00); 241 r = range_limit[y + cred]; 242 g = range_limit[y + cgreen]; 243 b = range_limit[y + cblue]; 244 rgb = PACK_SHORT_565(r, g, b); 245 *(INT16*)outptr0 = (INT16)rgb; 246 247 y = GETJSAMPLE(*inptr01); 248 r = range_limit[y + cred]; 249 g = range_limit[y + cgreen]; 250 b = range_limit[y + cblue]; 251 rgb = PACK_SHORT_565(r, g, b); 252 *(INT16*)outptr1 = (INT16)rgb; 253 } 254 } 255 256 257 INLINE 258 LOCAL(void) 259 h2v2_merged_upsample_565D_internal (j_decompress_ptr cinfo, 260 JSAMPIMAGE input_buf, 261 JDIMENSION in_row_group_ctr, 262 JSAMPARRAY output_buf) 263 { 264 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; 265 register int y, cred, cgreen, cblue; 266 int cb, cr; 267 register JSAMPROW outptr0, outptr1; 268 JSAMPROW inptr00, inptr01, inptr1, inptr2; 269 JDIMENSION col; 270 /* copy these pointers into registers if possible */ 271 register JSAMPLE * range_limit = cinfo->sample_range_limit; 272 int * Crrtab = upsample->Cr_r_tab; 273 int * Cbbtab = upsample->Cb_b_tab; 274 JLONG * Crgtab = upsample->Cr_g_tab; 275 JLONG * Cbgtab = upsample->Cb_g_tab; 276 JLONG d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; 277 JLONG d1 = dither_matrix[(cinfo->output_scanline+1) & DITHER_MASK]; 278 unsigned int r, g, b; 279 JLONG rgb; 280 SHIFT_TEMPS 281 282 inptr00 = input_buf[0][in_row_group_ctr*2]; 283 inptr01 = input_buf[0][in_row_group_ctr*2 + 1]; 284 inptr1 = input_buf[1][in_row_group_ctr]; 285 inptr2 = input_buf[2][in_row_group_ctr]; 286 outptr0 = output_buf[0]; 287 outptr1 = output_buf[1]; 288 289 /* Loop for each group of output pixels */ 290 for (col = cinfo->output_width >> 1; col > 0; col--) { 291 /* Do the chroma part of the calculation */ 292 cb = GETJSAMPLE(*inptr1++); 293 cr = GETJSAMPLE(*inptr2++); 294 cred = Crrtab[cr]; 295 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 296 cblue = Cbbtab[cb]; 297 298 /* Fetch 4 Y values and emit 4 pixels */ 299 y = GETJSAMPLE(*inptr00++); 300 r = range_limit[DITHER_565_R(y + cred, d0)]; 301 g = range_limit[DITHER_565_G(y + cgreen, d0)]; 302 b = range_limit[DITHER_565_B(y + cblue, d0)]; 303 d0 = DITHER_ROTATE(d0); 304 rgb = PACK_SHORT_565(r, g, b); 305 306 y = GETJSAMPLE(*inptr00++); 307 r = range_limit[DITHER_565_R(y + cred, d1)]; 308 g = range_limit[DITHER_565_G(y + cgreen, d1)]; 309 b = range_limit[DITHER_565_B(y + cblue, d1)]; 310 d1 = DITHER_ROTATE(d1); 311 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); 312 313 WRITE_TWO_PIXELS(outptr0, rgb); 314 outptr0 += 4; 315 316 y = GETJSAMPLE(*inptr01++); 317 r = range_limit[DITHER_565_R(y + cred, d0)]; 318 g = range_limit[DITHER_565_G(y + cgreen, d0)]; 319 b = range_limit[DITHER_565_B(y + cblue, d0)]; 320 d0 = DITHER_ROTATE(d0); 321 rgb = PACK_SHORT_565(r, g, b); 322 323 y = GETJSAMPLE(*inptr01++); 324 r = range_limit[DITHER_565_R(y + cred, d1)]; 325 g = range_limit[DITHER_565_G(y + cgreen, d1)]; 326 b = range_limit[DITHER_565_B(y + cblue, d1)]; 327 d1 = DITHER_ROTATE(d1); 328 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); 329 330 WRITE_TWO_PIXELS(outptr1, rgb); 331 outptr1 += 4; 332 } 333 334 /* If image width is odd, do the last output column separately */ 335 if (cinfo->output_width & 1) { 336 cb = GETJSAMPLE(*inptr1); 337 cr = GETJSAMPLE(*inptr2); 338 cred = Crrtab[cr]; 339 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS); 340 cblue = Cbbtab[cb]; 341 342 y = GETJSAMPLE(*inptr00); 343 r = range_limit[DITHER_565_R(y + cred, d0)]; 344 g = range_limit[DITHER_565_G(y + cgreen, d0)]; 345 b = range_limit[DITHER_565_B(y + cblue, d0)]; 346 rgb = PACK_SHORT_565(r, g, b); 347 *(INT16*)outptr0 = (INT16)rgb; 348 349 y = GETJSAMPLE(*inptr01); 350 r = range_limit[DITHER_565_R(y + cred, d1)]; 351 g = range_limit[DITHER_565_G(y + cgreen, d1)]; 352 b = range_limit[DITHER_565_B(y + cblue, d1)]; 353 rgb = PACK_SHORT_565(r, g, b); 354 *(INT16*)outptr1 = (INT16)rgb; 355 } 356 } 357
