gp_mix_pixels.gen.h

// SPDX-License-Identifier: GPL-2.1-or-later
/*
 * gp_mix_pixels.gen.h
 *
 * GENERATED on 2024 06 04 21:38:33 from gp_mix_pixels.gen.h.t
 *
 * DO NOT MODIFY THIS FILE DIRECTLY!
 */
#ifndef GP_MIX_PIXELS_GEN_H
#define GP_MIX_PIXELS_GEN_H
 
/*
 * Macros to mix two pixels accordingly to percentage.
 *
 * Copyright (C) 2011-2014 Cyril Hrubis <metan@ucw.cz>
 */
 
#include <core/gp_pixmap.h>
#include <core/gp_pixel.h>
#include <core/gp_get_put_pixel.h>
#include <core/gp_gamma_correction.h>
 
 
/*
 * Mixes two RGB101010 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGB101010(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGB101010(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGB101010(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGB101010(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGB101010(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGB101010(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGB101010(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGB101010(R, G, B); \
})
 
#define GP_MIX_PIXELS_RGB101010(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGB101010(pix1, pix2, perc)
 
/*
 * Mixes two xRGB8888 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_xRGB8888(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_xRGB8888(pix1) * (perc); \
        R += GP_PIXEL_GET_R_xRGB8888(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_xRGB8888(pix1) * (perc); \
        G += GP_PIXEL_GET_G_xRGB8888(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_xRGB8888(pix1) * (perc); \
        B += GP_PIXEL_GET_B_xRGB8888(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_xRGB8888(R, G, B); \
})
 
#define GP_MIX_PIXELS_xRGB8888(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_xRGB8888(pix1, pix2, perc)
 
/*
 * Mixes two RGBA8888 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGBA8888(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGBA8888(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGBA8888(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGBA8888(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGBA8888(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGBA8888(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGBA8888(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
        gp_pixel A; \
\
        A  = GP_PIXEL_GET_A_RGBA8888(pix1) * (perc); \
        A += GP_PIXEL_GET_A_RGBA8888(pix2) * (255 - (perc)); \
        A = (A + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGBA8888(R, G, B, A); \
})
 
#define GP_MIX_PIXELS_RGBA8888(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGBA8888(pix1, pix2, perc)
 
/*
 * Mixes two RGB888 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGB888(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGB888(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGB888(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGB888(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGB888(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGB888(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGB888(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGB888(R, G, B); \
})
 
#define GP_MIX_PIXELS_RGB888(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGB888(pix1, pix2, perc)
 
/*
 * Mixes two BGR888 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_BGR888(pix1, pix2, perc) ({ \
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_BGR888(pix1) * (perc); \
        B += GP_PIXEL_GET_B_BGR888(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_BGR888(pix1) * (perc); \
        G += GP_PIXEL_GET_G_BGR888(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_BGR888(pix1) * (perc); \
        R += GP_PIXEL_GET_R_BGR888(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
\
        GP_PIXEL_CREATE_BGR888(B, G, R); \
})
 
#define GP_MIX_PIXELS_BGR888(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_BGR888(pix1, pix2, perc)
 
/*
 * Mixes two RGB555 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGB555(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGB555(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGB555(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGB555(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGB555(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGB555(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGB555(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGB555(R, G, B); \
})
 
#define GP_MIX_PIXELS_RGB555(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGB555(pix1, pix2, perc)
 
/*
 * Mixes two RGB565 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGB565(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGB565(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGB565(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGB565(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGB565(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGB565(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGB565(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGB565(R, G, B); \
})
 
#define GP_MIX_PIXELS_RGB565(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGB565(pix1, pix2, perc)
 
/*
 * Mixes two RGB666 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGB666(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGB666(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGB666(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGB666(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGB666(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGB666(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGB666(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGB666(R, G, B); \
})
 
#define GP_MIX_PIXELS_RGB666(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGB666(pix1, pix2, perc)
 
/*
 * Mixes two RGB332 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_RGB332(pix1, pix2, perc) ({ \
        gp_pixel R; \
\
        R  = GP_PIXEL_GET_R_RGB332(pix1) * (perc); \
        R += GP_PIXEL_GET_R_RGB332(pix2) * (255 - (perc)); \
        R = (R + 128) / 255; \
\
        gp_pixel G; \
\
        G  = GP_PIXEL_GET_G_RGB332(pix1) * (perc); \
        G += GP_PIXEL_GET_G_RGB332(pix2) * (255 - (perc)); \
        G = (G + 128) / 255; \
\
        gp_pixel B; \
\
        B  = GP_PIXEL_GET_B_RGB332(pix1) * (perc); \
        B += GP_PIXEL_GET_B_RGB332(pix2) * (255 - (perc)); \
        B = (B + 128) / 255; \
\
\
        GP_PIXEL_CREATE_RGB332(R, G, B); \
})
 
#define GP_MIX_PIXELS_RGB332(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_RGB332(pix1, pix2, perc)
 
/*
 * Mixes two CMYK8888 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_CMYK8888(pix1, pix2, perc) ({ \
        gp_pixel K; \
\
        K  = GP_PIXEL_GET_K_CMYK8888(pix1) * (perc); \
        K += GP_PIXEL_GET_K_CMYK8888(pix2) * (255 - (perc)); \
        K = (K + 128) / 255; \
\
        gp_pixel Y; \
\
        Y  = GP_PIXEL_GET_Y_CMYK8888(pix1) * (perc); \
        Y += GP_PIXEL_GET_Y_CMYK8888(pix2) * (255 - (perc)); \
        Y = (Y + 128) / 255; \
\
        gp_pixel M; \
\
        M  = GP_PIXEL_GET_M_CMYK8888(pix1) * (perc); \
        M += GP_PIXEL_GET_M_CMYK8888(pix2) * (255 - (perc)); \
        M = (M + 128) / 255; \
\
        gp_pixel C; \
\
        C  = GP_PIXEL_GET_C_CMYK8888(pix1) * (perc); \
        C += GP_PIXEL_GET_C_CMYK8888(pix2) * (255 - (perc)); \
        C = (C + 128) / 255; \
\
\
        GP_PIXEL_CREATE_CMYK8888(K, Y, M, C); \
})
 
#define GP_MIX_PIXELS_CMYK8888(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_CMYK8888(pix1, pix2, perc)
 
/*
 * Mixes two P2 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_P2(pix1, pix2, perc) ({ \
        gp_pixel P; \
\
        P  = GP_PIXEL_GET_P_P2(pix1) * (perc); \
        P += GP_PIXEL_GET_P_P2(pix2) * (255 - (perc)); \
        P = (P + 128) / 255; \
\
\
        GP_PIXEL_CREATE_P2(P); \
})
 
#define GP_MIX_PIXELS_P2(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_P2(pix1, pix2, perc)
 
/*
 * Mixes two P4 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_P4(pix1, pix2, perc) ({ \
        gp_pixel P; \
\
        P  = GP_PIXEL_GET_P_P4(pix1) * (perc); \
        P += GP_PIXEL_GET_P_P4(pix2) * (255 - (perc)); \
        P = (P + 128) / 255; \
\
\
        GP_PIXEL_CREATE_P4(P); \
})
 
#define GP_MIX_PIXELS_P4(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_P4(pix1, pix2, perc)
 
/*
 * Mixes two P8 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_P8(pix1, pix2, perc) ({ \
        gp_pixel P; \
\
        P  = GP_PIXEL_GET_P_P8(pix1) * (perc); \
        P += GP_PIXEL_GET_P_P8(pix2) * (255 - (perc)); \
        P = (P + 128) / 255; \
\
\
        GP_PIXEL_CREATE_P8(P); \
})
 
#define GP_MIX_PIXELS_P8(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_P8(pix1, pix2, perc)
 
/*
 * Mixes two G1_DB pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G1_DB(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G1_DB(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G1_DB(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G1_DB(V); \
})
 
#define GP_MIX_PIXELS_G1_DB(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G1_DB(pix1, pix2, perc)
 
/*
 * Mixes two G2_DB pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G2_DB(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G2_DB(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G2_DB(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G2_DB(V); \
})
 
#define GP_MIX_PIXELS_G2_DB(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G2_DB(pix1, pix2, perc)
 
/*
 * Mixes two G4_DB pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G4_DB(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G4_DB(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G4_DB(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G4_DB(V); \
})
 
#define GP_MIX_PIXELS_G4_DB(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G4_DB(pix1, pix2, perc)
 
/*
 * Mixes two G1_UB pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G1_UB(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G1_UB(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G1_UB(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G1_UB(V); \
})
 
#define GP_MIX_PIXELS_G1_UB(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G1_UB(pix1, pix2, perc)
 
/*
 * Mixes two G2_UB pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G2_UB(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G2_UB(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G2_UB(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G2_UB(V); \
})
 
#define GP_MIX_PIXELS_G2_UB(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G2_UB(pix1, pix2, perc)
 
/*
 * Mixes two G4_UB pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G4_UB(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G4_UB(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G4_UB(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G4_UB(V); \
})
 
#define GP_MIX_PIXELS_G4_UB(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G4_UB(pix1, pix2, perc)
 
/*
 * Mixes two G8 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G8(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G8(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G8(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G8(V); \
})
 
#define GP_MIX_PIXELS_G8(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G8(pix1, pix2, perc)
 
/*
 * Mixes two GA88 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_GA88(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_GA88(pix1) * (perc); \
        V += GP_PIXEL_GET_V_GA88(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
        gp_pixel A; \
\
        A  = GP_PIXEL_GET_A_GA88(pix1) * (perc); \
        A += GP_PIXEL_GET_A_GA88(pix2) * (255 - (perc)); \
        A = (A + 128) / 255; \
\
\
        GP_PIXEL_CREATE_GA88(V, A); \
})
 
#define GP_MIX_PIXELS_GA88(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_GA88(pix1, pix2, perc)
 
/*
 * Mixes two G16 pixels.
 *
 * The percentage is expected as 8 bit unsigned integer [0 .. 255]
 */
#define GP_MIX_PIXELS_LINEAR_G16(pix1, pix2, perc) ({ \
        gp_pixel V; \
\
        V  = GP_PIXEL_GET_V_G16(pix1) * (perc); \
        V += GP_PIXEL_GET_V_G16(pix2) * (255 - (perc)); \
        V = (V + 128) / 255; \
\
\
        GP_PIXEL_CREATE_G16(V); \
})
 
#define GP_MIX_PIXELS_G16(pix1, pix2, perc) \
        GP_MIX_PIXELS_LINEAR_G16(pix1, pix2, perc)
 
static inline gp_pixel gp_mix_pixels(gp_pixel pix1, gp_pixel pix2,
                                     uint8_t perc, gp_pixel_type pixel_type)
{
        switch (pixel_type) {
        case GP_PIXEL_RGB101010:
                return GP_MIX_PIXELS_LINEAR_RGB101010(pix1, pix2, perc);
        case GP_PIXEL_xRGB8888:
                return GP_MIX_PIXELS_LINEAR_xRGB8888(pix1, pix2, perc);
        case GP_PIXEL_RGBA8888:
                return GP_MIX_PIXELS_LINEAR_RGBA8888(pix1, pix2, perc);
        case GP_PIXEL_RGB888:
                return GP_MIX_PIXELS_LINEAR_RGB888(pix1, pix2, perc);
        case GP_PIXEL_BGR888:
                return GP_MIX_PIXELS_LINEAR_BGR888(pix1, pix2, perc);
        case GP_PIXEL_RGB555:
                return GP_MIX_PIXELS_LINEAR_RGB555(pix1, pix2, perc);
        case GP_PIXEL_RGB565:
                return GP_MIX_PIXELS_LINEAR_RGB565(pix1, pix2, perc);
        case GP_PIXEL_RGB666:
                return GP_MIX_PIXELS_LINEAR_RGB666(pix1, pix2, perc);
        case GP_PIXEL_RGB332:
                return GP_MIX_PIXELS_LINEAR_RGB332(pix1, pix2, perc);
        case GP_PIXEL_CMYK8888:
                return GP_MIX_PIXELS_LINEAR_CMYK8888(pix1, pix2, perc);
        case GP_PIXEL_P2:
                return GP_MIX_PIXELS_LINEAR_P2(pix1, pix2, perc);
        case GP_PIXEL_P4:
                return GP_MIX_PIXELS_LINEAR_P4(pix1, pix2, perc);
        case GP_PIXEL_P8:
                return GP_MIX_PIXELS_LINEAR_P8(pix1, pix2, perc);
        case GP_PIXEL_G1_DB:
                return GP_MIX_PIXELS_LINEAR_G1_DB(pix1, pix2, perc);
        case GP_PIXEL_G2_DB:
                return GP_MIX_PIXELS_LINEAR_G2_DB(pix1, pix2, perc);
        case GP_PIXEL_G4_DB:
                return GP_MIX_PIXELS_LINEAR_G4_DB(pix1, pix2, perc);
        case GP_PIXEL_G1_UB:
                return GP_MIX_PIXELS_LINEAR_G1_UB(pix1, pix2, perc);
        case GP_PIXEL_G2_UB:
                return GP_MIX_PIXELS_LINEAR_G2_UB(pix1, pix2, perc);
        case GP_PIXEL_G4_UB:
                return GP_MIX_PIXELS_LINEAR_G4_UB(pix1, pix2, perc);
        case GP_PIXEL_G8:
                return GP_MIX_PIXELS_LINEAR_G8(pix1, pix2, perc);
        case GP_PIXEL_GA88:
                return GP_MIX_PIXELS_LINEAR_GA88(pix1, pix2, perc);
        case GP_PIXEL_G16:
                return GP_MIX_PIXELS_LINEAR_G16(pix1, pix2, perc);
        default:
                GP_ABORT("Unknown pixeltype");
        }
}
 
 
static inline void gp_mix_pixel_raw_RGB101010(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_32BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGB101010(pixel, pix, perc);
        gp_putpixel_raw_32BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_xRGB8888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_32BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_xRGB8888(pixel, pix, perc);
        gp_putpixel_raw_32BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_RGBA8888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_32BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGBA8888(pixel, pix, perc);
        gp_putpixel_raw_32BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_RGB888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_24BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGB888(pixel, pix, perc);
        gp_putpixel_raw_24BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_BGR888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_24BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_BGR888(pixel, pix, perc);
        gp_putpixel_raw_24BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_RGB555(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_16BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGB555(pixel, pix, perc);
        gp_putpixel_raw_16BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_RGB565(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_16BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGB565(pixel, pix, perc);
        gp_putpixel_raw_16BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_RGB666(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_18BPP_DB(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGB666(pixel, pix, perc);
        gp_putpixel_raw_18BPP_DB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_RGB332(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_8BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_RGB332(pixel, pix, perc);
        gp_putpixel_raw_8BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_CMYK8888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_32BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_CMYK8888(pixel, pix, perc);
        gp_putpixel_raw_32BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_P2(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_2BPP_UB(pixmap, x, y);
        pix = GP_MIX_PIXELS_P2(pixel, pix, perc);
        gp_putpixel_raw_2BPP_UB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_P4(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_4BPP_UB(pixmap, x, y);
        pix = GP_MIX_PIXELS_P4(pixel, pix, perc);
        gp_putpixel_raw_4BPP_UB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_P8(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_8BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_P8(pixel, pix, perc);
        gp_putpixel_raw_8BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G1_DB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_1BPP_DB(pixmap, x, y);
        pix = GP_MIX_PIXELS_G1_DB(pixel, pix, perc);
        gp_putpixel_raw_1BPP_DB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G2_DB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_2BPP_DB(pixmap, x, y);
        pix = GP_MIX_PIXELS_G2_DB(pixel, pix, perc);
        gp_putpixel_raw_2BPP_DB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G4_DB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_4BPP_DB(pixmap, x, y);
        pix = GP_MIX_PIXELS_G4_DB(pixel, pix, perc);
        gp_putpixel_raw_4BPP_DB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G1_UB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_1BPP_UB(pixmap, x, y);
        pix = GP_MIX_PIXELS_G1_UB(pixel, pix, perc);
        gp_putpixel_raw_1BPP_UB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G2_UB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_2BPP_UB(pixmap, x, y);
        pix = GP_MIX_PIXELS_G2_UB(pixel, pix, perc);
        gp_putpixel_raw_2BPP_UB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G4_UB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_4BPP_UB(pixmap, x, y);
        pix = GP_MIX_PIXELS_G4_UB(pixel, pix, perc);
        gp_putpixel_raw_4BPP_UB(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G8(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_8BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_G8(pixel, pix, perc);
        gp_putpixel_raw_8BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_GA88(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_16BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_GA88(pixel, pix, perc);
        gp_putpixel_raw_16BPP(pixmap, x, y, pix);
}
 
static inline void gp_mix_pixel_raw_G16(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        gp_pixel pix = gp_getpixel_raw_16BPP(pixmap, x, y);
        pix = GP_MIX_PIXELS_G16(pixel, pix, perc);
        gp_putpixel_raw_16BPP(pixmap, x, y, pix);
}
 
 
static inline void gp_mix_pixel_raw_clipped_RGB101010(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGB101010(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_xRGB8888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_xRGB8888(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_RGBA8888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGBA8888(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_RGB888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGB888(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_BGR888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_BGR888(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_RGB555(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGB555(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_RGB565(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGB565(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_RGB666(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGB666(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_RGB332(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_RGB332(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_CMYK8888(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_CMYK8888(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_P2(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_P2(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_P4(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_P4(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_P8(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_P8(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G1_DB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G1_DB(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G2_DB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G2_DB(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G4_DB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G4_DB(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G1_UB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G1_UB(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G2_UB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G2_UB(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G4_UB(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G4_UB(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G8(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G8(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_GA88(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_GA88(pixmap, x, y, pixel, perc);
}
 
static inline void gp_mix_pixel_raw_clipped_G16(gp_pixmap *pixmap,
                        gp_coord x, gp_coord y, gp_pixel pixel, uint8_t perc)
{
        if (GP_PIXEL_IS_CLIPPED(pixmap, x, y))
                return;
 
        gp_mix_pixel_raw_G16(pixmap, x, y, pixel, perc);
}
 
 
static inline void gp_mix_pixel_raw(gp_pixmap *pixmap, gp_coord x, gp_coord y,
                                    gp_pixel pixel, uint8_t perc)
{
        switch (pixmap->pixel_type) {
        case GP_PIXEL_RGB101010:
                                gp_mix_pixel_raw_RGB101010(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_xRGB8888:
                                gp_mix_pixel_raw_xRGB8888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGBA8888:
                                gp_mix_pixel_raw_RGBA8888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB888:
                                gp_mix_pixel_raw_RGB888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_BGR888:
                                gp_mix_pixel_raw_BGR888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB555:
                                gp_mix_pixel_raw_RGB555(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB565:
                                gp_mix_pixel_raw_RGB565(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB666:
                                gp_mix_pixel_raw_RGB666(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB332:
                                gp_mix_pixel_raw_RGB332(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_CMYK8888:
                                gp_mix_pixel_raw_CMYK8888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_P2:
                                gp_mix_pixel_raw_P2(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_P4:
                                gp_mix_pixel_raw_P4(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_P8:
                                gp_mix_pixel_raw_P8(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G1_DB:
                                gp_mix_pixel_raw_G1_DB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G2_DB:
                                gp_mix_pixel_raw_G2_DB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G4_DB:
                                gp_mix_pixel_raw_G4_DB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G1_UB:
                                gp_mix_pixel_raw_G1_UB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G2_UB:
                                gp_mix_pixel_raw_G2_UB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G4_UB:
                                gp_mix_pixel_raw_G4_UB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G8:
                                gp_mix_pixel_raw_G8(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_GA88:
                                gp_mix_pixel_raw_GA88(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G16:
                                gp_mix_pixel_raw_G16(pixmap, x, y, pixel, perc);
        break;
        default:
                GP_ABORT("Unknown pixeltype");
        }
}
 
static inline void gp_mix_pixel_raw_clipped(gp_pixmap *pixmap,
                                            gp_coord x, gp_coord y,
                                            gp_pixel pixel, uint8_t perc)
{
        switch (pixmap->pixel_type) {
        case GP_PIXEL_RGB101010:
                gp_mix_pixel_raw_clipped_RGB101010(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_xRGB8888:
                gp_mix_pixel_raw_clipped_xRGB8888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGBA8888:
                gp_mix_pixel_raw_clipped_RGBA8888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB888:
                gp_mix_pixel_raw_clipped_RGB888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_BGR888:
                gp_mix_pixel_raw_clipped_BGR888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB555:
                gp_mix_pixel_raw_clipped_RGB555(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB565:
                gp_mix_pixel_raw_clipped_RGB565(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB666:
                gp_mix_pixel_raw_clipped_RGB666(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_RGB332:
                gp_mix_pixel_raw_clipped_RGB332(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_CMYK8888:
                gp_mix_pixel_raw_clipped_CMYK8888(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_P2:
                gp_mix_pixel_raw_clipped_P2(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_P4:
                gp_mix_pixel_raw_clipped_P4(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_P8:
                gp_mix_pixel_raw_clipped_P8(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G1_DB:
                gp_mix_pixel_raw_clipped_G1_DB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G2_DB:
                gp_mix_pixel_raw_clipped_G2_DB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G4_DB:
                gp_mix_pixel_raw_clipped_G4_DB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G1_UB:
                gp_mix_pixel_raw_clipped_G1_UB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G2_UB:
                gp_mix_pixel_raw_clipped_G2_UB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G4_UB:
                gp_mix_pixel_raw_clipped_G4_UB(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G8:
                gp_mix_pixel_raw_clipped_G8(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_GA88:
                gp_mix_pixel_raw_clipped_GA88(pixmap, x, y, pixel, perc);
        break;
        case GP_PIXEL_G16:
                gp_mix_pixel_raw_clipped_G16(pixmap, x, y, pixel, perc);
        break;
        default:
                GP_ABORT("Unknown pixeltype");
        }
}
#endif /* GP_MIX_PIXELS_GEN_H */