Chromium Code Reviews Chromium Code Reviews
Issue 1270213002:
Add support for decoding to 565 to libjpeg_turbo (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/libjpeg_turbo.git@master| OLD | NEW |
|---|---|
| (Empty) | |
| 1 /* | |
|
Noel Gordon
2015/08/04 23:58:16
This file is new. Does it need to be added to the
msarett
2015/08/05 13:41:07
This file is included by jdcolor.c (similar to jdc
| |
| 2 * jdcol565.c | |
| 3 * | |
| 4 * This file was part of the Independent JPEG Group's software: | |
| 5 * Copyright (C) 1991-1997, Thomas G. Lane. | |
| 6 * Modifications: | |
| 7 * Copyright (C) 2013, Linaro Limited. | |
| 8 * Copyright (C) 2014, D. R. Commander. | |
| 9 * For conditions of distribution and use, see the accompanying README file. | |
| 10 * | |
| 11 * This file contains output colorspace conversion routines. | |
| 12 */ | |
| 13 | |
| 14 /* This file is included by jdcolor.c */ | |
| 15 | |
| 16 | |
| 17 INLINE | |
| 18 LOCAL(void) | |
| 19 ycc_rgb565_convert_internal (j_decompress_ptr cinfo, | |
| 20 JSAMPIMAGE input_buf, JDIMENSION input_row, | |
| 21 JSAMPARRAY output_buf, int num_rows) | |
| 22 { | |
| 23 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; | |
| 24 register int y, cb, cr; | |
| 25 register JSAMPROW outptr; | |
| 26 register JSAMPROW inptr0, inptr1, inptr2; | |
| 27 register JDIMENSION col; | |
| 28 JDIMENSION num_cols = cinfo->output_width; | |
| 29 /* copy these pointers into registers if possible */ | |
| 30 register JSAMPLE * range_limit = cinfo->sample_range_limit; | |
| 31 register int * Crrtab = cconvert->Cr_r_tab; | |
| 32 register int * Cbbtab = cconvert->Cb_b_tab; | |
| 33 register INT32 * Crgtab = cconvert->Cr_g_tab; | |
| 34 register INT32 * Cbgtab = cconvert->Cb_g_tab; | |
| 35 SHIFT_TEMPS | |
| 36 | |
| 37 while (--num_rows >= 0) { | |
| 38 INT32 rgb; | |
| 39 unsigned int r, g, b; | |
| 40 inptr0 = input_buf[0][input_row]; | |
| 41 inptr1 = input_buf[1][input_row]; | |
| 42 inptr2 = input_buf[2][input_row]; | |
| 43 input_row++; | |
| 44 outptr = *output_buf++; | |
| 45 | |
| 46 if (PACK_NEED_ALIGNMENT(outptr)) { | |
| 47 y = GETJSAMPLE(*inptr0++); | |
| 48 cb = GETJSAMPLE(*inptr1++); | |
| 49 cr = GETJSAMPLE(*inptr2++); | |
| 50 r = range_limit[y + Crrtab[cr]]; | |
| 51 g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 52 SCALEBITS))]; | |
| 53 b = range_limit[y + Cbbtab[cb]]; | |
| 54 rgb = PACK_SHORT_565(r, g, b); | |
| 55 *(INT16*)outptr = rgb; | |
| 56 outptr += 2; | |
| 57 num_cols--; | |
| 58 } | |
| 59 for (col = 0; col < (num_cols >> 1); col++) { | |
| 60 y = GETJSAMPLE(*inptr0++); | |
| 61 cb = GETJSAMPLE(*inptr1++); | |
| 62 cr = GETJSAMPLE(*inptr2++); | |
| 63 r = range_limit[y + Crrtab[cr]]; | |
| 64 g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 65 SCALEBITS))]; | |
| 66 b = range_limit[y + Cbbtab[cb]]; | |
| 67 rgb = PACK_SHORT_565(r, g, b); | |
| 68 | |
| 69 y = GETJSAMPLE(*inptr0++); | |
| 70 cb = GETJSAMPLE(*inptr1++); | |
| 71 cr = GETJSAMPLE(*inptr2++); | |
| 72 r = range_limit[y + Crrtab[cr]]; | |
| 73 g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 74 SCALEBITS))]; | |
| 75 b = range_limit[y + Cbbtab[cb]]; | |
| 76 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); | |
| 77 | |
| 78 WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); | |
| 79 outptr += 4; | |
| 80 } | |
| 81 if (num_cols & 1) { | |
| 82 y = GETJSAMPLE(*inptr0); | |
| 83 cb = GETJSAMPLE(*inptr1); | |
| 84 cr = GETJSAMPLE(*inptr2); | |
| 85 r = range_limit[y + Crrtab[cr]]; | |
| 86 g = range_limit[y + ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 87 SCALEBITS))]; | |
| 88 b = range_limit[y + Cbbtab[cb]]; | |
| 89 rgb = PACK_SHORT_565(r, g, b); | |
| 90 *(INT16*)outptr = rgb; | |
| 91 } | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 | |
| 96 INLINE | |
| 97 LOCAL(void) | |
| 98 ycc_rgb565D_convert_internal (j_decompress_ptr cinfo, | |
| 99 JSAMPIMAGE input_buf, JDIMENSION input_row, | |
| 100 JSAMPARRAY output_buf, int num_rows) | |
| 101 { | |
| 102 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; | |
| 103 register int y, cb, cr; | |
| 104 register JSAMPROW outptr; | |
| 105 register JSAMPROW inptr0, inptr1, inptr2; | |
| 106 register JDIMENSION col; | |
| 107 JDIMENSION num_cols = cinfo->output_width; | |
| 108 /* copy these pointers into registers if possible */ | |
| 109 register JSAMPLE * range_limit = cinfo->sample_range_limit; | |
| 110 register int * Crrtab = cconvert->Cr_r_tab; | |
| 111 register int * Cbbtab = cconvert->Cb_b_tab; | |
| 112 register INT32 * Crgtab = cconvert->Cr_g_tab; | |
| 113 register INT32 * Cbgtab = cconvert->Cb_g_tab; | |
| 114 INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; | |
| 115 SHIFT_TEMPS | |
| 116 | |
| 117 while (--num_rows >= 0) { | |
| 118 INT32 rgb; | |
| 119 unsigned int r, g, b; | |
| 120 | |
| 121 inptr0 = input_buf[0][input_row]; | |
| 122 inptr1 = input_buf[1][input_row]; | |
| 123 inptr2 = input_buf[2][input_row]; | |
| 124 input_row++; | |
| 125 outptr = *output_buf++; | |
| 126 if (PACK_NEED_ALIGNMENT(outptr)) { | |
| 127 y = GETJSAMPLE(*inptr0++); | |
| 128 cb = GETJSAMPLE(*inptr1++); | |
| 129 cr = GETJSAMPLE(*inptr2++); | |
| 130 r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; | |
| 131 g = range_limit[DITHER_565_G(y + | |
| 132 ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 133 SCALEBITS)), d0)]; | |
| 134 b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; | |
| 135 rgb = PACK_SHORT_565(r, g, b); | |
| 136 *(INT16*)outptr = rgb; | |
| 137 outptr += 2; | |
| 138 num_cols--; | |
| 139 } | |
| 140 for (col = 0; col < (num_cols >> 1); col++) { | |
| 141 y = GETJSAMPLE(*inptr0++); | |
| 142 cb = GETJSAMPLE(*inptr1++); | |
| 143 cr = GETJSAMPLE(*inptr2++); | |
| 144 r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; | |
| 145 g = range_limit[DITHER_565_G(y + | |
| 146 ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 147 SCALEBITS)), d0)]; | |
| 148 b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; | |
| 149 d0 = DITHER_ROTATE(d0); | |
| 150 rgb = PACK_SHORT_565(r, g, b); | |
| 151 | |
| 152 y = GETJSAMPLE(*inptr0++); | |
| 153 cb = GETJSAMPLE(*inptr1++); | |
| 154 cr = GETJSAMPLE(*inptr2++); | |
| 155 r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; | |
| 156 g = range_limit[DITHER_565_G(y + | |
| 157 ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 158 SCALEBITS)), d0)]; | |
| 159 b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; | |
| 160 d0 = DITHER_ROTATE(d0); | |
| 161 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); | |
| 162 | |
| 163 WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); | |
| 164 outptr += 4; | |
| 165 } | |
| 166 if (num_cols & 1) { | |
| 167 y = GETJSAMPLE(*inptr0); | |
| 168 cb = GETJSAMPLE(*inptr1); | |
| 169 cr = GETJSAMPLE(*inptr2); | |
| 170 r = range_limit[DITHER_565_R(y + Crrtab[cr], d0)]; | |
| 171 g = range_limit[DITHER_565_G(y + | |
| 172 ((int)RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], | |
| 173 SCALEBITS)), d0)]; | |
| 174 b = range_limit[DITHER_565_B(y + Cbbtab[cb], d0)]; | |
| 175 rgb = PACK_SHORT_565(r, g, b); | |
| 176 *(INT16*)outptr = rgb; | |
| 177 } | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 | |
| 182 INLINE | |
| 183 LOCAL(void) | |
| 184 rgb_rgb565_convert_internal (j_decompress_ptr cinfo, | |
| 185 JSAMPIMAGE input_buf, JDIMENSION input_row, | |
| 186 JSAMPARRAY output_buf, int num_rows) | |
| 187 { | |
| 188 register JSAMPROW outptr; | |
| 189 register JSAMPROW inptr0, inptr1, inptr2; | |
| 190 register JDIMENSION col; | |
| 191 JDIMENSION num_cols = cinfo->output_width; | |
| 192 SHIFT_TEMPS | |
| 193 | |
| 194 while (--num_rows >= 0) { | |
| 195 INT32 rgb; | |
| 196 unsigned int r, g, b; | |
| 197 | |
| 198 inptr0 = input_buf[0][input_row]; | |
| 199 inptr1 = input_buf[1][input_row]; | |
| 200 inptr2 = input_buf[2][input_row]; | |
| 201 input_row++; | |
| 202 outptr = *output_buf++; | |
| 203 if (PACK_NEED_ALIGNMENT(outptr)) { | |
| 204 r = GETJSAMPLE(*inptr0++); | |
| 205 g = GETJSAMPLE(*inptr1++); | |
| 206 b = GETJSAMPLE(*inptr2++); | |
| 207 rgb = PACK_SHORT_565(r, g, b); | |
| 208 *(INT16*)outptr = rgb; | |
| 209 outptr += 2; | |
| 210 num_cols--; | |
| 211 } | |
| 212 for (col = 0; col < (num_cols >> 1); col++) { | |
| 213 r = GETJSAMPLE(*inptr0++); | |
| 214 g = GETJSAMPLE(*inptr1++); | |
| 215 b = GETJSAMPLE(*inptr2++); | |
| 216 rgb = PACK_SHORT_565(r, g, b); | |
| 217 | |
| 218 r = GETJSAMPLE(*inptr0++); | |
| 219 g = GETJSAMPLE(*inptr1++); | |
| 220 b = GETJSAMPLE(*inptr2++); | |
| 221 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); | |
| 222 | |
| 223 WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); | |
| 224 outptr += 4; | |
| 225 } | |
| 226 if (num_cols & 1) { | |
| 227 r = GETJSAMPLE(*inptr0); | |
| 228 g = GETJSAMPLE(*inptr1); | |
| 229 b = GETJSAMPLE(*inptr2); | |
| 230 rgb = PACK_SHORT_565(r, g, b); | |
| 231 *(INT16*)outptr = rgb; | |
| 232 } | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 | |
| 237 INLINE | |
| 238 LOCAL(void) | |
| 239 rgb_rgb565D_convert_internal (j_decompress_ptr cinfo, | |
| 240 JSAMPIMAGE input_buf, JDIMENSION input_row, | |
| 241 JSAMPARRAY output_buf, int num_rows) | |
| 242 { | |
| 243 register JSAMPROW outptr; | |
| 244 register JSAMPROW inptr0, inptr1, inptr2; | |
| 245 register JDIMENSION col; | |
| 246 register JSAMPLE * range_limit = cinfo->sample_range_limit; | |
| 247 JDIMENSION num_cols = cinfo->output_width; | |
| 248 INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; | |
| 249 SHIFT_TEMPS | |
| 250 | |
| 251 while (--num_rows >= 0) { | |
| 252 INT32 rgb; | |
| 253 unsigned int r, g, b; | |
| 254 | |
| 255 inptr0 = input_buf[0][input_row]; | |
| 256 inptr1 = input_buf[1][input_row]; | |
| 257 inptr2 = input_buf[2][input_row]; | |
| 258 input_row++; | |
| 259 outptr = *output_buf++; | |
| 260 if (PACK_NEED_ALIGNMENT(outptr)) { | |
| 261 r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)]; | |
| 262 g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)]; | |
| 263 b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)]; | |
| 264 rgb = PACK_SHORT_565(r, g, b); | |
| 265 *(INT16*)outptr = rgb; | |
| 266 outptr += 2; | |
| 267 num_cols--; | |
| 268 } | |
| 269 for (col = 0; col < (num_cols >> 1); col++) { | |
| 270 r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)]; | |
| 271 g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)]; | |
| 272 b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)]; | |
| 273 d0 = DITHER_ROTATE(d0); | |
| 274 rgb = PACK_SHORT_565(r, g, b); | |
| 275 | |
| 276 r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0++), d0)]; | |
| 277 g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1++), d0)]; | |
| 278 b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2++), d0)]; | |
| 279 d0 = DITHER_ROTATE(d0); | |
| 280 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(r, g, b)); | |
| 281 | |
| 282 WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); | |
| 283 outptr += 4; | |
| 284 } | |
| 285 if (num_cols & 1) { | |
| 286 r = range_limit[DITHER_565_R(GETJSAMPLE(*inptr0), d0)]; | |
| 287 g = range_limit[DITHER_565_G(GETJSAMPLE(*inptr1), d0)]; | |
| 288 b = range_limit[DITHER_565_B(GETJSAMPLE(*inptr2), d0)]; | |
| 289 rgb = PACK_SHORT_565(r, g, b); | |
| 290 *(INT16*)outptr = rgb; | |
| 291 } | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 | |
| 296 INLINE | |
| 297 LOCAL(void) | |
| 298 gray_rgb565_convert_internal (j_decompress_ptr cinfo, | |
| 299 JSAMPIMAGE input_buf, JDIMENSION input_row, | |
| 300 JSAMPARRAY output_buf, int num_rows) | |
| 301 { | |
| 302 register JSAMPROW inptr, outptr; | |
| 303 register JDIMENSION col; | |
| 304 JDIMENSION num_cols = cinfo->output_width; | |
| 305 | |
| 306 while (--num_rows >= 0) { | |
| 307 INT32 rgb; | |
| 308 unsigned int g; | |
| 309 | |
| 310 inptr = input_buf[0][input_row++]; | |
| 311 outptr = *output_buf++; | |
| 312 if (PACK_NEED_ALIGNMENT(outptr)) { | |
| 313 g = *inptr++; | |
| 314 rgb = PACK_SHORT_565(g, g, g); | |
| 315 *(INT16*)outptr = rgb; | |
| 316 outptr += 2; | |
| 317 num_cols--; | |
| 318 } | |
| 319 for (col = 0; col < (num_cols >> 1); col++) { | |
| 320 g = *inptr++; | |
| 321 rgb = PACK_SHORT_565(g, g, g); | |
| 322 g = *inptr++; | |
| 323 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g)); | |
| 324 WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); | |
| 325 outptr += 4; | |
| 326 } | |
| 327 if (num_cols & 1) { | |
| 328 g = *inptr; | |
| 329 rgb = PACK_SHORT_565(g, g, g); | |
| 330 *(INT16*)outptr = rgb; | |
| 331 } | |
| 332 } | |
| 333 } | |
| 334 | |
| 335 | |
| 336 INLINE | |
| 337 LOCAL(void) | |
| 338 gray_rgb565D_convert_internal (j_decompress_ptr cinfo, | |
| 339 JSAMPIMAGE input_buf, JDIMENSION input_row, | |
| 340 JSAMPARRAY output_buf, int num_rows) | |
| 341 { | |
| 342 register JSAMPROW inptr, outptr; | |
| 343 register JDIMENSION col; | |
| 344 register JSAMPLE * range_limit = cinfo->sample_range_limit; | |
| 345 JDIMENSION num_cols = cinfo->output_width; | |
| 346 INT32 d0 = dither_matrix[cinfo->output_scanline & DITHER_MASK]; | |
| 347 | |
| 348 while (--num_rows >= 0) { | |
| 349 INT32 rgb; | |
| 350 unsigned int g; | |
| 351 | |
| 352 inptr = input_buf[0][input_row++]; | |
| 353 outptr = *output_buf++; | |
| 354 if (PACK_NEED_ALIGNMENT(outptr)) { | |
| 355 g = *inptr++; | |
| 356 g = range_limit[DITHER_565_R(g, d0)]; | |
| 357 rgb = PACK_SHORT_565(g, g, g); | |
| 358 *(INT16*)outptr = rgb; | |
| 359 outptr += 2; | |
| 360 num_cols--; | |
| 361 } | |
| 362 for (col = 0; col < (num_cols >> 1); col++) { | |
| 363 g = *inptr++; | |
| 364 g = range_limit[DITHER_565_R(g, d0)]; | |
| 365 rgb = PACK_SHORT_565(g, g, g); | |
| 366 d0 = DITHER_ROTATE(d0); | |
| 367 | |
| 368 g = *inptr++; | |
| 369 g = range_limit[DITHER_565_R(g, d0)]; | |
| 370 rgb = PACK_TWO_PIXELS(rgb, PACK_SHORT_565(g, g, g)); | |
| 371 d0 = DITHER_ROTATE(d0); | |
| 372 | |
| 373 WRITE_TWO_ALIGNED_PIXELS(outptr, rgb); | |
| 374 outptr += 4; | |
| 375 } | |
| 376 if (num_cols & 1) { | |
| 377 g = *inptr; | |
| 378 g = range_limit[DITHER_565_R(g, d0)]; | |
| 379 rgb = PACK_SHORT_565(g, g, g); | |
| 380 *(INT16*)outptr = rgb; | |
| 381 } | |
| 382 } | |
| 383 } | |
| OLD | NEW |
