IMG_GammaTable.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        IMG_GammaTable.h ( IMG Library, C++)
 *
 * COMMENTS:    Gamma table computer
 */

#ifndef __IMG_GammaTable__
#define __IMG_GammaTable__

#include <SYS/SYS_Types.h>
#include "IMG_API.h"
#include "IMG_TextureFilter.h"
#include <limits>

class IMG_API IMG_GammaTableDetail
{
public:
    static constexpr int        AutoStride = 0;

    static const IMG_GammaTableDetail &get();

    template <typename T> static constexpr inline T
    linearToSRGB(T x)
    {
        constexpr T      zero = 0.0031308;
        constexpr T      scale = 12.92;
        constexpr T      a = 0.055;
        constexpr T      gamma = 2.4;
        return x <= zero ? x*scale : (1+a)*SYSpow(x, 1/gamma) - a;
    }
    template <typename T> static constexpr inline T
    linearToRec709(T x)
    {
        constexpr T      zero = 0.018;
        constexpr T      scale = 4.5;
        constexpr T      a = 0.099;
        constexpr T      gamma = 0.45;
        return x <= zero ? x*scale : (1+a)*SYSpow(x, gamma) - a;
    }
    template <typename T> static constexpr inline T
    linearToGamma(T x, T gamma)
    {
        return SYSsafepow(x, 1/gamma);
    }
    template <typename T> static constexpr inline T
    linearToGamma22(T x)
    {
        constexpr T gamma = 2.2;
        return linearToGamma(x, gamma);
    }

    template <typename T> static constexpr inline T
    srgbToLinear(T x)
    {
        constexpr T      zero = 0.04045;
        constexpr T      scale = 12.92;
        constexpr T      a = 0.055;
        constexpr T      gamma = 2.4;
        return x <= zero ? x*(1/scale) : SYSpow((x+a)*(1/(1+a)), gamma);
    }
    template <typename T> static constexpr inline T
    rec709ToLinear(T x)
    {
        constexpr T      zero = 0.081;
        constexpr T      scale = 4.5;
        constexpr T      a = 0.099;
        constexpr T      gamma = 0.45;
        return x <= zero ? x*(1/scale) : SYSpow((x+a)*(1/(1+a)), (1/gamma));
    }
    template <typename T> static constexpr inline T
    gammaToLinear(T x, T gamma)
    {
        return SYSsafepow(x, gamma);
    }
    template <typename T> static constexpr inline T
    gamma22ToLinear(T x)
    {
        constexpr T     gamma = 2.2;
        return gammaToLinear(x, gamma);
    }

    SYS_FORCE_INLINE void
    toFloat(float *result, const uint8 *src, int nchan, const float *lut) const
    {
        switch (nchan)
        {
            case 4:
                result[3] = myLinear01[src[3]];
                SYS_FALLTHROUGH;
            case 3:
                result[2] = lut[src[2]];
                SYS_FALLTHROUGH;
            case 2:
                result[1] = lut[src[1]];
                SYS_FALLTHROUGH;
            case 1:
                result[0] = lut[src[0]];
                break;
        }
    }
    // Convert 8-bit to float value
    float       linear01(uint8 v) const { return myLinear01[v]; }

    SYS_FORCE_INLINE void
    sRGBToFloat(float *result, const uint8 *src, int nchan) const
    {
        toFloat(result, src, nchan, myRGBtoLinear1);
    }
    SYS_FORCE_INLINE void
    rec709ToFloat(float *result, const uint8 *src, int nchan) const
    {
        toFloat(result, src, nchan, myRec709toLinear1);
    }
    SYS_FORCE_INLINE void
    gamma22ToFloat(float *result, const uint8 *src, int nchan) const
    {
        toFloat(result, src, nchan, myGamma22toLinear1);
    }

private:
    IMG_GammaTableDetail();

    float       myRGBtoLinear1[256]; // 0-1
    float       myRec709toLinear1[256]; // 0-1
    float       myGamma22toLinear1[256]; // 0-1
    float       myLinear01[256]; // 0-1
};

namespace IMG_GammaTable
{
    // IMG_GammaTable converts some well known color spaces to Linear Rec709
    // (Linear sRGB).
    static constexpr int        AutoStride = IMG_GammaTableDetail::AutoStride;

    /// Simple conversion from integral types to float
    template <typename T>
    static SYS_FORCE_INLINE float       toFloat(T data)
    {
        constexpr       float scale = float(1.0 / std::numeric_limits<T>::max());
        return float(data) * scale;
    }
    template <> float   toFloat<uint8>(uint8 d)
    {
        return IMG_GammaTableDetail::get().linear01(d);
    }
    template <> float   toFloat<fpreal16>(fpreal16 d) { return d; }
    template <> float   toFloat<fpreal32>(fpreal32 d) { return d; }
    template <> float   toFloat<fpreal64>(fpreal64 d) { return d; }

    template <typename T> static SYS_FORCE_INLINE
    void        linearToFloat(float *result, const T *src, int nchan)
    {
        for (int i = 0; i < nchan; ++i)
            result[i] = toFloat(src[i]);
    }

    template <typename T> static SYS_FORCE_INLINE
    void        sRGBToFloat(float *dst, const T *src, int nchan)
    {
        switch (nchan)
        {
            case 4:
                dst[3] = toFloat(src[3]);
                SYS_FALLTHROUGH;
            case 3:
                dst[2] = IMG_GammaTableDetail::srgbToLinear(toFloat(src[2]));
                SYS_FALLTHROUGH;
            case 2:
                dst[1] = IMG_GammaTableDetail::srgbToLinear(toFloat(src[1]));
                SYS_FALLTHROUGH;
            case 1:
                dst[0] = IMG_GammaTableDetail::srgbToLinear(toFloat(src[0]));
                break;
        }
    }
    template <typename T> static SYS_FORCE_INLINE
    void        rec709ToFloat(float *dst, const T *src, int nchan)
    {
        switch (nchan)
        {
            case 4:
                dst[3] = toFloat(src[3]);
                SYS_FALLTHROUGH;
            case 3:
                dst[2] = IMG_GammaTableDetail::rec709ToLinear(toFloat(src[2]));
                SYS_FALLTHROUGH;
            case 2:
                dst[1] = IMG_GammaTableDetail::rec709ToLinear(toFloat(src[1]));
                SYS_FALLTHROUGH;
            case 1:
                dst[0] = IMG_GammaTableDetail::rec709ToLinear(toFloat(src[0]));
                break;
        }
    }
    template <typename T> static SYS_FORCE_INLINE
    void        gamma22ToFloat(float *dst, const T *src, int nchan)
    {
        switch (nchan)
        {
            case 4:
                dst[3] = toFloat(src[3]);
                SYS_FALLTHROUGH;
            case 3:
                dst[2] = IMG_GammaTableDetail::gamma22ToLinear(toFloat(src[2]));
                SYS_FALLTHROUGH;
            case 2:
                dst[1] = IMG_GammaTableDetail::gamma22ToLinear(toFloat(src[1]));
                SYS_FALLTHROUGH;
            case 1:
                dst[0] = IMG_GammaTableDetail::gamma22ToLinear(toFloat(src[0]));
                break;
        }
    }
    // uint8 specializations
    template <> SYS_FORCE_INLINE
    void        sRGBToFloat<uint8>(float *dst, const uint8 *src, int nchan)
    {
        IMG_GammaTableDetail::get().sRGBToFloat(dst, src, nchan);
    }
    template <> SYS_FORCE_INLINE
    void        rec709ToFloat<uint8>(float *dst, const uint8 *src, int nchan)
    {
        IMG_GammaTableDetail::get().rec709ToFloat(dst, src, nchan);
    }
    template <> SYS_FORCE_INLINE
    void        gamma22ToFloat<uint8>(float *dst, const uint8 *src, int nchan)
    {
        IMG_GammaTableDetail::get().gamma22ToFloat(dst, src, nchan);
    }

    /// Convert from source data to linear float using built-in color manager
    template <typename T> static SYS_FORCE_INLINE void
    builtinConvert(float *result, const T *src, int n, IMG_ColorSpace cs)
    {
        switch (cs)
        {
            case IMG_COLORSPACE_AUTO:   // non-uint8 defaults to linear
            case IMG_COLORSPACE_LINEAR:
                linearToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_SRGB:
                sRGBToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_GAMMA22:
                gamma22ToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_REC709:
                rec709ToFloat(result, src, n);
                break;
        }
    }
    // Specialize for uint8
    template <> void
    builtinConvert<uint8>(float *result, const uint8 *src, int n, IMG_ColorSpace cs)
    {
        switch (cs)
        {
            case IMG_COLORSPACE_AUTO:   // uint8 defaults to sRGB
            case IMG_COLORSPACE_SRGB:
                IMG_GammaTableDetail::get().sRGBToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_LINEAR:
                linearToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_GAMMA22:
                IMG_GammaTableDetail::get().gamma22ToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_REC709:
                IMG_GammaTableDetail::get().rec709ToFloat(result, src, n);
                break;
        }
    }

    /// Convert from source data to linear float using the proper color manager
    template <typename T> static SYS_FORCE_INLINE void
    convert(float *result, const T *src, int n, IMG_ColorSpace cs)
    {
        switch (cs)
        {
            case IMG_COLORSPACE_AUTO:   // non-uint8 defaults to linear
            case IMG_COLORSPACE_LINEAR:
                linearToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_SRGB:
                sRGBToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_GAMMA22:
                gamma22ToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_REC709:
                rec709ToFloat(result, src, n);
                break;
        }
    }

    // Specialize for uint8, using the proper color manager
    template <> void
    convert<uint8>(float *result, const uint8 *src, int n, IMG_ColorSpace cs)
    {
        switch (cs)
        {
            case IMG_COLORSPACE_AUTO:   // uint8 defaults to sRGB
            case IMG_COLORSPACE_SRGB:
                IMG_GammaTableDetail::get().sRGBToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_LINEAR:
                linearToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_GAMMA22:
                IMG_GammaTableDetail::get().gamma22ToFloat(result, src, n);
                break;
            case IMG_COLORSPACE_REC709:
                IMG_GammaTableDetail::get().rec709ToFloat(result, src, n);
                break;
        }
    }
}

#endif