1 //--------------------------------------------------------------------------------- 2 // 3 // Little Color Management System 4 // Copyright (c) 1998-2016 Marti Maria Saguer 5 // 6 // Permission is hereby granted, free of charge, to any person obtaining 7 // a copy of this software and associated documentation files (the "Software"), 8 // to deal in the Software without restriction, including without limitation 9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 // and/or sell copies of the Software, and to permit persons to whom the Software 11 // is furnished to do so, subject to the following conditions: 12 // 13 // The above copyright notice and this permission notice shall be included in 14 // all copies or substantial portions of the Software. 15 // 16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 18 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 // 24 //--------------------------------------------------------------------------------- 25 // 26 27 #include "lcms2_internal.h" 28 29 // This module handles all formats supported by lcms. There are two flavors, 16 bits and 30 // floating point. Floating point is supported only in a subset, those formats holding 31 // cmsFloat32Number (4 bytes per component) and double (marked as 0 bytes per component 32 // as special case) 33 34 // --------------------------------------------------------------------------- 35 36 37 // This macro return words stored as big endian 38 #define CHANGE_ENDIAN(w) (cmsUInt16Number) ((cmsUInt16Number) ((w)<<8)|((w)>>8)) 39 40 // These macros handles reversing (negative) 41 #define REVERSE_FLAVOR_8(x) ((cmsUInt8Number) (0xff-(x))) 42 #define REVERSE_FLAVOR_16(x) ((cmsUInt16Number)(0xffff-(x))) 43 44 // * 0xffff / 0xff00 = (255 * 257) / (255 * 256) = 257 / 256 45 cmsINLINE cmsUInt16Number FomLabV2ToLabV4(cmsUInt16Number x) 46 { 47 int a = (x << 8 | x) >> 8; // * 257 / 256 48 if ( a > 0xffff) return 0xffff; 49 return (cmsUInt16Number) a; 50 } 51 52 // * 0xf00 / 0xffff = * 256 / 257 53 cmsINLINE cmsUInt16Number FomLabV4ToLabV2(cmsUInt16Number x) 54 { 55 return (cmsUInt16Number) (((x << 8) + 0x80) / 257); 56 } 57 58 59 typedef struct { 60 cmsUInt32Number Type; 61 cmsUInt32Number Mask; 62 cmsFormatter16 Frm; 63 64 } cmsFormatters16; 65 66 typedef struct { 67 cmsUInt32Number Type; 68 cmsUInt32Number Mask; 69 cmsFormatterFloat Frm; 70 71 } cmsFormattersFloat; 72 73 74 #define ANYSPACE COLORSPACE_SH(31) 75 #define ANYCHANNELS CHANNELS_SH(15) 76 #define ANYEXTRA EXTRA_SH(7) 77 #define ANYPLANAR PLANAR_SH(1) 78 #define ANYENDIAN ENDIAN16_SH(1) 79 #define ANYSWAP DOSWAP_SH(1) 80 #define ANYSWAPFIRST SWAPFIRST_SH(1) 81 #define ANYFLAVOR FLAVOR_SH(1) 82 83 84 // Suppress waning about info never being used 85 86 #ifdef _MSC_VER 87 #pragma warning(disable : 4100) 88 #endif 89 90 // Unpacking routines (16 bits) ---------------------------------------------------------------------------------------- 91 92 93 // Does almost everything but is slow 94 static 95 cmsUInt8Number* UnrollChunkyBytes(register _cmsTRANSFORM* info, 96 register cmsUInt16Number wIn[], 97 register cmsUInt8Number* accum, 98 register cmsUInt32Number Stride) 99 { 100 int nChan = T_CHANNELS(info -> InputFormat); 101 int DoSwap = T_DOSWAP(info ->InputFormat); 102 int Reverse = T_FLAVOR(info ->InputFormat); 103 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 104 int Extra = T_EXTRA(info -> InputFormat); 105 int ExtraFirst = DoSwap ^ SwapFirst; 106 cmsUInt16Number v; 107 int i; 108 109 if (ExtraFirst) { 110 accum += Extra; 111 } 112 113 for (i=0; i < nChan; i++) { 114 int index = DoSwap ? (nChan - i - 1) : i; 115 116 v = FROM_8_TO_16(*accum); 117 v = Reverse ? REVERSE_FLAVOR_16(v) : v; 118 wIn[index] = v; 119 accum++; 120 } 121 122 if (!ExtraFirst) { 123 accum += Extra; 124 } 125 126 if (Extra == 0 && SwapFirst) { 127 cmsUInt16Number tmp = wIn[0]; 128 129 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number)); 130 wIn[nChan-1] = tmp; 131 } 132 133 return accum; 134 135 cmsUNUSED_PARAMETER(info); 136 cmsUNUSED_PARAMETER(Stride); 137 138 } 139 140 // Extra channels are just ignored because come in the next planes 141 static 142 cmsUInt8Number* UnrollPlanarBytes(register _cmsTRANSFORM* info, 143 register cmsUInt16Number wIn[], 144 register cmsUInt8Number* accum, 145 register cmsUInt32Number Stride) 146 { 147 int nChan = T_CHANNELS(info -> InputFormat); 148 int DoSwap = T_DOSWAP(info ->InputFormat); 149 int SwapFirst = T_SWAPFIRST(info ->InputFormat); 150 int Reverse = T_FLAVOR(info ->InputFormat); 151 int i; 152 cmsUInt8Number* Init = accum; 153 154 if (DoSwap ^ SwapFirst) { 155 accum += T_EXTRA(info -> InputFormat) * Stride; 156 } 157 158 for (i=0; i < nChan; i++) { 159 160 int index = DoSwap ? (nChan - i - 1) : i; 161 cmsUInt16Number v = FROM_8_TO_16(*accum); 162 163 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v; 164 accum += Stride; 165 } 166 167 return (Init + 1); 168 } 169 170 // Special cases, provided for performance 171 static 172 cmsUInt8Number* Unroll4Bytes(register _cmsTRANSFORM* info, 173 register cmsUInt16Number wIn[], 174 register cmsUInt8Number* accum, 175 register cmsUInt32Number Stride) 176 { 177 wIn[0] = FROM_8_TO_16(*accum); accum++; // C 178 wIn[1] = FROM_8_TO_16(*accum); accum++; // M 179 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y 180 wIn[3] = FROM_8_TO_16(*accum); accum++; // K 181 182 return accum; 183 184 cmsUNUSED_PARAMETER(info); 185 cmsUNUSED_PARAMETER(Stride); 186 } 187 188 static 189 cmsUInt8Number* Unroll4BytesReverse(register _cmsTRANSFORM* info, 190 register cmsUInt16Number wIn[], 191 register cmsUInt8Number* accum, 192 register cmsUInt32Number Stride) 193 { 194 wIn[0] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // C 195 wIn[1] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // M 196 wIn[2] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // Y 197 wIn[3] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // K 198 199 return accum; 200 201 cmsUNUSED_PARAMETER(info); 202 cmsUNUSED_PARAMETER(Stride); 203 } 204 205 static 206 cmsUInt8Number* Unroll4BytesSwapFirst(register _cmsTRANSFORM* info, 207 register cmsUInt16Number wIn[], 208 register cmsUInt8Number* accum, 209 register cmsUInt32Number Stride) 210 { 211 wIn[3] = FROM_8_TO_16(*accum); accum++; // K 212 wIn[0] = FROM_8_TO_16(*accum); accum++; // C 213 wIn[1] = FROM_8_TO_16(*accum); accum++; // M 214 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y 215 216 return accum; 217 218 cmsUNUSED_PARAMETER(info); 219 cmsUNUSED_PARAMETER(Stride); 220 } 221 222 // KYMC 223 static 224 cmsUInt8Number* Unroll4BytesSwap(register _cmsTRANSFORM* info, 225 register cmsUInt16Number wIn[], 226 register cmsUInt8Number* accum, 227 register cmsUInt32Number Stride) 228 { 229 wIn[3] = FROM_8_TO_16(*accum); accum++; // K 230 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y 231 wIn[1] = FROM_8_TO_16(*accum); accum++; // M 232 wIn[0] = FROM_8_TO_16(*accum); accum++; // C 233 234 return accum; 235 236 cmsUNUSED_PARAMETER(info); 237 cmsUNUSED_PARAMETER(Stride); 238 } 239 240 static 241 cmsUInt8Number* Unroll4BytesSwapSwapFirst(register _cmsTRANSFORM* info, 242 register cmsUInt16Number wIn[], 243 register cmsUInt8Number* accum, 244 register cmsUInt32Number Stride) 245 { 246 wIn[2] = FROM_8_TO_16(*accum); accum++; // K 247 wIn[1] = FROM_8_TO_16(*accum); accum++; // Y 248 wIn[0] = FROM_8_TO_16(*accum); accum++; // M 249 wIn[3] = FROM_8_TO_16(*accum); accum++; // C 250 251 return accum; 252 253 cmsUNUSED_PARAMETER(info); 254 cmsUNUSED_PARAMETER(Stride); 255 } 256 257 static 258 cmsUInt8Number* Unroll3Bytes(register _cmsTRANSFORM* info, 259 register cmsUInt16Number wIn[], 260 register cmsUInt8Number* accum, 261 register cmsUInt32Number Stride) 262 { 263 wIn[0] = FROM_8_TO_16(*accum); accum++; // R 264 wIn[1] = FROM_8_TO_16(*accum); accum++; // G 265 wIn[2] = FROM_8_TO_16(*accum); accum++; // B 266 267 return accum; 268 269 cmsUNUSED_PARAMETER(info); 270 cmsUNUSED_PARAMETER(Stride); 271 } 272 273 static 274 cmsUInt8Number* Unroll3BytesSkip1Swap(register _cmsTRANSFORM* info, 275 register cmsUInt16Number wIn[], 276 register cmsUInt8Number* accum, 277 register cmsUInt32Number Stride) 278 { 279 accum++; // A 280 wIn[2] = FROM_8_TO_16(*accum); accum++; // B 281 wIn[1] = FROM_8_TO_16(*accum); accum++; // G 282 wIn[0] = FROM_8_TO_16(*accum); accum++; // R 283 284 return accum; 285 286 cmsUNUSED_PARAMETER(info); 287 cmsUNUSED_PARAMETER(Stride); 288 } 289 290 static 291 cmsUInt8Number* Unroll3BytesSkip1SwapSwapFirst(register _cmsTRANSFORM* info, 292 register cmsUInt16Number wIn[], 293 register cmsUInt8Number* accum, 294 register cmsUInt32Number Stride) 295 { 296 wIn[2] = FROM_8_TO_16(*accum); accum++; // B 297 wIn[1] = FROM_8_TO_16(*accum); accum++; // G 298 wIn[0] = FROM_8_TO_16(*accum); accum++; // R 299 accum++; // A 300 301 return accum; 302 303 cmsUNUSED_PARAMETER(info); 304 cmsUNUSED_PARAMETER(Stride); 305 } 306 307 static 308 cmsUInt8Number* Unroll3BytesSkip1SwapFirst(register _cmsTRANSFORM* info, 309 register cmsUInt16Number wIn[], 310 register cmsUInt8Number* accum, 311 register cmsUInt32Number Stride) 312 { 313 accum++; // A 314 wIn[0] = FROM_8_TO_16(*accum); accum++; // R 315 wIn[1] = FROM_8_TO_16(*accum); accum++; // G 316 wIn[2] = FROM_8_TO_16(*accum); accum++; // B 317 318 return accum; 319 320 cmsUNUSED_PARAMETER(info); 321 cmsUNUSED_PARAMETER(Stride); 322 } 323 324 325 // BRG 326 static 327 cmsUInt8Number* Unroll3BytesSwap(register _cmsTRANSFORM* info, 328 register cmsUInt16Number wIn[], 329 register cmsUInt8Number* accum, 330 register cmsUInt32Number Stride) 331 { 332 wIn[2] = FROM_8_TO_16(*accum); accum++; // B 333 wIn[1] = FROM_8_TO_16(*accum); accum++; // G 334 wIn[0] = FROM_8_TO_16(*accum); accum++; // R 335 336 return accum; 337 338 cmsUNUSED_PARAMETER(info); 339 cmsUNUSED_PARAMETER(Stride); 340 } 341 342 static 343 cmsUInt8Number* UnrollLabV2_8(register _cmsTRANSFORM* info, 344 register cmsUInt16Number wIn[], 345 register cmsUInt8Number* accum, 346 register cmsUInt32Number Stride) 347 { 348 wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // L 349 wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // a 350 wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b 351 352 return accum; 353 354 cmsUNUSED_PARAMETER(info); 355 cmsUNUSED_PARAMETER(Stride); 356 } 357 358 static 359 cmsUInt8Number* UnrollALabV2_8(register _cmsTRANSFORM* info, 360 register cmsUInt16Number wIn[], 361 register cmsUInt8Number* accum, 362 register cmsUInt32Number Stride) 363 { 364 accum++; // A 365 wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // L 366 wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // a 367 wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b 368 369 return accum; 370 371 cmsUNUSED_PARAMETER(info); 372 cmsUNUSED_PARAMETER(Stride); 373 } 374 375 static 376 cmsUInt8Number* UnrollLabV2_16(register _cmsTRANSFORM* info, 377 register cmsUInt16Number wIn[], 378 register cmsUInt8Number* accum, 379 register cmsUInt32Number Stride) 380 { 381 wIn[0] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // L 382 wIn[1] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // a 383 wIn[2] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // b 384 385 return accum; 386 387 cmsUNUSED_PARAMETER(info); 388 cmsUNUSED_PARAMETER(Stride); 389 } 390 391 // for duplex 392 static 393 cmsUInt8Number* Unroll2Bytes(register _cmsTRANSFORM* info, 394 register cmsUInt16Number wIn[], 395 register cmsUInt8Number* accum, 396 register cmsUInt32Number Stride) 397 { 398 wIn[0] = FROM_8_TO_16(*accum); accum++; // ch1 399 wIn[1] = FROM_8_TO_16(*accum); accum++; // ch2 400 401 return accum; 402 403 cmsUNUSED_PARAMETER(info); 404 cmsUNUSED_PARAMETER(Stride); 405 } 406 407 408 409 410 // Monochrome duplicates L into RGB for null-transforms 411 static 412 cmsUInt8Number* Unroll1Byte(register _cmsTRANSFORM* info, 413 register cmsUInt16Number wIn[], 414 register cmsUInt8Number* accum, 415 register cmsUInt32Number Stride) 416 { 417 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L 418 419 return accum; 420 421 cmsUNUSED_PARAMETER(info); 422 cmsUNUSED_PARAMETER(Stride); 423 } 424 425 426 static 427 cmsUInt8Number* Unroll1ByteSkip1(register _cmsTRANSFORM* info, 428 register cmsUInt16Number wIn[], 429 register cmsUInt8Number* accum, 430 register cmsUInt32Number Stride) 431 { 432 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L 433 accum += 1; 434 435 return accum; 436 437 cmsUNUSED_PARAMETER(info); 438 cmsUNUSED_PARAMETER(Stride); 439 } 440 441 static 442 cmsUInt8Number* Unroll1ByteSkip2(register _cmsTRANSFORM* info, 443 register cmsUInt16Number wIn[], 444 register cmsUInt8Number* accum, 445 register cmsUInt32Number Stride) 446 { 447 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L 448 accum += 2; 449 450 return accum; 451 452 cmsUNUSED_PARAMETER(info); 453 cmsUNUSED_PARAMETER(Stride); 454 } 455 456 static 457 cmsUInt8Number* Unroll1ByteReversed(register _cmsTRANSFORM* info, 458 register cmsUInt16Number wIn[], 459 register cmsUInt8Number* accum, 460 register cmsUInt32Number Stride) 461 { 462 wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(FROM_8_TO_16(*accum)); accum++; // L 463 464 return accum; 465 466 cmsUNUSED_PARAMETER(info); 467 cmsUNUSED_PARAMETER(Stride); 468 } 469 470 471 static 472 cmsUInt8Number* UnrollAnyWords(register _cmsTRANSFORM* info, 473 register cmsUInt16Number wIn[], 474 register cmsUInt8Number* accum, 475 register cmsUInt32Number Stride) 476 { 477 int nChan = T_CHANNELS(info -> InputFormat); 478 int SwapEndian = T_ENDIAN16(info -> InputFormat); 479 int DoSwap = T_DOSWAP(info ->InputFormat); 480 int Reverse = T_FLAVOR(info ->InputFormat); 481 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 482 int Extra = T_EXTRA(info -> InputFormat); 483 int ExtraFirst = DoSwap ^ SwapFirst; 484 int i; 485 486 if (ExtraFirst) { 487 accum += Extra * sizeof(cmsUInt16Number); 488 } 489 490 for (i=0; i < nChan; i++) { 491 492 int index = DoSwap ? (nChan - i - 1) : i; 493 cmsUInt16Number v = *(cmsUInt16Number*) accum; 494 495 if (SwapEndian) 496 v = CHANGE_ENDIAN(v); 497 498 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v; 499 500 accum += sizeof(cmsUInt16Number); 501 } 502 503 if (!ExtraFirst) { 504 accum += Extra * sizeof(cmsUInt16Number); 505 } 506 507 if (Extra == 0 && SwapFirst) { 508 509 cmsUInt16Number tmp = wIn[0]; 510 511 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number)); 512 wIn[nChan-1] = tmp; 513 } 514 515 return accum; 516 517 cmsUNUSED_PARAMETER(Stride); 518 } 519 520 static 521 cmsUInt8Number* UnrollPlanarWords(register _cmsTRANSFORM* info, 522 register cmsUInt16Number wIn[], 523 register cmsUInt8Number* accum, 524 register cmsUInt32Number Stride) 525 { 526 int nChan = T_CHANNELS(info -> InputFormat); 527 int DoSwap= T_DOSWAP(info ->InputFormat); 528 int Reverse= T_FLAVOR(info ->InputFormat); 529 int SwapEndian = T_ENDIAN16(info -> InputFormat); 530 int i; 531 cmsUInt8Number* Init = accum; 532 533 if (DoSwap) { 534 accum += T_EXTRA(info -> InputFormat) * Stride * sizeof(cmsUInt16Number); 535 } 536 537 for (i=0; i < nChan; i++) { 538 539 int index = DoSwap ? (nChan - i - 1) : i; 540 cmsUInt16Number v = *(cmsUInt16Number*) accum; 541 542 if (SwapEndian) 543 v = CHANGE_ENDIAN(v); 544 545 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v; 546 547 accum += Stride * sizeof(cmsUInt16Number); 548 } 549 550 return (Init + sizeof(cmsUInt16Number)); 551 } 552 553 554 static 555 cmsUInt8Number* Unroll4Words(register _cmsTRANSFORM* info, 556 register cmsUInt16Number wIn[], 557 register cmsUInt8Number* accum, 558 register cmsUInt32Number Stride) 559 { 560 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C 561 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M 562 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y 563 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K 564 565 return accum; 566 567 cmsUNUSED_PARAMETER(info); 568 cmsUNUSED_PARAMETER(Stride); 569 } 570 571 static 572 cmsUInt8Number* Unroll4WordsReverse(register _cmsTRANSFORM* info, 573 register cmsUInt16Number wIn[], 574 register cmsUInt8Number* accum, 575 register cmsUInt32Number Stride) 576 { 577 wIn[0] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // C 578 wIn[1] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // M 579 wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // Y 580 wIn[3] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // K 581 582 return accum; 583 584 cmsUNUSED_PARAMETER(info); 585 cmsUNUSED_PARAMETER(Stride); 586 } 587 588 static 589 cmsUInt8Number* Unroll4WordsSwapFirst(register _cmsTRANSFORM* info, 590 register cmsUInt16Number wIn[], 591 register cmsUInt8Number* accum, 592 register cmsUInt32Number Stride) 593 { 594 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K 595 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C 596 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M 597 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y 598 599 return accum; 600 601 cmsUNUSED_PARAMETER(info); 602 cmsUNUSED_PARAMETER(Stride); 603 } 604 605 // KYMC 606 static 607 cmsUInt8Number* Unroll4WordsSwap(register _cmsTRANSFORM* info, 608 register cmsUInt16Number wIn[], 609 register cmsUInt8Number* accum, 610 register cmsUInt32Number Stride) 611 { 612 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K 613 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y 614 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M 615 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C 616 617 return accum; 618 619 cmsUNUSED_PARAMETER(info); 620 cmsUNUSED_PARAMETER(Stride); 621 } 622 623 static 624 cmsUInt8Number* Unroll4WordsSwapSwapFirst(register _cmsTRANSFORM* info, 625 register cmsUInt16Number wIn[], 626 register cmsUInt8Number* accum, 627 register cmsUInt32Number Stride) 628 { 629 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // K 630 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // Y 631 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // M 632 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // C 633 634 return accum; 635 636 cmsUNUSED_PARAMETER(info); 637 cmsUNUSED_PARAMETER(Stride); 638 } 639 640 static 641 cmsUInt8Number* Unroll3Words(register _cmsTRANSFORM* info, 642 register cmsUInt16Number wIn[], 643 register cmsUInt8Number* accum, 644 register cmsUInt32Number Stride) 645 { 646 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C R 647 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G 648 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y B 649 650 return accum; 651 652 cmsUNUSED_PARAMETER(info); 653 cmsUNUSED_PARAMETER(Stride); 654 } 655 656 static 657 cmsUInt8Number* Unroll3WordsSwap(register _cmsTRANSFORM* info, 658 register cmsUInt16Number wIn[], 659 register cmsUInt8Number* accum, 660 register cmsUInt32Number Stride) 661 { 662 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // C R 663 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G 664 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // Y B 665 666 return accum; 667 668 cmsUNUSED_PARAMETER(info); 669 cmsUNUSED_PARAMETER(Stride); 670 } 671 672 static 673 cmsUInt8Number* Unroll3WordsSkip1Swap(register _cmsTRANSFORM* info, 674 register cmsUInt16Number wIn[], 675 register cmsUInt8Number* accum, 676 register cmsUInt32Number Stride) 677 { 678 accum += 2; // A 679 wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // R 680 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // G 681 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // B 682 683 return accum; 684 685 cmsUNUSED_PARAMETER(info); 686 cmsUNUSED_PARAMETER(Stride); 687 } 688 689 static 690 cmsUInt8Number* Unroll3WordsSkip1SwapFirst(register _cmsTRANSFORM* info, 691 register cmsUInt16Number wIn[], 692 register cmsUInt8Number* accum, 693 register cmsUInt32Number Stride) 694 { 695 accum += 2; // A 696 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // R 697 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // G 698 wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // B 699 700 return accum; 701 702 cmsUNUSED_PARAMETER(info); 703 cmsUNUSED_PARAMETER(Stride); 704 } 705 706 static 707 cmsUInt8Number* Unroll1Word(register _cmsTRANSFORM* info, 708 register cmsUInt16Number wIn[], 709 register cmsUInt8Number* accum, 710 register cmsUInt32Number Stride) 711 { 712 wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // L 713 714 return accum; 715 716 cmsUNUSED_PARAMETER(info); 717 cmsUNUSED_PARAMETER(Stride); 718 } 719 720 static 721 cmsUInt8Number* Unroll1WordReversed(register _cmsTRANSFORM* info, 722 register cmsUInt16Number wIn[], 723 register cmsUInt8Number* accum, 724 register cmsUInt32Number Stride) 725 { 726 wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; 727 728 return accum; 729 730 cmsUNUSED_PARAMETER(info); 731 cmsUNUSED_PARAMETER(Stride); 732 } 733 734 static 735 cmsUInt8Number* Unroll1WordSkip3(register _cmsTRANSFORM* info, 736 register cmsUInt16Number wIn[], 737 register cmsUInt8Number* accum, 738 register cmsUInt32Number Stride) 739 { 740 wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum; 741 742 accum += 8; 743 744 return accum; 745 746 cmsUNUSED_PARAMETER(info); 747 cmsUNUSED_PARAMETER(Stride); 748 } 749 750 static 751 cmsUInt8Number* Unroll2Words(register _cmsTRANSFORM* info, 752 register cmsUInt16Number wIn[], 753 register cmsUInt8Number* accum, 754 register cmsUInt32Number Stride) 755 { 756 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // ch1 757 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // ch2 758 759 return accum; 760 761 cmsUNUSED_PARAMETER(info); 762 cmsUNUSED_PARAMETER(Stride); 763 } 764 765 766 // This is a conversion of Lab double to 16 bits 767 static 768 cmsUInt8Number* UnrollLabDoubleTo16(register _cmsTRANSFORM* info, 769 register cmsUInt16Number wIn[], 770 register cmsUInt8Number* accum, 771 register cmsUInt32Number Stride) 772 { 773 if (T_PLANAR(info -> InputFormat)) { 774 775 cmsFloat64Number* Pt = (cmsFloat64Number*) accum; 776 777 cmsCIELab Lab; 778 779 Lab.L = Pt[0]; 780 Lab.a = Pt[Stride]; 781 Lab.b = Pt[Stride*2]; 782 783 cmsFloat2LabEncoded(wIn, &Lab); 784 return accum + sizeof(cmsFloat64Number); 785 } 786 else { 787 788 cmsFloat2LabEncoded(wIn, (cmsCIELab*) accum); 789 accum += sizeof(cmsCIELab) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat64Number); 790 return accum; 791 } 792 } 793 794 795 // This is a conversion of Lab float to 16 bits 796 static 797 cmsUInt8Number* UnrollLabFloatTo16(register _cmsTRANSFORM* info, 798 register cmsUInt16Number wIn[], 799 register cmsUInt8Number* accum, 800 register cmsUInt32Number Stride) 801 { 802 cmsCIELab Lab; 803 804 if (T_PLANAR(info -> InputFormat)) { 805 806 cmsFloat32Number* Pt = (cmsFloat32Number*) accum; 807 808 809 Lab.L = Pt[0]; 810 Lab.a = Pt[Stride]; 811 Lab.b = Pt[Stride*2]; 812 813 cmsFloat2LabEncoded(wIn, &Lab); 814 return accum + sizeof(cmsFloat32Number); 815 } 816 else { 817 818 Lab.L = ((cmsFloat32Number*) accum)[0]; 819 Lab.a = ((cmsFloat32Number*) accum)[1]; 820 Lab.b = ((cmsFloat32Number*) accum)[2]; 821 822 cmsFloat2LabEncoded(wIn, &Lab); 823 accum += (3 + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat32Number); 824 return accum; 825 } 826 } 827 828 // This is a conversion of XYZ double to 16 bits 829 static 830 cmsUInt8Number* UnrollXYZDoubleTo16(register _cmsTRANSFORM* info, 831 register cmsUInt16Number wIn[], 832 register cmsUInt8Number* accum, 833 register cmsUInt32Number Stride) 834 { 835 if (T_PLANAR(info -> InputFormat)) { 836 837 cmsFloat64Number* Pt = (cmsFloat64Number*) accum; 838 cmsCIEXYZ XYZ; 839 840 XYZ.X = Pt[0]; 841 XYZ.Y = Pt[Stride]; 842 XYZ.Z = Pt[Stride*2]; 843 cmsFloat2XYZEncoded(wIn, &XYZ); 844 845 return accum + sizeof(cmsFloat64Number); 846 847 } 848 849 else { 850 cmsFloat2XYZEncoded(wIn, (cmsCIEXYZ*) accum); 851 accum += sizeof(cmsCIEXYZ) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat64Number); 852 853 return accum; 854 } 855 } 856 857 // This is a conversion of XYZ float to 16 bits 858 static 859 cmsUInt8Number* UnrollXYZFloatTo16(register _cmsTRANSFORM* info, 860 register cmsUInt16Number wIn[], 861 register cmsUInt8Number* accum, 862 register cmsUInt32Number Stride) 863 { 864 if (T_PLANAR(info -> InputFormat)) { 865 866 cmsFloat32Number* Pt = (cmsFloat32Number*) accum; 867 cmsCIEXYZ XYZ; 868 869 XYZ.X = Pt[0]; 870 XYZ.Y = Pt[Stride]; 871 XYZ.Z = Pt[Stride*2]; 872 cmsFloat2XYZEncoded(wIn, &XYZ); 873 874 return accum + sizeof(cmsFloat32Number); 875 876 } 877 878 else { 879 cmsFloat32Number* Pt = (cmsFloat32Number*) accum; 880 cmsCIEXYZ XYZ; 881 882 XYZ.X = Pt[0]; 883 XYZ.Y = Pt[1]; 884 XYZ.Z = Pt[2]; 885 cmsFloat2XYZEncoded(wIn, &XYZ); 886 887 accum += 3 * sizeof(cmsFloat32Number) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat32Number); 888 889 return accum; 890 } 891 } 892 893 // Check if space is marked as ink 894 cmsINLINE cmsBool IsInkSpace(cmsUInt32Number Type) 895 { 896 switch (T_COLORSPACE(Type)) { 897 898 case PT_CMY: 899 case PT_CMYK: 900 case PT_MCH5: 901 case PT_MCH6: 902 case PT_MCH7: 903 case PT_MCH8: 904 case PT_MCH9: 905 case PT_MCH10: 906 case PT_MCH11: 907 case PT_MCH12: 908 case PT_MCH13: 909 case PT_MCH14: 910 case PT_MCH15: return TRUE; 911 912 default: return FALSE; 913 } 914 } 915 916 // Inks does come in percentage, remaining cases are between 0..1.0, again to 16 bits 917 static 918 cmsUInt8Number* UnrollDoubleTo16(register _cmsTRANSFORM* info, 919 register cmsUInt16Number wIn[], 920 register cmsUInt8Number* accum, 921 register cmsUInt32Number Stride) 922 { 923 924 int nChan = T_CHANNELS(info -> InputFormat); 925 int DoSwap = T_DOSWAP(info ->InputFormat); 926 int Reverse = T_FLAVOR(info ->InputFormat); 927 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 928 int Extra = T_EXTRA(info -> InputFormat); 929 int ExtraFirst = DoSwap ^ SwapFirst; 930 int Planar = T_PLANAR(info -> InputFormat); 931 cmsFloat64Number v; 932 cmsUInt16Number vi; 933 int i, start = 0; 934 cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0; 935 936 937 if (ExtraFirst) 938 start = Extra; 939 940 for (i=0; i < nChan; i++) { 941 942 int index = DoSwap ? (nChan - i - 1) : i; 943 944 if (Planar) 945 v = (cmsFloat32Number) ((cmsFloat64Number*) accum)[(i + start) * Stride]; 946 else 947 v = (cmsFloat32Number) ((cmsFloat64Number*) accum)[i + start]; 948 949 vi = _cmsQuickSaturateWord(v * maximum); 950 951 if (Reverse) 952 vi = REVERSE_FLAVOR_16(vi); 953 954 wIn[index] = vi; 955 } 956 957 958 if (Extra == 0 && SwapFirst) { 959 cmsUInt16Number tmp = wIn[0]; 960 961 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number)); 962 wIn[nChan-1] = tmp; 963 } 964 965 if (T_PLANAR(info -> InputFormat)) 966 return accum + sizeof(cmsFloat64Number); 967 else 968 return accum + (nChan + Extra) * sizeof(cmsFloat64Number); 969 } 970 971 972 973 static 974 cmsUInt8Number* UnrollFloatTo16(register _cmsTRANSFORM* info, 975 register cmsUInt16Number wIn[], 976 register cmsUInt8Number* accum, 977 register cmsUInt32Number Stride) 978 { 979 980 int nChan = T_CHANNELS(info -> InputFormat); 981 int DoSwap = T_DOSWAP(info ->InputFormat); 982 int Reverse = T_FLAVOR(info ->InputFormat); 983 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 984 int Extra = T_EXTRA(info -> InputFormat); 985 int ExtraFirst = DoSwap ^ SwapFirst; 986 int Planar = T_PLANAR(info -> InputFormat); 987 cmsFloat32Number v; 988 cmsUInt16Number vi; 989 int i, start = 0; 990 cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0; 991 992 993 if (ExtraFirst) 994 start = Extra; 995 996 for (i=0; i < nChan; i++) { 997 998 int index = DoSwap ? (nChan - i - 1) : i; 999 1000 if (Planar) 1001 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[(i + start) * Stride]; 1002 else 1003 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[i + start]; 1004 1005 vi = _cmsQuickSaturateWord(v * maximum); 1006 1007 if (Reverse) 1008 vi = REVERSE_FLAVOR_16(vi); 1009 1010 wIn[index] = vi; 1011 } 1012 1013 1014 if (Extra == 0 && SwapFirst) { 1015 cmsUInt16Number tmp = wIn[0]; 1016 1017 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number)); 1018 wIn[nChan-1] = tmp; 1019 } 1020 1021 if (T_PLANAR(info -> InputFormat)) 1022 return accum + sizeof(cmsFloat32Number); 1023 else 1024 return accum + (nChan + Extra) * sizeof(cmsFloat32Number); 1025 } 1026 1027 1028 1029 1030 // For 1 channel, we need to duplicate data (it comes in 0..1.0 range) 1031 static 1032 cmsUInt8Number* UnrollDouble1Chan(register _cmsTRANSFORM* info, 1033 register cmsUInt16Number wIn[], 1034 register cmsUInt8Number* accum, 1035 register cmsUInt32Number Stride) 1036 { 1037 cmsFloat64Number* Inks = (cmsFloat64Number*) accum; 1038 1039 wIn[0] = wIn[1] = wIn[2] = _cmsQuickSaturateWord(Inks[0] * 65535.0); 1040 1041 return accum + sizeof(cmsFloat64Number); 1042 1043 cmsUNUSED_PARAMETER(info); 1044 cmsUNUSED_PARAMETER(Stride); 1045 } 1046 1047 //------------------------------------------------------------------------------------------------------------------- 1048 1049 // For anything going from cmsFloat32Number 1050 static 1051 cmsUInt8Number* UnrollFloatsToFloat(_cmsTRANSFORM* info, 1052 cmsFloat32Number wIn[], 1053 cmsUInt8Number* accum, 1054 cmsUInt32Number Stride) 1055 { 1056 1057 int nChan = T_CHANNELS(info -> InputFormat); 1058 int DoSwap = T_DOSWAP(info ->InputFormat); 1059 int Reverse = T_FLAVOR(info ->InputFormat); 1060 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 1061 int Extra = T_EXTRA(info -> InputFormat); 1062 int ExtraFirst = DoSwap ^ SwapFirst; 1063 int Planar = T_PLANAR(info -> InputFormat); 1064 cmsFloat32Number v; 1065 int i, start = 0; 1066 cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 100.0F : 1.0F; 1067 1068 1069 if (ExtraFirst) 1070 start = Extra; 1071 1072 for (i=0; i < nChan; i++) { 1073 1074 int index = DoSwap ? (nChan - i - 1) : i; 1075 1076 if (Planar) 1077 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[(i + start) * Stride]; 1078 else 1079 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[i + start]; 1080 1081 v /= maximum; 1082 1083 wIn[index] = Reverse ? 1 - v : v; 1084 } 1085 1086 1087 if (Extra == 0 && SwapFirst) { 1088 cmsFloat32Number tmp = wIn[0]; 1089 1090 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number)); 1091 wIn[nChan-1] = tmp; 1092 } 1093 1094 if (T_PLANAR(info -> InputFormat)) 1095 return accum + sizeof(cmsFloat32Number); 1096 else 1097 return accum + (nChan + Extra) * sizeof(cmsFloat32Number); 1098 } 1099 1100 // For anything going from double 1101 1102 static 1103 cmsUInt8Number* UnrollDoublesToFloat(_cmsTRANSFORM* info, 1104 cmsFloat32Number wIn[], 1105 cmsUInt8Number* accum, 1106 cmsUInt32Number Stride) 1107 { 1108 1109 int nChan = T_CHANNELS(info -> InputFormat); 1110 int DoSwap = T_DOSWAP(info ->InputFormat); 1111 int Reverse = T_FLAVOR(info ->InputFormat); 1112 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 1113 int Extra = T_EXTRA(info -> InputFormat); 1114 int ExtraFirst = DoSwap ^ SwapFirst; 1115 int Planar = T_PLANAR(info -> InputFormat); 1116 cmsFloat64Number v; 1117 int i, start = 0; 1118 cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 100.0 : 1.0; 1119 1120 1121 if (ExtraFirst) 1122 start = Extra; 1123 1124 for (i=0; i < nChan; i++) { 1125 1126 int index = DoSwap ? (nChan - i - 1) : i; 1127 1128 if (Planar) 1129 v = (cmsFloat64Number) ((cmsFloat64Number*) accum)[(i + start) * Stride]; 1130 else 1131 v = (cmsFloat64Number) ((cmsFloat64Number*) accum)[i + start]; 1132 1133 v /= maximum; 1134 1135 wIn[index] = (cmsFloat32Number) (Reverse ? 1.0 - v : v); 1136 } 1137 1138 1139 if (Extra == 0 && SwapFirst) { 1140 cmsFloat32Number tmp = wIn[0]; 1141 1142 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number)); 1143 wIn[nChan-1] = tmp; 1144 } 1145 1146 if (T_PLANAR(info -> InputFormat)) 1147 return accum + sizeof(cmsFloat64Number); 1148 else 1149 return accum + (nChan + Extra) * sizeof(cmsFloat64Number); 1150 } 1151 1152 1153 1154 // From Lab double to cmsFloat32Number 1155 static 1156 cmsUInt8Number* UnrollLabDoubleToFloat(_cmsTRANSFORM* info, 1157 cmsFloat32Number wIn[], 1158 cmsUInt8Number* accum, 1159 cmsUInt32Number Stride) 1160 { 1161 cmsFloat64Number* Pt = (cmsFloat64Number*) accum; 1162 1163 if (T_PLANAR(info -> InputFormat)) { 1164 1165 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1 1166 wIn[1] = (cmsFloat32Number) ((Pt[Stride] + 128) / 255.0); // form -128..+127 to 0..1 1167 wIn[2] = (cmsFloat32Number) ((Pt[Stride*2] + 128) / 255.0); 1168 1169 return accum + sizeof(cmsFloat64Number); 1170 } 1171 else { 1172 1173 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1 1174 wIn[1] = (cmsFloat32Number) ((Pt[1] + 128) / 255.0); // form -128..+127 to 0..1 1175 wIn[2] = (cmsFloat32Number) ((Pt[2] + 128) / 255.0); 1176 1177 accum += sizeof(cmsFloat64Number)*(3 + T_EXTRA(info ->InputFormat)); 1178 return accum; 1179 } 1180 } 1181 1182 // From Lab double to cmsFloat32Number 1183 static 1184 cmsUInt8Number* UnrollLabFloatToFloat(_cmsTRANSFORM* info, 1185 cmsFloat32Number wIn[], 1186 cmsUInt8Number* accum, 1187 cmsUInt32Number Stride) 1188 { 1189 cmsFloat32Number* Pt = (cmsFloat32Number*) accum; 1190 1191 if (T_PLANAR(info -> InputFormat)) { 1192 1193 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1 1194 wIn[1] = (cmsFloat32Number) ((Pt[Stride] + 128) / 255.0); // form -128..+127 to 0..1 1195 wIn[2] = (cmsFloat32Number) ((Pt[Stride*2] + 128) / 255.0); 1196 1197 return accum + sizeof(cmsFloat32Number); 1198 } 1199 else { 1200 1201 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1 1202 wIn[1] = (cmsFloat32Number) ((Pt[1] + 128) / 255.0); // form -128..+127 to 0..1 1203 wIn[2] = (cmsFloat32Number) ((Pt[2] + 128) / 255.0); 1204 1205 accum += sizeof(cmsFloat32Number)*(3 + T_EXTRA(info ->InputFormat)); 1206 return accum; 1207 } 1208 } 1209 1210 1211 1212 // 1.15 fixed point, that means maximum value is MAX_ENCODEABLE_XYZ (0xFFFF) 1213 static 1214 cmsUInt8Number* UnrollXYZDoubleToFloat(_cmsTRANSFORM* info, 1215 cmsFloat32Number wIn[], 1216 cmsUInt8Number* accum, 1217 cmsUInt32Number Stride) 1218 { 1219 cmsFloat64Number* Pt = (cmsFloat64Number*) accum; 1220 1221 if (T_PLANAR(info -> InputFormat)) { 1222 1223 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ); 1224 wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ); 1225 wIn[2] = (cmsFloat32Number) (Pt[Stride*2] / MAX_ENCODEABLE_XYZ); 1226 1227 return accum + sizeof(cmsFloat64Number); 1228 } 1229 else { 1230 1231 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ); 1232 wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ); 1233 wIn[2] = (cmsFloat32Number) (Pt[2] / MAX_ENCODEABLE_XYZ); 1234 1235 accum += sizeof(cmsFloat64Number)*(3 + T_EXTRA(info ->InputFormat)); 1236 return accum; 1237 } 1238 } 1239 1240 static 1241 cmsUInt8Number* UnrollXYZFloatToFloat(_cmsTRANSFORM* info, 1242 cmsFloat32Number wIn[], 1243 cmsUInt8Number* accum, 1244 cmsUInt32Number Stride) 1245 { 1246 cmsFloat32Number* Pt = (cmsFloat32Number*) accum; 1247 1248 if (T_PLANAR(info -> InputFormat)) { 1249 1250 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ); 1251 wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ); 1252 wIn[2] = (cmsFloat32Number) (Pt[Stride*2] / MAX_ENCODEABLE_XYZ); 1253 1254 return accum + sizeof(cmsFloat32Number); 1255 } 1256 else { 1257 1258 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ); 1259 wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ); 1260 wIn[2] = (cmsFloat32Number) (Pt[2] / MAX_ENCODEABLE_XYZ); 1261 1262 accum += sizeof(cmsFloat32Number)*(3 + T_EXTRA(info ->InputFormat)); 1263 return accum; 1264 } 1265 } 1266 1267 1268 1269 // Packing routines ----------------------------------------------------------------------------------------------------------- 1270 1271 1272 // Generic chunky for byte 1273 1274 static 1275 cmsUInt8Number* PackAnyBytes(register _cmsTRANSFORM* info, 1276 register cmsUInt16Number wOut[], 1277 register cmsUInt8Number* output, 1278 register cmsUInt32Number Stride) 1279 { 1280 int nChan = T_CHANNELS(info -> OutputFormat); 1281 int DoSwap = T_DOSWAP(info ->OutputFormat); 1282 int Reverse = T_FLAVOR(info ->OutputFormat); 1283 int Extra = T_EXTRA(info -> OutputFormat); 1284 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 1285 int ExtraFirst = DoSwap ^ SwapFirst; 1286 cmsUInt8Number* swap1; 1287 cmsUInt8Number v = 0; 1288 int i; 1289 1290 swap1 = output; 1291 1292 if (ExtraFirst) { 1293 output += Extra; 1294 } 1295 1296 for (i=0; i < nChan; i++) { 1297 1298 int index = DoSwap ? (nChan - i - 1) : i; 1299 1300 v = FROM_16_TO_8(wOut[index]); 1301 1302 if (Reverse) 1303 v = REVERSE_FLAVOR_8(v); 1304 1305 *output++ = v; 1306 } 1307 1308 if (!ExtraFirst) { 1309 output += Extra; 1310 } 1311 1312 if (Extra == 0 && SwapFirst) { 1313 1314 memmove(swap1 + 1, swap1, nChan-1); 1315 *swap1 = v; 1316 } 1317 1318 1319 return output; 1320 1321 cmsUNUSED_PARAMETER(Stride); 1322 } 1323 1324 1325 1326 static 1327 cmsUInt8Number* PackAnyWords(register _cmsTRANSFORM* info, 1328 register cmsUInt16Number wOut[], 1329 register cmsUInt8Number* output, 1330 register cmsUInt32Number Stride) 1331 { 1332 int nChan = T_CHANNELS(info -> OutputFormat); 1333 int SwapEndian = T_ENDIAN16(info -> InputFormat); 1334 int DoSwap = T_DOSWAP(info ->OutputFormat); 1335 int Reverse = T_FLAVOR(info ->OutputFormat); 1336 int Extra = T_EXTRA(info -> OutputFormat); 1337 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 1338 int ExtraFirst = DoSwap ^ SwapFirst; 1339 cmsUInt16Number* swap1; 1340 cmsUInt16Number v = 0; 1341 int i; 1342 1343 swap1 = (cmsUInt16Number*) output; 1344 1345 if (ExtraFirst) { 1346 output += Extra * sizeof(cmsUInt16Number); 1347 } 1348 1349 for (i=0; i < nChan; i++) { 1350 1351 int index = DoSwap ? (nChan - i - 1) : i; 1352 1353 v = wOut[index]; 1354 1355 if (SwapEndian) 1356 v = CHANGE_ENDIAN(v); 1357 1358 if (Reverse) 1359 v = REVERSE_FLAVOR_16(v); 1360 1361 *(cmsUInt16Number*) output = v; 1362 1363 output += sizeof(cmsUInt16Number); 1364 } 1365 1366 if (!ExtraFirst) { 1367 output += Extra * sizeof(cmsUInt16Number); 1368 } 1369 1370 if (Extra == 0 && SwapFirst) { 1371 1372 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number)); 1373 *swap1 = v; 1374 } 1375 1376 1377 return output; 1378 1379 cmsUNUSED_PARAMETER(Stride); 1380 } 1381 1382 1383 static 1384 cmsUInt8Number* PackPlanarBytes(register _cmsTRANSFORM* info, 1385 register cmsUInt16Number wOut[], 1386 register cmsUInt8Number* output, 1387 register cmsUInt32Number Stride) 1388 { 1389 int nChan = T_CHANNELS(info -> OutputFormat); 1390 int DoSwap = T_DOSWAP(info ->OutputFormat); 1391 int SwapFirst = T_SWAPFIRST(info ->OutputFormat); 1392 int Reverse = T_FLAVOR(info ->OutputFormat); 1393 int i; 1394 cmsUInt8Number* Init = output; 1395 1396 1397 if (DoSwap ^ SwapFirst) { 1398 output += T_EXTRA(info -> OutputFormat) * Stride; 1399 } 1400 1401 1402 for (i=0; i < nChan; i++) { 1403 1404 int index = DoSwap ? (nChan - i - 1) : i; 1405 cmsUInt8Number v = FROM_16_TO_8(wOut[index]); 1406 1407 *(cmsUInt8Number*) output = (cmsUInt8Number) (Reverse ? REVERSE_FLAVOR_8(v) : v); 1408 output += Stride; 1409 } 1410 1411 return (Init + 1); 1412 1413 cmsUNUSED_PARAMETER(Stride); 1414 } 1415 1416 1417 static 1418 cmsUInt8Number* PackPlanarWords(register _cmsTRANSFORM* info, 1419 register cmsUInt16Number wOut[], 1420 register cmsUInt8Number* output, 1421 register cmsUInt32Number Stride) 1422 { 1423 int nChan = T_CHANNELS(info -> OutputFormat); 1424 int DoSwap = T_DOSWAP(info ->OutputFormat); 1425 int Reverse= T_FLAVOR(info ->OutputFormat); 1426 int SwapEndian = T_ENDIAN16(info -> OutputFormat); 1427 int i; 1428 cmsUInt8Number* Init = output; 1429 cmsUInt16Number v; 1430 1431 if (DoSwap) { 1432 output += T_EXTRA(info -> OutputFormat) * Stride * sizeof(cmsUInt16Number); 1433 } 1434 1435 for (i=0; i < nChan; i++) { 1436 1437 int index = DoSwap ? (nChan - i - 1) : i; 1438 1439 v = wOut[index]; 1440 1441 if (SwapEndian) 1442 v = CHANGE_ENDIAN(v); 1443 1444 if (Reverse) 1445 v = REVERSE_FLAVOR_16(v); 1446 1447 *(cmsUInt16Number*) output = v; 1448 output += (Stride * sizeof(cmsUInt16Number)); 1449 } 1450 1451 return (Init + sizeof(cmsUInt16Number)); 1452 } 1453 1454 // CMYKcm (unrolled for speed) 1455 1456 static 1457 cmsUInt8Number* Pack6Bytes(register _cmsTRANSFORM* info, 1458 register cmsUInt16Number wOut[], 1459 register cmsUInt8Number* output, 1460 register cmsUInt32Number Stride) 1461 { 1462 *output++ = FROM_16_TO_8(wOut[0]); 1463 *output++ = FROM_16_TO_8(wOut[1]); 1464 *output++ = FROM_16_TO_8(wOut[2]); 1465 *output++ = FROM_16_TO_8(wOut[3]); 1466 *output++ = FROM_16_TO_8(wOut[4]); 1467 *output++ = FROM_16_TO_8(wOut[5]); 1468 1469 return output; 1470 1471 cmsUNUSED_PARAMETER(info); 1472 cmsUNUSED_PARAMETER(Stride); 1473 } 1474 1475 // KCMYcm 1476 1477 static 1478 cmsUInt8Number* Pack6BytesSwap(register _cmsTRANSFORM* info, 1479 register cmsUInt16Number wOut[], 1480 register cmsUInt8Number* output, 1481 register cmsUInt32Number Stride) 1482 { 1483 *output++ = FROM_16_TO_8(wOut[5]); 1484 *output++ = FROM_16_TO_8(wOut[4]); 1485 *output++ = FROM_16_TO_8(wOut[3]); 1486 *output++ = FROM_16_TO_8(wOut[2]); 1487 *output++ = FROM_16_TO_8(wOut[1]); 1488 *output++ = FROM_16_TO_8(wOut[0]); 1489 1490 return output; 1491 1492 cmsUNUSED_PARAMETER(info); 1493 cmsUNUSED_PARAMETER(Stride); 1494 } 1495 1496 // CMYKcm 1497 static 1498 cmsUInt8Number* Pack6Words(register _cmsTRANSFORM* info, 1499 register cmsUInt16Number wOut[], 1500 register cmsUInt8Number* output, 1501 register cmsUInt32Number Stride) 1502 { 1503 *(cmsUInt16Number*) output = wOut[0]; 1504 output+= 2; 1505 *(cmsUInt16Number*) output = wOut[1]; 1506 output+= 2; 1507 *(cmsUInt16Number*) output = wOut[2]; 1508 output+= 2; 1509 *(cmsUInt16Number*) output = wOut[3]; 1510 output+= 2; 1511 *(cmsUInt16Number*) output = wOut[4]; 1512 output+= 2; 1513 *(cmsUInt16Number*) output = wOut[5]; 1514 output+= 2; 1515 1516 return output; 1517 1518 cmsUNUSED_PARAMETER(info); 1519 cmsUNUSED_PARAMETER(Stride); 1520 } 1521 1522 // KCMYcm 1523 static 1524 cmsUInt8Number* Pack6WordsSwap(register _cmsTRANSFORM* info, 1525 register cmsUInt16Number wOut[], 1526 register cmsUInt8Number* output, 1527 register cmsUInt32Number Stride) 1528 { 1529 *(cmsUInt16Number*) output = wOut[5]; 1530 output+= 2; 1531 *(cmsUInt16Number*) output = wOut[4]; 1532 output+= 2; 1533 *(cmsUInt16Number*) output = wOut[3]; 1534 output+= 2; 1535 *(cmsUInt16Number*) output = wOut[2]; 1536 output+= 2; 1537 *(cmsUInt16Number*) output = wOut[1]; 1538 output+= 2; 1539 *(cmsUInt16Number*) output = wOut[0]; 1540 output+= 2; 1541 1542 return output; 1543 1544 cmsUNUSED_PARAMETER(info); 1545 cmsUNUSED_PARAMETER(Stride); 1546 } 1547 1548 1549 static 1550 cmsUInt8Number* Pack4Bytes(register _cmsTRANSFORM* info, 1551 register cmsUInt16Number wOut[], 1552 register cmsUInt8Number* output, 1553 register cmsUInt32Number Stride) 1554 { 1555 *output++ = FROM_16_TO_8(wOut[0]); 1556 *output++ = FROM_16_TO_8(wOut[1]); 1557 *output++ = FROM_16_TO_8(wOut[2]); 1558 *output++ = FROM_16_TO_8(wOut[3]); 1559 1560 return output; 1561 1562 cmsUNUSED_PARAMETER(info); 1563 cmsUNUSED_PARAMETER(Stride); 1564 } 1565 1566 static 1567 cmsUInt8Number* Pack4BytesReverse(register _cmsTRANSFORM* info, 1568 register cmsUInt16Number wOut[], 1569 register cmsUInt8Number* output, 1570 register cmsUInt32Number Stride) 1571 { 1572 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[0])); 1573 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[1])); 1574 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[2])); 1575 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[3])); 1576 1577 return output; 1578 1579 cmsUNUSED_PARAMETER(info); 1580 cmsUNUSED_PARAMETER(Stride); 1581 } 1582 1583 1584 static 1585 cmsUInt8Number* Pack4BytesSwapFirst(register _cmsTRANSFORM* info, 1586 register cmsUInt16Number wOut[], 1587 register cmsUInt8Number* output, 1588 register cmsUInt32Number Stride) 1589 { 1590 *output++ = FROM_16_TO_8(wOut[3]); 1591 *output++ = FROM_16_TO_8(wOut[0]); 1592 *output++ = FROM_16_TO_8(wOut[1]); 1593 *output++ = FROM_16_TO_8(wOut[2]); 1594 1595 return output; 1596 1597 cmsUNUSED_PARAMETER(info); 1598 cmsUNUSED_PARAMETER(Stride); 1599 } 1600 1601 // ABGR 1602 static 1603 cmsUInt8Number* Pack4BytesSwap(register _cmsTRANSFORM* info, 1604 register cmsUInt16Number wOut[], 1605 register cmsUInt8Number* output, 1606 register cmsUInt32Number Stride) 1607 { 1608 *output++ = FROM_16_TO_8(wOut[3]); 1609 *output++ = FROM_16_TO_8(wOut[2]); 1610 *output++ = FROM_16_TO_8(wOut[1]); 1611 *output++ = FROM_16_TO_8(wOut[0]); 1612 1613 return output; 1614 1615 cmsUNUSED_PARAMETER(info); 1616 cmsUNUSED_PARAMETER(Stride); 1617 } 1618 1619 static 1620 cmsUInt8Number* Pack4BytesSwapSwapFirst(register _cmsTRANSFORM* info, 1621 register cmsUInt16Number wOut[], 1622 register cmsUInt8Number* output, 1623 register cmsUInt32Number Stride) 1624 { 1625 *output++ = FROM_16_TO_8(wOut[2]); 1626 *output++ = FROM_16_TO_8(wOut[1]); 1627 *output++ = FROM_16_TO_8(wOut[0]); 1628 *output++ = FROM_16_TO_8(wOut[3]); 1629 1630 return output; 1631 1632 cmsUNUSED_PARAMETER(info); 1633 cmsUNUSED_PARAMETER(Stride); 1634 } 1635 1636 static 1637 cmsUInt8Number* Pack4Words(register _cmsTRANSFORM* info, 1638 register cmsUInt16Number wOut[], 1639 register cmsUInt8Number* output, 1640 register cmsUInt32Number Stride) 1641 { 1642 *(cmsUInt16Number*) output = wOut[0]; 1643 output+= 2; 1644 *(cmsUInt16Number*) output = wOut[1]; 1645 output+= 2; 1646 *(cmsUInt16Number*) output = wOut[2]; 1647 output+= 2; 1648 *(cmsUInt16Number*) output = wOut[3]; 1649 output+= 2; 1650 1651 return output; 1652 1653 cmsUNUSED_PARAMETER(info); 1654 cmsUNUSED_PARAMETER(Stride); 1655 } 1656 1657 static 1658 cmsUInt8Number* Pack4WordsReverse(register _cmsTRANSFORM* info, 1659 register cmsUInt16Number wOut[], 1660 register cmsUInt8Number* output, 1661 register cmsUInt32Number Stride) 1662 { 1663 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]); 1664 output+= 2; 1665 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[1]); 1666 output+= 2; 1667 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[2]); 1668 output+= 2; 1669 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[3]); 1670 output+= 2; 1671 1672 return output; 1673 1674 cmsUNUSED_PARAMETER(info); 1675 cmsUNUSED_PARAMETER(Stride); 1676 } 1677 1678 // ABGR 1679 static 1680 cmsUInt8Number* Pack4WordsSwap(register _cmsTRANSFORM* info, 1681 register cmsUInt16Number wOut[], 1682 register cmsUInt8Number* output, 1683 register cmsUInt32Number Stride) 1684 { 1685 *(cmsUInt16Number*) output = wOut[3]; 1686 output+= 2; 1687 *(cmsUInt16Number*) output = wOut[2]; 1688 output+= 2; 1689 *(cmsUInt16Number*) output = wOut[1]; 1690 output+= 2; 1691 *(cmsUInt16Number*) output = wOut[0]; 1692 output+= 2; 1693 1694 return output; 1695 1696 cmsUNUSED_PARAMETER(info); 1697 cmsUNUSED_PARAMETER(Stride); 1698 } 1699 1700 // CMYK 1701 static 1702 cmsUInt8Number* Pack4WordsBigEndian(register _cmsTRANSFORM* info, 1703 register cmsUInt16Number wOut[], 1704 register cmsUInt8Number* output, 1705 register cmsUInt32Number Stride) 1706 { 1707 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]); 1708 output+= 2; 1709 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]); 1710 output+= 2; 1711 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]); 1712 output+= 2; 1713 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[3]); 1714 output+= 2; 1715 1716 return output; 1717 1718 cmsUNUSED_PARAMETER(info); 1719 cmsUNUSED_PARAMETER(Stride); 1720 } 1721 1722 1723 static 1724 cmsUInt8Number* PackLabV2_8(register _cmsTRANSFORM* info, 1725 register cmsUInt16Number wOut[], 1726 register cmsUInt8Number* output, 1727 register cmsUInt32Number Stride) 1728 { 1729 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0])); 1730 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1])); 1731 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2])); 1732 1733 return output; 1734 1735 cmsUNUSED_PARAMETER(info); 1736 cmsUNUSED_PARAMETER(Stride); 1737 } 1738 1739 static 1740 cmsUInt8Number* PackALabV2_8(register _cmsTRANSFORM* info, 1741 register cmsUInt16Number wOut[], 1742 register cmsUInt8Number* output, 1743 register cmsUInt32Number Stride) 1744 { 1745 output++; 1746 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0])); 1747 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1])); 1748 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2])); 1749 1750 return output; 1751 1752 cmsUNUSED_PARAMETER(info); 1753 cmsUNUSED_PARAMETER(Stride); 1754 } 1755 1756 static 1757 cmsUInt8Number* PackLabV2_16(register _cmsTRANSFORM* info, 1758 register cmsUInt16Number wOut[], 1759 register cmsUInt8Number* output, 1760 register cmsUInt32Number Stride) 1761 { 1762 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[0]); 1763 output += 2; 1764 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[1]); 1765 output += 2; 1766 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[2]); 1767 output += 2; 1768 1769 return output; 1770 1771 cmsUNUSED_PARAMETER(info); 1772 cmsUNUSED_PARAMETER(Stride); 1773 } 1774 1775 static 1776 cmsUInt8Number* Pack3Bytes(register _cmsTRANSFORM* info, 1777 register cmsUInt16Number wOut[], 1778 register cmsUInt8Number* output, 1779 register cmsUInt32Number Stride) 1780 { 1781 *output++ = FROM_16_TO_8(wOut[0]); 1782 *output++ = FROM_16_TO_8(wOut[1]); 1783 *output++ = FROM_16_TO_8(wOut[2]); 1784 1785 return output; 1786 1787 cmsUNUSED_PARAMETER(info); 1788 cmsUNUSED_PARAMETER(Stride); 1789 } 1790 1791 static 1792 cmsUInt8Number* Pack3BytesOptimized(register _cmsTRANSFORM* info, 1793 register cmsUInt16Number wOut[], 1794 register cmsUInt8Number* output, 1795 register cmsUInt32Number Stride) 1796 { 1797 *output++ = (wOut[0] & 0xFF); 1798 *output++ = (wOut[1] & 0xFF); 1799 *output++ = (wOut[2] & 0xFF); 1800 1801 return output; 1802 1803 cmsUNUSED_PARAMETER(info); 1804 cmsUNUSED_PARAMETER(Stride); 1805 } 1806 1807 static 1808 cmsUInt8Number* Pack3BytesSwap(register _cmsTRANSFORM* info, 1809 register cmsUInt16Number wOut[], 1810 register cmsUInt8Number* output, 1811 register cmsUInt32Number Stride) 1812 { 1813 *output++ = FROM_16_TO_8(wOut[2]); 1814 *output++ = FROM_16_TO_8(wOut[1]); 1815 *output++ = FROM_16_TO_8(wOut[0]); 1816 1817 return output; 1818 1819 cmsUNUSED_PARAMETER(info); 1820 cmsUNUSED_PARAMETER(Stride); 1821 } 1822 1823 static 1824 cmsUInt8Number* Pack3BytesSwapOptimized(register _cmsTRANSFORM* info, 1825 register cmsUInt16Number wOut[], 1826 register cmsUInt8Number* output, 1827 register cmsUInt32Number Stride) 1828 { 1829 *output++ = (wOut[2] & 0xFF); 1830 *output++ = (wOut[1] & 0xFF); 1831 *output++ = (wOut[0] & 0xFF); 1832 1833 return output; 1834 1835 cmsUNUSED_PARAMETER(info); 1836 cmsUNUSED_PARAMETER(Stride); 1837 } 1838 1839 1840 static 1841 cmsUInt8Number* Pack3Words(register _cmsTRANSFORM* info, 1842 register cmsUInt16Number wOut[], 1843 register cmsUInt8Number* output, 1844 register cmsUInt32Number Stride) 1845 { 1846 *(cmsUInt16Number*) output = wOut[0]; 1847 output+= 2; 1848 *(cmsUInt16Number*) output = wOut[1]; 1849 output+= 2; 1850 *(cmsUInt16Number*) output = wOut[2]; 1851 output+= 2; 1852 1853 return output; 1854 1855 cmsUNUSED_PARAMETER(info); 1856 cmsUNUSED_PARAMETER(Stride); 1857 } 1858 1859 static 1860 cmsUInt8Number* Pack3WordsSwap(register _cmsTRANSFORM* info, 1861 register cmsUInt16Number wOut[], 1862 register cmsUInt8Number* output, 1863 register cmsUInt32Number Stride) 1864 { 1865 *(cmsUInt16Number*) output = wOut[2]; 1866 output+= 2; 1867 *(cmsUInt16Number*) output = wOut[1]; 1868 output+= 2; 1869 *(cmsUInt16Number*) output = wOut[0]; 1870 output+= 2; 1871 1872 return output; 1873 1874 cmsUNUSED_PARAMETER(info); 1875 cmsUNUSED_PARAMETER(Stride); 1876 } 1877 1878 static 1879 cmsUInt8Number* Pack3WordsBigEndian(register _cmsTRANSFORM* info, 1880 register cmsUInt16Number wOut[], 1881 register cmsUInt8Number* output, 1882 register cmsUInt32Number Stride) 1883 { 1884 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]); 1885 output+= 2; 1886 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]); 1887 output+= 2; 1888 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]); 1889 output+= 2; 1890 1891 return output; 1892 1893 cmsUNUSED_PARAMETER(info); 1894 cmsUNUSED_PARAMETER(Stride); 1895 } 1896 1897 static 1898 cmsUInt8Number* Pack3BytesAndSkip1(register _cmsTRANSFORM* info, 1899 register cmsUInt16Number wOut[], 1900 register cmsUInt8Number* output, 1901 register cmsUInt32Number Stride) 1902 { 1903 *output++ = FROM_16_TO_8(wOut[0]); 1904 *output++ = FROM_16_TO_8(wOut[1]); 1905 *output++ = FROM_16_TO_8(wOut[2]); 1906 output++; 1907 1908 return output; 1909 1910 cmsUNUSED_PARAMETER(info); 1911 cmsUNUSED_PARAMETER(Stride); 1912 } 1913 1914 static 1915 cmsUInt8Number* Pack3BytesAndSkip1Optimized(register _cmsTRANSFORM* info, 1916 register cmsUInt16Number wOut[], 1917 register cmsUInt8Number* output, 1918 register cmsUInt32Number Stride) 1919 { 1920 *output++ = (wOut[0] & 0xFF); 1921 *output++ = (wOut[1] & 0xFF); 1922 *output++ = (wOut[2] & 0xFF); 1923 output++; 1924 1925 return output; 1926 1927 cmsUNUSED_PARAMETER(info); 1928 cmsUNUSED_PARAMETER(Stride); 1929 } 1930 1931 1932 static 1933 cmsUInt8Number* Pack3BytesAndSkip1SwapFirst(register _cmsTRANSFORM* info, 1934 register cmsUInt16Number wOut[], 1935 register cmsUInt8Number* output, 1936 register cmsUInt32Number Stride) 1937 { 1938 output++; 1939 *output++ = FROM_16_TO_8(wOut[0]); 1940 *output++ = FROM_16_TO_8(wOut[1]); 1941 *output++ = FROM_16_TO_8(wOut[2]); 1942 1943 return output; 1944 1945 cmsUNUSED_PARAMETER(info); 1946 cmsUNUSED_PARAMETER(Stride); 1947 } 1948 1949 static 1950 cmsUInt8Number* Pack3BytesAndSkip1SwapFirstOptimized(register _cmsTRANSFORM* info, 1951 register cmsUInt16Number wOut[], 1952 register cmsUInt8Number* output, 1953 register cmsUInt32Number Stride) 1954 { 1955 output++; 1956 *output++ = (wOut[0] & 0xFF); 1957 *output++ = (wOut[1] & 0xFF); 1958 *output++ = (wOut[2] & 0xFF); 1959 1960 return output; 1961 1962 cmsUNUSED_PARAMETER(info); 1963 cmsUNUSED_PARAMETER(Stride); 1964 } 1965 1966 static 1967 cmsUInt8Number* Pack3BytesAndSkip1Swap(register _cmsTRANSFORM* info, 1968 register cmsUInt16Number wOut[], 1969 register cmsUInt8Number* output, 1970 register cmsUInt32Number Stride) 1971 { 1972 output++; 1973 *output++ = FROM_16_TO_8(wOut[2]); 1974 *output++ = FROM_16_TO_8(wOut[1]); 1975 *output++ = FROM_16_TO_8(wOut[0]); 1976 1977 return output; 1978 1979 cmsUNUSED_PARAMETER(info); 1980 cmsUNUSED_PARAMETER(Stride); 1981 } 1982 1983 static 1984 cmsUInt8Number* Pack3BytesAndSkip1SwapOptimized(register _cmsTRANSFORM* info, 1985 register cmsUInt16Number wOut[], 1986 register cmsUInt8Number* output, 1987 register cmsUInt32Number Stride) 1988 { 1989 output++; 1990 *output++ = (wOut[2] & 0xFF); 1991 *output++ = (wOut[1] & 0xFF); 1992 *output++ = (wOut[0] & 0xFF); 1993 1994 return output; 1995 1996 cmsUNUSED_PARAMETER(info); 1997 cmsUNUSED_PARAMETER(Stride); 1998 } 1999 2000 2001 static 2002 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info, 2003 register cmsUInt16Number wOut[], 2004 register cmsUInt8Number* output, 2005 register cmsUInt32Number Stride) 2006 { 2007 *output++ = FROM_16_TO_8(wOut[2]); 2008 *output++ = FROM_16_TO_8(wOut[1]); 2009 *output++ = FROM_16_TO_8(wOut[0]); 2010 output++; 2011 2012 return output; 2013 2014 cmsUNUSED_PARAMETER(info); 2015 cmsUNUSED_PARAMETER(Stride); 2016 } 2017 2018 static 2019 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirstOptimized(register _cmsTRANSFORM* info, 2020 register cmsUInt16Number wOut[], 2021 register cmsUInt8Number* output, 2022 register cmsUInt32Number Stride) 2023 { 2024 *output++ = (wOut[2] & 0xFF); 2025 *output++ = (wOut[1] & 0xFF); 2026 *output++ = (wOut[0] & 0xFF); 2027 output++; 2028 2029 return output; 2030 2031 cmsUNUSED_PARAMETER(info); 2032 cmsUNUSED_PARAMETER(Stride); 2033 } 2034 2035 static 2036 cmsUInt8Number* Pack3WordsAndSkip1(register _cmsTRANSFORM* info, 2037 register cmsUInt16Number wOut[], 2038 register cmsUInt8Number* output, 2039 register cmsUInt32Number Stride) 2040 { 2041 *(cmsUInt16Number*) output = wOut[0]; 2042 output+= 2; 2043 *(cmsUInt16Number*) output = wOut[1]; 2044 output+= 2; 2045 *(cmsUInt16Number*) output = wOut[2]; 2046 output+= 2; 2047 output+= 2; 2048 2049 return output; 2050 2051 cmsUNUSED_PARAMETER(info); 2052 cmsUNUSED_PARAMETER(Stride); 2053 } 2054 2055 static 2056 cmsUInt8Number* Pack3WordsAndSkip1Swap(register _cmsTRANSFORM* info, 2057 register cmsUInt16Number wOut[], 2058 register cmsUInt8Number* output, 2059 register cmsUInt32Number Stride) 2060 { 2061 output+= 2; 2062 *(cmsUInt16Number*) output = wOut[2]; 2063 output+= 2; 2064 *(cmsUInt16Number*) output = wOut[1]; 2065 output+= 2; 2066 *(cmsUInt16Number*) output = wOut[0]; 2067 output+= 2; 2068 2069 return output; 2070 2071 cmsUNUSED_PARAMETER(info); 2072 cmsUNUSED_PARAMETER(Stride); 2073 } 2074 2075 2076 static 2077 cmsUInt8Number* Pack3WordsAndSkip1SwapFirst(register _cmsTRANSFORM* info, 2078 register cmsUInt16Number wOut[], 2079 register cmsUInt8Number* output, 2080 register cmsUInt32Number Stride) 2081 { 2082 output+= 2; 2083 *(cmsUInt16Number*) output = wOut[0]; 2084 output+= 2; 2085 *(cmsUInt16Number*) output = wOut[1]; 2086 output+= 2; 2087 *(cmsUInt16Number*) output = wOut[2]; 2088 output+= 2; 2089 2090 return output; 2091 2092 cmsUNUSED_PARAMETER(info); 2093 cmsUNUSED_PARAMETER(Stride); 2094 } 2095 2096 2097 static 2098 cmsUInt8Number* Pack3WordsAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info, 2099 register cmsUInt16Number wOut[], 2100 register cmsUInt8Number* output, 2101 register cmsUInt32Number Stride) 2102 { 2103 *(cmsUInt16Number*) output = wOut[2]; 2104 output+= 2; 2105 *(cmsUInt16Number*) output = wOut[1]; 2106 output+= 2; 2107 *(cmsUInt16Number*) output = wOut[0]; 2108 output+= 2; 2109 output+= 2; 2110 2111 return output; 2112 2113 cmsUNUSED_PARAMETER(info); 2114 cmsUNUSED_PARAMETER(Stride); 2115 } 2116 2117 2118 2119 static 2120 cmsUInt8Number* Pack1Byte(register _cmsTRANSFORM* info, 2121 register cmsUInt16Number wOut[], 2122 register cmsUInt8Number* output, 2123 register cmsUInt32Number Stride) 2124 { 2125 *output++ = FROM_16_TO_8(wOut[0]); 2126 2127 return output; 2128 2129 cmsUNUSED_PARAMETER(info); 2130 cmsUNUSED_PARAMETER(Stride); 2131 } 2132 2133 2134 static 2135 cmsUInt8Number* Pack1ByteReversed(register _cmsTRANSFORM* info, 2136 register cmsUInt16Number wOut[], 2137 register cmsUInt8Number* output, 2138 register cmsUInt32Number Stride) 2139 { 2140 *output++ = FROM_16_TO_8(REVERSE_FLAVOR_16(wOut[0])); 2141 2142 return output; 2143 2144 cmsUNUSED_PARAMETER(info); 2145 cmsUNUSED_PARAMETER(Stride); 2146 } 2147 2148 2149 static 2150 cmsUInt8Number* Pack1ByteSkip1(register _cmsTRANSFORM* info, 2151 register cmsUInt16Number wOut[], 2152 register cmsUInt8Number* output, 2153 register cmsUInt32Number Stride) 2154 { 2155 *output++ = FROM_16_TO_8(wOut[0]); 2156 output++; 2157 2158 return output; 2159 2160 cmsUNUSED_PARAMETER(info); 2161 cmsUNUSED_PARAMETER(Stride); 2162 } 2163 2164 2165 static 2166 cmsUInt8Number* Pack1ByteSkip1SwapFirst(register _cmsTRANSFORM* info, 2167 register cmsUInt16Number wOut[], 2168 register cmsUInt8Number* output, 2169 register cmsUInt32Number Stride) 2170 { 2171 output++; 2172 *output++ = FROM_16_TO_8(wOut[0]); 2173 2174 return output; 2175 2176 cmsUNUSED_PARAMETER(info); 2177 cmsUNUSED_PARAMETER(Stride); 2178 } 2179 2180 static 2181 cmsUInt8Number* Pack1Word(register _cmsTRANSFORM* info, 2182 register cmsUInt16Number wOut[], 2183 register cmsUInt8Number* output, 2184 register cmsUInt32Number Stride) 2185 { 2186 *(cmsUInt16Number*) output = wOut[0]; 2187 output+= 2; 2188 2189 return output; 2190 2191 cmsUNUSED_PARAMETER(info); 2192 cmsUNUSED_PARAMETER(Stride); 2193 } 2194 2195 2196 static 2197 cmsUInt8Number* Pack1WordReversed(register _cmsTRANSFORM* info, 2198 register cmsUInt16Number wOut[], 2199 register cmsUInt8Number* output, 2200 register cmsUInt32Number Stride) 2201 { 2202 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]); 2203 output+= 2; 2204 2205 return output; 2206 2207 cmsUNUSED_PARAMETER(info); 2208 cmsUNUSED_PARAMETER(Stride); 2209 } 2210 2211 static 2212 cmsUInt8Number* Pack1WordBigEndian(register _cmsTRANSFORM* info, 2213 register cmsUInt16Number wOut[], 2214 register cmsUInt8Number* output, 2215 register cmsUInt32Number Stride) 2216 { 2217 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]); 2218 output+= 2; 2219 2220 return output; 2221 2222 cmsUNUSED_PARAMETER(info); 2223 cmsUNUSED_PARAMETER(Stride); 2224 } 2225 2226 2227 static 2228 cmsUInt8Number* Pack1WordSkip1(register _cmsTRANSFORM* info, 2229 register cmsUInt16Number wOut[], 2230 register cmsUInt8Number* output, 2231 register cmsUInt32Number Stride) 2232 { 2233 *(cmsUInt16Number*) output = wOut[0]; 2234 output+= 4; 2235 2236 return output; 2237 2238 cmsUNUSED_PARAMETER(info); 2239 cmsUNUSED_PARAMETER(Stride); 2240 } 2241 2242 static 2243 cmsUInt8Number* Pack1WordSkip1SwapFirst(register _cmsTRANSFORM* info, 2244 register cmsUInt16Number wOut[], 2245 register cmsUInt8Number* output, 2246 register cmsUInt32Number Stride) 2247 { 2248 output += 2; 2249 *(cmsUInt16Number*) output = wOut[0]; 2250 output+= 2; 2251 2252 return output; 2253 2254 cmsUNUSED_PARAMETER(info); 2255 cmsUNUSED_PARAMETER(Stride); 2256 } 2257 2258 2259 // Unencoded Float values -- don't try optimize speed 2260 static 2261 cmsUInt8Number* PackLabDoubleFrom16(register _cmsTRANSFORM* info, 2262 register cmsUInt16Number wOut[], 2263 register cmsUInt8Number* output, 2264 register cmsUInt32Number Stride) 2265 { 2266 2267 if (T_PLANAR(info -> OutputFormat)) { 2268 2269 cmsCIELab Lab; 2270 cmsFloat64Number* Out = (cmsFloat64Number*) output; 2271 cmsLabEncoded2Float(&Lab, wOut); 2272 2273 Out[0] = Lab.L; 2274 Out[Stride] = Lab.a; 2275 Out[Stride*2] = Lab.b; 2276 2277 return output + sizeof(cmsFloat64Number); 2278 } 2279 else { 2280 2281 cmsLabEncoded2Float((cmsCIELab*) output, wOut); 2282 return output + (sizeof(cmsCIELab) + T_EXTRA(info ->OutputFormat) * sizeof(cmsFloat64Number)); 2283 } 2284 } 2285 2286 2287 static 2288 cmsUInt8Number* PackLabFloatFrom16(register _cmsTRANSFORM* info, 2289 register cmsUInt16Number wOut[], 2290 register cmsUInt8Number* output, 2291 register cmsUInt32Number Stride) 2292 { 2293 cmsCIELab Lab; 2294 cmsLabEncoded2Float(&Lab, wOut); 2295 2296 if (T_PLANAR(info -> OutputFormat)) { 2297 2298 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2299 2300 Out[0] = (cmsFloat32Number)Lab.L; 2301 Out[Stride] = (cmsFloat32Number)Lab.a; 2302 Out[Stride*2] = (cmsFloat32Number)Lab.b; 2303 2304 return output + sizeof(cmsFloat32Number); 2305 } 2306 else { 2307 2308 ((cmsFloat32Number*) output)[0] = (cmsFloat32Number) Lab.L; 2309 ((cmsFloat32Number*) output)[1] = (cmsFloat32Number) Lab.a; 2310 ((cmsFloat32Number*) output)[2] = (cmsFloat32Number) Lab.b; 2311 2312 return output + (3 + T_EXTRA(info ->OutputFormat)) * sizeof(cmsFloat32Number); 2313 } 2314 } 2315 2316 static 2317 cmsUInt8Number* PackXYZDoubleFrom16(register _cmsTRANSFORM* Info, 2318 register cmsUInt16Number wOut[], 2319 register cmsUInt8Number* output, 2320 register cmsUInt32Number Stride) 2321 { 2322 if (T_PLANAR(Info -> OutputFormat)) { 2323 2324 cmsCIEXYZ XYZ; 2325 cmsFloat64Number* Out = (cmsFloat64Number*) output; 2326 cmsXYZEncoded2Float(&XYZ, wOut); 2327 2328 Out[0] = XYZ.X; 2329 Out[Stride] = XYZ.Y; 2330 Out[Stride*2] = XYZ.Z; 2331 2332 return output + sizeof(cmsFloat64Number); 2333 2334 } 2335 else { 2336 2337 cmsXYZEncoded2Float((cmsCIEXYZ*) output, wOut); 2338 2339 return output + (sizeof(cmsCIEXYZ) + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number)); 2340 } 2341 } 2342 2343 static 2344 cmsUInt8Number* PackXYZFloatFrom16(register _cmsTRANSFORM* Info, 2345 register cmsUInt16Number wOut[], 2346 register cmsUInt8Number* output, 2347 register cmsUInt32Number Stride) 2348 { 2349 if (T_PLANAR(Info -> OutputFormat)) { 2350 2351 cmsCIEXYZ XYZ; 2352 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2353 cmsXYZEncoded2Float(&XYZ, wOut); 2354 2355 Out[0] = (cmsFloat32Number) XYZ.X; 2356 Out[Stride] = (cmsFloat32Number) XYZ.Y; 2357 Out[Stride*2] = (cmsFloat32Number) XYZ.Z; 2358 2359 return output + sizeof(cmsFloat32Number); 2360 2361 } 2362 else { 2363 2364 cmsCIEXYZ XYZ; 2365 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2366 cmsXYZEncoded2Float(&XYZ, wOut); 2367 2368 Out[0] = (cmsFloat32Number) XYZ.X; 2369 Out[1] = (cmsFloat32Number) XYZ.Y; 2370 Out[2] = (cmsFloat32Number) XYZ.Z; 2371 2372 return output + (3 * sizeof(cmsFloat32Number) + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number)); 2373 } 2374 } 2375 2376 static 2377 cmsUInt8Number* PackDoubleFrom16(register _cmsTRANSFORM* info, 2378 register cmsUInt16Number wOut[], 2379 register cmsUInt8Number* output, 2380 register cmsUInt32Number Stride) 2381 { 2382 int nChan = T_CHANNELS(info -> OutputFormat); 2383 int DoSwap = T_DOSWAP(info ->OutputFormat); 2384 int Reverse = T_FLAVOR(info ->OutputFormat); 2385 int Extra = T_EXTRA(info -> OutputFormat); 2386 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 2387 int Planar = T_PLANAR(info -> OutputFormat); 2388 int ExtraFirst = DoSwap ^ SwapFirst; 2389 cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35 : 65535.0; 2390 cmsFloat64Number v = 0; 2391 cmsFloat64Number* swap1 = (cmsFloat64Number*) output; 2392 int i, start = 0; 2393 2394 if (ExtraFirst) 2395 start = Extra; 2396 2397 for (i=0; i < nChan; i++) { 2398 2399 int index = DoSwap ? (nChan - i - 1) : i; 2400 2401 v = (cmsFloat64Number) wOut[index] / maximum; 2402 2403 if (Reverse) 2404 v = maximum - v; 2405 2406 if (Planar) 2407 ((cmsFloat64Number*) output)[(i + start) * Stride]= v; 2408 else 2409 ((cmsFloat64Number*) output)[i + start] = v; 2410 } 2411 2412 2413 if (Extra == 0 && SwapFirst) { 2414 2415 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number)); 2416 *swap1 = v; 2417 } 2418 2419 if (T_PLANAR(info -> OutputFormat)) 2420 return output + sizeof(cmsFloat64Number); 2421 else 2422 return output + (nChan + Extra) * sizeof(cmsFloat64Number); 2423 2424 } 2425 2426 2427 static 2428 cmsUInt8Number* PackFloatFrom16(register _cmsTRANSFORM* info, 2429 register cmsUInt16Number wOut[], 2430 register cmsUInt8Number* output, 2431 register cmsUInt32Number Stride) 2432 { 2433 int nChan = T_CHANNELS(info->OutputFormat); 2434 int DoSwap = T_DOSWAP(info->OutputFormat); 2435 int Reverse = T_FLAVOR(info->OutputFormat); 2436 int Extra = T_EXTRA(info->OutputFormat); 2437 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2438 int Planar = T_PLANAR(info->OutputFormat); 2439 int ExtraFirst = DoSwap ^ SwapFirst; 2440 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 655.35 : 65535.0; 2441 cmsFloat64Number v = 0; 2442 cmsFloat32Number* swap1 = (cmsFloat32Number*)output; 2443 int i, start = 0; 2444 2445 if (ExtraFirst) 2446 start = Extra; 2447 2448 for (i = 0; i < nChan; i++) { 2449 2450 int index = DoSwap ? (nChan - i - 1) : i; 2451 2452 v = (cmsFloat64Number)wOut[index] / maximum; 2453 2454 if (Reverse) 2455 v = maximum - v; 2456 2457 if (Planar) 2458 ((cmsFloat32Number*)output)[(i + start) * Stride] = (cmsFloat32Number)v; 2459 else 2460 ((cmsFloat32Number*)output)[i + start] = (cmsFloat32Number)v; 2461 } 2462 2463 2464 if (Extra == 0 && SwapFirst) { 2465 2466 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat32Number)); 2467 *swap1 = (cmsFloat32Number)v; 2468 } 2469 2470 if (T_PLANAR(info->OutputFormat)) 2471 return output + sizeof(cmsFloat32Number); 2472 else 2473 return output + (nChan + Extra) * sizeof(cmsFloat32Number); 2474 } 2475 2476 2477 2478 // -------------------------------------------------------------------------------------------------------- 2479 2480 static 2481 cmsUInt8Number* PackFloatsFromFloat(_cmsTRANSFORM* info, 2482 cmsFloat32Number wOut[], 2483 cmsUInt8Number* output, 2484 cmsUInt32Number Stride) 2485 { 2486 int nChan = T_CHANNELS(info->OutputFormat); 2487 int DoSwap = T_DOSWAP(info->OutputFormat); 2488 int Reverse = T_FLAVOR(info->OutputFormat); 2489 int Extra = T_EXTRA(info->OutputFormat); 2490 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2491 int Planar = T_PLANAR(info->OutputFormat); 2492 int ExtraFirst = DoSwap ^ SwapFirst; 2493 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 100.0 : 1.0; 2494 cmsFloat32Number* swap1 = (cmsFloat32Number*)output; 2495 cmsFloat64Number v = 0; 2496 int i, start = 0; 2497 2498 if (ExtraFirst) 2499 start = Extra; 2500 2501 for (i = 0; i < nChan; i++) { 2502 2503 int index = DoSwap ? (nChan - i - 1) : i; 2504 2505 v = wOut[index] * maximum; 2506 2507 if (Reverse) 2508 v = maximum - v; 2509 2510 if (Planar) 2511 ((cmsFloat32Number*)output)[(i + start)* Stride] = (cmsFloat32Number)v; 2512 else 2513 ((cmsFloat32Number*)output)[i + start] = (cmsFloat32Number)v; 2514 } 2515 2516 2517 if (Extra == 0 && SwapFirst) { 2518 2519 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat32Number)); 2520 *swap1 = (cmsFloat32Number)v; 2521 } 2522 2523 if (T_PLANAR(info->OutputFormat)) 2524 return output + sizeof(cmsFloat32Number); 2525 else 2526 return output + (nChan + Extra) * sizeof(cmsFloat32Number); 2527 } 2528 2529 static 2530 cmsUInt8Number* PackDoublesFromFloat(_cmsTRANSFORM* info, 2531 cmsFloat32Number wOut[], 2532 cmsUInt8Number* output, 2533 cmsUInt32Number Stride) 2534 { 2535 int nChan = T_CHANNELS(info->OutputFormat); 2536 int DoSwap = T_DOSWAP(info->OutputFormat); 2537 int Reverse = T_FLAVOR(info->OutputFormat); 2538 int Extra = T_EXTRA(info->OutputFormat); 2539 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2540 int Planar = T_PLANAR(info->OutputFormat); 2541 int ExtraFirst = DoSwap ^ SwapFirst; 2542 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 100.0 : 1.0; 2543 cmsFloat64Number v = 0; 2544 cmsFloat64Number* swap1 = (cmsFloat64Number*)output; 2545 int i, start = 0; 2546 2547 if (ExtraFirst) 2548 start = Extra; 2549 2550 for (i = 0; i < nChan; i++) { 2551 2552 int index = DoSwap ? (nChan - i - 1) : i; 2553 2554 v = wOut[index] * maximum; 2555 2556 if (Reverse) 2557 v = maximum - v; 2558 2559 if (Planar) 2560 ((cmsFloat64Number*)output)[(i + start) * Stride] = v; 2561 else 2562 ((cmsFloat64Number*)output)[i + start] = v; 2563 } 2564 2565 if (Extra == 0 && SwapFirst) { 2566 2567 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat64Number)); 2568 *swap1 = v; 2569 } 2570 2571 2572 if (T_PLANAR(info->OutputFormat)) 2573 return output + sizeof(cmsFloat64Number); 2574 else 2575 return output + (nChan + Extra) * sizeof(cmsFloat64Number); 2576 2577 } 2578 2579 2580 2581 2582 2583 static 2584 cmsUInt8Number* PackLabFloatFromFloat(_cmsTRANSFORM* Info, 2585 cmsFloat32Number wOut[], 2586 cmsUInt8Number* output, 2587 cmsUInt32Number Stride) 2588 { 2589 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2590 2591 if (T_PLANAR(Info -> OutputFormat)) { 2592 2593 Out[0] = (cmsFloat32Number) (wOut[0] * 100.0); 2594 Out[Stride] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0); 2595 Out[Stride*2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0); 2596 2597 return output + sizeof(cmsFloat32Number); 2598 } 2599 else { 2600 2601 Out[0] = (cmsFloat32Number) (wOut[0] * 100.0); 2602 Out[1] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0); 2603 Out[2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0); 2604 2605 return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number)); 2606 } 2607 2608 } 2609 2610 2611 static 2612 cmsUInt8Number* PackLabDoubleFromFloat(_cmsTRANSFORM* Info, 2613 cmsFloat32Number wOut[], 2614 cmsUInt8Number* output, 2615 cmsUInt32Number Stride) 2616 { 2617 cmsFloat64Number* Out = (cmsFloat64Number*) output; 2618 2619 if (T_PLANAR(Info -> OutputFormat)) { 2620 2621 Out[0] = (cmsFloat64Number) (wOut[0] * 100.0); 2622 Out[Stride] = (cmsFloat64Number) (wOut[1] * 255.0 - 128.0); 2623 Out[Stride*2] = (cmsFloat64Number) (wOut[2] * 255.0 - 128.0); 2624 2625 return output + sizeof(cmsFloat64Number); 2626 } 2627 else { 2628 2629 Out[0] = (cmsFloat64Number) (wOut[0] * 100.0); 2630 Out[1] = (cmsFloat64Number) (wOut[1] * 255.0 - 128.0); 2631 Out[2] = (cmsFloat64Number) (wOut[2] * 255.0 - 128.0); 2632 2633 return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number)); 2634 } 2635 2636 } 2637 2638 2639 // From 0..1 range to 0..MAX_ENCODEABLE_XYZ 2640 static 2641 cmsUInt8Number* PackXYZFloatFromFloat(_cmsTRANSFORM* Info, 2642 cmsFloat32Number wOut[], 2643 cmsUInt8Number* output, 2644 cmsUInt32Number Stride) 2645 { 2646 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2647 2648 if (T_PLANAR(Info -> OutputFormat)) { 2649 2650 Out[0] = (cmsFloat32Number) (wOut[0] * MAX_ENCODEABLE_XYZ); 2651 Out[Stride] = (cmsFloat32Number) (wOut[1] * MAX_ENCODEABLE_XYZ); 2652 Out[Stride*2] = (cmsFloat32Number) (wOut[2] * MAX_ENCODEABLE_XYZ); 2653 2654 return output + sizeof(cmsFloat32Number); 2655 } 2656 else { 2657 2658 Out[0] = (cmsFloat32Number) (wOut[0] * MAX_ENCODEABLE_XYZ); 2659 Out[1] = (cmsFloat32Number) (wOut[1] * MAX_ENCODEABLE_XYZ); 2660 Out[2] = (cmsFloat32Number) (wOut[2] * MAX_ENCODEABLE_XYZ); 2661 2662 return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number)); 2663 } 2664 2665 } 2666 2667 // Same, but convert to double 2668 static 2669 cmsUInt8Number* PackXYZDoubleFromFloat(_cmsTRANSFORM* Info, 2670 cmsFloat32Number wOut[], 2671 cmsUInt8Number* output, 2672 cmsUInt32Number Stride) 2673 { 2674 cmsFloat64Number* Out = (cmsFloat64Number*) output; 2675 2676 if (T_PLANAR(Info -> OutputFormat)) { 2677 2678 Out[0] = (cmsFloat64Number) (wOut[0] * MAX_ENCODEABLE_XYZ); 2679 Out[Stride] = (cmsFloat64Number) (wOut[1] * MAX_ENCODEABLE_XYZ); 2680 Out[Stride*2] = (cmsFloat64Number) (wOut[2] * MAX_ENCODEABLE_XYZ); 2681 2682 return output + sizeof(cmsFloat64Number); 2683 } 2684 else { 2685 2686 Out[0] = (cmsFloat64Number) (wOut[0] * MAX_ENCODEABLE_XYZ); 2687 Out[1] = (cmsFloat64Number) (wOut[1] * MAX_ENCODEABLE_XYZ); 2688 Out[2] = (cmsFloat64Number) (wOut[2] * MAX_ENCODEABLE_XYZ); 2689 2690 return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number)); 2691 } 2692 2693 } 2694 2695 2696 // ---------------------------------------------------------------------------------------------------------------- 2697 2698 #ifndef CMS_NO_HALF_SUPPORT 2699 2700 // Decodes an stream of half floats to wIn[] described by input format 2701 2702 static 2703 cmsUInt8Number* UnrollHalfTo16(register _cmsTRANSFORM* info, 2704 register cmsUInt16Number wIn[], 2705 register cmsUInt8Number* accum, 2706 register cmsUInt32Number Stride) 2707 { 2708 2709 int nChan = T_CHANNELS(info -> InputFormat); 2710 int DoSwap = T_DOSWAP(info ->InputFormat); 2711 int Reverse = T_FLAVOR(info ->InputFormat); 2712 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 2713 int Extra = T_EXTRA(info -> InputFormat); 2714 int ExtraFirst = DoSwap ^ SwapFirst; 2715 int Planar = T_PLANAR(info -> InputFormat); 2716 cmsFloat32Number v; 2717 int i, start = 0; 2718 cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 655.35F : 65535.0F; 2719 2720 2721 if (ExtraFirst) 2722 start = Extra; 2723 2724 for (i=0; i < nChan; i++) { 2725 2726 int index = DoSwap ? (nChan - i - 1) : i; 2727 2728 if (Planar) 2729 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[(i + start) * Stride] ); 2730 else 2731 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[i + start] ) ; 2732 2733 if (Reverse) v = maximum - v; 2734 2735 wIn[index] = _cmsQuickSaturateWord(v * maximum); 2736 } 2737 2738 2739 if (Extra == 0 && SwapFirst) { 2740 cmsUInt16Number tmp = wIn[0]; 2741 2742 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number)); 2743 wIn[nChan-1] = tmp; 2744 } 2745 2746 if (T_PLANAR(info -> InputFormat)) 2747 return accum + sizeof(cmsUInt16Number); 2748 else 2749 return accum + (nChan + Extra) * sizeof(cmsUInt16Number); 2750 } 2751 2752 // Decodes an stream of half floats to wIn[] described by input format 2753 2754 static 2755 cmsUInt8Number* UnrollHalfToFloat(_cmsTRANSFORM* info, 2756 cmsFloat32Number wIn[], 2757 cmsUInt8Number* accum, 2758 cmsUInt32Number Stride) 2759 { 2760 2761 int nChan = T_CHANNELS(info -> InputFormat); 2762 int DoSwap = T_DOSWAP(info ->InputFormat); 2763 int Reverse = T_FLAVOR(info ->InputFormat); 2764 int SwapFirst = T_SWAPFIRST(info -> InputFormat); 2765 int Extra = T_EXTRA(info -> InputFormat); 2766 int ExtraFirst = DoSwap ^ SwapFirst; 2767 int Planar = T_PLANAR(info -> InputFormat); 2768 cmsFloat32Number v; 2769 int i, start = 0; 2770 cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 100.0F : 1.0F; 2771 2772 2773 if (ExtraFirst) 2774 start = Extra; 2775 2776 for (i=0; i < nChan; i++) { 2777 2778 int index = DoSwap ? (nChan - i - 1) : i; 2779 2780 if (Planar) 2781 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[(i + start) * Stride] ); 2782 else 2783 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[i + start] ) ; 2784 2785 v /= maximum; 2786 2787 wIn[index] = Reverse ? 1 - v : v; 2788 } 2789 2790 2791 if (Extra == 0 && SwapFirst) { 2792 cmsFloat32Number tmp = wIn[0]; 2793 2794 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number)); 2795 wIn[nChan-1] = tmp; 2796 } 2797 2798 if (T_PLANAR(info -> InputFormat)) 2799 return accum + sizeof(cmsUInt16Number); 2800 else 2801 return accum + (nChan + Extra) * sizeof(cmsUInt16Number); 2802 } 2803 2804 2805 static 2806 cmsUInt8Number* PackHalfFrom16(register _cmsTRANSFORM* info, 2807 register cmsUInt16Number wOut[], 2808 register cmsUInt8Number* output, 2809 register cmsUInt32Number Stride) 2810 { 2811 int nChan = T_CHANNELS(info->OutputFormat); 2812 int DoSwap = T_DOSWAP(info->OutputFormat); 2813 int Reverse = T_FLAVOR(info->OutputFormat); 2814 int Extra = T_EXTRA(info->OutputFormat); 2815 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2816 int Planar = T_PLANAR(info->OutputFormat); 2817 int ExtraFirst = DoSwap ^ SwapFirst; 2818 cmsFloat32Number maximum = IsInkSpace(info->OutputFormat) ? 655.35F : 65535.0F; 2819 cmsFloat32Number v = 0; 2820 cmsUInt16Number* swap1 = (cmsUInt16Number*)output; 2821 int i, start = 0; 2822 2823 if (ExtraFirst) 2824 start = Extra; 2825 2826 for (i = 0; i < nChan; i++) { 2827 2828 int index = DoSwap ? (nChan - i - 1) : i; 2829 2830 v = (cmsFloat32Number)wOut[index] / maximum; 2831 2832 if (Reverse) 2833 v = maximum - v; 2834 2835 if (Planar) 2836 ((cmsUInt16Number*)output)[(i + start) * Stride] = _cmsFloat2Half(v); 2837 else 2838 ((cmsUInt16Number*)output)[i + start] = _cmsFloat2Half(v); 2839 } 2840 2841 2842 if (Extra == 0 && SwapFirst) { 2843 2844 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsUInt16Number)); 2845 *swap1 = _cmsFloat2Half(v); 2846 } 2847 2848 if (T_PLANAR(info->OutputFormat)) 2849 return output + sizeof(cmsUInt16Number); 2850 else 2851 return output + (nChan + Extra) * sizeof(cmsUInt16Number); 2852 } 2853 2854 2855 2856 static 2857 cmsUInt8Number* PackHalfFromFloat(_cmsTRANSFORM* info, 2858 cmsFloat32Number wOut[], 2859 cmsUInt8Number* output, 2860 cmsUInt32Number Stride) 2861 { 2862 int nChan = T_CHANNELS(info->OutputFormat); 2863 int DoSwap = T_DOSWAP(info->OutputFormat); 2864 int Reverse = T_FLAVOR(info->OutputFormat); 2865 int Extra = T_EXTRA(info->OutputFormat); 2866 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2867 int Planar = T_PLANAR(info->OutputFormat); 2868 int ExtraFirst = DoSwap ^ SwapFirst; 2869 cmsFloat32Number maximum = IsInkSpace(info->OutputFormat) ? 100.0F : 1.0F; 2870 cmsUInt16Number* swap1 = (cmsUInt16Number*)output; 2871 cmsFloat32Number v = 0; 2872 int i, start = 0; 2873 2874 if (ExtraFirst) 2875 start = Extra; 2876 2877 for (i = 0; i < nChan; i++) { 2878 2879 int index = DoSwap ? (nChan - i - 1) : i; 2880 2881 v = wOut[index] * maximum; 2882 2883 if (Reverse) 2884 v = maximum - v; 2885 2886 if (Planar) 2887 ((cmsUInt16Number*)output)[(i + start)* Stride] = _cmsFloat2Half(v); 2888 else 2889 ((cmsUInt16Number*)output)[i + start] = _cmsFloat2Half(v); 2890 } 2891 2892 2893 if (Extra == 0 && SwapFirst) { 2894 2895 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsUInt16Number)); 2896 *swap1 = (cmsUInt16Number)_cmsFloat2Half(v); 2897 } 2898 2899 if (T_PLANAR(info->OutputFormat)) 2900 return output + sizeof(cmsUInt16Number); 2901 else 2902 return output + (nChan + Extra)* sizeof(cmsUInt16Number); 2903 } 2904 2905 #endif 2906 2907 // ---------------------------------------------------------------------------------------------------------------- 2908 2909 2910 static cmsFormatters16 InputFormatters16[] = { 2911 2912 // Type Mask Function 2913 // ---------------------------- ------------------------------------ ---------------------------- 2914 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleTo16}, 2915 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleTo16}, 2916 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatTo16}, 2917 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatTo16}, 2918 { TYPE_GRAY_DBL, 0, UnrollDouble1Chan}, 2919 { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2920 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollDoubleTo16}, 2921 { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2922 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollFloatTo16}, 2923 #ifndef CMS_NO_HALF_SUPPORT 2924 { FLOAT_SH(1)|BYTES_SH(2), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2925 ANYEXTRA|ANYSWAP|ANYSPACE, UnrollHalfTo16}, 2926 #endif 2927 2928 { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Unroll1Byte}, 2929 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Unroll1ByteSkip1}, 2930 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(2), ANYSPACE, Unroll1ByteSkip2}, 2931 { CHANNELS_SH(1)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Unroll1ByteReversed}, 2932 { COLORSPACE_SH(PT_MCH2)|CHANNELS_SH(2)|BYTES_SH(1), 0, Unroll2Bytes}, 2933 2934 { TYPE_LabV2_8, 0, UnrollLabV2_8 }, 2935 { TYPE_ALabV2_8, 0, UnrollALabV2_8 }, 2936 { TYPE_LabV2_16, 0, UnrollLabV2_16 }, 2937 2938 { CHANNELS_SH(3)|BYTES_SH(1), ANYSPACE, Unroll3Bytes}, 2939 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3BytesSwap}, 2940 { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3BytesSkip1Swap}, 2941 { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll3BytesSkip1SwapFirst}, 2942 2943 { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), 2944 ANYSPACE, Unroll3BytesSkip1SwapSwapFirst}, 2945 2946 { CHANNELS_SH(4)|BYTES_SH(1), ANYSPACE, Unroll4Bytes}, 2947 { CHANNELS_SH(4)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Unroll4BytesReverse}, 2948 { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapFirst}, 2949 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll4BytesSwap}, 2950 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapSwapFirst}, 2951 2952 { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAPFIRST| 2953 ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarBytes}, 2954 2955 { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP| 2956 ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollChunkyBytes}, 2957 2958 { CHANNELS_SH(1)|BYTES_SH(2), ANYSPACE, Unroll1Word}, 2959 { CHANNELS_SH(1)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Unroll1WordReversed}, 2960 { CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(3), ANYSPACE, Unroll1WordSkip3}, 2961 2962 { CHANNELS_SH(2)|BYTES_SH(2), ANYSPACE, Unroll2Words}, 2963 { CHANNELS_SH(3)|BYTES_SH(2), ANYSPACE, Unroll3Words}, 2964 { CHANNELS_SH(4)|BYTES_SH(2), ANYSPACE, Unroll4Words}, 2965 2966 { CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Unroll3WordsSwap}, 2967 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll3WordsSkip1SwapFirst}, 2968 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3WordsSkip1Swap}, 2969 { CHANNELS_SH(4)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Unroll4WordsReverse}, 2970 { CHANNELS_SH(4)|BYTES_SH(2)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapFirst}, 2971 { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Unroll4WordsSwap}, 2972 { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapSwapFirst}, 2973 2974 2975 { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarWords}, 2976 { BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollAnyWords}, 2977 }; 2978 2979 2980 2981 static cmsFormattersFloat InputFormattersFloat[] = { 2982 2983 // Type Mask Function 2984 // ---------------------------- ------------------------------------ ---------------------------- 2985 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleToFloat}, 2986 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatToFloat}, 2987 2988 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleToFloat}, 2989 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatToFloat}, 2990 2991 { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA| 2992 ANYCHANNELS|ANYSPACE, UnrollFloatsToFloat}, 2993 2994 { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA| 2995 ANYCHANNELS|ANYSPACE, UnrollDoublesToFloat}, 2996 #ifndef CMS_NO_HALF_SUPPORT 2997 { FLOAT_SH(1)|BYTES_SH(2), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA| 2998 ANYCHANNELS|ANYSPACE, UnrollHalfToFloat}, 2999 #endif 3000 }; 3001 3002 3003 // Bit fields set to one in the mask are not compared 3004 static 3005 cmsFormatter _cmsGetStockInputFormatter(cmsUInt32Number dwInput, cmsUInt32Number dwFlags) 3006 { 3007 cmsUInt32Number i; 3008 cmsFormatter fr; 3009 3010 switch (dwFlags) { 3011 3012 case CMS_PACK_FLAGS_16BITS: { 3013 for (i=0; i < sizeof(InputFormatters16) / sizeof(cmsFormatters16); i++) { 3014 cmsFormatters16* f = InputFormatters16 + i; 3015 3016 if ((dwInput & ~f ->Mask) == f ->Type) { 3017 fr.Fmt16 = f ->Frm; 3018 return fr; 3019 } 3020 } 3021 } 3022 break; 3023 3024 case CMS_PACK_FLAGS_FLOAT: { 3025 for (i=0; i < sizeof(InputFormattersFloat) / sizeof(cmsFormattersFloat); i++) { 3026 cmsFormattersFloat* f = InputFormattersFloat + i; 3027 3028 if ((dwInput & ~f ->Mask) == f ->Type) { 3029 fr.FmtFloat = f ->Frm; 3030 return fr; 3031 } 3032 } 3033 } 3034 break; 3035 3036 default:; 3037 3038 } 3039 3040 fr.Fmt16 = NULL; 3041 return fr; 3042 } 3043 3044 static cmsFormatters16 OutputFormatters16[] = { 3045 // Type Mask Function 3046 // ---------------------------- ------------------------------------ ---------------------------- 3047 3048 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, PackLabDoubleFrom16}, 3049 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, PackXYZDoubleFrom16}, 3050 3051 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, PackLabFloatFrom16}, 3052 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, PackXYZFloatFrom16}, 3053 3054 { FLOAT_SH(1)|BYTES_SH(0), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP| 3055 ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackDoubleFrom16}, 3056 { FLOAT_SH(1)|BYTES_SH(4), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP| 3057 ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackFloatFrom16}, 3058 #ifndef CMS_NO_HALF_SUPPORT 3059 { FLOAT_SH(1)|BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP| 3060 ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackHalfFrom16}, 3061 #endif 3062 3063 { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Pack1Byte}, 3064 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Pack1ByteSkip1}, 3065 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack1ByteSkip1SwapFirst}, 3066 3067 { CHANNELS_SH(1)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Pack1ByteReversed}, 3068 3069 { TYPE_LabV2_8, 0, PackLabV2_8 }, 3070 { TYPE_ALabV2_8, 0, PackALabV2_8 }, 3071 { TYPE_LabV2_16, 0, PackLabV2_16 }, 3072 3073 { CHANNELS_SH(3)|BYTES_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesOptimized}, 3074 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesAndSkip1Optimized}, 3075 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1), 3076 ANYSPACE, Pack3BytesAndSkip1SwapFirstOptimized}, 3077 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1), 3078 ANYSPACE, Pack3BytesAndSkip1SwapSwapFirstOptimized}, 3079 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1), 3080 ANYSPACE, Pack3BytesAndSkip1SwapOptimized}, 3081 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesSwapOptimized}, 3082 3083 3084 3085 { CHANNELS_SH(3)|BYTES_SH(1), ANYSPACE, Pack3Bytes}, 3086 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Pack3BytesAndSkip1}, 3087 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack3BytesAndSkip1SwapFirst}, 3088 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), 3089 ANYSPACE, Pack3BytesAndSkip1SwapSwapFirst}, 3090 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1), ANYSPACE, Pack3BytesAndSkip1Swap}, 3091 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack3BytesSwap}, 3092 { CHANNELS_SH(6)|BYTES_SH(1), ANYSPACE, Pack6Bytes}, 3093 { CHANNELS_SH(6)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack6BytesSwap}, 3094 { CHANNELS_SH(4)|BYTES_SH(1), ANYSPACE, Pack4Bytes}, 3095 { CHANNELS_SH(4)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Pack4BytesReverse}, 3096 { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapFirst}, 3097 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack4BytesSwap}, 3098 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapSwapFirst}, 3099 3100 { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyBytes}, 3101 { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarBytes}, 3102 3103 { CHANNELS_SH(1)|BYTES_SH(2), ANYSPACE, Pack1Word}, 3104 { CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(1), ANYSPACE, Pack1WordSkip1}, 3105 { CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack1WordSkip1SwapFirst}, 3106 { CHANNELS_SH(1)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Pack1WordReversed}, 3107 { CHANNELS_SH(1)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack1WordBigEndian}, 3108 { CHANNELS_SH(3)|BYTES_SH(2), ANYSPACE, Pack3Words}, 3109 { CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack3WordsSwap}, 3110 { CHANNELS_SH(3)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack3WordsBigEndian}, 3111 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1), ANYSPACE, Pack3WordsAndSkip1}, 3112 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack3WordsAndSkip1Swap}, 3113 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack3WordsAndSkip1SwapFirst}, 3114 3115 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), 3116 ANYSPACE, Pack3WordsAndSkip1SwapSwapFirst}, 3117 3118 { CHANNELS_SH(4)|BYTES_SH(2), ANYSPACE, Pack4Words}, 3119 { CHANNELS_SH(4)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Pack4WordsReverse}, 3120 { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack4WordsSwap}, 3121 { CHANNELS_SH(4)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack4WordsBigEndian}, 3122 3123 { CHANNELS_SH(6)|BYTES_SH(2), ANYSPACE, Pack6Words}, 3124 { CHANNELS_SH(6)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack6WordsSwap}, 3125 3126 { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYENDIAN|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarWords}, 3127 { BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyWords} 3128 3129 }; 3130 3131 3132 static cmsFormattersFloat OutputFormattersFloat[] = { 3133 // Type Mask Function 3134 // ---------------------------- --------------------------------------------------- ---------------------------- 3135 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, PackLabFloatFromFloat}, 3136 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, PackXYZFloatFromFloat}, 3137 3138 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, PackLabDoubleFromFloat}, 3139 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, PackXYZDoubleFromFloat}, 3140 3141 { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR| 3142 ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackFloatsFromFloat }, 3143 { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR| 3144 ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackDoublesFromFloat }, 3145 #ifndef CMS_NO_HALF_SUPPORT 3146 { FLOAT_SH(1)|BYTES_SH(2), 3147 ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackHalfFromFloat }, 3148 #endif 3149 3150 3151 3152 }; 3153 3154 3155 // Bit fields set to one in the mask are not compared 3156 static 3157 cmsFormatter _cmsGetStockOutputFormatter(cmsUInt32Number dwInput, cmsUInt32Number dwFlags) 3158 { 3159 cmsUInt32Number i; 3160 cmsFormatter fr; 3161 3162 // Optimization is only a hint 3163 dwInput &= ~OPTIMIZED_SH(1); 3164 3165 switch (dwFlags) 3166 { 3167 3168 case CMS_PACK_FLAGS_16BITS: { 3169 3170 for (i=0; i < sizeof(OutputFormatters16) / sizeof(cmsFormatters16); i++) { 3171 cmsFormatters16* f = OutputFormatters16 + i; 3172 3173 if ((dwInput & ~f ->Mask) == f ->Type) { 3174 fr.Fmt16 = f ->Frm; 3175 return fr; 3176 } 3177 } 3178 } 3179 break; 3180 3181 case CMS_PACK_FLAGS_FLOAT: { 3182 3183 for (i=0; i < sizeof(OutputFormattersFloat) / sizeof(cmsFormattersFloat); i++) { 3184 cmsFormattersFloat* f = OutputFormattersFloat + i; 3185 3186 if ((dwInput & ~f ->Mask) == f ->Type) { 3187 fr.FmtFloat = f ->Frm; 3188 return fr; 3189 } 3190 } 3191 } 3192 break; 3193 3194 default:; 3195 3196 } 3197 3198 fr.Fmt16 = NULL; 3199 return fr; 3200 } 3201 3202 3203 typedef struct _cms_formatters_factory_list { 3204 3205 cmsFormatterFactory Factory; 3206 struct _cms_formatters_factory_list *Next; 3207 3208 } cmsFormattersFactoryList; 3209 3210 _cmsFormattersPluginChunkType _cmsFormattersPluginChunk = { NULL }; 3211 3212 3213 // Duplicates the zone of memory used by the plug-in in the new context 3214 static 3215 void DupFormatterFactoryList(struct _cmsContext_struct* ctx, 3216 const struct _cmsContext_struct* src) 3217 { 3218 _cmsFormattersPluginChunkType newHead = { NULL }; 3219 cmsFormattersFactoryList* entry; 3220 cmsFormattersFactoryList* Anterior = NULL; 3221 _cmsFormattersPluginChunkType* head = (_cmsFormattersPluginChunkType*) src->chunks[FormattersPlugin]; 3222 3223 _cmsAssert(head != NULL); 3224 3225 // Walk the list copying all nodes 3226 for (entry = head->FactoryList; 3227 entry != NULL; 3228 entry = entry ->Next) { 3229 3230 cmsFormattersFactoryList *newEntry = ( cmsFormattersFactoryList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(cmsFormattersFactoryList)); 3231 3232 if (newEntry == NULL) 3233 return; 3234 3235 // We want to keep the linked list order, so this is a little bit tricky 3236 newEntry -> Next = NULL; 3237 if (Anterior) 3238 Anterior -> Next = newEntry; 3239 3240 Anterior = newEntry; 3241 3242 if (newHead.FactoryList == NULL) 3243 newHead.FactoryList = newEntry; 3244 } 3245 3246 ctx ->chunks[FormattersPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsFormattersPluginChunkType)); 3247 } 3248 3249 // The interpolation plug-in memory chunk allocator/dup 3250 void _cmsAllocFormattersPluginChunk(struct _cmsContext_struct* ctx, 3251 const struct _cmsContext_struct* src) 3252 { 3253 _cmsAssert(ctx != NULL); 3254 3255 if (src != NULL) { 3256 3257 // Duplicate the LIST 3258 DupFormatterFactoryList(ctx, src); 3259 } 3260 else { 3261 static _cmsFormattersPluginChunkType FormattersPluginChunk = { NULL }; 3262 ctx ->chunks[FormattersPlugin] = _cmsSubAllocDup(ctx ->MemPool, &FormattersPluginChunk, sizeof(_cmsFormattersPluginChunkType)); 3263 } 3264 } 3265 3266 3267 3268 // Formatters management 3269 cmsBool _cmsRegisterFormattersPlugin(cmsContext ContextID, cmsPluginBase* Data) 3270 { 3271 _cmsFormattersPluginChunkType* ctx = ( _cmsFormattersPluginChunkType*) _cmsContextGetClientChunk(ContextID, FormattersPlugin); 3272 cmsPluginFormatters* Plugin = (cmsPluginFormatters*) Data; 3273 cmsFormattersFactoryList* fl ; 3274 3275 // Reset to built-in defaults 3276 if (Data == NULL) { 3277 3278 ctx ->FactoryList = NULL; 3279 return TRUE; 3280 } 3281 3282 fl = (cmsFormattersFactoryList*) _cmsPluginMalloc(ContextID, sizeof(cmsFormattersFactoryList)); 3283 if (fl == NULL) return FALSE; 3284 3285 fl ->Factory = Plugin ->FormattersFactory; 3286 3287 fl ->Next = ctx -> FactoryList; 3288 ctx ->FactoryList = fl; 3289 3290 return TRUE; 3291 } 3292 3293 cmsFormatter _cmsGetFormatter(cmsContext ContextID, 3294 cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8 3295 cmsFormatterDirection Dir, 3296 cmsUInt32Number dwFlags) 3297 { 3298 _cmsFormattersPluginChunkType* ctx = ( _cmsFormattersPluginChunkType*) _cmsContextGetClientChunk(ContextID, FormattersPlugin); 3299 cmsFormattersFactoryList* f; 3300 3301 for (f =ctx->FactoryList; f != NULL; f = f ->Next) { 3302 3303 cmsFormatter fn = f ->Factory(Type, Dir, dwFlags); 3304 if (fn.Fmt16 != NULL) return fn; 3305 } 3306 3307 // Revert to default 3308 if (Dir == cmsFormatterInput) 3309 return _cmsGetStockInputFormatter(Type, dwFlags); 3310 else 3311 return _cmsGetStockOutputFormatter(Type, dwFlags); 3312 } 3313 3314 3315 // Return whatever given formatter refers to float values 3316 cmsBool _cmsFormatterIsFloat(cmsUInt32Number Type) 3317 { 3318 return T_FLOAT(Type) ? TRUE : FALSE; 3319 } 3320 3321 // Return whatever given formatter refers to 8 bits 3322 cmsBool _cmsFormatterIs8bit(cmsUInt32Number Type) 3323 { 3324 int Bytes = T_BYTES(Type); 3325 3326 return (Bytes == 1); 3327 } 3328 3329 // Build a suitable formatter for the colorspace of this profile 3330 cmsUInt32Number CMSEXPORT cmsFormatterForColorspaceOfProfile(cmsHPROFILE hProfile, cmsUInt32Number nBytes, cmsBool lIsFloat) 3331 { 3332 3333 cmsColorSpaceSignature ColorSpace = cmsGetColorSpace(hProfile); 3334 cmsUInt32Number ColorSpaceBits = _cmsLCMScolorSpace(ColorSpace); 3335 cmsUInt32Number nOutputChans = cmsChannelsOf(ColorSpace); 3336 cmsUInt32Number Float = lIsFloat ? 1 : 0; 3337 3338 // Create a fake formatter for result 3339 return FLOAT_SH(Float) | COLORSPACE_SH(ColorSpaceBits) | BYTES_SH(nBytes) | CHANNELS_SH(nOutputChans); 3340 } 3341 3342 // Build a suitable formatter for the colorspace of this profile 3343 cmsUInt32Number CMSEXPORT cmsFormatterForPCSOfProfile(cmsHPROFILE hProfile, cmsUInt32Number nBytes, cmsBool lIsFloat) 3344 { 3345 3346 cmsColorSpaceSignature ColorSpace = cmsGetPCS(hProfile); 3347 int ColorSpaceBits = _cmsLCMScolorSpace(ColorSpace); 3348 cmsUInt32Number nOutputChans = cmsChannelsOf(ColorSpace); 3349 cmsUInt32Number Float = lIsFloat ? 1 : 0; 3350 3351 // Create a fake formatter for result 3352 return FLOAT_SH(Float) | COLORSPACE_SH(ColorSpaceBits) | BYTES_SH(nBytes) | CHANNELS_SH(nOutputChans); 3353 } 3354 3355
