gp_get_put_pixel.gen.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.1-or-later
/*
 * gp_get_put_pixel.gen.h
 *
 * GENERATED on 2024 04 14 13:01:17 from gp_get_put_pixel.gen.h.t
 *
 * DO NOT MODIFY THIS FILE DIRECTLY!
 */
#ifndef GP_GET_PUT_PIXEL_GEN_H
#define GP_GET_PUT_PIXEL_GEN_H
 
/*
 * Access pixel bytes, get and put pixel
 * Do not include directly, use gp_pixel.h
 *
 * Copyright (C) 2011-2024 Cyril Hrubis <metan@ucw.cz>
 * Copyright (C) 2011      Tomas Gavenciak <gavento@ucw.cz>
 */
 
#include <core/gp_get_set_bits.h>
#include <core/gp_pixmap.h>
 
 
#define GP_PIXEL_ADDR_1BPP_DB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (1 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_1BPP_DB(pixmap, x) \
        (((x + (pixmap)->offset) % 8) * 1)
 
#define GP_PIXEL_ADDR_OFFSET_1BPP_DB(pixmap, x) \
        (((pixmap)->offset + x) % 8)
 
static inline gp_pixel gp_getpixel_raw_1BPP_DB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * Whole pixel is stored in one byte
         *
         * The full list = {1, 2, 4}
         */
        return GP_GET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_1BPP_DB(c, x), 1,
                GP_PIXEL_ADDR_1BPP_DB(c, x, y));
}
 
static inline void gp_putpixel_raw_1BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * Whole pixel is stored one byte
         *
         * The full list = {1, 2, 4}
         */
        GP_SET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_1BPP_DB(c, x), 1,
                             GP_PIXEL_ADDR_1BPP_DB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_1BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_1BPP_DB(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_1BPP_UB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (1 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_1BPP_UB(pixmap, x) \
        (7 - ((x + (pixmap)->offset) % 8) * 1)
 
#define GP_PIXEL_ADDR_OFFSET_1BPP_UB(pixmap, x) \
        (((pixmap)->offset + x) % 8)
 
static inline gp_pixel gp_getpixel_raw_1BPP_UB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * Whole pixel is stored in one byte
         *
         * The full list = {1, 2, 4}
         */
        return GP_GET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_1BPP_UB(c, x), 1,
                GP_PIXEL_ADDR_1BPP_UB(c, x, y));
}
 
static inline void gp_putpixel_raw_1BPP_UB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * Whole pixel is stored one byte
         *
         * The full list = {1, 2, 4}
         */
        GP_SET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_1BPP_UB(c, x), 1,
                             GP_PIXEL_ADDR_1BPP_UB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_1BPP_UB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_1BPP_UB(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_2BPP_DB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (2 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_2BPP_DB(pixmap, x) \
        (((x + (pixmap)->offset) % 4) * 2)
 
#define GP_PIXEL_ADDR_OFFSET_2BPP_DB(pixmap, x) \
        (((pixmap)->offset + x) % 4)
 
static inline gp_pixel gp_getpixel_raw_2BPP_DB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * Whole pixel is stored in one byte
         *
         * The full list = {1, 2, 4}
         */
        return GP_GET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_2BPP_DB(c, x), 2,
                GP_PIXEL_ADDR_2BPP_DB(c, x, y));
}
 
static inline void gp_putpixel_raw_2BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * Whole pixel is stored one byte
         *
         * The full list = {1, 2, 4}
         */
        GP_SET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_2BPP_DB(c, x), 2,
                             GP_PIXEL_ADDR_2BPP_DB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_2BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_2BPP_DB(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_2BPP_UB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (2 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_2BPP_UB(pixmap, x) \
        (6 - ((x + (pixmap)->offset) % 4) * 2)
 
#define GP_PIXEL_ADDR_OFFSET_2BPP_UB(pixmap, x) \
        (((pixmap)->offset + x) % 4)
 
static inline gp_pixel gp_getpixel_raw_2BPP_UB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * Whole pixel is stored in one byte
         *
         * The full list = {1, 2, 4}
         */
        return GP_GET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_2BPP_UB(c, x), 2,
                GP_PIXEL_ADDR_2BPP_UB(c, x, y));
}
 
static inline void gp_putpixel_raw_2BPP_UB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * Whole pixel is stored one byte
         *
         * The full list = {1, 2, 4}
         */
        GP_SET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_2BPP_UB(c, x), 2,
                             GP_PIXEL_ADDR_2BPP_UB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_2BPP_UB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_2BPP_UB(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_4BPP_DB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (4 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_4BPP_DB(pixmap, x) \
        (((x + (pixmap)->offset) % 2) * 4)
 
#define GP_PIXEL_ADDR_OFFSET_4BPP_DB(pixmap, x) \
        (((pixmap)->offset + x) % 2)
 
static inline gp_pixel gp_getpixel_raw_4BPP_DB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * Whole pixel is stored in one byte
         *
         * The full list = {1, 2, 4}
         */
        return GP_GET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_4BPP_DB(c, x), 4,
                GP_PIXEL_ADDR_4BPP_DB(c, x, y));
}
 
static inline void gp_putpixel_raw_4BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * Whole pixel is stored one byte
         *
         * The full list = {1, 2, 4}
         */
        GP_SET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_4BPP_DB(c, x), 4,
                             GP_PIXEL_ADDR_4BPP_DB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_4BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_4BPP_DB(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_4BPP_UB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (4 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_4BPP_UB(pixmap, x) \
        (4 - ((x + (pixmap)->offset) % 2) * 4)
 
#define GP_PIXEL_ADDR_OFFSET_4BPP_UB(pixmap, x) \
        (((pixmap)->offset + x) % 2)
 
static inline gp_pixel gp_getpixel_raw_4BPP_UB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * Whole pixel is stored in one byte
         *
         * The full list = {1, 2, 4}
         */
        return GP_GET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_4BPP_UB(c, x), 4,
                GP_PIXEL_ADDR_4BPP_UB(c, x, y));
}
 
static inline void gp_putpixel_raw_4BPP_UB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * Whole pixel is stored one byte
         *
         * The full list = {1, 2, 4}
         */
        GP_SET_BITS1_ALIGNED(GP_PIXEL_ADDR_SHIFT_4BPP_UB(c, x), 4,
                             GP_PIXEL_ADDR_4BPP_UB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_4BPP_UB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_4BPP_UB(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_8BPP(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (8 * (x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_8BPP(pixmap, x) \
        (0)
 
#define GP_PIXEL_ADDR_OFFSET_8BPP(pixmap, x) \
        (0)
 
static inline gp_pixel gp_getpixel_raw_8BPP(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * 8 BPP is byte aligned
         */
        return *((uint8_t*)GP_PIXEL_ADDR_8BPP(c, x, y));
}
 
static inline void gp_putpixel_raw_8BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * 8 BPP is byte aligned
         */
        *((uint8_t*)GP_PIXEL_ADDR_8BPP(c, x, y)) = p;
}
 
static inline void gp_putpixel_raw_clipped_8BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_8BPP(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_16BPP(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (16 * (x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_16BPP(pixmap, x) \
        (0)
 
#define GP_PIXEL_ADDR_OFFSET_16BPP(pixmap, x) \
        (0)
 
static inline gp_pixel gp_getpixel_raw_16BPP(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * 16 BPP is expected to have aligned pixels
         */
        return *((uint16_t*)GP_PIXEL_ADDR_16BPP(c, x, y));
}
 
static inline void gp_putpixel_raw_16BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * 16 BPP is expected to have aligned pixels
         */
        *((uint16_t*)GP_PIXEL_ADDR_16BPP(c, x, y)) = p;
}
 
static inline void gp_putpixel_raw_clipped_16BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_16BPP(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_24BPP(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (24 * (x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_24BPP(pixmap, x) \
        (0)
 
#define GP_PIXEL_ADDR_OFFSET_24BPP(pixmap, x) \
        (0)
 
static inline gp_pixel gp_getpixel_raw_24BPP(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * The pixel is stored in two or three bytes
         *
         * The max from subgroup (of mod 8 factor group) generated by
         * pixel_size mod 8 + pixel_size <= 24
         *
         * The full list = {11, 13, 14, 15, 17, 18, 20, 24}
         *
         * Hint: If the pixel size is coprime to 8 the group is generated by
         *       pixel_size mod 8 and maximal size thus is pixel_size + 7
         */
        return GP_GET_BITS3_ALIGNED(GP_PIXEL_ADDR_SHIFT_24BPP(c, x), 24,
                GP_PIXEL_ADDR_24BPP(c, x, y));
}
 
static inline void gp_putpixel_raw_24BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * The pixel is stored in two or three bytes
         *
         * The max from subgroup (of mod 8 factor group) generated by
         * pixel_size mod 8 + pixel_size <= 24
         *
         * The full list = {11, 13, 14, 15, 17, 18, 20, 24}
         *
         * Hint: If the pixel size is coprime to 8 the group is generated by
         *       pixel_size mod 8 and maximal size thus is pixel_size + 7
         */
        GP_SET_BITS3_ALIGNED(GP_PIXEL_ADDR_SHIFT_24BPP(c, x), 24,
                             GP_PIXEL_ADDR_24BPP(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_24BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_24BPP(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_32BPP(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (32 * (x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_32BPP(pixmap, x) \
        (0)
 
#define GP_PIXEL_ADDR_OFFSET_32BPP(pixmap, x) \
        (0)
 
static inline gp_pixel gp_getpixel_raw_32BPP(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * 32 BPP is expected to have aligned pixels
         */
        return *((uint32_t*)GP_PIXEL_ADDR_32BPP(c, x, y));
}
 
static inline void gp_putpixel_raw_32BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * 32 BPP is expected to have aligned pixels
         */
        *((uint32_t*)GP_PIXEL_ADDR_32BPP(c, x, y)) = p;
}
 
static inline void gp_putpixel_raw_clipped_32BPP(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_32BPP(c, x, y, p);
}
 
#define GP_PIXEL_ADDR_18BPP_DB(pixmap, x, y) \
        ((gp_pixel*)(((void*)((pixmap)->pixels)) + (pixmap)->bytes_per_row * (y) + \
        (18 * ((pixmap)->offset + x)) / 8))
 
#define GP_PIXEL_ADDR_SHIFT_18BPP_DB(pixmap, x) \
        ((18 * (x + (pixmap)->offset)) % 8)
 
#define GP_PIXEL_ADDR_OFFSET_18BPP_DB(pixmap, x) \
        (0)
 
static inline gp_pixel gp_getpixel_raw_18BPP_DB(const gp_pixmap *c, gp_coord x, gp_coord y)
{
        /*
         * The pixel is stored in two or three bytes
         *
         * The max from subgroup (of mod 8 factor group) generated by
         * pixel_size mod 8 + pixel_size <= 24
         *
         * The full list = {11, 13, 14, 15, 17, 18, 20, 24}
         *
         * Hint: If the pixel size is coprime to 8 the group is generated by
         *       pixel_size mod 8 and maximal size thus is pixel_size + 7
         */
        return GP_GET_BITS3_ALIGNED(GP_PIXEL_ADDR_SHIFT_18BPP_DB(c, x), 18,
                GP_PIXEL_ADDR_18BPP_DB(c, x, y));
}
 
static inline void gp_putpixel_raw_18BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        /*
         * The pixel is stored in two or three bytes
         *
         * The max from subgroup (of mod 8 factor group) generated by
         * pixel_size mod 8 + pixel_size <= 24
         *
         * The full list = {11, 13, 14, 15, 17, 18, 20, 24}
         *
         * Hint: If the pixel size is coprime to 8 the group is generated by
         *       pixel_size mod 8 and maximal size thus is pixel_size + 7
         */
        GP_SET_BITS3_ALIGNED(GP_PIXEL_ADDR_SHIFT_18BPP_DB(c, x), 18,
                             GP_PIXEL_ADDR_18BPP_DB(c, x, y), p);
}
 
static inline void gp_putpixel_raw_clipped_18BPP_DB(gp_pixmap *c, gp_coord x, gp_coord y, gp_pixel p)
{
        if (GP_PIXEL_IS_CLIPPED(c, x, y))
                return;
 
        gp_putpixel_raw_18BPP_DB(c, x, y, p);
}
#endif /* GP_GET_PUT_PIXEL_GEN_H */