gp_gamma_pixel.gen.h

// SPDX-License-Identifier: GPL-2.1-or-later
/*
 * gp_gamma_pixel.gen.h
 *
 * GENERATED on 2024 04 14 13:01:17 from gp_gamma_pixel.gen.h.t
 *
 * DO NOT MODIFY THIS FILE DIRECTLY!
 */
#ifndef GP_GAMMA_PIXEL_GEN_H
#define GP_GAMMA_PIXEL_GEN_H
 
/*
 * Gamma correction for pixels
 *
 * Copyright (C) 2012-2014 Cyril Hrubis <metan@ucw.cz>
 */
 
#include <core/GP_Types.h>
#include <core/gp_gamma_correction.h>
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB101010_R(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB101010_R(val, gamma) ({ \
        gamma->tables[3]->u16[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB101010_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB101010_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB101010_G(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB101010_G(val, gamma) ({ \
        gamma->tables[4]->u16[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB101010_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB101010_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB101010_B(val, gamma) ({ \
        gamma->tables[2]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB101010_B(val, gamma) ({ \
        gamma->tables[5]->u16[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB101010_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB101010_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_xRGB8888_R(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_xRGB8888_R(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_xRGB8888_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_xRGB8888_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_xRGB8888_G(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_xRGB8888_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_xRGB8888_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_xRGB8888_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_xRGB8888_B(val, gamma) ({ \
        gamma->tables[2]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_xRGB8888_B(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_xRGB8888_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_xRGB8888_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGBA8888_R(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGBA8888_R(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGBA8888_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGBA8888_R(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGBA8888_G(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGBA8888_G(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGBA8888_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGBA8888_G(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGBA8888_B(val, gamma) ({ \
        gamma->tables[2]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGBA8888_B(val, gamma) ({ \
        gamma->tables[6]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGBA8888_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGBA8888_B(gp_gamma *gamma)
{
        return gamma->tables[6];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGBA8888_A(val, gamma) ({ \
        gamma->tables[3]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGBA8888_A(val, gamma) ({ \
        gamma->tables[7]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGBA8888_A(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGBA8888_A(gp_gamma *gamma)
{
        return gamma->tables[7];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB888_R(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB888_R(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB888_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB888_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB888_G(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB888_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB888_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB888_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB888_B(val, gamma) ({ \
        gamma->tables[2]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB888_B(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB888_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB888_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_BGR888_B(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_BGR888_B(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_BGR888_B(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_BGR888_B(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_BGR888_G(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_BGR888_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_BGR888_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_BGR888_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_BGR888_R(val, gamma) ({ \
        gamma->tables[2]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_BGR888_R(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_BGR888_R(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_BGR888_R(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB555_R(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB555_R(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB555_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB555_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB555_G(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB555_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB555_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB555_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB555_B(val, gamma) ({ \
        gamma->tables[2]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB555_B(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB555_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB555_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB565_R(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB565_R(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB565_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB565_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB565_G(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB565_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB565_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB565_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB565_B(val, gamma) ({ \
        gamma->tables[2]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB565_B(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB565_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB565_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB666_R(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB666_R(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB666_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB666_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB666_G(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB666_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB666_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB666_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB666_B(val, gamma) ({ \
        gamma->tables[2]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB666_B(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB666_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB666_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB332_R(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB332_R(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB332_R(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB332_R(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB332_G(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB332_G(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB332_G(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB332_G(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_RGB332_B(val, gamma) ({ \
        gamma->tables[2]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_RGB332_B(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_RGB332_B(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_RGB332_B(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_CMYK8888_K(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_CMYK8888_K(val, gamma) ({ \
        gamma->tables[4]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_CMYK8888_K(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_CMYK8888_K(gp_gamma *gamma)
{
        return gamma->tables[4];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_CMYK8888_Y(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_CMYK8888_Y(val, gamma) ({ \
        gamma->tables[5]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_CMYK8888_Y(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_CMYK8888_Y(gp_gamma *gamma)
{
        return gamma->tables[5];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_CMYK8888_M(val, gamma) ({ \
        gamma->tables[2]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_CMYK8888_M(val, gamma) ({ \
        gamma->tables[6]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_CMYK8888_M(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_CMYK8888_M(gp_gamma *gamma)
{
        return gamma->tables[6];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_CMYK8888_C(val, gamma) ({ \
        gamma->tables[3]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_CMYK8888_C(val, gamma) ({ \
        gamma->tables[7]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_CMYK8888_C(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_CMYK8888_C(gp_gamma *gamma)
{
        return gamma->tables[7];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G1_DB_V(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G1_DB_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G1_DB_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G1_DB_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G2_DB_V(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G2_DB_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G2_DB_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G2_DB_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G4_DB_V(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G4_DB_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G4_DB_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G4_DB_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G1_UB_V(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G1_UB_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G1_UB_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G1_UB_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G2_UB_V(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G2_UB_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G2_UB_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G2_UB_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G4_UB_V(val, gamma) ({ \
        gamma->tables[0]->u8[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G4_UB_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G4_UB_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G4_UB_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G8_V(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G8_V(val, gamma) ({ \
        gamma->tables[1]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G8_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G8_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_GA88_V(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_GA88_V(val, gamma) ({ \
        gamma->tables[2]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_GA88_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_GA88_V(gp_gamma *gamma)
{
        return gamma->tables[2];
}
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_GA88_A(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_GA88_A(val, gamma) ({ \
        gamma->tables[3]->u8[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_GA88_A(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_GA88_A(gp_gamma *gamma)
{
        return gamma->tables[3];
}
 
 
 
/*
 * Converts gamma encoded pixel value to linear value.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_gamma2lin_G16_V(val, gamma) ({ \
        gamma->tables[0]->u16[val]; \
})
 
/*
 * Converts linear encoded pixel into gamma encoded pixel.
 *
 * Parameters are, converted value and gp_gamma structure.
 */
#define gp_lin2gamma_G16_V(val, gamma) ({ \
        gamma->tables[1]->u16[val]; \
})
 
static inline gp_gamma_table *gp_gamma_table_G16_V(gp_gamma *gamma)
{
        return gamma->tables[0];
}
 
static inline gp_gamma_table *gp_gamma_inverse_table_G16_V(gp_gamma *gamma)
{
        return gamma->tables[1];
}
 
 
#define gp_gamma2lin(val, chan_bits, gamma_table) ({ \
#if chan_bits > 6
        gamma_table->u16[val] \
#else
        gamma_table->u8[val] \
#endif
})
 
#define gp_lin2gamma(val, chan_bits, gamma_table) ({ \
#if chan_bits > 8
        gamma_table->table16[val] \
#else
        gamma_table->table8[val] \
#endif
})
#endif /* GP_GAMMA_PIXEL_GEN_H */