/*

 * 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 Color Management System

//

// 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 "lcms2_internal.h"

// This module handles all formats supported by lcms. There are two flavors, 16 bits and

// floating point. Floating point is supported only in a subset, those formats holding

// cmsFloat32Number (4 bytes per component) and double (marked as 0 bytes per component

// as special case)

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

// This macro return words stored as big endian

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

// These macros handles reversing (negative)

#define REVERSE_FLAVOR_8(x)     ((cmsUInt8Number) (0xff-(x)))

#define REVERSE_FLAVOR_16(x)    ((cmsUInt16Number)(0xffff-(x)))

// * 0xffff / 0xff00 = (255 * 257) / (255 * 256) = 257 / 256

cmsINLINE cmsUInt16Number FomLabV2ToLabV4(cmsUInt16Number x)

{

    int a = (x << 8 | x) >> 8;  // * 257 / 256

    if ( a > 0xffff) return 0xffff;

    return (cmsUInt16Number) a;

}

// * 0xf00 / 0xffff = * 256 / 257

cmsINLINE cmsUInt16Number FomLabV4ToLabV2(cmsUInt16Number x)

{

    return (cmsUInt16Number) (((x << 8) + 0x80) / 257);

}

typedef struct {

    cmsUInt32Number Type;

    cmsUInt32Number Mask;

    cmsFormatter16  Frm;

} cmsFormatters16;

typedef struct {

    cmsUInt32Number    Type;

    cmsUInt32Number    Mask;

    cmsFormatterFloat  Frm;

} cmsFormattersFloat;

#define ANYSPACE        COLORSPACE_SH(31)

#define ANYCHANNELS     CHANNELS_SH(15)

#define ANYEXTRA        EXTRA_SH(7)

#define ANYPLANAR       PLANAR_SH(1)

#define ANYENDIAN       ENDIAN16_SH(1)

#define ANYSWAP         DOSWAP_SH(1)

#define ANYSWAPFIRST    SWAPFIRST_SH(1)

#define ANYFLAVOR       FLAVOR_SH(1)

#ifdef _MSC_VER

#pragma warning(disable : 4100)

#endif

// Unpacking routines (16 bits) ----------------------------------------------------------------------------------------

// Does almost everything but is slow

static

cmsUInt8Number* UnrollChunkyBytes(register _cmsTRANSFORM* info,

                                  register cmsUInt16Number wIn[],

                                  register cmsUInt8Number* accum,

                                  register cmsUInt32Number Stride)

{

    int nChan      = T_CHANNELS(info -> InputFormat);

    int DoSwap     = T_DOSWAP(info ->InputFormat);

    int Reverse    = T_FLAVOR(info ->InputFormat);

    int SwapFirst  = T_SWAPFIRST(info -> InputFormat);

    int Extra      = T_EXTRA(info -> InputFormat);

    int ExtraFirst = DoSwap ^ SwapFirst;

    cmsUInt16Number v;

    int i;

    if (ExtraFirst) {

        accum += Extra;

    }

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

        int index = DoSwap ? (nChan - i - 1) : i;

        v = FROM_8_TO_16(*accum);

        v = Reverse ? REVERSE_FLAVOR_16(v) : v;

        wIn[index] = v;

        accum++;

    }

    if (!ExtraFirst) {

        accum += Extra;

    }

    if (Extra == 0 && SwapFirst) {

        cmsUInt16Number tmp = wIn[0];

        memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));

        wIn[nChan-1] = tmp;

    }

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

// Extra channels are just ignored because come in the next planes

static

cmsUInt8Number* UnrollPlanarBytes(register _cmsTRANSFORM* info,

                                  register cmsUInt16Number wIn[],

                                  register cmsUInt8Number* accum,

                                  register cmsUInt32Number Stride)

{

    int nChan     = T_CHANNELS(info -> InputFormat);

    int DoSwap    = T_DOSWAP(info ->InputFormat);

    int SwapFirst = T_SWAPFIRST(info ->InputFormat);

    int Reverse   = T_FLAVOR(info ->InputFormat);

    int i;

    cmsUInt8Number* Init = accum;

    if (DoSwap ^ SwapFirst) {

        accum += T_EXTRA(info -> InputFormat) * Stride;

    }

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

        int index = DoSwap ? (nChan - i - 1) : i;

        cmsUInt16Number v = FROM_8_TO_16(*accum);

        wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;

        accum += Stride;

    }

    return (Init + 1);

}

// Special cases, provided for performance

static

cmsUInt8Number* Unroll4Bytes(register _cmsTRANSFORM* info,

                             register cmsUInt16Number wIn[],

                             register cmsUInt8Number* accum,

                             register cmsUInt32Number Stride)

{

    wIn[0] = FROM_8_TO_16(*accum); accum++; // C

    wIn[1] = FROM_8_TO_16(*accum); accum++; // M

    wIn[2] = FROM_8_TO_16(*accum); accum++; // Y

    wIn[3] = FROM_8_TO_16(*accum); accum++; // K

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll4BytesReverse(register _cmsTRANSFORM* info,

                                    register cmsUInt16Number wIn[],

                                    register cmsUInt8Number* accum,

                                    register cmsUInt32Number Stride)

{

    wIn[0] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // C

    wIn[1] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // M

    wIn[2] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // Y

    wIn[3] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // K

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll4BytesSwapFirst(register _cmsTRANSFORM* info,

                                      register cmsUInt16Number wIn[],

                                      register cmsUInt8Number* accum,

                                      register cmsUInt32Number Stride)

{

    wIn[3] = FROM_8_TO_16(*accum); accum++; // K

    wIn[0] = FROM_8_TO_16(*accum); accum++; // C

    wIn[1] = FROM_8_TO_16(*accum); accum++; // M

    wIn[2] = FROM_8_TO_16(*accum); accum++; // Y

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

// KYMC

static

cmsUInt8Number* Unroll4BytesSwap(register _cmsTRANSFORM* info,

                                 register cmsUInt16Number wIn[],

                                 register cmsUInt8Number* accum,

                                 register cmsUInt32Number Stride)

{

    wIn[3] = FROM_8_TO_16(*accum); accum++;  // K

    wIn[2] = FROM_8_TO_16(*accum); accum++;  // Y

    wIn[1] = FROM_8_TO_16(*accum); accum++;  // M

    wIn[0] = FROM_8_TO_16(*accum); accum++;  // C

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll4BytesSwapSwapFirst(register _cmsTRANSFORM* info,

                                          register cmsUInt16Number wIn[],

                                          register cmsUInt8Number* accum,

                                          register cmsUInt32Number Stride)

{

    wIn[2] = FROM_8_TO_16(*accum); accum++;  // K

    wIn[1] = FROM_8_TO_16(*accum); accum++;  // Y

    wIn[0] = FROM_8_TO_16(*accum); accum++;  // M

    wIn[3] = FROM_8_TO_16(*accum); accum++;  // C

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll3Bytes(register _cmsTRANSFORM* info,

                             register cmsUInt16Number wIn[],

                             register cmsUInt8Number* accum,

                             register cmsUInt32Number Stride)

{

    wIn[0] = FROM_8_TO_16(*accum); accum++;     // R

    wIn[1] = FROM_8_TO_16(*accum); accum++;     // G

    wIn[2] = FROM_8_TO_16(*accum); accum++;     // B

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll3BytesSkip1Swap(register _cmsTRANSFORM* info,

                                      register cmsUInt16Number wIn[],

                                      register cmsUInt8Number* accum,

                                      register cmsUInt32Number Stride)

{

    accum++; // A

    wIn[2] = FROM_8_TO_16(*accum); accum++; // B

    wIn[1] = FROM_8_TO_16(*accum); accum++; // G

    wIn[0] = FROM_8_TO_16(*accum); accum++; // R

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll3BytesSkip1SwapSwapFirst(register _cmsTRANSFORM* info,

                                              register cmsUInt16Number wIn[],

                                              register cmsUInt8Number* accum,

                                              register cmsUInt32Number Stride)

{

    wIn[2] = FROM_8_TO_16(*accum); accum++; // B

    wIn[1] = FROM_8_TO_16(*accum); accum++; // G

    wIn[0] = FROM_8_TO_16(*accum); accum++; // R

    accum++; // A

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll3BytesSkip1SwapFirst(register _cmsTRANSFORM* info,

                                           register cmsUInt16Number wIn[],

                                           register cmsUInt8Number* accum,

                                           register cmsUInt32Number Stride)

{

    accum++; // A

    wIn[0] = FROM_8_TO_16(*accum); accum++; // R

    wIn[1] = FROM_8_TO_16(*accum); accum++; // G

    wIn[2] = FROM_8_TO_16(*accum); accum++; // B

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

// BRG

static

cmsUInt8Number* Unroll3BytesSwap(register _cmsTRANSFORM* info,

                                 register cmsUInt16Number wIn[],

                                 register cmsUInt8Number* accum,

                                 register cmsUInt32Number Stride)

{

    wIn[2] = FROM_8_TO_16(*accum); accum++;     // B

    wIn[1] = FROM_8_TO_16(*accum); accum++;     // G

    wIn[0] = FROM_8_TO_16(*accum); accum++;     // R

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* UnrollLabV2_8(register _cmsTRANSFORM* info,

                              register cmsUInt16Number wIn[],

                              register cmsUInt8Number* accum,

                              register cmsUInt32Number Stride)

{

    wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++;     // L

    wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++;     // a

    wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++;     // b

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* UnrollALabV2_8(register _cmsTRANSFORM* info,

                               register cmsUInt16Number wIn[],

                               register cmsUInt8Number* accum,

                               register cmsUInt32Number Stride)

{

    accum++;  // A

    wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++;     // L

    wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++;     // a

    wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++;     // b

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* UnrollLabV2_16(register _cmsTRANSFORM* info,

                               register cmsUInt16Number wIn[],

                               register cmsUInt8Number* accum,

                               register cmsUInt32Number Stride)

{

    wIn[0] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2;     // L

    wIn[1] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2;     // a

    wIn[2] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2;     // b

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

// for duplex

static

cmsUInt8Number* Unroll2Bytes(register _cmsTRANSFORM* info,

                                     register cmsUInt16Number wIn[],

                                     register cmsUInt8Number* accum,

                                     register cmsUInt32Number Stride)

{

    wIn[0] = FROM_8_TO_16(*accum); accum++;     // ch1

    wIn[1] = FROM_8_TO_16(*accum); accum++;     // ch2

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

// Monochrome duplicates L into RGB for null-transforms

static

cmsUInt8Number* Unroll1Byte(register _cmsTRANSFORM* info,

                            register cmsUInt16Number wIn[],

                            register cmsUInt8Number* accum,

                            register cmsUInt32Number Stride)

{

    wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++;     // L

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll1ByteSkip1(register _cmsTRANSFORM* info,

                                 register cmsUInt16Number wIn[],

                                 register cmsUInt8Number* accum,

                                 register cmsUInt32Number Stride)

{

    wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++;     // L

    accum += 1;

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll1ByteSkip2(register _cmsTRANSFORM* info,

                                 register cmsUInt16Number wIn[],

                                 register cmsUInt8Number* accum,

                                 register cmsUInt32Number Stride)

{

    wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++;     // L

    accum += 2;

    return accum;

    cmsUNUSED_PARAMETER(info);

    cmsUNUSED_PARAMETER(Stride);

}

static

cmsUInt8Number* Unroll1ByteReversed(register _cmsTRANSFORM* info,

                                    register cmsUInt16Number wIn[],

                                    register cmsUInt8Number* accum,

                                    register cmsUInt32Number Stride)

{

    wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(FROM_8_TO_16(*accum)); accum++;     // L

    return accum;