| OLD | NEW |
|---|
| (Empty) | |
| 1 /* |
| 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 |
|---|
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