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