1/* 2 * jdcolor.c 3 * 4 * This file was part of the Independent JPEG Group's software: 5 * Copyright (C) 1991-1997, Thomas G. Lane. 6 * Modified 2011 by Guido Vollbeding. 7 * libjpeg-turbo Modifications: 8 * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB 9 * Copyright (C) 2009, 2011-2012, 2014-2015, D. R. Commander. 10 * Copyright (C) 2013, Linaro Limited. 11 * For conditions of distribution and use, see the accompanying README.ijg 12 * file. 13 * 14 * This file contains output colorspace conversion routines. 15 */ 16 17#define JPEG_INTERNALS 18#include "jinclude.h" 19#include "jpeglib.h" 20#include "jsimd.h" 21#include "jconfigint.h" 22 23 24/* Private subobject */ 25 26typedef struct { 27 struct jpeg_color_deconverter pub; /* public fields */ 28 29 /* Private state for YCC->RGB conversion */ 30 int *Cr_r_tab; /* => table for Cr to R conversion */ 31 int *Cb_b_tab; /* => table for Cb to B conversion */ 32 JLONG *Cr_g_tab; /* => table for Cr to G conversion */ 33 JLONG *Cb_g_tab; /* => table for Cb to G conversion */ 34 35 /* Private state for RGB->Y conversion */ 36 JLONG *rgb_y_tab; /* => table for RGB to Y conversion */ 37} my_color_deconverter; 38 39typedef my_color_deconverter *my_cconvert_ptr; 40 41 42/**************** YCbCr -> RGB conversion: most common case **************/ 43/**************** RGB -> Y conversion: less common case **************/ 44 45/* 46 * YCbCr is defined per CCIR 601-1, except that Cb and Cr are 47 * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5. 48 * The conversion equations to be implemented are therefore 49 * 50 * R = Y + 1.40200 * Cr 51 * G = Y - 0.34414 * Cb - 0.71414 * Cr 52 * B = Y + 1.77200 * Cb 53 * 54 * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B 55 * 56 * where Cb and Cr represent the incoming values less CENTERJSAMPLE. 57 * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.) 58 * 59 * To avoid floating-point arithmetic, we represent the fractional constants 60 * as integers scaled up by 2^16 (about 4 digits precision); we have to divide 61 * the products by 2^16, with appropriate rounding, to get the correct answer. 62 * Notice that Y, being an integral input, does not contribute any fraction 63 * so it need not participate in the rounding. 64 * 65 * For even more speed, we avoid doing any multiplications in the inner loop 66 * by precalculating the constants times Cb and Cr for all possible values. 67 * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table); 68 * for 12-bit samples it is still acceptable. It's not very reasonable for 69 * 16-bit samples, but if you want lossless storage you shouldn't be changing 70 * colorspace anyway. 71 * The Cr=>R and Cb=>B values can be rounded to integers in advance; the 72 * values for the G calculation are left scaled up, since we must add them 73 * together before rounding. 74 */ 75 76#define SCALEBITS 16 /* speediest right-shift on some machines */ 77#define ONE_HALF ((JLONG) 1 << (SCALEBITS-1)) 78#define FIX(x) ((JLONG) ((x) * (1L<<SCALEBITS) + 0.5)) 79 80/* We allocate one big table for RGB->Y conversion and divide it up into 81 * three parts, instead of doing three alloc_small requests. This lets us 82 * use a single table base address, which can be held in a register in the 83 * inner loops on many machines (more than can hold all three addresses, 84 * anyway). 85 */ 86 87#define R_Y_OFF 0 /* offset to R => Y section */ 88#define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */ 89#define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */ 90#define TABLE_SIZE (3*(MAXJSAMPLE+1)) 91 92 93/* Include inline routines for colorspace extensions */ 94 95#include "jdcolext.c" 96#undef RGB_RED 97#undef RGB_GREEN 98#undef RGB_BLUE 99#undef RGB_PIXELSIZE 100 101#define RGB_RED EXT_RGB_RED 102#define RGB_GREEN EXT_RGB_GREEN 103#define RGB_BLUE EXT_RGB_BLUE 104#define RGB_PIXELSIZE EXT_RGB_PIXELSIZE 105#define ycc_rgb_convert_internal ycc_extrgb_convert_internal 106#define gray_rgb_convert_internal gray_extrgb_convert_internal 107#define rgb_rgb_convert_internal rgb_extrgb_convert_internal 108#include "jdcolext.c" 109#undef RGB_RED 110#undef RGB_GREEN 111#undef RGB_BLUE 112#undef RGB_PIXELSIZE 113#undef ycc_rgb_convert_internal 114#undef gray_rgb_convert_internal 115#undef rgb_rgb_convert_internal 116 117#define RGB_RED EXT_RGBX_RED 118#define RGB_GREEN EXT_RGBX_GREEN 119#define RGB_BLUE EXT_RGBX_BLUE 120#define RGB_ALPHA 3 121#define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE 122#define ycc_rgb_convert_internal ycc_extrgbx_convert_internal 123#define gray_rgb_convert_internal gray_extrgbx_convert_internal 124#define rgb_rgb_convert_internal rgb_extrgbx_convert_internal 125#include "jdcolext.c" 126#undef RGB_RED 127#undef RGB_GREEN 128#undef RGB_BLUE 129#undef RGB_ALPHA 130#undef RGB_PIXELSIZE 131#undef ycc_rgb_convert_internal 132#undef gray_rgb_convert_internal 133#undef rgb_rgb_convert_internal 134 135#define RGB_RED EXT_BGR_RED 136#define RGB_GREEN EXT_BGR_GREEN 137#define RGB_BLUE EXT_BGR_BLUE 138#define RGB_PIXELSIZE EXT_BGR_PIXELSIZE 139#define ycc_rgb_convert_internal ycc_extbgr_convert_internal 140#define gray_rgb_convert_internal gray_extbgr_convert_internal 141#define rgb_rgb_convert_internal rgb_extbgr_convert_internal 142#include "jdcolext.c" 143#undef RGB_RED 144#undef RGB_GREEN 145#undef RGB_BLUE 146#undef RGB_PIXELSIZE 147#undef ycc_rgb_convert_internal 148#undef gray_rgb_convert_internal 149#undef rgb_rgb_convert_internal 150 151#define RGB_RED EXT_BGRX_RED 152#define RGB_GREEN EXT_BGRX_GREEN 153#define RGB_BLUE EXT_BGRX_BLUE 154#define RGB_ALPHA 3 155#define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE 156#define ycc_rgb_convert_internal ycc_extbgrx_convert_internal 157#define gray_rgb_convert_internal gray_extbgrx_convert_internal 158#define rgb_rgb_convert_internal rgb_extbgrx_convert_internal 159#include "jdcolext.c" 160#undef RGB_RED 161#undef RGB_GREEN 162#undef RGB_BLUE 163#undef RGB_ALPHA 164#undef RGB_PIXELSIZE 165#undef ycc_rgb_convert_internal 166#undef gray_rgb_convert_internal 167#undef rgb_rgb_convert_internal 168 169#define RGB_RED EXT_XBGR_RED 170#define RGB_GREEN EXT_XBGR_GREEN 171#define RGB_BLUE EXT_XBGR_BLUE 172#define RGB_ALPHA 0 173#define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE 174#define ycc_rgb_convert_internal ycc_extxbgr_convert_internal 175#define gray_rgb_convert_internal gray_extxbgr_convert_internal 176#define rgb_rgb_convert_internal rgb_extxbgr_convert_internal 177#include "jdcolext.c" 178#undef RGB_RED 179#undef RGB_GREEN 180#undef RGB_BLUE 181#undef RGB_ALPHA 182#undef RGB_PIXELSIZE 183#undef ycc_rgb_convert_internal 184#undef gray_rgb_convert_internal 185#undef rgb_rgb_convert_internal 186 187#define RGB_RED EXT_XRGB_RED 188#define RGB_GREEN EXT_XRGB_GREEN 189#define RGB_BLUE EXT_XRGB_BLUE 190#define RGB_ALPHA 0 191#define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE 192#define ycc_rgb_convert_internal ycc_extxrgb_convert_internal 193#define gray_rgb_convert_internal gray_extxrgb_convert_internal 194#define rgb_rgb_convert_internal rgb_extxrgb_convert_internal 195#include "jdcolext.c" 196#undef RGB_RED 197#undef RGB_GREEN 198#undef RGB_BLUE 199#undef RGB_ALPHA 200#undef RGB_PIXELSIZE 201#undef ycc_rgb_convert_internal 202#undef gray_rgb_convert_internal 203#undef rgb_rgb_convert_internal 204 205 206/* 207 * Initialize tables for YCC->RGB colorspace conversion. 208 */ 209 210LOCAL(void) 211build_ycc_rgb_table (j_decompress_ptr cinfo) 212{ 213 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 214 int i; 215 JLONG x; 216 SHIFT_TEMPS 217 218 cconvert->Cr_r_tab = (int *) 219 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 220 (MAXJSAMPLE+1) * sizeof(int)); 221 cconvert->Cb_b_tab = (int *) 222 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 223 (MAXJSAMPLE+1) * sizeof(int)); 224 cconvert->Cr_g_tab = (JLONG *) 225 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 226 (MAXJSAMPLE+1) * sizeof(JLONG)); 227 cconvert->Cb_g_tab = (JLONG *) 228 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 229 (MAXJSAMPLE+1) * sizeof(JLONG)); 230 231 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) { 232 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */ 233 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */ 234 /* Cr=>R value is nearest int to 1.40200 * x */ 235 cconvert->Cr_r_tab[i] = (int) 236 RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS); 237 /* Cb=>B value is nearest int to 1.77200 * x */ 238 cconvert->Cb_b_tab[i] = (int) 239 RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS); 240 /* Cr=>G value is scaled-up -0.71414 * x */ 241 cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x; 242 /* Cb=>G value is scaled-up -0.34414 * x */ 243 /* We also add in ONE_HALF so that need not do it in inner loop */ 244 cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF; 245 } 246} 247 248 249/* 250 * Convert some rows of samples to the output colorspace. 251 */ 252 253METHODDEF(void) 254ycc_rgb_convert (j_decompress_ptr cinfo, 255 JSAMPIMAGE input_buf, JDIMENSION input_row, 256 JSAMPARRAY output_buf, int num_rows) 257{ 258 switch (cinfo->out_color_space) { 259 case JCS_EXT_RGB: 260 ycc_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf, 261 num_rows); 262 break; 263 case JCS_EXT_RGBX: 264 case JCS_EXT_RGBA: 265 ycc_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf, 266 num_rows); 267 break; 268 case JCS_EXT_BGR: 269 ycc_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf, 270 num_rows); 271 break; 272 case JCS_EXT_BGRX: 273 case JCS_EXT_BGRA: 274 ycc_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf, 275 num_rows); 276 break; 277 case JCS_EXT_XBGR: 278 case JCS_EXT_ABGR: 279 ycc_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf, 280 num_rows); 281 break; 282 case JCS_EXT_XRGB: 283 case JCS_EXT_ARGB: 284 ycc_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf, 285 num_rows); 286 break; 287 default: 288 ycc_rgb_convert_internal(cinfo, input_buf, input_row, output_buf, 289 num_rows); 290 break; 291 } 292} 293 294 295/**************** Cases other than YCbCr -> RGB **************/ 296 297 298/* 299 * Initialize for RGB->grayscale colorspace conversion. 300 */ 301 302LOCAL(void) 303build_rgb_y_table (j_decompress_ptr cinfo) 304{ 305 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 306 JLONG *rgb_y_tab; 307 JLONG i; 308 309 /* Allocate and fill in the conversion tables. */ 310 cconvert->rgb_y_tab = rgb_y_tab = (JLONG *) 311 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 312 (TABLE_SIZE * sizeof(JLONG))); 313 314 for (i = 0; i <= MAXJSAMPLE; i++) { 315 rgb_y_tab[i+R_Y_OFF] = FIX(0.29900) * i; 316 rgb_y_tab[i+G_Y_OFF] = FIX(0.58700) * i; 317 rgb_y_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF; 318 } 319} 320 321 322/* 323 * Convert RGB to grayscale. 324 */ 325 326METHODDEF(void) 327rgb_gray_convert (j_decompress_ptr cinfo, 328 JSAMPIMAGE input_buf, JDIMENSION input_row, 329 JSAMPARRAY output_buf, int num_rows) 330{ 331 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 332 register int r, g, b; 333 register JLONG *ctab = cconvert->rgb_y_tab; 334 register JSAMPROW outptr; 335 register JSAMPROW inptr0, inptr1, inptr2; 336 register JDIMENSION col; 337 JDIMENSION num_cols = cinfo->output_width; 338 339 while (--num_rows >= 0) { 340 inptr0 = input_buf[0][input_row]; 341 inptr1 = input_buf[1][input_row]; 342 inptr2 = input_buf[2][input_row]; 343 input_row++; 344 outptr = *output_buf++; 345 for (col = 0; col < num_cols; col++) { 346 r = GETJSAMPLE(inptr0[col]); 347 g = GETJSAMPLE(inptr1[col]); 348 b = GETJSAMPLE(inptr2[col]); 349 /* Y */ 350 outptr[col] = (JSAMPLE) 351 ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF]) 352 >> SCALEBITS); 353 } 354 } 355} 356 357 358/* 359 * Color conversion for no colorspace change: just copy the data, 360 * converting from separate-planes to interleaved representation. 361 */ 362 363METHODDEF(void) 364null_convert (j_decompress_ptr cinfo, 365 JSAMPIMAGE input_buf, JDIMENSION input_row, 366 JSAMPARRAY output_buf, int num_rows) 367{ 368 register JSAMPROW inptr, inptr0, inptr1, inptr2, inptr3, outptr; 369 register JDIMENSION col; 370 register int num_components = cinfo->num_components; 371 JDIMENSION num_cols = cinfo->output_width; 372 int ci; 373 374 if (num_components == 3) { 375 while (--num_rows >= 0) { 376 inptr0 = input_buf[0][input_row]; 377 inptr1 = input_buf[1][input_row]; 378 inptr2 = input_buf[2][input_row]; 379 input_row++; 380 outptr = *output_buf++; 381 for (col = 0; col < num_cols; col++) { 382 *outptr++ = inptr0[col]; 383 *outptr++ = inptr1[col]; 384 *outptr++ = inptr2[col]; 385 } 386 } 387 } else if (num_components == 4) { 388 while (--num_rows >= 0) { 389 inptr0 = input_buf[0][input_row]; 390 inptr1 = input_buf[1][input_row]; 391 inptr2 = input_buf[2][input_row]; 392 inptr3 = input_buf[3][input_row]; 393 input_row++; 394 outptr = *output_buf++; 395 for (col = 0; col < num_cols; col++) { 396 *outptr++ = inptr0[col]; 397 *outptr++ = inptr1[col]; 398 *outptr++ = inptr2[col]; 399 *outptr++ = inptr3[col]; 400 } 401 } 402 } else { 403 while (--num_rows >= 0) { 404 for (ci = 0; ci < num_components; ci++) { 405 inptr = input_buf[ci][input_row]; 406 outptr = *output_buf; 407 for (col = 0; col < num_cols; col++) { 408 outptr[ci] = inptr[col]; 409 outptr += num_components; 410 } 411 } 412 output_buf++; 413 input_row++; 414 } 415 } 416} 417 418 419/* 420 * Color conversion for grayscale: just copy the data. 421 * This also works for YCbCr -> grayscale conversion, in which 422 * we just copy the Y (luminance) component and ignore chrominance. 423 */ 424 425METHODDEF(void) 426grayscale_convert (j_decompress_ptr cinfo, 427 JSAMPIMAGE input_buf, JDIMENSION input_row, 428 JSAMPARRAY output_buf, int num_rows) 429{ 430 jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0, 431 num_rows, cinfo->output_width); 432} 433 434 435/* 436 * Convert grayscale to RGB 437 */ 438 439METHODDEF(void) 440gray_rgb_convert (j_decompress_ptr cinfo, 441 JSAMPIMAGE input_buf, JDIMENSION input_row, 442 JSAMPARRAY output_buf, int num_rows) 443{ 444 switch (cinfo->out_color_space) { 445 case JCS_EXT_RGB: 446 gray_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf, 447 num_rows); 448 break; 449 case JCS_EXT_RGBX: 450 case JCS_EXT_RGBA: 451 gray_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf, 452 num_rows); 453 break; 454 case JCS_EXT_BGR: 455 gray_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf, 456 num_rows); 457 break; 458 case JCS_EXT_BGRX: 459 case JCS_EXT_BGRA: 460 gray_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf, 461 num_rows); 462 break; 463 case JCS_EXT_XBGR: 464 case JCS_EXT_ABGR: 465 gray_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf, 466 num_rows); 467 break; 468 case JCS_EXT_XRGB: 469 case JCS_EXT_ARGB: 470 gray_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf, 471 num_rows); 472 break; 473 default: 474 gray_rgb_convert_internal(cinfo, input_buf, input_row, output_buf, 475 num_rows); 476 break; 477 } 478} 479 480 481/* 482 * Convert plain RGB to extended RGB 483 */ 484 485METHODDEF(void) 486rgb_rgb_convert (j_decompress_ptr cinfo, 487 JSAMPIMAGE input_buf, JDIMENSION input_row, 488 JSAMPARRAY output_buf, int num_rows) 489{ 490 switch (cinfo->out_color_space) { 491 case JCS_EXT_RGB: 492 rgb_extrgb_convert_internal(cinfo, input_buf, input_row, output_buf, 493 num_rows); 494 break; 495 case JCS_EXT_RGBX: 496 case JCS_EXT_RGBA: 497 rgb_extrgbx_convert_internal(cinfo, input_buf, input_row, output_buf, 498 num_rows); 499 break; 500 case JCS_EXT_BGR: 501 rgb_extbgr_convert_internal(cinfo, input_buf, input_row, output_buf, 502 num_rows); 503 break; 504 case JCS_EXT_BGRX: 505 case JCS_EXT_BGRA: 506 rgb_extbgrx_convert_internal(cinfo, input_buf, input_row, output_buf, 507 num_rows); 508 break; 509 case JCS_EXT_XBGR: 510 case JCS_EXT_ABGR: 511 rgb_extxbgr_convert_internal(cinfo, input_buf, input_row, output_buf, 512 num_rows); 513 break; 514 case JCS_EXT_XRGB: 515 case JCS_EXT_ARGB: 516 rgb_extxrgb_convert_internal(cinfo, input_buf, input_row, output_buf, 517 num_rows); 518 break; 519 default: 520 rgb_rgb_convert_internal(cinfo, input_buf, input_row, output_buf, 521 num_rows); 522 break; 523 } 524} 525 526 527/* 528 * Adobe-style YCCK->CMYK conversion. 529 * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same 530 * conversion as above, while passing K (black) unchanged. 531 * We assume build_ycc_rgb_table has been called. 532 */ 533 534METHODDEF(void) 535ycck_cmyk_convert (j_decompress_ptr cinfo, 536 JSAMPIMAGE input_buf, JDIMENSION input_row, 537 JSAMPARRAY output_buf, int num_rows) 538{ 539 my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert; 540 register int y, cb, cr; 541 register JSAMPROW outptr; 542 register JSAMPROW inptr0, inptr1, inptr2, inptr3; 543 register JDIMENSION col; 544 JDIMENSION num_cols = cinfo->output_width; 545 /* copy these pointers into registers if possible */ 546 register JSAMPLE *range_limit = cinfo->sample_range_limit; 547 register int *Crrtab = cconvert->Cr_r_tab; 548 register int *Cbbtab = cconvert->Cb_b_tab; 549 register JLONG *Crgtab = cconvert->Cr_g_tab; 550 register JLONG *Cbgtab = cconvert->Cb_g_tab; 551 SHIFT_TEMPS 552 553 while (--num_rows >= 0) { 554 inptr0 = input_buf[0][input_row]; 555 inptr1 = input_buf[1][input_row]; 556 inptr2 = input_buf[2][input_row]; 557 inptr3 = input_buf[3][input_row]; 558 input_row++; 559 outptr = *output_buf++; 560 for (col = 0; col < num_cols; col++) { 561 y = GETJSAMPLE(inptr0[col]); 562 cb = GETJSAMPLE(inptr1[col]); 563 cr = GETJSAMPLE(inptr2[col]); 564 /* Range-limiting is essential due to noise introduced by DCT losses. */ 565 outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */ 566 outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */ 567 ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], 568 SCALEBITS)))]; 569 outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */ 570 /* K passes through unchanged */ 571 outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */ 572 outptr += 4; 573 } 574 } 575} 576 577 578/* 579 * RGB565 conversion 580 */ 581 582#define PACK_SHORT_565_LE(r, g, b) ((((r) << 8) & 0xF800) | \ 583 (((g) << 3) & 0x7E0) | ((b) >> 3)) 584#define PACK_SHORT_565_BE(r, g, b) (((r) & 0xF8) | ((g) >> 5) | \ 585 (((g) << 11) & 0xE000) | \ 586 (((b) << 5) & 0x1F00)) 587 588#define PACK_TWO_PIXELS_LE(l, r) ((r << 16) | l) 589#define PACK_TWO_PIXELS_BE(l, r) ((l << 16) | r) 590 591#define PACK_NEED_ALIGNMENT(ptr) (((size_t)(ptr)) & 3) 592 593#define WRITE_TWO_ALIGNED_PIXELS(addr, pixels) ((*(int *)(addr)) = pixels) 594 595#define DITHER_565_R(r, dither) ((r) + ((dither) & 0xFF)) 596#define DITHER_565_G(g, dither) ((g) + (((dither) & 0xFF) >> 1)) 597#define DITHER_565_B(b, dither) ((b) + ((dither) & 0xFF)) 598 599 600/* Declarations for ordered dithering 601 * 602 * We use a 4x4 ordered dither array packed into 32 bits. This array is 603 * sufficent for dithering RGB888 to RGB565. 604 */ 605 606#define DITHER_MASK 0x3 607#define DITHER_ROTATE(x) ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF)) 608static const JLONG dither_matrix[4] = { 609 0x0008020A, 610 0x0C040E06, 611 0x030B0109, 612 0x0F070D05 613}; 614 615 616static INLINE boolean is_big_endian(void) 617{ 618 int test_value = 1; 619 if (*(char *)&test_value != 1) 620 return TRUE; 621 return FALSE; 622} 623 624 625/* Include inline routines for RGB565 conversion */ 626 627#define PACK_SHORT_565 PACK_SHORT_565_LE 628#define PACK_TWO_PIXELS PACK_TWO_PIXELS_LE 629#define ycc_rgb565_convert_internal ycc_rgb565_convert_le 630#define ycc_rgb565D_convert_internal ycc_rgb565D_convert_le 631#define rgb_rgb565_convert_internal rgb_rgb565_convert_le 632#define rgb_rgb565D_convert_internal rgb_rgb565D_convert_le 633#define gray_rgb565_convert_internal gray_rgb565_convert_le 634#define gray_rgb565D_convert_internal gray_rgb565D_convert_le 635#include "jdcol565.c" 636#undef PACK_SHORT_565 637#undef PACK_TWO_PIXELS 638#undef ycc_rgb565_convert_internal 639#undef ycc_rgb565D_convert_internal 640#undef rgb_rgb565_convert_internal 641#undef rgb_rgb565D_convert_internal 642#undef gray_rgb565_convert_internal 643#undef gray_rgb565D_convert_internal 644 645#define PACK_SHORT_565 PACK_SHORT_565_BE 646#define PACK_TWO_PIXELS PACK_TWO_PIXELS_BE 647#define ycc_rgb565_convert_internal ycc_rgb565_convert_be 648#define ycc_rgb565D_convert_internal ycc_rgb565D_convert_be 649#define rgb_rgb565_convert_internal rgb_rgb565_convert_be 650#define rgb_rgb565D_convert_internal rgb_rgb565D_convert_be 651#define gray_rgb565_convert_internal gray_rgb565_convert_be 652#define gray_rgb565D_convert_internal gray_rgb565D_convert_be 653#include "jdcol565.c" 654#undef PACK_SHORT_565 655#undef PACK_TWO_PIXELS 656#undef ycc_rgb565_convert_internal 657#undef ycc_rgb565D_convert_internal 658#undef rgb_rgb565_convert_internal 659#undef rgb_rgb565D_convert_internal 660#undef gray_rgb565_convert_internal 661#undef gray_rgb565D_convert_internal 662 663 664METHODDEF(void) 665ycc_rgb565_convert (j_decompress_ptr cinfo, 666 JSAMPIMAGE input_buf, JDIMENSION input_row, 667 JSAMPARRAY output_buf, int num_rows) 668{ 669 if (is_big_endian()) 670 ycc_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); 671 else 672 ycc_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); 673} 674 675 676METHODDEF(void) 677ycc_rgb565D_convert (j_decompress_ptr cinfo, 678 JSAMPIMAGE input_buf, JDIMENSION input_row, 679 JSAMPARRAY output_buf, int num_rows) 680{ 681 if (is_big_endian()) 682 ycc_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); 683 else 684 ycc_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); 685} 686 687 688METHODDEF(void) 689rgb_rgb565_convert (j_decompress_ptr cinfo, 690 JSAMPIMAGE input_buf, JDIMENSION input_row, 691 JSAMPARRAY output_buf, int num_rows) 692{ 693 if (is_big_endian()) 694 rgb_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); 695 else 696 rgb_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); 697} 698 699 700METHODDEF(void) 701rgb_rgb565D_convert (j_decompress_ptr cinfo, 702 JSAMPIMAGE input_buf, JDIMENSION input_row, 703 JSAMPARRAY output_buf, int num_rows) 704{ 705 if (is_big_endian()) 706 rgb_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); 707 else 708 rgb_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); 709} 710 711 712METHODDEF(void) 713gray_rgb565_convert (j_decompress_ptr cinfo, 714 JSAMPIMAGE input_buf, JDIMENSION input_row, 715 JSAMPARRAY output_buf, int num_rows) 716{ 717 if (is_big_endian()) 718 gray_rgb565_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); 719 else 720 gray_rgb565_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); 721} 722 723 724METHODDEF(void) 725gray_rgb565D_convert (j_decompress_ptr cinfo, 726 JSAMPIMAGE input_buf, JDIMENSION input_row, 727 JSAMPARRAY output_buf, int num_rows) 728{ 729 if (is_big_endian()) 730 gray_rgb565D_convert_be(cinfo, input_buf, input_row, output_buf, num_rows); 731 else 732 gray_rgb565D_convert_le(cinfo, input_buf, input_row, output_buf, num_rows); 733} 734 735 736/* 737 * Empty method for start_pass. 738 */ 739 740METHODDEF(void) 741start_pass_dcolor (j_decompress_ptr cinfo) 742{ 743 /* no work needed */ 744} 745 746 747/* 748 * Module initialization routine for output colorspace conversion. 749 */ 750 751GLOBAL(void) 752jinit_color_deconverter (j_decompress_ptr cinfo) 753{ 754 my_cconvert_ptr cconvert; 755 int ci; 756 757 cconvert = (my_cconvert_ptr) 758 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 759 sizeof(my_color_deconverter)); 760 cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert; 761 cconvert->pub.start_pass = start_pass_dcolor; 762 763 /* Make sure num_components agrees with jpeg_color_space */ 764 switch (cinfo->jpeg_color_space) { 765 case JCS_GRAYSCALE: 766 if (cinfo->num_components != 1) 767 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 768 break; 769 770 case JCS_RGB: 771 case JCS_YCbCr: 772 if (cinfo->num_components != 3) 773 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 774 break; 775 776 case JCS_CMYK: 777 case JCS_YCCK: 778 if (cinfo->num_components != 4) 779 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 780 break; 781 782 default: /* JCS_UNKNOWN can be anything */ 783 if (cinfo->num_components < 1) 784 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 785 break; 786 } 787 788 /* Set out_color_components and conversion method based on requested space. 789 * Also clear the component_needed flags for any unused components, 790 * so that earlier pipeline stages can avoid useless computation. 791 */ 792 793 switch (cinfo->out_color_space) { 794 case JCS_GRAYSCALE: 795 cinfo->out_color_components = 1; 796 if (cinfo->jpeg_color_space == JCS_GRAYSCALE || 797 cinfo->jpeg_color_space == JCS_YCbCr) { 798 cconvert->pub.color_convert = grayscale_convert; 799 /* For color->grayscale conversion, only the Y (0) component is needed */ 800 for (ci = 1; ci < cinfo->num_components; ci++) 801 cinfo->comp_info[ci].component_needed = FALSE; 802 } else if (cinfo->jpeg_color_space == JCS_RGB) { 803 cconvert->pub.color_convert = rgb_gray_convert; 804 build_rgb_y_table(cinfo); 805 } else 806 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 807 break; 808 809 case JCS_RGB: 810 case JCS_EXT_RGB: 811 case JCS_EXT_RGBX: 812 case JCS_EXT_BGR: 813 case JCS_EXT_BGRX: 814 case JCS_EXT_XBGR: 815 case JCS_EXT_XRGB: 816 case JCS_EXT_RGBA: 817 case JCS_EXT_BGRA: 818 case JCS_EXT_ABGR: 819 case JCS_EXT_ARGB: 820 cinfo->out_color_components = rgb_pixelsize[cinfo->out_color_space]; 821 if (cinfo->jpeg_color_space == JCS_YCbCr) { 822 if (jsimd_can_ycc_rgb()) 823 cconvert->pub.color_convert = jsimd_ycc_rgb_convert; 824 else { 825 cconvert->pub.color_convert = ycc_rgb_convert; 826 build_ycc_rgb_table(cinfo); 827 } 828 } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { 829 cconvert->pub.color_convert = gray_rgb_convert; 830 } else if (cinfo->jpeg_color_space == JCS_RGB) { 831 if (rgb_red[cinfo->out_color_space] == 0 && 832 rgb_green[cinfo->out_color_space] == 1 && 833 rgb_blue[cinfo->out_color_space] == 2 && 834 rgb_pixelsize[cinfo->out_color_space] == 3) 835 cconvert->pub.color_convert = null_convert; 836 else 837 cconvert->pub.color_convert = rgb_rgb_convert; 838 } else 839 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 840 break; 841 842 case JCS_RGB565: 843 cinfo->out_color_components = 3; 844 if (cinfo->dither_mode == JDITHER_NONE) { 845 if (cinfo->jpeg_color_space == JCS_YCbCr) { 846 if (jsimd_can_ycc_rgb565()) 847 cconvert->pub.color_convert = jsimd_ycc_rgb565_convert; 848 else { 849 cconvert->pub.color_convert = ycc_rgb565_convert; 850 build_ycc_rgb_table(cinfo); 851 } 852 } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { 853 cconvert->pub.color_convert = gray_rgb565_convert; 854 } else if (cinfo->jpeg_color_space == JCS_RGB) { 855 cconvert->pub.color_convert = rgb_rgb565_convert; 856 } else 857 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 858 } else { 859 /* only ordered dithering is supported */ 860 if (cinfo->jpeg_color_space == JCS_YCbCr) { 861 cconvert->pub.color_convert = ycc_rgb565D_convert; 862 build_ycc_rgb_table(cinfo); 863 } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { 864 cconvert->pub.color_convert = gray_rgb565D_convert; 865 } else if (cinfo->jpeg_color_space == JCS_RGB) { 866 cconvert->pub.color_convert = rgb_rgb565D_convert; 867 } else 868 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 869 } 870 break; 871 872 case JCS_CMYK: 873 cinfo->out_color_components = 4; 874 if (cinfo->jpeg_color_space == JCS_YCCK) { 875 cconvert->pub.color_convert = ycck_cmyk_convert; 876 build_ycc_rgb_table(cinfo); 877 } else if (cinfo->jpeg_color_space == JCS_CMYK) { 878 cconvert->pub.color_convert = null_convert; 879 } else 880 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 881 break; 882 883 default: 884 /* Permit null conversion to same output space */ 885 if (cinfo->out_color_space == cinfo->jpeg_color_space) { 886 cinfo->out_color_components = cinfo->num_components; 887 cconvert->pub.color_convert = null_convert; 888 } else /* unsupported non-null conversion */ 889 ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL); 890 break; 891 } 892 893 if (cinfo->quantize_colors) 894 cinfo->output_components = 1; /* single colormapped output component */ 895 else 896 cinfo->output_components = cinfo->out_color_components; 897} 898