/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

// This file is available under and governed by the GNU General Public
// License version 2 only, as published by the Free Software Foundation.
// However, the following notice accompanied the original version of this
// file:
//
//  Little cms
//  Copyright (C) 1998-2007 Marti Maria
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software
// is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


#include "lcms.h"

// This module handles all formats supported by lcms


// ---------------------------------------------------------------------------


// This macro return words stored as big endian

#define CHANGE_ENDIAN(w)    (WORD) ((WORD) ((w)<<8)|((w)>>8))

// These macros handles reversing (negative)

#define REVERSE_FLAVOR_8(x)     ((BYTE) (0xff-(x)))
#define REVERSE_FLAVOR_16(x)    ((WORD)(0xffff-(x)))

// Supress waning about info never being used

#ifdef __BORLANDC__
#pragma warn -par
#endif

#ifdef _MSC_VER
#pragma warning(disable : 4100)
#endif

// -------------------------------------------------------- Unpacking routines.


static
LPBYTE UnrollAnyBytes(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       int nChan = T_CHANNELS(info -> InputFormat);
       register int i;

       for (i=0; i < nChan; i++) {

              wIn[i] = RGB_8_TO_16(*accum); accum++;
       }

       return accum + T_EXTRA(info -> InputFormat);
}


static
LPBYTE Unroll4Bytes(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = RGB_8_TO_16(*accum); accum++; // C
       wIn[1] = RGB_8_TO_16(*accum); accum++; // M
       wIn[2] = RGB_8_TO_16(*accum); accum++; // Y
       wIn[3] = RGB_8_TO_16(*accum); accum++; // K

       return accum;
}

static
LPBYTE Unroll4BytesReverse(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = RGB_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // C
       wIn[1] = RGB_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // M
       wIn[2] = RGB_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // Y
       wIn[3] = RGB_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // K

       return accum;
}


static
LPBYTE Unroll4BytesSwapFirst(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{

       wIn[3] = RGB_8_TO_16(*accum); accum++; // K
       wIn[0] = RGB_8_TO_16(*accum); accum++; // C
       wIn[1] = RGB_8_TO_16(*accum); accum++; // M
       wIn[2] = RGB_8_TO_16(*accum); accum++; // Y


       return accum;
}


// KYMC
static
LPBYTE Unroll4BytesSwap(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[3] = RGB_8_TO_16(*accum); accum++;  // K
       wIn[2] = RGB_8_TO_16(*accum); accum++;  // Y
       wIn[1] = RGB_8_TO_16(*accum); accum++;  // M
       wIn[0] = RGB_8_TO_16(*accum); accum++;  // C

       return accum;
}


static
LPBYTE Unroll4BytesSwapSwapFirst(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[2] = RGB_8_TO_16(*accum); accum++;  // K
       wIn[1] = RGB_8_TO_16(*accum); accum++;  // Y
       wIn[0] = RGB_8_TO_16(*accum); accum++;  // M
       wIn[3] = RGB_8_TO_16(*accum); accum++;  // C

       return accum;
}


static
LPBYTE UnrollAnyWords(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
     int nChan = T_CHANNELS(info -> InputFormat);
     register int i;

     for (i=0; i < nChan; i++) {

              wIn[i] = *(LPWORD) accum; accum += 2;
     }

     return accum + T_EXTRA(info -> InputFormat) * sizeof(WORD);
}


static
LPBYTE Unroll4Words(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = *(LPWORD) accum; accum+= 2; // C
       wIn[1] = *(LPWORD) accum; accum+= 2; // M
       wIn[2] = *(LPWORD) accum; accum+= 2; // Y
       wIn[3] = *(LPWORD) accum; accum+= 2; // K

       return accum;
}

static
LPBYTE Unroll4WordsReverse(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = REVERSE_FLAVOR_16(*(LPWORD) accum); accum+= 2; // C
       wIn[1] = REVERSE_FLAVOR_16(*(LPWORD) accum); accum+= 2; // M
       wIn[2] = REVERSE_FLAVOR_16(*(LPWORD) accum); accum+= 2; // Y
       wIn[3] = REVERSE_FLAVOR_16(*(LPWORD) accum); accum+= 2; // K

       return accum;
}


static
LPBYTE Unroll4WordsSwapFirst(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[3] = *(LPWORD) accum; accum+= 2; // K
       wIn[0] = *(LPWORD) accum; accum+= 2; // C
       wIn[1] = *(LPWORD) accum; accum+= 2; // M
       wIn[2] = *(LPWORD) accum; accum+= 2; // Y

       return accum;
}


// KYMC
static
LPBYTE Unroll4WordsSwap(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[3] = *(LPWORD) accum; accum+= 2; // K
       wIn[2] = *(LPWORD) accum; accum+= 2; // Y
       wIn[1] = *(LPWORD) accum; accum+= 2; // M
       wIn[0] = *(LPWORD) accum; accum+= 2; // C

       return accum;
}

static
LPBYTE Unroll4WordsSwapSwapFirst(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[2] = *(LPWORD) accum; accum+= 2; // K
       wIn[1] = *(LPWORD) accum; accum+= 2; // Y
       wIn[0] = *(LPWORD) accum; accum+= 2; // M
       wIn[3] = *(LPWORD) accum; accum+= 2; // C

       return accum;
}


static
LPBYTE Unroll4WordsBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //C
       wIn[1] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //M
       wIn[2] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //Y
       wIn[3] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //K

       return accum;
}

static
LPBYTE Unroll4WordsBigEndianReverse(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = REVERSE_FLAVOR_16(CHANGE_ENDIAN(*(LPWORD) accum)); accum+= 2; //C
       wIn[1] = REVERSE_FLAVOR_16(CHANGE_ENDIAN(*(LPWORD) accum)); accum+= 2; //M
       wIn[2] = REVERSE_FLAVOR_16(CHANGE_ENDIAN(*(LPWORD) accum)); accum+= 2; //Y
       wIn[3] = REVERSE_FLAVOR_16(CHANGE_ENDIAN(*(LPWORD) accum)); accum+= 2; //K

       return accum;
}


// KYMC
static
LPBYTE Unroll4WordsSwapBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[3] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //K
       wIn[2] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //Y
       wIn[1] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //M
       wIn[0] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2; //C

       return accum;
}

static
LPBYTE Unroll3Bytes(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{

       wIn[0] = RGB_8_TO_16(*accum); accum++;     // R
       wIn[1] = RGB_8_TO_16(*accum); accum++;     // G
       wIn[2] = RGB_8_TO_16(*accum); accum++;     // B

       return accum;
}


// Lab8 encoding using v2 PCS

static
LPBYTE Unroll3BytesLab(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{

       wIn[0] = (WORD) ((*accum) << 8); accum++;
       wIn[1] = (WORD) ((*accum) << 8); accum++;
       wIn[2] = (WORD) ((*accum) << 8); accum++;

       return accum;
}


// BRG

static
LPBYTE Unroll3BytesSwap(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{

       wIn[2] = RGB_8_TO_16(*accum); accum++;     // B
       wIn[1] = RGB_8_TO_16(*accum); accum++;     // G
       wIn[0] = RGB_8_TO_16(*accum); accum++;     // R

       return accum;
}

static
LPBYTE Unroll3Words(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = *(LPWORD) accum; accum+= 2;  // C R
       wIn[1] = *(LPWORD) accum; accum+= 2;  // M G
       wIn[2] = *(LPWORD) accum; accum+= 2;  // Y B
       return accum;
}


static
LPBYTE Unroll3WordsSwap(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[2] = *(LPWORD) accum; accum+= 2;  // C R
       wIn[1] = *(LPWORD) accum; accum+= 2;  // M G
       wIn[0] = *(LPWORD) accum; accum+= 2;  // Y B
       return accum;
}


static
LPBYTE Unroll3WordsBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       wIn[1] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       wIn[2] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       return accum;
}


static
LPBYTE Unroll3WordsSwapBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[2] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       wIn[1] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       wIn[0] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       return accum;
}


// Monochrome duplicates L into RGB for null-transforms

static
LPBYTE Unroll1Byte(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = RGB_8_TO_16(*accum); accum++;     // L
       return accum;
}


static
LPBYTE Unroll1ByteSkip2(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = RGB_8_TO_16(*accum); accum++;     // L
       accum += 2;
       return accum;
}

static
LPBYTE Unroll1ByteReversed(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(RGB_8_TO_16(*accum)); accum++;     // L
       return accum;
}


static
LPBYTE Unroll1Word(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = *(LPWORD) accum; accum+= 2;   // L
       return accum;
}

static
LPBYTE Unroll1WordReversed(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(*(LPWORD) accum); accum+= 2;
       return accum;
}


static
LPBYTE Unroll1WordBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       return accum;
}

static
LPBYTE Unroll1WordSkip3(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = *(LPWORD) accum;

       accum += 8;
       return accum;
}


// Monochrome + alpha. Alpha is lost

static
LPBYTE Unroll2Byte(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = RGB_8_TO_16(*accum); accum++;     // L
       wIn[3] = RGB_8_TO_16(*accum); accum++;                       // alpha
       return accum;
}

static
LPBYTE Unroll2ByteSwapFirst(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[3] = RGB_8_TO_16(*accum); accum++;                       // alpha
       wIn[0] = wIn[1] = wIn[2] = RGB_8_TO_16(*accum); accum++;     // L
       return accum;
}


static
LPBYTE Unroll2Word(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = *(LPWORD) accum; accum+= 2;   // L
       wIn[3] = *(LPWORD) accum; accum += 2;                    // alpha

       return accum;
}


static
LPBYTE Unroll2WordSwapFirst(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[3] = *(LPWORD) accum; accum += 2;                    // alpha
       wIn[0] = wIn[1] = wIn[2] = *(LPWORD) accum; accum+= 2;   // L

       return accum;
}

static
LPBYTE Unroll2WordBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       wIn[0] = wIn[1] = wIn[2] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;
       wIn[3] = CHANGE_ENDIAN(*(LPWORD) accum); accum+= 2;

       return accum;
}


static
LPBYTE UnrollPlanarBytes(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       int nChan = T_CHANNELS(info -> InputFormat);
       register int i;
       LPBYTE Init = accum;

       for (i=0; i < nChan; i++) {

              wIn[i] = RGB_8_TO_16(*accum);
              accum += info -> StrideIn;
       }

       return (Init + 1);
}


static
LPBYTE UnrollPlanarWords(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       int nChan = T_CHANNELS(info -> InputFormat);
       register int i;
       LPBYTE Init = accum;

       for (i=0; i < nChan; i++) {

              wIn[i] = *(LPWORD) accum;
              accum += (info -> StrideIn * sizeof(WORD));
       }

       return (Init + sizeof(WORD));
}


static
LPBYTE UnrollPlanarWordsBigEndian(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
       int nChan = T_CHANNELS(info -> InputFormat);
       register int i;
       LPBYTE Init = accum;

       for (i=0; i < nChan; i++) {

              wIn[i] = CHANGE_ENDIAN(*(LPWORD) accum);
              accum += (info -> StrideIn * sizeof(WORD));
       }

       return (Init + sizeof(WORD));
}


// floating point
static
LPBYTE UnrollLabDouble(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{

    if (T_PLANAR(info -> InputFormat)) {

        double* Pt = (double*) accum;

        cmsCIELab Lab;

        Lab.L = Pt[0];
        Lab.a = Pt[info->StrideIn];
        Lab.b = Pt[info->StrideIn*2];

        if (info ->lInputV4Lab)
            cmsFloat2LabEncoded4(wIn, &Lab);
        else
            cmsFloat2LabEncoded(wIn, &Lab);

        return accum + sizeof(double);
    }
    else {

        if (info ->lInputV4Lab)
            cmsFloat2LabEncoded4(wIn, (LPcmsCIELab) accum);
        else
            cmsFloat2LabEncoded(wIn, (LPcmsCIELab) accum);

        accum += sizeof(cmsCIELab);

        return accum;
    }
}

static
LPBYTE UnrollXYZDouble(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
    if (T_PLANAR(info -> InputFormat)) {

        double* Pt = (double*) accum;
        cmsCIEXYZ XYZ;

        XYZ.X = Pt[0];
        XYZ.Y = Pt[info->StrideIn];
        XYZ.Z = Pt[info->StrideIn*2];
        cmsFloat2XYZEncoded(wIn, &XYZ);

        return accum + sizeof(double);

    }

    else {


        cmsFloat2XYZEncoded(wIn, (LPcmsCIEXYZ) accum);
        accum += sizeof(cmsCIEXYZ);

        return accum;
    }
}


// Inks does come in percentage
static
LPBYTE UnrollInkDouble(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
    double* Inks = (double*) accum;
    int nChan  = T_CHANNELS(info -> InputFormat);
    int Planar = T_PLANAR(info -> InputFormat);
    int i;
    double v;

    for (i=0; i <  nChan; i++) {

        if (Planar)

            v = Inks[i * info ->StrideIn];
        else
            v = Inks[i];

        v = floor(v * 655.35 + 0.5);

        if (v > 65535.0) v = 65535.0;
        if (v < 0) v = 0;

        wIn[i] = (WORD) v;
    }

    if (T_PLANAR(info -> InputFormat))
        return accum + sizeof(double);
    else
        return accum + (nChan + T_EXTRA(info ->InputFormat)) * sizeof(double);
}


// Remaining cases are between 0..1.0
static
LPBYTE UnrollDouble(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
    double* Inks = (double*) accum;
    int nChan = T_CHANNELS(info -> InputFormat);
    int Planar = T_PLANAR(info -> InputFormat);
    int i;
    double v;

    for (i=0; i < nChan; i++) {

        if (Planar)

            v = Inks[i * info ->StrideIn];
        else
            v = Inks[i];

        v = floor(v * 65535.0 + 0.5);

        if (v > 65535.0) v = 65535.0;
        if (v < 0) v = 0;

        wIn[i] = (WORD) v;
    }

    if (T_PLANAR(info -> InputFormat))
        return accum + sizeof(double);
    else
        return accum + (nChan + T_EXTRA(info ->InputFormat)) * sizeof(double);
}


static
LPBYTE UnrollDouble1Chan(register _LPcmsTRANSFORM info, register WORD wIn[], register LPBYTE accum)
{
    double* Inks = (double*) accum;
    double v;


    v = floor(Inks[0] * 65535.0 + 0.5);

    if (v > 65535.0) v = 65535.0;
    if (v < 0) v = 0;


    wIn[0] = wIn[1] = wIn[2] = (WORD) v;

    return accum + sizeof(double);
}


// ----------------------------------------------------------- Packing routines


// Generic N-bytes plus dither 16-to-8 conversion. Currently is just a quick hack

static int err[MAXCHANNELS];

static
LPBYTE PackNBytesDither(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;
       unsigned int n, pe, pf;

       for (i=0; i < nChan;  i++) {

              n = wOut[i] + err[i]; // Value

              pe = (n / 257);       // Whole part
              pf = (n % 257);       // Fractional part

              err[i] = pf;          // Store it for next pixel

              *output++ = (BYTE) pe;
       }

       return output + T_EXTRA(info ->OutputFormat);
}


static
LPBYTE PackNBytesSwapDither(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;
       unsigned int n, pe, pf;

       for (i=nChan-1; i >= 0;  --i) {

              n = wOut[i] + err[i];     // Value

              pe = (n / 257);           // Whole part
              pf = (n % 257);           // Fractional part

              err[i] = pf;              // Store it for next pixel

              *output++ = (BYTE) pe;
       }


       return output + T_EXTRA(info ->OutputFormat);
}


// Generic chunky for byte

static
LPBYTE PackNBytes(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;

       for (i=0; i < nChan;  i++)
              *output++ = RGB_16_TO_8(wOut[i]);

       return output + T_EXTRA(info ->OutputFormat);
}

// Chunky reversed order bytes

static
LPBYTE PackNBytesSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;

       for (i=nChan-1; i >= 0;  --i)
              *output++ = RGB_16_TO_8(wOut[i]);

       return output + T_EXTRA(info ->OutputFormat);

}


static
LPBYTE PackNWords(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;

       for (i=0; i < nChan; i++) {
              *(LPWORD) output = wOut[i];
              output += sizeof(WORD);
       }

       return output + T_EXTRA(info ->OutputFormat) * sizeof(WORD);
}

static
LPBYTE PackNWordsSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;

       for (i=nChan-1; i >= 0; --i) {
              *(LPWORD) output = wOut[i];
              output += sizeof(WORD);
       }

       return output + T_EXTRA(info ->OutputFormat) * sizeof(WORD);
}


static
LPBYTE PackNWordsBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;

       for (i=0; i < nChan; i++) {
              *(LPWORD) output = CHANGE_ENDIAN(wOut[i]);
              output += sizeof(WORD);
       }

       return output + T_EXTRA(info ->OutputFormat) * sizeof(WORD);
}


static
LPBYTE PackNWordsSwapBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan  = T_CHANNELS(info -> OutputFormat);
       register int i;

       for (i=nChan-1; i >= 0; --i) {
              *(LPWORD) output = CHANGE_ENDIAN(wOut[i]);
              output += sizeof(WORD);
       }

       return output + T_EXTRA(info ->OutputFormat) * sizeof(WORD);
}


static
LPBYTE PackPlanarBytes(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan = T_CHANNELS(info -> OutputFormat);
       register int i;
       LPBYTE Init = output;

       for (i=0; i < nChan; i++) {

              *(LPBYTE) output = RGB_16_TO_8(wOut[i]);
              output += info -> StrideOut;
       }

       return (Init + 1);
}


static
LPBYTE PackPlanarWords(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       int nChan = T_CHANNELS(info -> OutputFormat);
       register int i;
       LPBYTE Init = output;

       for (i=0; i < nChan; i++) {

              *(LPWORD) output = wOut[i];
              output += (info -> StrideOut * sizeof(WORD));
       }

       return (Init + 2);
}


// CMYKcm (unrolled for speed)

static
LPBYTE Pack6Bytes(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
         *output++ = RGB_16_TO_8(wOut[0]);
         *output++ = RGB_16_TO_8(wOut[1]);
         *output++ = RGB_16_TO_8(wOut[2]);
         *output++ = RGB_16_TO_8(wOut[3]);
         *output++ = RGB_16_TO_8(wOut[4]);
         *output++ = RGB_16_TO_8(wOut[5]);

         return output;
}

// KCMYcm

static
LPBYTE Pack6BytesSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[3]);
       *output++ = RGB_16_TO_8(wOut[0]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[2]);
       *output++ = RGB_16_TO_8(wOut[4]);
       *output++ = RGB_16_TO_8(wOut[5]);

       return output;
}

// CMYKcm
static
LPBYTE Pack6Words(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[0];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[3];
       output+= 2;
       *(LPWORD) output = wOut[4];
       output+= 2;
       *(LPWORD) output = wOut[5];
       output+= 2;

       return output;
}

// KCMYcm
static
LPBYTE Pack6WordsSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[3];
       output+= 2;
       *(LPWORD) output = wOut[0];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[4];
       output+= 2;
       *(LPWORD) output = wOut[5];
       output+= 2;

       return output;
}

// CMYKcm
static
LPBYTE Pack6WordsBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[3]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[4]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[5]);
       output+= 2;

       return output;
}

// KCMYcm
static
LPBYTE Pack6WordsSwapBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[3]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[4]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[5]);
       output+= 2;

       return output;
}


static
LPBYTE Pack4Bytes(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
         *output++ = RGB_16_TO_8(wOut[0]);
         *output++ = RGB_16_TO_8(wOut[1]);
         *output++ = RGB_16_TO_8(wOut[2]);
         *output++ = RGB_16_TO_8(wOut[3]);

         return output;
}

static
LPBYTE Pack4BytesReverse(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
         *output++ = REVERSE_FLAVOR_8(RGB_16_TO_8(wOut[0]));
         *output++ = REVERSE_FLAVOR_8(RGB_16_TO_8(wOut[1]));
         *output++ = REVERSE_FLAVOR_8(RGB_16_TO_8(wOut[2]));
         *output++ = REVERSE_FLAVOR_8(RGB_16_TO_8(wOut[3]));

         return output;
}


static
LPBYTE Pack4BytesSwapFirst(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
         *output++ = RGB_16_TO_8(wOut[3]);
         *output++ = RGB_16_TO_8(wOut[0]);
         *output++ = RGB_16_TO_8(wOut[1]);
         *output++ = RGB_16_TO_8(wOut[2]);

         return output;
}


// ABGR

static
LPBYTE Pack4BytesSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[3]);
       *output++ = RGB_16_TO_8(wOut[2]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[0]);

       return output;
}


static
LPBYTE Pack4BytesSwapSwapFirst(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[2]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[0]);
       *output++ = RGB_16_TO_8(wOut[3]);

       return output;
}


static
LPBYTE Pack4Words(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[0];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[3];
       output+= 2;

       return output;
}


static
LPBYTE Pack4WordsReverse(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = REVERSE_FLAVOR_16(wOut[0]);
       output+= 2;
       *(LPWORD) output = REVERSE_FLAVOR_16(wOut[1]);
       output+= 2;
       *(LPWORD) output = REVERSE_FLAVOR_16(wOut[2]);
       output+= 2;
       *(LPWORD) output = REVERSE_FLAVOR_16(wOut[3]);
       output+= 2;

       return output;
}

// ABGR

static
LPBYTE Pack4WordsSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[3];
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[0];
       output+= 2;

       return output;
}

// CMYK
static
LPBYTE Pack4WordsBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[3]);
       output+= 2;

       return output;
}


static
LPBYTE Pack4WordsBigEndianReverse(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(REVERSE_FLAVOR_16(wOut[0]));
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(REVERSE_FLAVOR_16(wOut[1]));
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(REVERSE_FLAVOR_16(wOut[2]));
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(REVERSE_FLAVOR_16(wOut[3]));
       output+= 2;

       return output;
}

// KYMC

static
LPBYTE Pack4WordsSwapBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[3]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;

       return output;
}

static
LPBYTE Pack3Bytes(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[0]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[2]);

       return output;
}

static
LPBYTE Pack3BytesLab(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *output++ = (BYTE) (wOut[0] >> 8);
       *output++ = (BYTE) (wOut[1] >> 8);
       *output++ = (BYTE) (wOut[2] >> 8);

       return output;
}


static
LPBYTE Pack3BytesSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[2]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[0]);

       return output;
}


static
LPBYTE Pack3Words(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[0];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;

       return output;
}

static
LPBYTE Pack3WordsSwap(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[0];
       output+= 2;

       return output;
}

static
LPBYTE Pack3WordsBigEndian(register _LPcmsTRANSFORM info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;

       return output;
}


static
LPBYTE Pack3WordsSwapBigEndian(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;

       return output;
}


static
LPBYTE Pack3BytesAndSkip1(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[0]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[2]);
       output++;

       return output;
}


static
LPBYTE Pack3BytesAndSkip1SwapFirst(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
        output++;
       *output++ = RGB_16_TO_8(wOut[0]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[2]);

       return output;
}

static
LPBYTE Pack3BytesAndSkip1Swap(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
        output++;
       *output++ = RGB_16_TO_8(wOut[2]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[0]);

       return output;
}


static
LPBYTE Pack3BytesAndSkip1SwapSwapFirst(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[2]);
       *output++ = RGB_16_TO_8(wOut[1]);
       *output++ = RGB_16_TO_8(wOut[0]);
       output++;

       return output;
}


static
LPBYTE Pack3WordsAndSkip1(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[0];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;
       output+= 2;

       return output;
}

static
LPBYTE Pack3WordsAndSkip1Swap(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       output+= 2;
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[0];
       output+= 2;


       return output;
}


static
LPBYTE Pack3WordsAndSkip1SwapSwapFirst(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[2];
       output+= 2;
       *(LPWORD) output = wOut[1];
       output+= 2;
       *(LPWORD) output = wOut[0];
       output+= 2;
       output+= 2;


       return output;
}


static
LPBYTE Pack3WordsAndSkip1BigEndian(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       output+= 2;

       return output;
}


static
LPBYTE Pack3WordsAndSkip1SwapBigEndian(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
        output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[2]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[1]);
       output+= 2;
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;


       return output;
}


static
LPBYTE Pack1Byte(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[0]);
       return output;
}


static
LPBYTE Pack1ByteAndSkip1(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *output++ = RGB_16_TO_8(wOut[0]);
       output++;
       return output;
}


static
LPBYTE Pack1ByteAndSkip1SwapFirst(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       output++;
       *output++ = RGB_16_TO_8(wOut[0]);

       return output;
}

static
LPBYTE Pack1Word(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[0];
       output+= 2;

       return output;
}

static
LPBYTE Pack1WordBigEndian(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 2;

       return output;
}


static
LPBYTE Pack1WordAndSkip1(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = wOut[0];
       output+= 4;

       return output;
}

static
LPBYTE Pack1WordAndSkip1SwapFirst(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       output += 2;
       *(LPWORD) output = wOut[0];
       output+= 2;

       return output;
}


static
LPBYTE Pack1WordAndSkip1BigEndian(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
       *(LPWORD) output = CHANGE_ENDIAN(wOut[0]);
       output+= 4;

       return output;
}


// Unencoded Float values -- don't try optimize speed

static
LPBYTE PackLabDouble(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{

    if (T_PLANAR(Info -> OutputFormat)) {

        cmsCIELab  Lab;
        double* Out = (double*) output;
        cmsLabEncoded2Float(&Lab, wOut);

        Out[0]                  = Lab.L;
        Out[Info ->StrideOut]   = Lab.a;
        Out[Info ->StrideOut*2] = Lab.b;

        return output + sizeof(double);

    }
    else {

       if (Info ->lOutputV4Lab)
           cmsLabEncoded2Float4((LPcmsCIELab) output, wOut);
       else
           cmsLabEncoded2Float((LPcmsCIELab) output, wOut);

        return output + (sizeof(cmsCIELab) + T_EXTRA(Info ->OutputFormat) * sizeof(double));
    }

}

static
LPBYTE PackXYZDouble(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{

    if (T_PLANAR(Info -> OutputFormat)) {

        cmsCIEXYZ XYZ;
        double* Out = (double*) output;
        cmsXYZEncoded2Float(&XYZ, wOut);

        Out[0]                  = XYZ.X;
        Out[Info ->StrideOut]   = XYZ.Y;
        Out[Info ->StrideOut*2] = XYZ.Z;

        return output + sizeof(double);

    }
    else {

        cmsXYZEncoded2Float((LPcmsCIEXYZ) output, wOut);

        return output + (sizeof(cmsCIEXYZ) + T_EXTRA(Info ->OutputFormat) * sizeof(double));
    }
}


static
LPBYTE PackInkDouble(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
    double* Inks = (double*) output;
    int nChan = T_CHANNELS(Info -> OutputFormat);
    int i;

    if (T_PLANAR(Info -> OutputFormat)) {

        for (i=0; i <  nChan; i++) {

            Inks[i*Info ->StrideOut] = wOut[i] / 655.35;
        }

        return output + sizeof(double);
    }
    else {

        for (i=0; i <  nChan; i++) {

            Inks[i] = wOut[i] /  655.35;
        }


    return output + (nChan + T_EXTRA(Info ->OutputFormat)) * sizeof(double);
    }

}


static
LPBYTE PackDouble(register _LPcmsTRANSFORM Info, register WORD wOut[], register LPBYTE output)
{
    double* Inks = (double*) output;
    int nChan = T_CHANNELS(Info -> OutputFormat);
    int i;


    if (T_PLANAR(Info -> OutputFormat)) {

        for (i=0; i <  nChan; i++) {

            Inks[i*Info ->StrideOut] = wOut[i] / 65535.0;
        }

        return output + sizeof(double);

    }
    else {
        for (i=0; i <  nChan; i++) {

            Inks[i] = wOut[i] /  65535.0;
        }

        return output + (nChan + T_EXTRA(Info ->OutputFormat)) * sizeof(double);
    }

}


//  choose routine from Input identifier

_cmsFIXFN _cmsIdentifyInputFormat(_LPcmsTRANSFORM xform, DWORD dwInput)
{
       _cmsFIXFN FromInput = NULL;


       // Check Named Color

       if (xform) {

           if (xform ->InputProfile) {

           if (cmsGetDeviceClass(xform ->InputProfile) == icSigNamedColorClass) {

                if (dwInput != TYPE_NAMED_COLOR_INDEX) {
                    cmsSignalError(LCMS_ERRC_ABORTED, "Named color needs TYPE_NAMED_COLOR_INDEX");
                    return NULL;
                }
           }

        }
       }

       // Unencoded modes

       if (T_BYTES(dwInput) == 0) {

           switch (T_COLORSPACE(dwInput)) {

           case PT_Lab:
                    FromInput = UnrollLabDouble;
                    break;
           case PT_XYZ:
                    FromInput = UnrollXYZDouble;
                    break;

           // 0.0 .. 1.0 range

           case PT_GRAY:
           case PT_RGB:
           case PT_YCbCr:
           case PT_YUV:
           case PT_YUVK:
           case PT_HSV:
           case PT_HLS:
           case PT_Yxy:
                    if (T_CHANNELS(dwInput) == 1)
                        FromInput = UnrollDouble1Chan;
                    else
                        FromInput = UnrollDouble;
                    break;

            // Inks (%) 0.0 .. 100.0

           default:
                    FromInput = UnrollInkDouble;
                    break;
           }

       }
       else {

           if (T_PLANAR(dwInput)) {

               switch (T_BYTES(dwInput)) {

               case 1:
                   FromInput = UnrollPlanarBytes;
                   break;

               case 2:
                   if (T_ENDIAN16(dwInput))
                       FromInput = UnrollPlanarWordsBigEndian;
                   else
                       FromInput = UnrollPlanarWords;
                   break;

               default:;
               }
       }
       else {

       switch (T_BYTES(dwInput)) {

       case 1: // 1 byte per channel

              switch (T_CHANNELS(dwInput) + T_EXTRA(dwInput)) {

              case 1: if (T_FLAVOR(dwInput))
                                FromInput = Unroll1ByteReversed;
                            else
                                  FromInput = Unroll1Byte;
                      break;

              case 2: if (T_SWAPFIRST(dwInput))
                        FromInput = Unroll2ByteSwapFirst;
                      else
                        FromInput = Unroll2Byte;
                      break;

              case 3: if (T_DOSWAP(dwInput))
                            FromInput = Unroll3BytesSwap;
                      else {
                            if (T_EXTRA(dwInput) == 2)
                                FromInput = Unroll1ByteSkip2;
                            else
                                if (T_COLORSPACE(dwInput) == PT_Lab)
                                    FromInput = Unroll3BytesLab;
                                else
                                    FromInput = Unroll3Bytes;
                      }
                      break;
              case 4:
                      // TODO: ALab8 must be fixed to match v2 encoding

                      if (T_DOSWAP(dwInput)) {
                            if (T_SWAPFIRST(dwInput))

                                FromInput = Unroll4BytesSwapSwapFirst;
                            else
                                FromInput = Unroll4BytesSwap;
                      }
                      else {
                            if (T_SWAPFIRST(dwInput))
                                FromInput = Unroll4BytesSwapFirst;
                            else {
                                if (T_FLAVOR(dwInput))
                                    FromInput = Unroll4BytesReverse;
                                else
                                    FromInput = Unroll4Bytes;
                            }
                      }
                      break;


              case 5:
              case 6:
              case 7:
              case 8:
                   if (!T_DOSWAP(dwInput) && !T_SWAPFIRST(dwInput))
                       FromInput = UnrollAnyBytes;
                   break;


              default:;
              }
              break;


       case 2: // 1 word per channel

              switch (T_CHANNELS(dwInput) + T_EXTRA(dwInput))
              {
              case 1: if (T_ENDIAN16(dwInput))
                            FromInput = Unroll1WordBigEndian;
                      else
                          if (T_FLAVOR(dwInput))
                                FromInput = Unroll1WordReversed;
                            else
                                  FromInput = Unroll1Word;
                      break;

              case 2: if (T_ENDIAN16(dwInput))
                            FromInput = Unroll2WordBigEndian;
                        else {
                          if (T_SWAPFIRST(dwInput))
                              FromInput = Unroll2WordSwapFirst;
                          else
                              FromInput = Unroll2Word;
                        }
                        break;

              case 3: if (T_DOSWAP(dwInput)) {
                            if (T_ENDIAN16(dwInput))
                                   FromInput = Unroll3WordsSwapBigEndian;
                            else
                                   FromInput = Unroll3WordsSwap;
                      }
                      else {
                            if (T_ENDIAN16(dwInput))
                                   FromInput = Unroll3WordsBigEndian;
                            else
                                   FromInput = Unroll3Words;
                      }
                      break;

              case 4: if (T_DOSWAP(dwInput)) {

                            if (T_ENDIAN16(dwInput))
                                   FromInput = Unroll4WordsSwapBigEndian;
                            else {

                                    if (T_SWAPFIRST(dwInput))
                                        FromInput = Unroll4WordsSwapSwapFirst;
                                    else
                                        FromInput = Unroll4WordsSwap;

                            }

                      }
                      else {

                            if (T_EXTRA(dwInput) == 3)
                                    FromInput = Unroll1WordSkip3;
                            else

                                if (T_ENDIAN16(dwInput)) {

                                    if (T_FLAVOR(dwInput))
                                        FromInput = Unroll4WordsBigEndianReverse;
                                    else
                                        FromInput = Unroll4WordsBigEndian;
                                }
                            else {
                                  if (T_SWAPFIRST(dwInput))
                                    FromInput = Unroll4WordsSwapFirst;
                                  else {
                                      if (T_FLAVOR(dwInput))
                                            FromInput = Unroll4WordsReverse;
                                      else
                                            FromInput = Unroll4Words;
                                  }
                            }
                      }
                      break;


              case 5:
              case 6:
              case 7:
              case 8:
                    if (!T_DOSWAP(dwInput) && !T_SWAPFIRST(dwInput))
                       FromInput = UnrollAnyWords;
                    break;

              }
              break;

       default:;
       }
       }
       }


       if (!FromInput)
              cmsSignalError(LCMS_ERRC_ABORTED, "Unknown input format");

       return FromInput;
}

//  choose routine from Input identifier

_cmsFIXFN _cmsIdentifyOutputFormat(_LPcmsTRANSFORM xform, DWORD dwOutput)
{
       _cmsFIXFN ToOutput = NULL;


       if (T_BYTES(dwOutput) == 0) {

           switch (T_COLORSPACE(dwOutput)) {

           case PT_Lab:
                    ToOutput = PackLabDouble;
                    break;
           case PT_XYZ:
                    ToOutput = PackXYZDouble;
                    break;

           // 0.0 .. 1.0 range
           case PT_GRAY:
           case PT_RGB:
           case PT_YCbCr:
           case PT_YUV:
           case PT_YUVK:
           case PT_HSV:
           case PT_HLS:
           case PT_Yxy:
                    ToOutput = PackDouble;
                    break;

            // Inks (%) 0.0 .. 100.0

           default:
                    ToOutput = PackInkDouble;
                    break;
           }

       }
       else

       if (T_PLANAR(dwOutput)) {

       switch (T_BYTES(dwOutput)) {

              case 1: ToOutput = PackPlanarBytes;
                      break;

              case 2:if (!T_ENDIAN16(dwOutput))
                            ToOutput = PackPlanarWords;
                      break;

              default:;
       }
       }
       else {

              switch (T_BYTES(dwOutput)) {

              case 1:
                     switch (T_CHANNELS(dwOutput))
                     {
                     case 1:
                            if (T_DITHER(dwOutput))
                                    ToOutput = PackNBytesDither;
                            else
                            ToOutput = Pack1Byte;
                            if (T_EXTRA(dwOutput) == 1) {
                                if (T_SWAPFIRST(dwOutput))
                                   ToOutput = Pack1ByteAndSkip1SwapFirst;
                                else
                                   ToOutput = Pack1ByteAndSkip1;
                            }
                            break;

                     case 3:
                         switch (T_EXTRA(dwOutput)) {

                         case 0: if (T_DOSWAP(dwOutput))
                                   ToOutput = Pack3BytesSwap;
                                 else
                                     if (T_COLORSPACE(dwOutput) == PT_Lab)
                                        ToOutput = Pack3BytesLab;
                                     else {
                                         if (T_DITHER(dwOutput))
                                                 ToOutput = PackNBytesDither;
                                     else
                                        ToOutput = Pack3Bytes;
                                     }
                             break;

                         case 1:    // TODO: ALab8 should be handled here

                                    if (T_DOSWAP(dwOutput)) {

                                    if (T_SWAPFIRST(dwOutput))
                                        ToOutput = Pack3BytesAndSkip1SwapSwapFirst;
                                    else
                                        ToOutput = Pack3BytesAndSkip1Swap;
                                 }
                             else {
                                   if (T_SWAPFIRST(dwOutput))
                                    ToOutput = Pack3BytesAndSkip1SwapFirst;
                                   else
                                    ToOutput = Pack3BytesAndSkip1;
                             }
                             break;

                         default:;
                         }
                         break;

                     case 4: if (T_EXTRA(dwOutput) == 0) {


                                if (T_DOSWAP(dwOutput)) {


                                     if (T_SWAPFIRST(dwOutput)) {
                                         ToOutput = Pack4BytesSwapSwapFirst;
                                     }
                                     else {

                                           if (T_DITHER(dwOutput)) {
                                                  ToOutput = PackNBytesSwapDither;
                                           }
                                           else {
                                         ToOutput = Pack4BytesSwap;
                                 }
                                     }
                                 }
                                 else {
                                     if (T_SWAPFIRST(dwOutput))
                                         ToOutput = Pack4BytesSwapFirst;
                                     else {

                                         if (T_FLAVOR(dwOutput))
                                             ToOutput = Pack4BytesReverse;
                                         else {
                                             if (T_DITHER(dwOutput))
                                                 ToOutput = PackNBytesDither;
                                         else
                                             ToOutput = Pack4Bytes;
                                     }
                                 }
                             }
                             }
                            else {
                                    if (!T_DOSWAP(dwOutput) && !T_SWAPFIRST(dwOutput))
                                             ToOutput = PackNBytes;
                            }
                            break;

                     // Hexachrome separations.
                     case 6: if (T_EXTRA(dwOutput) == 0) {

                                    if( T_DOSWAP(dwOutput))
                                            ToOutput = Pack6BytesSwap;
                            else
                                   ToOutput = Pack6Bytes;
                            }
                            else {
                                    if (!T_DOSWAP(dwOutput) && !T_SWAPFIRST(dwOutput))
                                             ToOutput = PackNBytes;

                            }
                            break;

                     case 2:
                     case 5:
                     case 7:
                     case 8:
                     case 9:
                     case 10:
                     case 11:
                     case 12:
                     case 13:
                     case 14:
                     case 15:

                            if ((T_EXTRA(dwOutput) == 0) && (T_SWAPFIRST(dwOutput) == 0))
                            {
                                   if (T_DOSWAP(dwOutput))
                                          ToOutput = PackNBytesSwap;
                                   else {

                                       if (T_DITHER(dwOutput))
                                                 ToOutput = PackNBytesDither;
                                   else
                                          ToOutput = PackNBytes;
                                   }
                            }
                            break;

                     default:;
                     }
                     break;


              case 2:

                     switch (T_CHANNELS(dwOutput)) {

                     case 1:
                            if (T_ENDIAN16(dwOutput))

                                   ToOutput = Pack1WordBigEndian;
                            else
                                   ToOutput = Pack1Word;

                            if (T_EXTRA(dwOutput) == 1) {

                               if (T_ENDIAN16(dwOutput))

                                   ToOutput = Pack1WordAndSkip1BigEndian;
                               else {
                                   if (T_SWAPFIRST(dwOutput))
                                      ToOutput = Pack1WordAndSkip1SwapFirst;
                                   else
                                      ToOutput = Pack1WordAndSkip1;
                               }
                            }
                            break;

                     case 3:

                         switch (T_EXTRA(dwOutput)) {

                         case 0:
                               if (T_DOSWAP(dwOutput)) {

                                   if (T_ENDIAN16(dwOutput))

                                          ToOutput = Pack3WordsSwapBigEndian;
                                   else
                                          ToOutput = Pack3WordsSwap;
                               }
                               else {
                                   if (T_ENDIAN16(dwOutput))

                                      ToOutput = Pack3WordsBigEndian;
                                   else
                                      ToOutput = Pack3Words;
                                   }
                             break;

                         case 1: if (T_DOSWAP(dwOutput)) {

                                   if (T_ENDIAN16(dwOutput))

                                          ToOutput = Pack3WordsAndSkip1SwapBigEndian;
                                   else {
                                       if (T_SWAPFIRST(dwOutput))
                                          ToOutput = Pack3WordsAndSkip1SwapSwapFirst;
                                       else
                                          ToOutput = Pack3WordsAndSkip1Swap;
                                   }
                             }
                             else  {
                                   if (T_ENDIAN16(dwOutput))
                                          ToOutput = Pack3WordsAndSkip1BigEndian;
                                   else
                                          ToOutput = Pack3WordsAndSkip1;
                                   }
                         default:;
                         }
                         break;

                     case 4: if (T_EXTRA(dwOutput) == 0) {

                                   if (T_DOSWAP(dwOutput)) {

                                           if (T_ENDIAN16(dwOutput))
                                                 ToOutput = Pack4WordsSwapBigEndian;
                                           else
                                                 ToOutput = Pack4WordsSwap;
                                   }
                                   else {

                                       if (T_ENDIAN16(dwOutput)) {

                                           if (T_FLAVOR(dwOutput))
                                                ToOutput = Pack4WordsBigEndianReverse;
                                           else
                                                ToOutput = Pack4WordsBigEndian;
                                       }
                                       else {
                                          if (T_FLAVOR(dwOutput))
                                              ToOutput = Pack4WordsReverse;
                                          else
                                               ToOutput = Pack4Words;
                                        }
                                   }
                            }
                            else {
                                    if (!T_DOSWAP(dwOutput) && !T_SWAPFIRST(dwOutput))
                                             ToOutput = PackNWords;
                            }
                            break;

                     case 6: if (T_EXTRA(dwOutput) == 0) {

                                   if (T_DOSWAP(dwOutput)) {

                                          if (T_ENDIAN16(dwOutput))
                                                 ToOutput = Pack6WordsSwapBigEndian;
                                          else
                                                 ToOutput = Pack6WordsSwap;
                                   }
                                   else {

                                   if (T_ENDIAN16(dwOutput))
                                          ToOutput = Pack6WordsBigEndian;
                                   else
                                          ToOutput = Pack6Words;
                                   }
                             }
                            else {
                                    if (!T_DOSWAP(dwOutput) && !T_SWAPFIRST(dwOutput))
                                             ToOutput = PackNWords;
                            }
                            break;


                     case 2:
                     case 5:
                     case 7:
                     case 8:
                     case 9:
                     case 10:
                     case 11:
                     case 12:
                     case 13:
                     case 14:
                     case 15: if ((T_EXTRA(dwOutput) == 0) && (T_SWAPFIRST(dwOutput) == 0)) {

                                   if (T_DOSWAP(dwOutput)) {

                                          if (T_ENDIAN16(dwOutput))
                                                 ToOutput = PackNWordsSwapBigEndian;
                                          else
                                                 ToOutput = PackNWordsSwap;
                                   }
                                   else {

                                          if (T_ENDIAN16(dwOutput))
                                                 ToOutput = PackNWordsBigEndian;
                                          else
                                                 ToOutput = PackNWords;
                                          }
                             }
                             break;

                     default:;
                     }
                     break;

              default:;
              }
              }

              if (!ToOutput)
                     cmsSignalError(LCMS_ERRC_ABORTED, "Unknown output format");

              return ToOutput;
}

// User formatters for (weird) cases not already included

void LCMSEXPORT cmsSetUserFormatters(cmsHTRANSFORM hTransform, DWORD dwInput,  cmsFORMATTER Input,
                                                               DWORD dwOutput, cmsFORMATTER Output)
{
    _LPcmsTRANSFORM xform = (_LPcmsTRANSFORM) (LPSTR) hTransform;

    if (Input != NULL) {
        xform ->FromInput = (_cmsFIXFN) Input;
        xform ->InputFormat = dwInput;
    }

    if (Output != NULL) {
        xform ->ToOutput  = (_cmsFIXFN) Output;
        xform ->OutputFormat = dwOutput;
    }

}

void LCMSEXPORT cmsGetUserFormatters(cmsHTRANSFORM hTransform,
                                     LPDWORD InputFormat, cmsFORMATTER* Input,
                                     LPDWORD OutputFormat, cmsFORMATTER* Output)
{
    _LPcmsTRANSFORM xform = (_LPcmsTRANSFORM) (LPSTR) hTransform;

    if (Input)        *Input =  (cmsFORMATTER) xform ->FromInput;
    if (InputFormat)  *InputFormat = xform -> InputFormat;
    if (Output)       *Output = (cmsFORMATTER) xform ->ToOutput;
    if (OutputFormat) *OutputFormat = xform -> OutputFormat;
}


// Change format of yet existing transform. No colorspace checking is performed

void LCMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
                                        DWORD dwInputFormat,
                                        DWORD dwOutputFormat)
{

    cmsSetUserFormatters(hTransform,
                        dwInputFormat,
                        (cmsFORMATTER) _cmsIdentifyInputFormat((_LPcmsTRANSFORM) hTransform, dwInputFormat),
                        dwOutputFormat,
                        (cmsFORMATTER) _cmsIdentifyOutputFormat((_LPcmsTRANSFORM) hTransform, dwOutputFormat));
}