gp_pixmap.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2011 Jiri "BlueBear" Dluhos
 *                         <jiri.bluebear.dluhos@gmail.com>
 *
 * Copyright (C) 2009-2024 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef CORE_GP_PIXMAP_H
#define CORE_GP_PIXMAP_H
 
#include <stdint.h>
#include <unistd.h>
 
#include <core/gp_common.h>
#include <core/gp_types.h>
#include <core/gp_pixel.h>
#include <core/gp_gamma_correction.h>
 
struct gp_pixmap {
        uint8_t *pixels;
        uint32_t bytes_per_row;
        uint32_t w;
        uint32_t h;
        uint8_t offset;
 
        enum gp_pixel_type pixel_type;
 
        gp_gamma *gamma;
 
        uint8_t axes_swap:1;
        uint8_t x_swap:1;
        uint8_t y_swap:1;
 
        uint8_t free_pixels:1;
};
 
#define GP_PIXEL_ADDR(pixmap, x, y) ((pixmap)->pixels \
        + (y) * (pixmap)->bytes_per_row \
        + ((x + (pixmap)->offset) * gp_pixel_size((pixmap)->pixel_type)) / 8)
 
#define GP_CALC_ROW_SIZE(pixel_type, width) \
         ((gp_pixel_size(pixel_type) * width) / 8 + \
        !!((gp_pixel_size(pixel_type) * width) % 8))
 
/* Performs a series of sanity checks on pixmap, aborting if any fails. */
#define GP_CHECK_PIXMAP(pixmap) do { \
        GP_CHECK(pixmap, "NULL passed as pixmap"); \
        GP_CHECK(pixmap->pixels || pixmap->w == 0 || pixmap->h == 0, "invalid pixmap: pixels NULL on nonzero w h"); \
} while (0)
 
#define GP_PIXEL_IS_CLIPPED(pixmap, x, y) \
        ((x) < 0 || x >= (typeof(x)) pixmap->w \
        || (y) < 0 || y >= (typeof(y)) pixmap->h) \
 
gp_pixmap *gp_pixmap_alloc_ex(gp_size w, gp_size h, gp_pixel_type type,
                              uint32_t stride);
 
static inline gp_pixmap *gp_pixmap_alloc(gp_size w, gp_size h, gp_pixel_type type)
{
        return gp_pixmap_alloc_ex(w, h, type, 0);
}
 
int gp_pixmap_correction_set(gp_pixmap *self, gp_correction_desc *corr_desc);
 
static inline int gp_pixmap_gamma_set(gp_pixmap *self, float gamma)
{
        gp_correction_desc desc = {
                .corr_type = GP_CORRECTION_TYPE_GAMMA,
                .gamma = gamma,
        };
 
        return gp_pixmap_correction_set(self, &desc);
}
 
static inline int gp_pixmap_srgb_set(gp_pixmap *self)
{
        gp_correction_desc desc = {
                .corr_type = GP_CORRECTION_TYPE_SRGB,
        };
 
        return gp_pixmap_correction_set(self, &desc);
}
 
void gp_pixmap_free(gp_pixmap *self);
 
enum gp_pixmap_init_flags {
        GP_PIXMAP_FREE_PIXELS = 0x01,
};
 
gp_pixmap *gp_pixmap_init(gp_pixmap *pixmap, gp_size w, gp_size h,
                          gp_pixel_type type, void *pixels,
                          enum gp_pixmap_init_flags flags);
 
gp_pixmap *gp_pixmap_init_ex(gp_pixmap *pixmap, gp_size w, gp_size h,
                             gp_pixel_type type, uint32_t bpr,
                             void *pixels, enum gp_pixmap_init_flags flags);
 
static inline gp_pixmap *gp_pixmap_from_data(gp_size w, gp_size h,
                                             gp_pixel_type type, void *pixels,
                                             enum gp_pixmap_init_flags flags)
{
        gp_pixmap *ret = malloc(sizeof(gp_pixmap));
 
        if (!ret)
                return NULL;
 
        return gp_pixmap_init(ret, w, h, type, pixels, flags);
}
 
int gp_pixmap_resize(gp_pixmap *self, gp_size w, gp_size h);
 
enum gp_pixmap_copy_flags {
        GP_PIXMAP_COPY_PIXELS   = 0x01,
        GP_PIXMAP_COPY_ROTATION = 0x02,
        GP_PIXMAP_COPY_GAMMA = 0x04,
};
 
gp_pixmap *gp_pixmap_copy(const gp_pixmap *src, enum gp_pixmap_copy_flags flags);
 
gp_pixmap *gp_sub_pixmap(const gp_pixmap *src, gp_pixmap *subpixmap,
                         gp_coord x, gp_coord y, gp_size w, gp_size h);
 
gp_pixmap *gp_sub_pixmap_alloc(const gp_pixmap *src,
                               gp_coord x, gp_coord y, gp_size w, gp_size h);
 
 
/*
 * Converts pixmap to a different pixel type.
 * Returns a newly allocated pixmap.
 *
 * This is naive implementation that doesn't do any ditherings or error
 * diffusions.
 */
gp_pixmap *gp_pixmap_convert_alloc(const gp_pixmap *src,
                                   gp_pixel_type dst_pixel_type);
 
/*
 * Converts pixmap to a different pixel type.
 *
 * This is naive implementation that doesn't do any ditherings or error
 * diffusions.
 */
gp_pixmap *gp_pixmap_convert(const gp_pixmap *src, gp_pixmap *dst);
 
void gp_pixmap_print_info(const gp_pixmap *self);
 
void gp_pixmap_rotate(gp_pixmap *self, gp_symmetry symmetry);
 
static inline void gp_pixmap_rotate_cw(gp_pixmap *self)
{
        gp_pixmap_rotate(self, GP_ROTATE_CW);
}
 
static inline void gp_pixmap_rotate_ccw(gp_pixmap *self)
{
        gp_pixmap_rotate(self, GP_ROTATE_CCW);
}
 
static inline int gp_pixmap_rotation_equal(const gp_pixmap *c1,
                                           const gp_pixmap *c2)
{
        return c1->axes_swap == c2->axes_swap &&
               c1->x_swap == c2->x_swap &&
               c1->y_swap == c2->y_swap;
}
 
static inline void gp_pixmap_rotation_set(gp_pixmap *self, int axes_swap,
                                          int x_swap, int y_swap)
{
        self->axes_swap = axes_swap;
        self->x_swap = x_swap;
        self->y_swap = y_swap;
}
 
static inline void gp_pixmap_rotation_copy(const gp_pixmap *src,
                                           gp_pixmap *dst)
{
        dst->axes_swap = src->axes_swap;
        dst->x_swap = src->x_swap;
        dst->y_swap = src->y_swap;
}
 
static inline gp_size gp_pixmap_w(const gp_pixmap *self)
{
        if (self->axes_swap)
                return self->h;
        else
                return self->w;
}
 
static inline gp_size gp_pixmap_h(const gp_pixmap *self)
{
        if (self->axes_swap)
                return self->w;
        else
                return self->h;
}
 
/*
 * Compare two pixmaps. Returns true only if all of types, sizes and
 * bitmap data match. Takes transformations into account.
 *
 * For now ignores gamma tables.
 *
 * Currently rather slow (getpixel).
 * TODO: speed up for same rotation and same bit-offset data (per-row memcpy).
 */
 
int gp_pixmap_equal(const gp_pixmap *pixmap1, const gp_pixmap *pixmap2);
 
#endif /* CORE_GP_PIXMAP_H */