skcms_public.h File Reference

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

Go to the source code of this file.

Classes
struct	skcms_Matrix3x3
struct	skcms_Matrix3x4
struct	skcms_TransferFunction
union	skcms_Curve
struct	skcms_A2B
struct	skcms_B2A
struct	skcms_CICP
struct	skcms_ICCProfile

Macros
#define	SKCMS_API

Typedefs
typedef struct skcms_Matrix3x3	skcms_Matrix3x3
typedef struct skcms_Matrix3x4	skcms_Matrix3x4
typedef struct skcms_TransferFunction	skcms_TransferFunction
typedef enum skcms_TFType	skcms_TFType
typedef union skcms_Curve	skcms_Curve
typedef struct skcms_A2B	skcms_A2B
typedef struct skcms_B2A	skcms_B2A
typedef struct skcms_CICP	skcms_CICP
typedef struct skcms_ICCProfile	skcms_ICCProfile
typedef enum skcms_PixelFormat	skcms_PixelFormat
typedef enum skcms_AlphaFormat	skcms_AlphaFormat

Enumerations
enum	skcms_TFType {   skcms_TFType_Invalid , skcms_TFType_sRGBish , skcms_TFType_PQish , skcms_TFType_HLGish ,   skcms_TFType_HLGinvish }
enum	{   skcms_Signature_CMYK = 0x434D594B , skcms_Signature_Gray = 0x47524159 , skcms_Signature_RGB = 0x52474220 , skcms_Signature_Lab = 0x4C616220 ,   skcms_Signature_XYZ = 0x58595A20 }
enum	skcms_PixelFormat {   skcms_PixelFormat_A_8 , skcms_PixelFormat_A_8_ , skcms_PixelFormat_G_8 , skcms_PixelFormat_G_8_ ,   skcms_PixelFormat_RGB_565 , skcms_PixelFormat_BGR_565 , skcms_PixelFormat_ABGR_4444 , skcms_PixelFormat_ARGB_4444 ,   skcms_PixelFormat_RGB_888 , skcms_PixelFormat_BGR_888 , skcms_PixelFormat_RGBA_8888 , skcms_PixelFormat_BGRA_8888 ,   skcms_PixelFormat_RGBA_8888_sRGB , skcms_PixelFormat_BGRA_8888_sRGB , skcms_PixelFormat_RGBA_1010102 , skcms_PixelFormat_BGRA_1010102 ,   skcms_PixelFormat_RGB_161616LE , skcms_PixelFormat_BGR_161616LE , skcms_PixelFormat_RGBA_16161616LE , skcms_PixelFormat_BGRA_16161616LE ,   skcms_PixelFormat_RGB_161616BE , skcms_PixelFormat_BGR_161616BE , skcms_PixelFormat_RGBA_16161616BE , skcms_PixelFormat_BGRA_16161616BE ,   skcms_PixelFormat_RGB_hhh_Norm , skcms_PixelFormat_BGR_hhh_Norm , skcms_PixelFormat_RGBA_hhhh_Norm , skcms_PixelFormat_BGRA_hhhh_Norm ,   skcms_PixelFormat_RGB_hhh , skcms_PixelFormat_BGR_hhh , skcms_PixelFormat_RGBA_hhhh , skcms_PixelFormat_BGRA_hhhh ,   skcms_PixelFormat_RGB_fff , skcms_PixelFormat_BGR_fff , skcms_PixelFormat_RGBA_ffff , skcms_PixelFormat_BGRA_ffff ,   skcms_PixelFormat_RGB_101010x_XR , skcms_PixelFormat_BGR_101010x_XR }
enum	skcms_AlphaFormat { skcms_AlphaFormat_Opaque , skcms_AlphaFormat_Unpremul , skcms_AlphaFormat_PremulAsEncoded }

Functions
SKCMS_API bool	skcms_Matrix3x3_invert (const skcms_Matrix3x3 *, skcms_Matrix3x3 *)
SKCMS_API skcms_Matrix3x3	skcms_Matrix3x3_concat (const skcms_Matrix3x3 *, const skcms_Matrix3x3 *)
SKCMS_API float	skcms_TransferFunction_eval (const skcms_TransferFunction *, float)
SKCMS_API bool	skcms_TransferFunction_invert (const skcms_TransferFunction *, skcms_TransferFunction *)
SKCMS_API skcms_TFType	skcms_TransferFunction_getType (const skcms_TransferFunction *)
SKCMS_API bool	skcms_TransferFunction_makePQish (skcms_TransferFunction *, float A, float B, float C, float D, float E, float F)
SKCMS_API bool	skcms_TransferFunction_makeScaledHLGish (skcms_TransferFunction *, float K, float R, float G, float a, float b, float c)
static bool	skcms_TransferFunction_makeHLGish (skcms_TransferFunction *fn, float R, float G, float a, float b, float c)
static bool	skcms_TransferFunction_makePQ (skcms_TransferFunction *tf)
static bool	skcms_TransferFunction_makeHLG (skcms_TransferFunction *tf)
SKCMS_API bool	skcms_TransferFunction_isSRGBish (const skcms_TransferFunction *)
SKCMS_API bool	skcms_TransferFunction_isPQish (const skcms_TransferFunction *)
SKCMS_API bool	skcms_TransferFunction_isHLGish (const skcms_TransferFunction *)
SKCMS_API const skcms_ICCProfile *	skcms_sRGB_profile (void)
SKCMS_API const skcms_ICCProfile *	skcms_XYZD50_profile (void)
SKCMS_API const skcms_TransferFunction *	skcms_sRGB_TransferFunction (void)
SKCMS_API const skcms_TransferFunction *	skcms_sRGB_Inverse_TransferFunction (void)
SKCMS_API const skcms_TransferFunction *	skcms_Identity_TransferFunction (void)
SKCMS_API bool	skcms_ApproximatelyEqualProfiles (const skcms_ICCProfile *A, const skcms_ICCProfile *B)
SKCMS_API bool	skcms_AreApproximateInverses (const skcms_Curve *curve, const skcms_TransferFunction *inv_tf)
SKCMS_API bool	skcms_TRCs_AreApproximateInverse (const skcms_ICCProfile *profile, const skcms_TransferFunction *inv_tf)
SKCMS_API bool	skcms_ParseWithA2BPriority (const void *, size_t, const int priority[], int priorities, skcms_ICCProfile *)
static bool	skcms_Parse (const void *buf, size_t len, skcms_ICCProfile *profile)
SKCMS_API bool	skcms_ApproximateCurve (const skcms_Curve *curve, skcms_TransferFunction *approx, float *max_error)
SKCMS_API bool	skcms_GetCHAD (const skcms_ICCProfile *, skcms_Matrix3x3 *)
SKCMS_API bool	skcms_GetWTPT (const skcms_ICCProfile *, float xyz[3])
SKCMS_API bool	skcms_Transform (const void *src, skcms_PixelFormat srcFmt, skcms_AlphaFormat srcAlpha, const skcms_ICCProfile *srcProfile, void *dst, skcms_PixelFormat dstFmt, skcms_AlphaFormat dstAlpha, const skcms_ICCProfile *dstProfile, size_t npixels)
SKCMS_API bool	skcms_MakeUsableAsDestination (skcms_ICCProfile *profile)
SKCMS_API bool	skcms_MakeUsableAsDestinationWithSingleCurve (skcms_ICCProfile *profile)
SKCMS_API bool	skcms_AdaptToXYZD50 (float wx, float wy, skcms_Matrix3x3 *toXYZD50)
SKCMS_API bool	skcms_PrimariesToXYZD50 (float rx, float ry, float gx, float gy, float bx, float by, float wx, float wy, skcms_Matrix3x3 *toXYZD50)
SKCMS_API void	skcms_DisableRuntimeCPUDetection (void)
static void	skcms_Init (skcms_ICCProfile *p)
static void	skcms_SetTransferFunction (skcms_ICCProfile *p, const skcms_TransferFunction *tf)
static void	skcms_SetXYZD50 (skcms_ICCProfile *p, const skcms_Matrix3x3 *m)

Macro Definition Documentation

SKCMS_API

#define SKCMS_API

Definition at line 13 of file skcms_public.h.

Typedef Documentation

skcms_A2B

typedef struct skcms_A2B skcms_A2B

skcms_AlphaFormat

typedef enum skcms_AlphaFormat skcms_AlphaFormat

skcms_B2A

typedef struct skcms_B2A skcms_B2A

skcms_CICP

typedef struct skcms_CICP skcms_CICP

skcms_Curve

typedef union skcms_Curve skcms_Curve

skcms_ICCProfile

typedef struct skcms_ICCProfile skcms_ICCProfile

skcms_Matrix3x3

typedef struct skcms_Matrix3x3 skcms_Matrix3x3

skcms_Matrix3x4

typedef struct skcms_Matrix3x4 skcms_Matrix3x4

skcms_PixelFormat

typedef enum skcms_PixelFormat skcms_PixelFormat

skcms_TFType

typedef enum skcms_TFType skcms_TFType

skcms_TransferFunction

typedef struct skcms_TransferFunction skcms_TransferFunction

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
skcms_Signature_CMYK
skcms_Signature_Gray
skcms_Signature_RGB
skcms_Signature_Lab
skcms_Signature_XYZ

Definition at line 262 of file skcms_public.h.

     {
    // data_color_space
    skcms_Signature_CMYK = 0x434D594B,
    skcms_Signature_Gray = 0x47524159,
    skcms_Signature_RGB  = 0x52474220,
 
    // pcs
    skcms_Signature_Lab  = 0x4C616220,
    skcms_Signature_XYZ  = 0x58595A20,
};

skcms_AlphaFormat

enum skcms_AlphaFormat

Enumerator
skcms_AlphaFormat_Opaque
skcms_AlphaFormat_Unpremul
skcms_AlphaFormat_PremulAsEncoded

Definition at line 334 of file skcms_public.h.

                               {
    skcms_AlphaFormat_Opaque,          // alpha is always opaque
                                       //   tf-1(r),   tf-1(g),   tf-1(b),   1.0
    skcms_AlphaFormat_Unpremul,        // alpha and color are unassociated
                                       //   tf-1(r),   tf-1(g),   tf-1(b),   a
    skcms_AlphaFormat_PremulAsEncoded, // premultiplied while encoded
                                       //   tf-1(r)*a, tf-1(g)*a, tf-1(b)*a, a
} skcms_AlphaFormat;

skcms_PixelFormat

enum skcms_PixelFormat

Enumerator
skcms_PixelFormat_A_8
skcms_PixelFormat_A_8_
skcms_PixelFormat_G_8
skcms_PixelFormat_G_8_
skcms_PixelFormat_RGB_565
skcms_PixelFormat_BGR_565
skcms_PixelFormat_ABGR_4444
skcms_PixelFormat_ARGB_4444
skcms_PixelFormat_RGB_888
skcms_PixelFormat_BGR_888
skcms_PixelFormat_RGBA_8888
skcms_PixelFormat_BGRA_8888
skcms_PixelFormat_RGBA_8888_sRGB
skcms_PixelFormat_BGRA_8888_sRGB
skcms_PixelFormat_RGBA_1010102
skcms_PixelFormat_BGRA_1010102
skcms_PixelFormat_RGB_161616LE
skcms_PixelFormat_BGR_161616LE
skcms_PixelFormat_RGBA_16161616LE
skcms_PixelFormat_BGRA_16161616LE
skcms_PixelFormat_RGB_161616BE
skcms_PixelFormat_BGR_161616BE
skcms_PixelFormat_RGBA_16161616BE
skcms_PixelFormat_BGRA_16161616BE
skcms_PixelFormat_RGB_hhh_Norm
skcms_PixelFormat_BGR_hhh_Norm
skcms_PixelFormat_RGBA_hhhh_Norm
skcms_PixelFormat_BGRA_hhhh_Norm
skcms_PixelFormat_RGB_hhh
skcms_PixelFormat_BGR_hhh
skcms_PixelFormat_RGBA_hhhh
skcms_PixelFormat_BGRA_hhhh
skcms_PixelFormat_RGB_fff
skcms_PixelFormat_BGR_fff
skcms_PixelFormat_RGBA_ffff
skcms_PixelFormat_BGRA_ffff
skcms_PixelFormat_RGB_101010x_XR
skcms_PixelFormat_BGR_101010x_XR

Definition at line 273 of file skcms_public.h.

                               {
    skcms_PixelFormat_A_8,
    skcms_PixelFormat_A_8_,
    skcms_PixelFormat_G_8,
    skcms_PixelFormat_G_8_,
 
    skcms_PixelFormat_RGB_565,
    skcms_PixelFormat_BGR_565,
 
    skcms_PixelFormat_ABGR_4444,
    skcms_PixelFormat_ARGB_4444,
 
    skcms_PixelFormat_RGB_888,
    skcms_PixelFormat_BGR_888,
    skcms_PixelFormat_RGBA_8888,
    skcms_PixelFormat_BGRA_8888,
    skcms_PixelFormat_RGBA_8888_sRGB,   // Automatic sRGB encoding / decoding.
    skcms_PixelFormat_BGRA_8888_sRGB,   // (Generally used with linear transfer functions.)
 
    skcms_PixelFormat_RGBA_1010102,
    skcms_PixelFormat_BGRA_1010102,
 
    skcms_PixelFormat_RGB_161616LE,     // Little-endian.  Pointers must be 16-bit aligned.
    skcms_PixelFormat_BGR_161616LE,
    skcms_PixelFormat_RGBA_16161616LE,
    skcms_PixelFormat_BGRA_16161616LE,
 
    skcms_PixelFormat_RGB_161616BE,     // Big-endian.  Pointers must be 16-bit aligned.
    skcms_PixelFormat_BGR_161616BE,
    skcms_PixelFormat_RGBA_16161616BE,
    skcms_PixelFormat_BGRA_16161616BE,
 
    skcms_PixelFormat_RGB_hhh_Norm,   // 1-5-10 half-precision float in [0,1]
    skcms_PixelFormat_BGR_hhh_Norm,   // Pointers must be 16-bit aligned.
    skcms_PixelFormat_RGBA_hhhh_Norm,
    skcms_PixelFormat_BGRA_hhhh_Norm,
 
    skcms_PixelFormat_RGB_hhh,        // 1-5-10 half-precision float.
    skcms_PixelFormat_BGR_hhh,        // Pointers must be 16-bit aligned.
    skcms_PixelFormat_RGBA_hhhh,
    skcms_PixelFormat_BGRA_hhhh,
 
    skcms_PixelFormat_RGB_fff,        // 1-8-23 single-precision float (the normal kind).
    skcms_PixelFormat_BGR_fff,        // Pointers must be 32-bit aligned.
    skcms_PixelFormat_RGBA_ffff,
    skcms_PixelFormat_BGRA_ffff,
 
    skcms_PixelFormat_RGB_101010x_XR,  // Note: This is located here to signal no clamping.
    skcms_PixelFormat_BGR_101010x_XR,  // Compatible with MTLPixelFormatBGR10_XR.
} skcms_PixelFormat;

skcms_TFType

enum skcms_TFType

Enumerator
skcms_TFType_Invalid
skcms_TFType_sRGBish
skcms_TFType_PQish
skcms_TFType_HLGish
skcms_TFType_HLGinvish

Definition at line 54 of file skcms_public.h.

                          {
    skcms_TFType_Invalid,
    skcms_TFType_sRGBish,
    skcms_TFType_PQish,
    skcms_TFType_HLGish,
    skcms_TFType_HLGinvish,
} skcms_TFType;

Function Documentation

skcms_AdaptToXYZD50()

SKCMS_API bool skcms_AdaptToXYZD50	(	float	wx,
		float	wy,
		skcms_Matrix3x3 *	toXYZD50
	)

Definition at line 1706 of file skcms.cc.

                                                    {
    if (!is_zero_to_one(wx) || !is_zero_to_one(wy) ||
        !toXYZD50) {
        return false;
    }
 
    // Assumes that Y is 1.0f.
    skcms_Vector3 wXYZ = { { wx / wy, 1, (1 - wx - wy) / wy } };
 
    // Now convert toXYZ matrix to toXYZD50.
    skcms_Vector3 wXYZD50 = { { 0.96422f, 1.0f, 0.82521f } };
 
    // Calculate the chromatic adaptation matrix.  We will use the Bradford method, thus
    // the matrices below.  The Bradford method is used by Adobe and is widely considered
    // to be the best.
    skcms_Matrix3x3 xyz_to_lms = {{
        {  0.8951f,  0.2664f, -0.1614f },
        { -0.7502f,  1.7135f,  0.0367f },
        {  0.0389f, -0.0685f,  1.0296f },
    }};
    skcms_Matrix3x3 lms_to_xyz = {{
        {  0.9869929f, -0.1470543f, 0.1599627f },
        {  0.4323053f,  0.5183603f, 0.0492912f },
        { -0.0085287f,  0.0400428f, 0.9684867f },
    }};
 
    skcms_Vector3 srcCone = mv_mul(&xyz_to_lms, &wXYZ);
    skcms_Vector3 dstCone = mv_mul(&xyz_to_lms, &wXYZD50);
 
    *toXYZD50 = {{
        { dstCone.vals[0] / srcCone.vals[0], 0, 0 },
        { 0, dstCone.vals[1] / srcCone.vals[1], 0 },
        { 0, 0, dstCone.vals[2] / srcCone.vals[2] },
    }};
    *toXYZD50 = skcms_Matrix3x3_concat(toXYZD50, &xyz_to_lms);
    *toXYZD50 = skcms_Matrix3x3_concat(&lms_to_xyz, toXYZD50);
 
    return true;
}

skcms_ApproximateCurve()

SKCMS_API bool skcms_ApproximateCurve	(	const skcms_Curve *	curve,
		skcms_TransferFunction *	approx,
		float *	max_error
	)

Definition at line 2199 of file skcms.cc.

                                              {
    if (!curve || !approx || !max_error) {
        return false;
    }
 
    if (curve->table_entries == 0) {
        // No point approximating an skcms_TransferFunction with an skcms_TransferFunction!
        return false;
    }
 
    if (curve->table_entries == 1 || curve->table_entries > (uint32_t)INT_MAX) {
        // We need at least two points, and must put some reasonable cap on the maximum number.
        return false;
    }
 
    int N = (int)curve->table_entries;
    const float dx = 1.0f / static_cast<float>(N - 1);
 
    *max_error = INFINITY_;
    const float kTolerances[] = { 1.5f / 65535.0f, 1.0f / 512.0f };
    for (int t = 0; t < ARRAY_COUNT(kTolerances); t++) {
        skcms_TransferFunction tf,
                               tf_inv;
 
        // It's problematic to fit curves with non-zero f, so always force it to zero explicitly.
        tf.f = 0.0f;
        int L = fit_linear(curve, N, kTolerances[t], &tf.c, &tf.d);
 
        if (L == N) {
            // If the entire data set was linear, move the coefficients to the nonlinear portion
            // with G == 1.  This lets use a canonical representation with d == 0.
            tf.g = 1;
            tf.a = tf.c;
            tf.b = tf.f;
            tf.c = tf.d = tf.e = tf.f = 0;
        } else if (L == N - 1) {
            // Degenerate case with only two points in the nonlinear segment. Solve directly.
            tf.g = 1;
            tf.a = (eval_curve(curve, static_cast<float>(N-1)*dx) -
                    eval_curve(curve, static_cast<float>(N-2)*dx))
                 / dx;
            tf.b = eval_curve(curve, static_cast<float>(N-2)*dx)
                 - tf.a * static_cast<float>(N-2)*dx;
            tf.e = 0;
        } else {
            // Start by guessing a gamma-only curve through the midpoint.
            int mid = (L + N) / 2;
            float mid_x = static_cast<float>(mid) / static_cast<float>(N - 1);
            float mid_y = eval_curve(curve, mid_x);
            tf.g = log2f_(mid_y) / log2f_(mid_x);
            tf.a = 1;
            tf.b = 0;
            tf.e =    tf.c*tf.d + tf.f
              - powf_(tf.a*tf.d + tf.b, tf.g);
 
 
            if (!skcms_TransferFunction_invert(&tf, &tf_inv) ||
                !fit_nonlinear(curve, L,N, &tf_inv)) {
                continue;
            }
 
            // We fit tf_inv, so calculate tf to keep in sync.
            // fit_nonlinear() should guarantee invertibility.
            if (!skcms_TransferFunction_invert(&tf_inv, &tf)) {
                assert(false);
                continue;
            }
        }
 
        // We'd better have a sane, sRGB-ish TF by now.
        // Other non-Bad TFs would be fine, but we know we've only ever tried to fit sRGBish;
        // anything else is just some accident of math and the way we pun tf.g as a type flag.
        // fit_nonlinear() should guarantee this, but the special cases may fail this test.
        if (skcms_TFType_sRGBish != classify(tf)) {
            continue;
        }
 
        // We find our error by roundtripping the table through tf_inv.
        //
        // (The most likely use case for this approximation is to be inverted and
        // used as the transfer function for a destination color space.)
        //
        // We've kept tf and tf_inv in sync above, but we can't guarantee that tf is
        // invertible, so re-verify that here (and use the new inverse for testing).
        // fit_nonlinear() should guarantee this, but the special cases that don't use
        // it may fail this test.
        if (!skcms_TransferFunction_invert(&tf, &tf_inv)) {
            continue;
        }
 
        float err = skcms_MaxRoundtripError(curve, &tf_inv);
        if (*max_error > err) {
            *max_error = err;
            *approx    = tf;
        }
    }
    return isfinitef_(*max_error);
}

skcms_ApproximatelyEqualProfiles()

SKCMS_API bool skcms_ApproximatelyEqualProfiles	(	const skcms_ICCProfile *	A,
		const skcms_ICCProfile *	B
	)

Definition at line 1621 of file skcms.cc.

                                                                                            {
    // Test for exactly equal profiles first.
    if (A == B || 0 == memcmp(A,B, sizeof(skcms_ICCProfile))) {
        return true;
    }
 
    // For now this is the essentially the same strategy we use in test_only.c
    // for our skcms_Transform() smoke tests:
    //    1) transform A to XYZD50
    //    2) transform B to XYZD50
    //    3) return true if they're similar enough
    // Our current criterion in 3) is maximum 1 bit error per XYZD50 byte.
 
    // skcms_252_random_bytes are 252 of a random shuffle of all possible bytes.
    // 252 is evenly divisible by 3 and 4.  Only 192, 10, 241, and 43 are missing.
 
    // We want to allow otherwise equivalent profiles tagged as grayscale and RGB
    // to be treated as equal.  But CMYK profiles are a totally different ballgame.
    const auto CMYK = skcms_Signature_CMYK;
    if ((A->data_color_space == CMYK) != (B->data_color_space == CMYK)) {
        return false;
    }
 
    // Interpret as RGB_888 if data color space is RGB or GRAY, RGBA_8888 if CMYK.
    // TODO: working with RGBA_8888 either way is probably fastest.
    skcms_PixelFormat fmt = skcms_PixelFormat_RGB_888;
    size_t npixels = 84;
    if (A->data_color_space == skcms_Signature_CMYK) {
        fmt = skcms_PixelFormat_RGBA_8888;
        npixels = 63;
    }
 
    // TODO: if A or B is a known profile (skcms_sRGB_profile, skcms_XYZD50_profile),
    // use pre-canned results and skip that skcms_Transform() call?
    uint8_t dstA[252],
            dstB[252];
    if (!skcms_Transform(
                skcms_252_random_bytes,     fmt, skcms_AlphaFormat_Unpremul, A,
                dstA, skcms_PixelFormat_RGB_888, skcms_AlphaFormat_Unpremul, skcms_XYZD50_profile(),
                npixels)) {
        return false;
    }
    if (!skcms_Transform(
                skcms_252_random_bytes,     fmt, skcms_AlphaFormat_Unpremul, B,
                dstB, skcms_PixelFormat_RGB_888, skcms_AlphaFormat_Unpremul, skcms_XYZD50_profile(),
                npixels)) {
        return false;
    }
 
    // TODO: make sure this final check has reasonable codegen.
    for (size_t i = 0; i < 252; i++) {
        if (abs((int)dstA[i] - (int)dstB[i]) > 1) {
            return false;
        }
    }
    return true;
}

skcms_AreApproximateInverses()

SKCMS_API bool skcms_AreApproximateInverses	(	const skcms_Curve *	curve,
		const skcms_TransferFunction *	inv_tf
	)

Definition at line 285 of file skcms.cc.

                                                                                                  {
    return skcms_MaxRoundtripError(curve, inv_tf) < (1/512.0f);
}

skcms_DisableRuntimeCPUDetection()

SKCMS_API void skcms_DisableRuntimeCPUDetection

(

void

)

Definition at line 40 of file skcms.cc.

                                        {
    sAllowRuntimeCPUDetection = false;
}

skcms_GetCHAD()

SKCMS_API bool skcms_GetCHAD	(	const skcms_ICCProfile *	profile,
		skcms_Matrix3x3 *	m
	)

Definition at line 396 of file skcms.cc.

                                                                        {
    skcms_ICCTag tag;
    if (!skcms_GetTagBySignature(profile, skcms_Signature_CHAD, &tag)) {
        return false;
    }
 
    if (tag.type != skcms_Signature_sf32 || tag.size < SAFE_SIZEOF(sf32_Layout)) {
        return false;
    }
 
    const sf32_Layout* sf32Tag = (const sf32_Layout*)tag.buf;
    const uint8_t* values = sf32Tag->values;
    for (int r = 0; r < 3; ++r)
    for (int c = 0; c < 3; ++c, values += 4) {
        m->vals[r][c] = read_big_fixed(values);
    }
    return true;
}

skcms_GetWTPT()

SKCMS_API bool skcms_GetWTPT	(	const skcms_ICCProfile *	profile,
		float	xyz[3]
	)

Definition at line 438 of file skcms.cc.

                                                                  {
    skcms_ICCTag tag;
    return skcms_GetTagBySignature(profile, skcms_Signature_WTPT, &tag) &&
           read_tag_xyz(&tag, &xyz[0], &xyz[1], &xyz[2]);
}

skcms_Identity_TransferFunction()

SKCMS_API const skcms_TransferFunction * skcms_Identity_TransferFunction

(

void

)

Definition at line 1597 of file skcms.cc.

                                                                {
    static const skcms_TransferFunction identity = {1,1,0,0,0,0,0};
    return &identity;
}

skcms_Init()

static void skcms_Init ( skcms_ICCProfile *  p )

inlinestatic

Definition at line 382 of file skcms_public.h.

                                                   {
    memset(p, 0, sizeof(*p));
    p->data_color_space = skcms_Signature_RGB;
    p->pcs = skcms_Signature_XYZ;
}

skcms_MakeUsableAsDestination()

SKCMS_API bool skcms_MakeUsableAsDestination

(

skcms_ICCProfile *

profile

)

Definition at line 2819 of file skcms.cc.

                                                              {
    if (!profile->has_B2A) {
        skcms_Matrix3x3 fromXYZD50;
        if (!profile->has_trc || !profile->has_toXYZD50
            || !skcms_Matrix3x3_invert(&profile->toXYZD50, &fromXYZD50)) {
            return false;
        }
 
        skcms_TransferFunction tf[3];
        for (int i = 0; i < 3; i++) {
            skcms_TransferFunction inv;
            if (profile->trc[i].table_entries == 0
                && skcms_TransferFunction_invert(&profile->trc[i].parametric, &inv)) {
                tf[i] = profile->trc[i].parametric;
                continue;
            }
 
            float max_error;
            // Parametric curves from skcms_ApproximateCurve() are guaranteed to be invertible.
            if (!skcms_ApproximateCurve(&profile->trc[i], &tf[i], &max_error)) {
                return false;
            }
        }
 
        for (int i = 0; i < 3; ++i) {
            profile->trc[i].table_entries = 0;
            profile->trc[i].parametric = tf[i];
        }
    }
    assert_usable_as_destination(profile);
    return true;
}

skcms_MakeUsableAsDestinationWithSingleCurve()

SKCMS_API bool skcms_MakeUsableAsDestinationWithSingleCurve

(

skcms_ICCProfile *

profile

)

Definition at line 2852 of file skcms.cc.

                                                                             {
    // Call skcms_MakeUsableAsDestination() with B2A disabled;
    // on success that'll return a TRC/XYZ profile with three skcms_TransferFunctions.
    skcms_ICCProfile result = *profile;
    result.has_B2A = false;
    if (!skcms_MakeUsableAsDestination(&result)) {
        return false;
    }
 
    // Of the three, pick the transfer function that best fits the other two.
    int best_tf = 0;
    float min_max_error = INFINITY_;
    for (int i = 0; i < 3; i++) {
        skcms_TransferFunction inv;
        if (!skcms_TransferFunction_invert(&result.trc[i].parametric, &inv)) {
            return false;
        }
 
        float err = 0;
        for (int j = 0; j < 3; ++j) {
            err = fmaxf_(err, skcms_MaxRoundtripError(&profile->trc[j], &inv));
        }
        if (min_max_error > err) {
            min_max_error = err;
            best_tf = i;
        }
    }
 
    for (int i = 0; i < 3; i++) {
        result.trc[i].parametric = result.trc[best_tf].parametric;
    }
 
    *profile = result;
    assert_usable_as_destination(profile);
    return true;
}

skcms_Matrix3x3_concat()

SKCMS_API skcms_Matrix3x3 skcms_Matrix3x3_concat	(	const skcms_Matrix3x3 *	A,
		const skcms_Matrix3x3 *	B
	)

Definition at line 1849 of file skcms.cc.

                                                                                           {
    skcms_Matrix3x3 m = { { { 0,0,0 },{ 0,0,0 },{ 0,0,0 } } };
    for (int r = 0; r < 3; r++)
        for (int c = 0; c < 3; c++) {
            m.vals[r][c] = A->vals[r][0] * B->vals[0][c]
                         + A->vals[r][1] * B->vals[1][c]
                         + A->vals[r][2] * B->vals[2][c];
        }
    return m;
}

skcms_Matrix3x3_invert()

SKCMS_API bool skcms_Matrix3x3_invert	(	const skcms_Matrix3x3 *	src,
		skcms_Matrix3x3 *	dst
	)

Definition at line 1792 of file skcms.cc.

                                                                              {
    double a00 = src->vals[0][0],
           a01 = src->vals[1][0],
           a02 = src->vals[2][0],
           a10 = src->vals[0][1],
           a11 = src->vals[1][1],
           a12 = src->vals[2][1],
           a20 = src->vals[0][2],
           a21 = src->vals[1][2],
           a22 = src->vals[2][2];
 
    double b0 = a00*a11 - a01*a10,
           b1 = a00*a12 - a02*a10,
           b2 = a01*a12 - a02*a11,
           b3 = a20,
           b4 = a21,
           b5 = a22;
 
    double determinant = b0*b5
                       - b1*b4
                       + b2*b3;
 
    if (determinant == 0) {
        return false;
    }
 
    double invdet = 1.0 / determinant;
    if (invdet > +FLT_MAX || invdet < -FLT_MAX || !isfinitef_((float)invdet)) {
        return false;
    }
 
    b0 *= invdet;
    b1 *= invdet;
    b2 *= invdet;
    b3 *= invdet;
    b4 *= invdet;
    b5 *= invdet;
 
    dst->vals[0][0] = (float)( a11*b5 - a12*b4 );
    dst->vals[1][0] = (float)( a02*b4 - a01*b5 );
    dst->vals[2][0] = (float)(        +     b2 );
    dst->vals[0][1] = (float)( a12*b3 - a10*b5 );
    dst->vals[1][1] = (float)( a00*b5 - a02*b3 );
    dst->vals[2][1] = (float)(        -     b1 );
    dst->vals[0][2] = (float)( a10*b4 - a11*b3 );
    dst->vals[1][2] = (float)( a01*b3 - a00*b4 );
    dst->vals[2][2] = (float)(        +     b0 );
 
    for (int r = 0; r < 3; ++r)
    for (int c = 0; c < 3; ++c) {
        if (!isfinitef_(dst->vals[r][c])) {
            return false;
        }
    }
    return true;
}

skcms_Parse()

static bool skcms_Parse ( const void *  buf, size_t  len, skcms_ICCProfile *  profile  )

inlinestatic

Definition at line 245 of file skcms_public.h.

                                                                                       {
    // For continuity of existing user expectations,
    // prefer A2B0 (perceptual) over A2B1 (relative colormetric), and ignore A2B2 (saturation).
    const int priority[] = {0,1};
    return skcms_ParseWithA2BPriority(buf, len,
                                      priority, sizeof(priority)/sizeof(*priority),
                                      profile);
}

skcms_ParseWithA2BPriority()

SKCMS_API bool skcms_ParseWithA2BPriority	(	const void *	buf,
		size_t	len,
		const int	priority[],
		int	priorities,
		skcms_ICCProfile *	profile
	)

Definition at line 1241 of file skcms.cc.

                                                           {
    static_assert(SAFE_SIZEOF(header_Layout) == 132, "need to update header code");
 
    if (!profile) {
        return false;
    }
    memset(profile, 0, SAFE_SIZEOF(*profile));
 
    if (len < SAFE_SIZEOF(header_Layout)) {
        return false;
    }
 
    // Byte-swap all header fields
    const header_Layout* header  = (const header_Layout*)buf;
    profile->buffer              = (const uint8_t*)buf;
    profile->size                = read_big_u32(header->size);
    uint32_t version             = read_big_u32(header->version);
    profile->data_color_space    = read_big_u32(header->data_color_space);
    profile->pcs                 = read_big_u32(header->pcs);
    uint32_t signature           = read_big_u32(header->signature);
    float illuminant_X           = read_big_fixed(header->illuminant_X);
    float illuminant_Y           = read_big_fixed(header->illuminant_Y);
    float illuminant_Z           = read_big_fixed(header->illuminant_Z);
    profile->tag_count           = read_big_u32(header->tag_count);
 
    // Validate signature, size (smaller than buffer, large enough to hold tag table),
    // and major version
    uint64_t tag_table_size = profile->tag_count * SAFE_SIZEOF(tag_Layout);
    if (signature != skcms_Signature_acsp ||
        profile->size > len ||
        profile->size < SAFE_SIZEOF(header_Layout) + tag_table_size ||
        (version >> 24) > 4) {
        return false;
    }
 
    // Validate that illuminant is D50 white
    if (fabsf_(illuminant_X - 0.9642f) > 0.0100f ||
        fabsf_(illuminant_Y - 1.0000f) > 0.0100f ||
        fabsf_(illuminant_Z - 0.8249f) > 0.0100f) {
        return false;
    }
 
    // Validate that all tag entries have sane offset + size
    const tag_Layout* tags = get_tag_table(profile);
    for (uint32_t i = 0; i < profile->tag_count; ++i) {
        uint32_t tag_offset = read_big_u32(tags[i].offset);
        uint32_t tag_size   = read_big_u32(tags[i].size);
        uint64_t tag_end    = (uint64_t)tag_offset + (uint64_t)tag_size;
        if (tag_size < 4 || tag_end > profile->size) {
            return false;
        }
    }
 
    if (profile->pcs != skcms_Signature_XYZ && profile->pcs != skcms_Signature_Lab) {
        return false;
    }
 
    bool pcs_is_xyz = profile->pcs == skcms_Signature_XYZ;
 
    // Pre-parse commonly used tags.
    skcms_ICCTag kTRC;
    if (profile->data_color_space == skcms_Signature_Gray &&
        skcms_GetTagBySignature(profile, skcms_Signature_kTRC, &kTRC)) {
        if (!read_curve(kTRC.buf, kTRC.size, &profile->trc[0], nullptr)) {
            // Malformed tag
            return false;
        }
        profile->trc[1] = profile->trc[0];
        profile->trc[2] = profile->trc[0];
        profile->has_trc = true;
 
        if (pcs_is_xyz) {
            profile->toXYZD50.vals[0][0] = illuminant_X;
            profile->toXYZD50.vals[1][1] = illuminant_Y;
            profile->toXYZD50.vals[2][2] = illuminant_Z;
            profile->has_toXYZD50 = true;
        }
    } else {
        skcms_ICCTag rTRC, gTRC, bTRC;
        if (skcms_GetTagBySignature(profile, skcms_Signature_rTRC, &rTRC) &&
            skcms_GetTagBySignature(profile, skcms_Signature_gTRC, &gTRC) &&
            skcms_GetTagBySignature(profile, skcms_Signature_bTRC, &bTRC)) {
            if (!read_curve(rTRC.buf, rTRC.size, &profile->trc[0], nullptr) ||
                !read_curve(gTRC.buf, gTRC.size, &profile->trc[1], nullptr) ||
                !read_curve(bTRC.buf, bTRC.size, &profile->trc[2], nullptr)) {
                // Malformed TRC tags
                return false;
            }
            profile->has_trc = true;
        }
 
        skcms_ICCTag rXYZ, gXYZ, bXYZ;
        if (skcms_GetTagBySignature(profile, skcms_Signature_rXYZ, &rXYZ) &&
            skcms_GetTagBySignature(profile, skcms_Signature_gXYZ, &gXYZ) &&
            skcms_GetTagBySignature(profile, skcms_Signature_bXYZ, &bXYZ)) {
            if (!read_to_XYZD50(&rXYZ, &gXYZ, &bXYZ, &profile->toXYZD50)) {
                // Malformed XYZ tags
                return false;
            }
            profile->has_toXYZD50 = true;
        }
    }
 
    for (int i = 0; i < priorities; i++) {
        // enum { perceptual, relative_colormetric, saturation }
        if (priority[i] < 0 || priority[i] > 2) {
            return false;
        }
        uint32_t sig = skcms_Signature_A2B0 + static_cast<uint32_t>(priority[i]);
        skcms_ICCTag tag;
        if (skcms_GetTagBySignature(profile, sig, &tag)) {
            if (!read_a2b(&tag, &profile->A2B, pcs_is_xyz)) {
                // Malformed A2B tag
                return false;
            }
            profile->has_A2B = true;
            break;
        }
    }
 
    for (int i = 0; i < priorities; i++) {
        // enum { perceptual, relative_colormetric, saturation }
        if (priority[i] < 0 || priority[i] > 2) {
            return false;
        }
        uint32_t sig = skcms_Signature_B2A0 + static_cast<uint32_t>(priority[i]);
        skcms_ICCTag tag;
        if (skcms_GetTagBySignature(profile, sig, &tag)) {
            if (!read_b2a(&tag, &profile->B2A, pcs_is_xyz)) {
                // Malformed B2A tag
                return false;
            }
            profile->has_B2A = true;
            break;
        }
    }
 
    skcms_ICCTag cicp_tag;
    if (skcms_GetTagBySignature(profile, skcms_Signature_CICP, &cicp_tag)) {
        if (!read_cicp(&cicp_tag, &profile->CICP)) {
            // Malformed CICP tag
            return false;
        }
        profile->has_CICP = true;
    }
 
    return usable_as_src(profile);
}

skcms_PrimariesToXYZD50()

SKCMS_API bool skcms_PrimariesToXYZD50	(	float	rx,
		float	ry,
		float	gx,
		float	gy,
		float	bx,
		float	by,
		float	wx,
		float	wy,
		skcms_Matrix3x3 *	toXYZD50
	)

Definition at line 1747 of file skcms.cc.

                                                        {
    if (!is_zero_to_one(rx) || !is_zero_to_one(ry) ||
        !is_zero_to_one(gx) || !is_zero_to_one(gy) ||
        !is_zero_to_one(bx) || !is_zero_to_one(by) ||
        !is_zero_to_one(wx) || !is_zero_to_one(wy) ||
        !toXYZD50) {
        return false;
    }
 
    // First, we need to convert xy values (primaries) to XYZ.
    skcms_Matrix3x3 primaries = {{
        { rx, gx, bx },
        { ry, gy, by },
        { 1 - rx - ry, 1 - gx - gy, 1 - bx - by },
    }};
    skcms_Matrix3x3 primaries_inv;
    if (!skcms_Matrix3x3_invert(&primaries, &primaries_inv)) {
        return false;
    }
 
    // Assumes that Y is 1.0f.
    skcms_Vector3 wXYZ = { { wx / wy, 1, (1 - wx - wy) / wy } };
    skcms_Vector3 XYZ = mv_mul(&primaries_inv, &wXYZ);
 
    skcms_Matrix3x3 toXYZ = {{
        { XYZ.vals[0],           0,           0 },
        {           0, XYZ.vals[1],           0 },
        {           0,           0, XYZ.vals[2] },
    }};
    toXYZ = skcms_Matrix3x3_concat(&primaries, &toXYZ);
 
    skcms_Matrix3x3 DXtoD50;
    if (!skcms_AdaptToXYZD50(wx, wy, &DXtoD50)) {
        return false;
    }
 
    *toXYZD50 = skcms_Matrix3x3_concat(&DXtoD50, &toXYZ);
    return true;
}

skcms_SetTransferFunction()

static void skcms_SetTransferFunction ( skcms_ICCProfile *  p, const skcms_TransferFunction *  tf  )

inlinestatic

Definition at line 388 of file skcms_public.h.

                                                                               {
    p->has_trc = true;
    for (int i = 0; i < 3; ++i) {
        p->trc[i].table_entries = 0;
        p->trc[i].parametric = *tf;
    }
}

skcms_SetXYZD50()

static void skcms_SetXYZD50 ( skcms_ICCProfile *  p, const skcms_Matrix3x3 *  m  )

inlinestatic

Definition at line 397 of file skcms_public.h.

                                                                                  {
    p->has_toXYZD50 = true;
    p->toXYZD50 = *m;
}

skcms_sRGB_Inverse_TransferFunction()

SKCMS_API const skcms_TransferFunction * skcms_sRGB_Inverse_TransferFunction

(

void

)

Definition at line 1591 of file skcms.cc.

                                                                    {
    static const skcms_TransferFunction sRGB_inv =
        {0.416666657f, 1.137283325f, -0.0f, 12.920000076f, 0.003130805f, -0.054969788f, -0.0f};
    return &sRGB_inv;
}

skcms_sRGB_profile()

SKCMS_API const skcms_ICCProfile * skcms_sRGB_profile

(

void

)

Definition at line 1393 of file skcms.cc.

                                             {
    static const skcms_ICCProfile sRGB_profile = {
        nullptr,               // buffer, moot here
 
        0,                     // size, moot here
        skcms_Signature_RGB,   // data_color_space
        skcms_Signature_XYZ,   // pcs
        0,                     // tag count, moot here
 
        // We choose to represent sRGB with its canonical transfer function,
        // and with its canonical XYZD50 gamut matrix.
        true,  // has_trc, followed by the 3 trc curves
        {
            {{0, {2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0, 0}}},
            {{0, {2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0, 0}}},
            {{0, {2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0, 0}}},
        },
 
        true,  // has_toXYZD50, followed by 3x3 toXYZD50 matrix
        {{
            { 0.436065674f, 0.385147095f, 0.143066406f },
            { 0.222488403f, 0.716873169f, 0.060607910f },
            { 0.013916016f, 0.097076416f, 0.714096069f },
        }},
 
        false, // has_A2B, followed by A2B itself, which we don't care about.
        {
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
            {0,0,0,0},
            nullptr,
            nullptr,
 
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
            {{
                { 0,0,0,0 },
                { 0,0,0,0 },
                { 0,0,0,0 },
            }},
 
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
        },
 
        false, // has_B2A, followed by B2A itself, which we also don't care about.
        {
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
 
            0,
            {{
                { 0,0,0,0 },
                { 0,0,0,0 },
                { 0,0,0,0 },
            }},
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
 
            0,
            {0,0,0,0},
            nullptr,
            nullptr,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
        },
 
        false, // has_CICP, followed by cicp itself which we don't care about.
        { 0, 0, 0, 0 },
    };
    return &sRGB_profile;
}

skcms_sRGB_TransferFunction()

SKCMS_API const skcms_TransferFunction * skcms_sRGB_TransferFunction

(

void

)

Definition at line 1587 of file skcms.cc.

                                                            {
    return &skcms_sRGB_profile()->trc[0].parametric;
}

skcms_TransferFunction_eval()

SKCMS_API float skcms_TransferFunction_eval	(	const skcms_TransferFunction *	tf,
		float	x
	)

Definition at line 212 of file skcms.cc.

                                                                             {
    float sign = x < 0 ? -1.0f : 1.0f;
    x *= sign;
 
    TF_PQish  pq;
    TF_HLGish hlg;
    switch (classify(*tf, &pq, &hlg)) {
        case skcms_TFType_Invalid: break;
 
        case skcms_TFType_HLGish: {
            const float K = hlg.K_minus_1 + 1.0f;
            return K * sign * (x*hlg.R <= 1 ? powf_(x*hlg.R, hlg.G)
                                            : expf_((x-hlg.c)*hlg.a) + hlg.b);
        }
 
        // skcms_TransferFunction_invert() inverts R, G, and a for HLGinvish so this math is fast.
        case skcms_TFType_HLGinvish: {
            const float K = hlg.K_minus_1 + 1.0f;
            x /= K;
            return sign * (x <= 1 ? hlg.R * powf_(x, hlg.G)
                                  : hlg.a * logf_(x - hlg.b) + hlg.c);
        }
 
        case skcms_TFType_sRGBish:
            return sign * (x < tf->d ?       tf->c * x + tf->f
                                     : powf_(tf->a * x + tf->b, tf->g) + tf->e);
 
        case skcms_TFType_PQish:
            return sign *
                   powf_((pq.A + pq.B * powf_(x, pq.C)) / (pq.D + pq.E * powf_(x, pq.C)), pq.F);
    }
    return 0;
}

skcms_TransferFunction_getType()

SKCMS_API skcms_TFType skcms_TransferFunction_getType

(

const skcms_TransferFunction *

tf

)

Definition at line 183 of file skcms.cc.

                                                                              {
    return classify(*tf);
}

skcms_TransferFunction_invert()

SKCMS_API bool skcms_TransferFunction_invert	(	const skcms_TransferFunction *	src,
		skcms_TransferFunction *	dst
	)

Definition at line 1863 of file skcms.cc.

                                                                                                   {
    TF_PQish  pq;
    TF_HLGish hlg;
    switch (classify(*src, &pq, &hlg)) {
        case skcms_TFType_Invalid: return false;
        case skcms_TFType_sRGBish: break;  // handled below
 
        case skcms_TFType_PQish:
            *dst = { TFKind_marker(skcms_TFType_PQish), -pq.A,  pq.D, 1.0f/pq.F
                                                      ,  pq.B, -pq.E, 1.0f/pq.C};
            return true;
 
        case skcms_TFType_HLGish:
            *dst = { TFKind_marker(skcms_TFType_HLGinvish), 1.0f/hlg.R, 1.0f/hlg.G
                                                          , 1.0f/hlg.a, hlg.b, hlg.c
                                                          , hlg.K_minus_1 };
            return true;
 
        case skcms_TFType_HLGinvish:
            *dst = { TFKind_marker(skcms_TFType_HLGish), 1.0f/hlg.R, 1.0f/hlg.G
                                                       , 1.0f/hlg.a, hlg.b, hlg.c
                                                       , hlg.K_minus_1 };
            return true;
    }
 
    assert (classify(*src) == skcms_TFType_sRGBish);
 
    // We're inverting this function, solving for x in terms of y.
    //   y = (cx + f)         x < d
    //       (ax + b)^g + e   x ≥ d
    // The inverse of this function can be expressed in the same piecewise form.
    skcms_TransferFunction inv = {0,0,0,0,0,0,0};
 
    // We'll start by finding the new threshold inv.d.
    // In principle we should be able to find that by solving for y at x=d from either side.
    // (If those two d values aren't the same, it's a discontinuous transfer function.)
    float d_l =       src->c * src->d + src->f,
          d_r = powf_(src->a * src->d + src->b, src->g) + src->e;
    if (fabsf_(d_l - d_r) > 1/512.0f) {
        return false;
    }
    inv.d = d_l;  // TODO(mtklein): better in practice to choose d_r?
 
    // When d=0, the linear section collapses to a point.  We leave c,d,f all zero in that case.
    if (inv.d > 0) {
        // Inverting the linear section is pretty straightfoward:
        //        y       = cx + f
        //        y - f   = cx
        //   (1/c)y - f/c = x
        inv.c =    1.0f/src->c;
        inv.f = -src->f/src->c;
    }
 
    // The interesting part is inverting the nonlinear section:
    //         y                = (ax + b)^g + e.
    //         y - e            = (ax + b)^g
    //        (y - e)^1/g       =  ax + b
    //        (y - e)^1/g - b   =  ax
    //   (1/a)(y - e)^1/g - b/a =   x
    //
    // To make that fit our form, we need to move the (1/a) term inside the exponentiation:
    //   let k = (1/a)^g
    //   (1/a)( y -  e)^1/g - b/a = x
    //        (ky - ke)^1/g - b/a = x
 
    float k = powf_(src->a, -src->g);  // (1/a)^g == a^-g
    inv.g = 1.0f / src->g;
    inv.a = k;
    inv.b = -k * src->e;
    inv.e = -src->b / src->a;
 
    // We need to enforce the same constraints here that we do when fitting a curve,
    // a >= 0 and ad+b >= 0.  These constraints are checked by classify(), so they're true
    // of the source function if we're here.
 
    // Just like when fitting the curve, there's really no way to rescue a < 0.
    if (inv.a < 0) {
        return false;
    }
    // On the other hand we can rescue an ad+b that's gone slightly negative here.
    if (inv.a * inv.d + inv.b < 0) {
        inv.b = -inv.a * inv.d;
    }
 
    // That should usually make classify(inv) == sRGBish true, but there are a couple situations
    // where we might still fail here, like non-finite parameter values.
    if (classify(inv) != skcms_TFType_sRGBish) {
        return false;
    }
 
    assert (inv.a >= 0);
    assert (inv.a * inv.d + inv.b >= 0);
 
    // Now in principle we're done.
    // But to preserve the valuable invariant inv(src(1.0f)) == 1.0f, we'll tweak
    // e or f of the inverse, depending on which segment contains src(1.0f).
    float s = skcms_TransferFunction_eval(src, 1.0f);
    if (!isfinitef_(s)) {
        return false;
    }
 
    float sign = s < 0 ? -1.0f : 1.0f;
    s *= sign;
    if (s < inv.d) {
        inv.f = 1.0f - sign * inv.c * s;
    } else {
        inv.e = 1.0f - sign * powf_(inv.a * s + inv.b, inv.g);
    }
 
    *dst = inv;
    return classify(*dst) == skcms_TFType_sRGBish;
}

skcms_TransferFunction_isHLGish()

SKCMS_API bool skcms_TransferFunction_isHLGish

(

const skcms_TransferFunction *

tf

)

Definition at line 192 of file skcms.cc.

                                                                       {
    return classify(*tf) == skcms_TFType_HLGish;
}

skcms_TransferFunction_isPQish()

SKCMS_API bool skcms_TransferFunction_isPQish

(

const skcms_TransferFunction *

tf

)

Definition at line 189 of file skcms.cc.

                                                                      {
    return classify(*tf) == skcms_TFType_PQish;
}

skcms_TransferFunction_isSRGBish()

SKCMS_API bool skcms_TransferFunction_isSRGBish

(

const skcms_TransferFunction *

tf

)

Definition at line 186 of file skcms.cc.

                                                                        {
    return classify(*tf) == skcms_TFType_sRGBish;
}

skcms_TransferFunction_makeHLG()

static bool skcms_TransferFunction_makeHLG ( skcms_TransferFunction *  tf )

inlinestatic

Definition at line 95 of file skcms_public.h.

                                                                              {
    return skcms_TransferFunction_makeHLGish(tf, 2.0f, 2.0f
                                               , 1/0.17883277f, 0.28466892f, 0.55991073f);
}

skcms_TransferFunction_makeHLGish()

static bool skcms_TransferFunction_makeHLGish ( skcms_TransferFunction *  fn, float  R, float  G, float  a, float  b, float  c  )

inlinestatic

Definition at line 83 of file skcms_public.h.

                                                                                {
    return skcms_TransferFunction_makeScaledHLGish(fn, 1.0f, R,G, a,b,c);
}

skcms_TransferFunction_makePQ()

static bool skcms_TransferFunction_makePQ ( skcms_TransferFunction *  tf )

inlinestatic

Definition at line 90 of file skcms_public.h.

                                                                             {
    return skcms_TransferFunction_makePQish(tf, -107/128.0f,         1.0f,   32/2523.0f
                                              , 2413/128.0f, -2392/128.0f, 8192/1305.0f);
}

skcms_TransferFunction_makePQish()

SKCMS_API bool skcms_TransferFunction_makePQish	(	skcms_TransferFunction *	tf,
		float	A,
		float	B,
		float	C,
		float	D,
		float	E,
		float	F
	)

Definition at line 196 of file skcms.cc.

                                                                 {
    *tf = { TFKind_marker(skcms_TFType_PQish), A,B,C,D,E,F };
    assert(skcms_TransferFunction_isPQish(tf));
    return true;
}

skcms_TransferFunction_makeScaledHLGish()

SKCMS_API bool skcms_TransferFunction_makeScaledHLGish	(	skcms_TransferFunction *	tf,
		float	K,
		float	R,
		float	G,
		float	a,
		float	b,
		float	c
	)

Definition at line 204 of file skcms.cc.

                                                                        {
    *tf = { TFKind_marker(skcms_TFType_HLGish), R,G, a,b,c, K-1.0f };
    assert(skcms_TransferFunction_isHLGish(tf));
    return true;
}

skcms_Transform()

SKCMS_API bool skcms_Transform	(	const void *	src,
		skcms_PixelFormat	srcFmt,
		skcms_AlphaFormat	srcAlpha,
		const skcms_ICCProfile *	srcProfile,
		void *	dst,
		skcms_PixelFormat	dstFmt,
		skcms_AlphaFormat	dstAlpha,
		const skcms_ICCProfile *	dstProfile,
		size_t	npixels
	)

Definition at line 2494 of file skcms.cc.

                                                 {
    const size_t dst_bpp = bytes_per_pixel(dstFmt),
                 src_bpp = bytes_per_pixel(srcFmt);
    // Let's just refuse if the request is absurdly big.
    if (nz * dst_bpp > INT_MAX || nz * src_bpp > INT_MAX) {
        return false;
    }
    int n = (int)nz;
 
    // Null profiles default to sRGB. Passing null for both is handy when doing format conversion.
    if (!srcProfile) {
        srcProfile = skcms_sRGB_profile();
    }
    if (!dstProfile) {
        dstProfile = skcms_sRGB_profile();
    }
 
    // We can't transform in place unless the PixelFormats are the same size.
    if (dst == src && dst_bpp != src_bpp) {
        return false;
    }
    // TODO: more careful alias rejection (like, dst == src + 1)?
 
    Op          program[32];
    const void* context[32];
 
    Op*          ops      = program;
    const void** contexts = context;
 
    auto add_op = [&](Op o) {
        *ops++ = o;
        *contexts++ = nullptr;
    };
 
    auto add_op_ctx = [&](Op o, const void* c) {
        *ops++ = o;
        *contexts++ = c;
    };
 
    auto add_curve_ops = [&](const skcms_Curve* curves, int numChannels) {
        OpAndArg oa[4];
        assert(numChannels <= ARRAY_COUNT(oa));
 
        int numOps = select_curve_ops(curves, numChannels, oa);
 
        for (int i = 0; i < numOps; ++i) {
            add_op_ctx(oa[i].op, oa[i].arg);
        }
    };
 
    // These are always parametric curves of some sort.
    skcms_Curve dst_curves[3];
    dst_curves[0].table_entries =
    dst_curves[1].table_entries =
    dst_curves[2].table_entries = 0;
 
    skcms_Matrix3x3        from_xyz;
 
    switch (srcFmt >> 1) {
        default: return false;
        case skcms_PixelFormat_A_8             >> 1: add_op(Op::load_a8);         break;
        case skcms_PixelFormat_G_8             >> 1: add_op(Op::load_g8);         break;
        case skcms_PixelFormat_ABGR_4444       >> 1: add_op(Op::load_4444);       break;
        case skcms_PixelFormat_RGB_565         >> 1: add_op(Op::load_565);        break;
        case skcms_PixelFormat_RGB_888         >> 1: add_op(Op::load_888);        break;
        case skcms_PixelFormat_RGBA_8888       >> 1: add_op(Op::load_8888);       break;
        case skcms_PixelFormat_RGBA_1010102    >> 1: add_op(Op::load_1010102);    break;
        case skcms_PixelFormat_RGB_101010x_XR  >> 1: add_op(Op::load_101010x_XR); break;
        case skcms_PixelFormat_RGB_161616LE    >> 1: add_op(Op::load_161616LE);   break;
        case skcms_PixelFormat_RGBA_16161616LE >> 1: add_op(Op::load_16161616LE); break;
        case skcms_PixelFormat_RGB_161616BE    >> 1: add_op(Op::load_161616BE);   break;
        case skcms_PixelFormat_RGBA_16161616BE >> 1: add_op(Op::load_16161616BE); break;
        case skcms_PixelFormat_RGB_hhh_Norm    >> 1: add_op(Op::load_hhh);        break;
        case skcms_PixelFormat_RGBA_hhhh_Norm  >> 1: add_op(Op::load_hhhh);       break;
        case skcms_PixelFormat_RGB_hhh         >> 1: add_op(Op::load_hhh);        break;
        case skcms_PixelFormat_RGBA_hhhh       >> 1: add_op(Op::load_hhhh);       break;
        case skcms_PixelFormat_RGB_fff         >> 1: add_op(Op::load_fff);        break;
        case skcms_PixelFormat_RGBA_ffff       >> 1: add_op(Op::load_ffff);       break;
 
        case skcms_PixelFormat_RGBA_8888_sRGB >> 1:
            add_op(Op::load_8888);
            add_op_ctx(Op::tf_rgb, skcms_sRGB_TransferFunction());
            break;
    }
    if (srcFmt == skcms_PixelFormat_RGB_hhh_Norm ||
        srcFmt == skcms_PixelFormat_RGBA_hhhh_Norm) {
        add_op(Op::clamp);
    }
    if (srcFmt & 1) {
        add_op(Op::swap_rb);
    }
    skcms_ICCProfile gray_dst_profile;
    if ((dstFmt >> 1) == (skcms_PixelFormat_G_8 >> 1)) {
        // When transforming to gray, stop at XYZ (by setting toXYZ to identity), then transform
        // luminance (Y) by the destination transfer function.
        gray_dst_profile = *dstProfile;
        skcms_SetXYZD50(&gray_dst_profile, &skcms_XYZD50_profile()->toXYZD50);
        dstProfile = &gray_dst_profile;
    }
 
    if (srcProfile->data_color_space == skcms_Signature_CMYK) {
        // Photoshop creates CMYK images as inverse CMYK.
        // These happen to be the only ones we've _ever_ seen.
        add_op(Op::invert);
        // With CMYK, ignore the alpha type, to avoid changing K or conflating CMY with K.
        srcAlpha = skcms_AlphaFormat_Unpremul;
    }
 
    if (srcAlpha == skcms_AlphaFormat_Opaque) {
        add_op(Op::force_opaque);
    } else if (srcAlpha == skcms_AlphaFormat_PremulAsEncoded) {
        add_op(Op::unpremul);
    }
 
    if (dstProfile != srcProfile) {
 
        if (!prep_for_destination(dstProfile,
                                  &from_xyz,
                                  &dst_curves[0].parametric,
                                  &dst_curves[1].parametric,
                                  &dst_curves[2].parametric)) {
            return false;
        }
 
        if (srcProfile->has_A2B) {
            if (srcProfile->A2B.input_channels) {
                add_curve_ops(srcProfile->A2B.input_curves,
                              (int)srcProfile->A2B.input_channels);
                add_op(Op::clamp);
                add_op_ctx(Op::clut_A2B, &srcProfile->A2B);
            }
 
            if (srcProfile->A2B.matrix_channels == 3) {
                add_curve_ops(srcProfile->A2B.matrix_curves, /*numChannels=*/3);
 
                static const skcms_Matrix3x4 I = {{
                    {1,0,0,0},
                    {0,1,0,0},
                    {0,0,1,0},
                }};
                if (0 != memcmp(&I, &srcProfile->A2B.matrix, sizeof(I))) {
                    add_op_ctx(Op::matrix_3x4, &srcProfile->A2B.matrix);
                }
            }
 
            if (srcProfile->A2B.output_channels == 3) {
                add_curve_ops(srcProfile->A2B.output_curves, /*numChannels=*/3);
            }
 
            if (srcProfile->pcs == skcms_Signature_Lab) {
                add_op(Op::lab_to_xyz);
            }
 
        } else if (srcProfile->has_trc && srcProfile->has_toXYZD50) {
            add_curve_ops(srcProfile->trc, /*numChannels=*/3);
        } else {
            return false;
        }
 
        // A2B sources are in XYZD50 by now, but TRC sources are still in their original gamut.
        assert (srcProfile->has_A2B || srcProfile->has_toXYZD50);
 
        if (dstProfile->has_B2A) {
            // B2A needs its input in XYZD50, so transform TRC sources now.
            if (!srcProfile->has_A2B) {
                add_op_ctx(Op::matrix_3x3, &srcProfile->toXYZD50);
            }
 
            if (dstProfile->pcs == skcms_Signature_Lab) {
                add_op(Op::xyz_to_lab);
            }
 
            if (dstProfile->B2A.input_channels == 3) {
                add_curve_ops(dstProfile->B2A.input_curves, /*numChannels=*/3);
            }
 
            if (dstProfile->B2A.matrix_channels == 3) {
                static const skcms_Matrix3x4 I = {{
                    {1,0,0,0},
                    {0,1,0,0},
                    {0,0,1,0},
                }};
                if (0 != memcmp(&I, &dstProfile->B2A.matrix, sizeof(I))) {
                    add_op_ctx(Op::matrix_3x4, &dstProfile->B2A.matrix);
                }
 
                add_curve_ops(dstProfile->B2A.matrix_curves, /*numChannels=*/3);
            }
 
            if (dstProfile->B2A.output_channels) {
                add_op(Op::clamp);
                add_op_ctx(Op::clut_B2A, &dstProfile->B2A);
 
                add_curve_ops(dstProfile->B2A.output_curves,
                              (int)dstProfile->B2A.output_channels);
            }
        } else {
            // This is a TRC destination.
            // We'll concat any src->xyz matrix with our xyz->dst matrix into one src->dst matrix.
            // (A2B sources are already in XYZD50, making that src->xyz matrix I.)
            static const skcms_Matrix3x3 I = {{
                { 1.0f, 0.0f, 0.0f },
                { 0.0f, 1.0f, 0.0f },
                { 0.0f, 0.0f, 1.0f },
            }};
            const skcms_Matrix3x3* to_xyz = srcProfile->has_A2B ? &I : &srcProfile->toXYZD50;
 
            // There's a chance the source and destination gamuts are identical,
            // in which case we can skip the gamut transform.
            if (0 != memcmp(&dstProfile->toXYZD50, to_xyz, sizeof(skcms_Matrix3x3))) {
                // Concat the entire gamut transform into from_xyz,
                // now slightly misnamed but it's a handy spot to stash the result.
                from_xyz = skcms_Matrix3x3_concat(&from_xyz, to_xyz);
                add_op_ctx(Op::matrix_3x3, &from_xyz);
            }
 
            // Encode back to dst RGB using its parametric transfer functions.
            OpAndArg oa[3];
            int numOps = select_curve_ops(dst_curves, /*numChannels=*/3, oa);
            for (int index = 0; index < numOps; ++index) {
                assert(oa[index].op != Op::table_r &&
                       oa[index].op != Op::table_g &&
                       oa[index].op != Op::table_b &&
                       oa[index].op != Op::table_a);
                add_op_ctx(oa[index].op, oa[index].arg);
            }
        }
    }
 
    // Clamp here before premul to make sure we're clamping to normalized values _and_ gamut,
    // not just to values that fit in [0,1].
    //
    // E.g. r = 1.1, a = 0.5 would fit fine in fixed point after premul (ra=0.55,a=0.5),
    // but would be carrying r > 1, which is really unexpected for downstream consumers.
    if (dstFmt < skcms_PixelFormat_RGB_hhh) {
        add_op(Op::clamp);
    }
 
    if (dstProfile->data_color_space == skcms_Signature_CMYK) {
        // Photoshop creates CMYK images as inverse CMYK.
        // These happen to be the only ones we've _ever_ seen.
        add_op(Op::invert);
 
        // CMYK has no alpha channel, so make sure dstAlpha is a no-op.
        dstAlpha = skcms_AlphaFormat_Unpremul;
    }
 
    if (dstAlpha == skcms_AlphaFormat_Opaque) {
        add_op(Op::force_opaque);
    } else if (dstAlpha == skcms_AlphaFormat_PremulAsEncoded) {
        add_op(Op::premul);
    }
    if (dstFmt & 1) {
        add_op(Op::swap_rb);
    }
    switch (dstFmt >> 1) {
        default: return false;
        case skcms_PixelFormat_A_8             >> 1: add_op(Op::store_a8);         break;
        case skcms_PixelFormat_G_8             >> 1: add_op(Op::store_g8);         break;
        case skcms_PixelFormat_ABGR_4444       >> 1: add_op(Op::store_4444);       break;
        case skcms_PixelFormat_RGB_565         >> 1: add_op(Op::store_565);        break;
        case skcms_PixelFormat_RGB_888         >> 1: add_op(Op::store_888);        break;
        case skcms_PixelFormat_RGBA_8888       >> 1: add_op(Op::store_8888);       break;
        case skcms_PixelFormat_RGBA_1010102    >> 1: add_op(Op::store_1010102);    break;
        case skcms_PixelFormat_RGB_161616LE    >> 1: add_op(Op::store_161616LE);   break;
        case skcms_PixelFormat_RGBA_16161616LE >> 1: add_op(Op::store_16161616LE); break;
        case skcms_PixelFormat_RGB_161616BE    >> 1: add_op(Op::store_161616BE);   break;
        case skcms_PixelFormat_RGBA_16161616BE >> 1: add_op(Op::store_16161616BE); break;
        case skcms_PixelFormat_RGB_hhh_Norm    >> 1: add_op(Op::store_hhh);        break;
        case skcms_PixelFormat_RGBA_hhhh_Norm  >> 1: add_op(Op::store_hhhh);       break;
        case skcms_PixelFormat_RGB_101010x_XR  >> 1: add_op(Op::store_101010x_XR); break;
        case skcms_PixelFormat_RGB_hhh         >> 1: add_op(Op::store_hhh);        break;
        case skcms_PixelFormat_RGBA_hhhh       >> 1: add_op(Op::store_hhhh);       break;
        case skcms_PixelFormat_RGB_fff         >> 1: add_op(Op::store_fff);        break;
        case skcms_PixelFormat_RGBA_ffff       >> 1: add_op(Op::store_ffff);       break;
 
        case skcms_PixelFormat_RGBA_8888_sRGB >> 1:
            add_op_ctx(Op::tf_rgb, skcms_sRGB_Inverse_TransferFunction());
            add_op(Op::store_8888);
            break;
    }
 
    assert(ops      <= program + ARRAY_COUNT(program));
    assert(contexts <= context + ARRAY_COUNT(context));
 
    auto run = baseline::run_program;
    switch (cpu_type()) {
        case CpuType::SKX:
            #if !defined(SKCMS_DISABLE_SKX)
                run = skx::run_program;
                break;
            #endif
 
        case CpuType::HSW:
            #if !defined(SKCMS_DISABLE_HSW)
                run = hsw::run_program;
                break;
            #endif
 
        case CpuType::Baseline:
            break;
    }
 
    run(program, context, ops - program, (const char*)src, (char*)dst, n, src_bpp,dst_bpp);
    return true;
}

skcms_TRCs_AreApproximateInverse()

SKCMS_API bool skcms_TRCs_AreApproximateInverse	(	const skcms_ICCProfile *	profile,
		const skcms_TransferFunction *	inv_tf
	)

Definition at line 1679 of file skcms.cc.

                                                                            {
    if (!profile || !profile->has_trc) {
        return false;
    }
 
    return skcms_AreApproximateInverses(&profile->trc[0], inv_tf) &&
           skcms_AreApproximateInverses(&profile->trc[1], inv_tf) &&
           skcms_AreApproximateInverses(&profile->trc[2], inv_tf);
}

skcms_XYZD50_profile()

SKCMS_API const skcms_ICCProfile * skcms_XYZD50_profile

(

void

)

Definition at line 1490 of file skcms.cc.

                                               {
    // Just like sRGB above, but with identity transfer functions and toXYZD50 matrix.
    static const skcms_ICCProfile XYZD50_profile = {
        nullptr,               // buffer, moot here
 
        0,                     // size, moot here
        skcms_Signature_RGB,   // data_color_space
        skcms_Signature_XYZ,   // pcs
        0,                     // tag count, moot here
 
        true,  // has_trc, followed by the 3 trc curves
        {
            {{0, {1,1, 0,0,0,0,0}}},
            {{0, {1,1, 0,0,0,0,0}}},
            {{0, {1,1, 0,0,0,0,0}}},
        },
 
        true,  // has_toXYZD50, followed by 3x3 toXYZD50 matrix
        {{
            { 1,0,0 },
            { 0,1,0 },
            { 0,0,1 },
        }},
 
        false, // has_A2B, followed by A2B itself, which we don't care about.
        {
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
            {0,0,0,0},
            nullptr,
            nullptr,
 
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
            {{
                { 0,0,0,0 },
                { 0,0,0,0 },
                { 0,0,0,0 },
            }},
 
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
        },
 
        false, // has_B2A, followed by B2A itself, which we also don't care about.
        {
            0,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
 
            0,
            {{
                { 0,0,0,0 },
                { 0,0,0,0 },
                { 0,0,0,0 },
            }},
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
 
            0,
            {0,0,0,0},
            nullptr,
            nullptr,
            {
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
                {{0, {0,0, 0,0,0,0,0}}},
            },
        },
 
        false, // has_CICP, followed by cicp itself which we don't care about.
        { 0, 0, 0, 0 },
    };
 
    return &XYZD50_profile;
}