GFXprim
2D bitmap graphics library with emphasis on speed and correctness
Loading...
Searching...
No Matches
gp_pixmap.h
Go to the documentation of this file.
1// SPDX-License-Identifier: LGPL-2.1-or-later
2/*
3 * Copyright (C) 2009-2011 Jiri "BlueBear" Dluhos
4 * <jiri.bluebear.dluhos@gmail.com>
5 *
6 * Copyright (C) 2009-2024 Cyril Hrubis <metan@ucw.cz>
7 */
8
15#ifndef CORE_GP_PIXMAP_H
16#define CORE_GP_PIXMAP_H
17
18#include <stdint.h>
19#include <unistd.h>
20
21#include <core/gp_common.h>
22#include <core/gp_types.h>
23#include <core/gp_pixel.h>
25
33struct gp_pixmap {
35 uint8_t *pixels;
42 uint32_t bytes_per_row;
44 uint32_t w;
46 uint32_t h;
56 uint8_t offset;
57
64
71
79 uint8_t axes_swap:1;
87 uint8_t x_swap:1;
95 uint8_t y_swap:1;
96
98 uint8_t free_pixels:1;
99};
100
109#define GP_PIXEL_ADDR(pixmap, x, y) ((pixmap)->pixels \
110 + (y) * (pixmap)->bytes_per_row \
111 + ((x + (pixmap)->offset) * gp_pixel_size((pixmap)->pixel_type)) / 8)
112
113#define GP_CALC_ROW_SIZE(pixel_type, width) \
114 ((gp_pixel_size(pixel_type) * width) / 8 + \
115 !!((gp_pixel_size(pixel_type) * width) % 8))
116
117/* Performs a series of sanity checks on pixmap, aborting if any fails. */
118#define GP_CHECK_PIXMAP(pixmap) do { \
119 GP_CHECK(pixmap, "NULL passed as pixmap"); \
120 GP_CHECK(pixmap->pixels || pixmap->w == 0 || pixmap->h == 0, "invalid pixmap: pixels NULL on nonzero w h"); \
121} while (0)
122
131#define GP_PIXEL_IS_CLIPPED(pixmap, x, y) \
132 ((x) < 0 || x >= (typeof(x)) pixmap->w \
133 || (y) < 0 || y >= (typeof(y)) pixmap->h) \
134
170 uint32_t stride);
171
186{
187 return gp_pixmap_alloc_ex(w, h, type, 0);
188}
189
204
224static inline int gp_pixmap_gamma_set(gp_pixmap *self, float gamma)
225{
226 gp_correction_desc desc = {
227 .corr_type = GP_CORRECTION_TYPE_GAMMA,
228 .gamma = gamma,
229 };
230
231 return gp_pixmap_correction_set(self, &desc);
232}
233
251static inline int gp_pixmap_srgb_set(gp_pixmap *self)
252{
253 gp_correction_desc desc = {
254 .corr_type = GP_CORRECTION_TYPE_SRGB,
255 };
256
257 return gp_pixmap_correction_set(self, &desc);
258}
259
270
278
302 gp_pixel_type type, void *pixels,
303 enum gp_pixmap_init_flags flags);
304
325 gp_pixel_type type, uint32_t bpr,
326 void *pixels, enum gp_pixmap_init_flags flags);
327
347 gp_pixel_type type, void *pixels,
348 enum gp_pixmap_init_flags flags)
349{
350 gp_pixmap *ret = malloc(sizeof(gp_pixmap));
351
352 if (!ret)
353 return NULL;
354
355 return gp_pixmap_init(ret, w, h, type, pixels, flags);
356}
357
375
387
398
417 gp_coord x, gp_coord y, gp_size w, gp_size h);
418
437 gp_coord x, gp_coord y, gp_size w, gp_size h);
438
439
440/*
441 * Converts pixmap to a different pixel type.
442 * Returns a newly allocated pixmap.
443 *
444 * This is naive implementation that doesn't do any ditherings or error
445 * diffusions.
446 */
447gp_pixmap *gp_pixmap_convert_alloc(const gp_pixmap *src,
448 gp_pixel_type dst_pixel_type);
449
450/*
451 * Converts pixmap to a different pixel type.
452 *
453 * This is naive implementation that doesn't do any ditherings or error
454 * diffusions.
455 */
456gp_pixmap *gp_pixmap_convert(const gp_pixmap *src, gp_pixmap *dst);
457
464
475
484static inline void gp_pixmap_rotate_cw(gp_pixmap *self)
485{
487}
488
497static inline void gp_pixmap_rotate_ccw(gp_pixmap *self)
498{
500}
501
510static inline int gp_pixmap_rotation_equal(const gp_pixmap *c1,
511 const gp_pixmap *c2)
512{
513 return c1->axes_swap == c2->axes_swap &&
514 c1->x_swap == c2->x_swap &&
515 c1->y_swap == c2->y_swap;
516}
517
526static inline void gp_pixmap_rotation_set(gp_pixmap *self, int axes_swap,
527 int x_swap, int y_swap)
528{
529 self->axes_swap = axes_swap;
530 self->x_swap = x_swap;
531 self->y_swap = y_swap;
532}
533
540static inline void gp_pixmap_rotation_copy(const gp_pixmap *src,
541 gp_pixmap *dst)
542{
543 dst->axes_swap = src->axes_swap;
544 dst->x_swap = src->x_swap;
545 dst->y_swap = src->y_swap;
546}
547
554static inline gp_size gp_pixmap_w(const gp_pixmap *self)
555{
556 if (self->axes_swap)
557 return self->h;
558 else
559 return self->w;
560}
561
568static inline gp_size gp_pixmap_h(const gp_pixmap *self)
569{
570 if (self->axes_swap)
571 return self->w;
572 else
573 return self->h;
574}
575
576/*
577 * Compare two pixmaps. Returns true only if all of types, sizes and
578 * bitmap data match. Takes transformations into account.
579 *
580 * For now ignores gamma tables.
581 *
582 * Currently rather slow (getpixel).
583 * TODO: speed up for same rotation and same bit-offset data (per-row memcpy).
584 */
585
586int gp_pixmap_equal(const gp_pixmap *pixmap1, const gp_pixmap *pixmap2);
587
588#endif /* CORE_GP_PIXMAP_H */
589
Common macros.
A common types.
int gp_coord
Integer type for coordinates i.e. x, y, ...
Definition gp_types.h:19
unsigned int gp_size
Integer type for sizes i.e. w, h, ...
Definition gp_types.h:24
gp_symmetry
Rotation and mirroring flags.
Definition gp_types.h:47
@ GP_ROTATE_CCW
Rotate counter clockwise. Alias for GP_ROTATE_270.
Definition gp_types.h:57
@ GP_ROTATE_CW
Rotate clockwise. Alias for GP_ROTATE_90.
Definition gp_types.h:51
Gamma and sRGB corrections.
gp_pixel_type
List of all pixel types.
A pixel description.
int gp_pixmap_resize(gp_pixmap *self, gp_size w, gp_size h)
Resizes pixmap.
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)
Initializes allocated pixmap structure.
static void gp_pixmap_rotation_copy(const gp_pixmap *src, gp_pixmap *dst)
Copies rotation flags from one pixmap to another.
Definition gp_pixmap.h:540
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)
Initializes allocated pixmap structure.
static int gp_pixmap_rotation_equal(const gp_pixmap *c1, const gp_pixmap *c2)
Compares rotation flags for two pixmaps.
Definition gp_pixmap.h:510
void gp_pixmap_rotate(gp_pixmap *self, gp_symmetry symmetry)
Rotates pixmap accordingly to rotate flags.
static void gp_pixmap_rotation_set(gp_pixmap *self, int axes_swap, int x_swap, int y_swap)
Sets pixmap rotation flags.
Definition gp_pixmap.h:526
static void gp_pixmap_rotate_cw(gp_pixmap *self)
Rotates pixmap flags clockwise.
Definition gp_pixmap.h:484
void gp_pixmap_print_info(const gp_pixmap *self)
Prints pixmap information into stdout.
gp_pixmap_copy_flags
A pixmap copy flags.
Definition gp_pixmap.h:379
@ GP_PIXMAP_COPY_PIXELS
Definition gp_pixmap.h:381
@ GP_PIXMAP_COPY_ROTATION
Definition gp_pixmap.h:383
@ GP_PIXMAP_COPY_GAMMA
Definition gp_pixmap.h:385
gp_pixmap_init_flags
A pixmap init flags.
Definition gp_pixmap.h:274
@ GP_PIXMAP_FREE_PIXELS
Definition gp_pixmap.h:276
gp_pixmap * gp_sub_pixmap_alloc(const gp_pixmap *src, gp_coord x, gp_coord y, gp_size w, gp_size h)
Allocate and initalize a subpixmap.
static gp_size gp_pixmap_w(const gp_pixmap *self)
Returns pixmap width taking axes swap into account.
Definition gp_pixmap.h:554
gp_pixmap * gp_sub_pixmap(const gp_pixmap *src, gp_pixmap *subpixmap, gp_coord x, gp_coord y, gp_size w, gp_size h)
Initializes a subpixmap.
static void gp_pixmap_rotate_ccw(gp_pixmap *self)
Rotates pixmap flags counter clock wise.
Definition gp_pixmap.h:497
static gp_size gp_pixmap_h(const gp_pixmap *self)
Returns pixmap height taking axes swap into account.
Definition gp_pixmap.h:568
gp_pixmap * gp_pixmap_copy(const gp_pixmap *src, enum gp_pixmap_copy_flags flags)
Copies a pixmap.
@ GP_CORRECTION_TYPE_GAMMA
Classical gamma correction.
@ GP_CORRECTION_TYPE_SRGB
Standard RGB.
static int gp_pixmap_srgb_set(gp_pixmap *self)
Sets a sRGB correction for the pixmap.
Definition gp_pixmap.h:251
static int gp_pixmap_gamma_set(gp_pixmap *self, float gamma)
Sets a gamma correction for the pixmap.
Definition gp_pixmap.h:224
static gp_pixmap * gp_pixmap_from_data(gp_size w, gp_size h, gp_pixel_type type, void *pixels, enum gp_pixmap_init_flags flags)
Creates a pixmap from a buffer allocated by malloc().
Definition gp_pixmap.h:346
static gp_pixmap * gp_pixmap_alloc(gp_size w, gp_size h, gp_pixel_type type)
Allocates a pixmap.
Definition gp_pixmap.h:185
int gp_pixmap_correction_set(gp_pixmap *self, gp_correction_desc *corr_desc)
Sets a correction for the pixmap.
gp_pixmap * gp_pixmap_alloc_ex(gp_size w, gp_size h, gp_pixel_type type, uint32_t stride)
Allocates a pixmap.
void gp_pixmap_free(gp_pixmap *self)
Frees a pixmap.
A correction description.
A correction tables for all pixel channels.
A pixmap buffer.
Definition gp_pixmap.h:33
uint32_t h
Pixmap height in pixels.
Definition gp_pixmap.h:46
uint8_t * pixels
A pointer to image pixels.
Definition gp_pixmap.h:35
uint8_t x_swap
Mirrors image x axis for drawing.
Definition gp_pixmap.h:87
uint8_t free_pixels
If set pixels are freed on gp_pixmap_free.
Definition gp_pixmap.h:98
uint8_t y_swap
Mirrors image y axis for drawing.
Definition gp_pixmap.h:95
enum gp_pixel_type pixel_type
A pixel format.
Definition gp_pixmap.h:63
uint32_t bytes_per_row
Number of bytes per row.
Definition gp_pixmap.h:42
gp_gamma * gamma
A pointer to a gamma correction table.
Definition gp_pixmap.h:70
uint32_t w
Pixmap width in pixels.
Definition gp_pixmap.h:44
uint8_t offset
An offset to apply before the start of the pixel row.
Definition gp_pixmap.h:56
uint8_t axes_swap
Swaps image x and y axes for drawing.
Definition gp_pixmap.h:79