1 /* Copyright (C) 2001-2017 Peter Selinger.
2 This file is part of Potrace. It is free software and it is covered
3 by the GNU General Public License. See the file COPYING for details. */
4
5 #ifndef BITMAP_H
6 #define BITMAP_H
7
8 #include <string.h>
9 #include <stdlib.h>
10 #include <errno.h>
11 #include <stddef.h>
12
13 /* The bitmap type is defined in potracelib.h */
14 #include "potracelib.h"
15
16 /* The present file defines some convenient macros and static inline
17 functions for accessing bitmaps. Since they only produce inline
18 code, they can be conveniently shared by the library and frontends,
19 if desired */
20
21 /* ---------------------------------------------------------------------- */
22 /* some measurements */
23
24 #define BM_WORDSIZE ((int)sizeof(potrace_word))
25 #define BM_WORDBITS (8*BM_WORDSIZE)
26 #define BM_HIBIT (((potrace_word)1)<<(BM_WORDBITS-1))
27 #define BM_ALLBITS (~(potrace_word)0)
28
29 /* macros for accessing pixel at index (x,y). U* macros omit the
30 bounds check. */
31
32 #define bm_scanline(bm, y) ((bm)->map + (ptrdiff_t)(y)*(ptrdiff_t)(bm)->dy)
33 #define bm_index(bm, x, y) (&bm_scanline(bm, y)[(x)/BM_WORDBITS])
34 #define bm_mask(x) (BM_HIBIT >> ((x) & (BM_WORDBITS-1)))
35 #define bm_range(x, a) ((int)(x) >= 0 && (int)(x) < (a))
36 #define bm_safe(bm, x, y) (bm_range(x, (bm)->w) && bm_range(y, (bm)->h))
37 #define BM_UGET(bm, x, y) ((*bm_index(bm, x, y) & bm_mask(x)) != 0)
38 #define BM_USET(bm, x, y) (*bm_index(bm, x, y) |= bm_mask(x))
39 #define BM_UCLR(bm, x, y) (*bm_index(bm, x, y) &= ~bm_mask(x))
40 #define BM_UINV(bm, x, y) (*bm_index(bm, x, y) ^= bm_mask(x))
41 #define BM_UPUT(bm, x, y, b) ((b) ? BM_USET(bm, x, y) : BM_UCLR(bm, x, y))
42 #define BM_GET(bm, x, y) (bm_safe(bm, x, y) ? BM_UGET(bm, x, y) : 0)
43 #define BM_SET(bm, x, y) (bm_safe(bm, x, y) ? BM_USET(bm, x, y) : 0)
44 #define BM_CLR(bm, x, y) (bm_safe(bm, x, y) ? BM_UCLR(bm, x, y) : 0)
45 #define BM_INV(bm, x, y) (bm_safe(bm, x, y) ? BM_UINV(bm, x, y) : 0)
46 #define BM_PUT(bm, x, y, b) (bm_safe(bm, x, y) ? BM_UPUT(bm, x, y, b) : 0)
47
48 /* calculate the size, in bytes, required for the data area of a
49 bitmap of the given dy and h. Assume h >= 0. Return -1 if the size
50 does not fit into the ptrdiff_t type. */
getsize(int dy,int h)51 static inline ptrdiff_t getsize(int dy, int h) {
52 ptrdiff_t size;
53
54 if (dy < 0) {
55 dy = -dy;
56 }
57
58 size = (ptrdiff_t)dy * (ptrdiff_t)h * (ptrdiff_t)BM_WORDSIZE;
59
60 /* check for overflow error */
61 if (size < 0 || (h != 0 && dy != 0 && size / h / dy != BM_WORDSIZE)) {
62 return -1;
63 }
64
65 return size;
66 }
67
68 /* return the size, in bytes, of the data area of the bitmap. Return
69 -1 if the size does not fit into the ptrdiff_t type; however, this
70 cannot happen if the bitmap is well-formed, i.e., if created with
71 bm_new or bm_dup. */
bm_size(const potrace_bitmap_t * bm)72 static inline ptrdiff_t bm_size(const potrace_bitmap_t *bm) {
73 return getsize(bm->dy, bm->h);
74 }
75
76 /* calculate the base address of the bitmap data. Assume that the
77 bitmap is well-formed, i.e., its size fits into the ptrdiff_t type.
78 This is the case if created with bm_new or bm_dup. The base address
79 may differ from bm->map if dy is negative */
bm_base(const potrace_bitmap_t * bm)80 static inline potrace_word *bm_base(const potrace_bitmap_t *bm) {
81 int dy = bm->dy;
82
83 if (dy >= 0 || bm->h == 0) {
84 return bm->map;
85 } else {
86 return bm_scanline(bm, bm->h - 1);
87 }
88 }
89
90 /* free the given bitmap. Leaves errno untouched. */
bm_free(potrace_bitmap_t * bm)91 static inline void bm_free(potrace_bitmap_t *bm) {
92 if (bm && bm->map) {
93 free(bm_base(bm));
94 }
95 free(bm);
96 }
97
98 /* return new bitmap initialized to 0. NULL with errno on error.
99 Assumes w, h >= 0. */
bm_new(int w,int h)100 static inline potrace_bitmap_t *bm_new(int w, int h) {
101 potrace_bitmap_t *bm;
102 int dy = w == 0 ? 0 : (w - 1) / BM_WORDBITS + 1;
103 ptrdiff_t size;
104
105 size = getsize(dy, h);
106 if (size < 0) {
107 errno = ENOMEM;
108 return NULL;
109 }
110 if (size == 0) {
111 size = 1; /* make sure calloc() doesn't return NULL */
112 }
113
114 bm = (potrace_bitmap_t *) malloc(sizeof(potrace_bitmap_t));
115 if (!bm) {
116 return NULL;
117 }
118 bm->w = w;
119 bm->h = h;
120 bm->dy = dy;
121 bm->map = (potrace_word *) calloc(1, size);
122 if (!bm->map) {
123 free(bm);
124 return NULL;
125 }
126 return bm;
127 }
128
129 /* clear the given bitmap. Set all bits to c. Assumes a well-formed
130 bitmap. */
bm_clear(potrace_bitmap_t * bm,int c)131 static inline void bm_clear(potrace_bitmap_t *bm, int c) {
132 /* Note: if the bitmap was created with bm_new, then it is
133 guaranteed that size will fit into the ptrdiff_t type. */
134 ptrdiff_t size = bm_size(bm);
135 memset(bm_base(bm), c ? -1 : 0, size);
136 }
137
138 /* duplicate the given bitmap. Return NULL on error with errno
139 set. Assumes a well-formed bitmap. */
bm_dup(const potrace_bitmap_t * bm)140 static inline potrace_bitmap_t *bm_dup(const potrace_bitmap_t *bm) {
141 potrace_bitmap_t *bm1 = bm_new(bm->w, bm->h);
142 int y;
143
144 if (!bm1) {
145 return NULL;
146 }
147 for (y=0; y < bm->h; y++) {
148 memcpy(bm_scanline(bm1, y), bm_scanline(bm, y), (size_t)bm1->dy * (size_t)BM_WORDSIZE);
149 }
150 return bm1;
151 }
152
153 /* invert the given bitmap. */
bm_invert(potrace_bitmap_t * bm)154 static inline void bm_invert(potrace_bitmap_t *bm) {
155 int dy = bm->dy;
156 int y;
157 int i;
158 potrace_word *p;
159
160 if (dy < 0) {
161 dy = -dy;
162 }
163
164 for (y=0; y < bm->h; y++) {
165 p = bm_scanline(bm, y);
166 for (i=0; i < dy; i++) {
167 p[i] ^= BM_ALLBITS;
168 }
169 }
170 }
171
172 /* turn the given bitmap upside down. This does not move the bitmap
173 data or change the bm_base() address. */
bm_flip(potrace_bitmap_t * bm)174 static inline void bm_flip(potrace_bitmap_t *bm) {
175 int dy = bm->dy;
176
177 if (bm->h == 0 || bm->h == 1) {
178 return;
179 }
180
181 bm->map = bm_scanline(bm, bm->h - 1);
182 bm->dy = -dy;
183 }
184
185 /* resize the bitmap to the given new height. The bitmap data remains
186 bottom-aligned (truncated at the top) when dy >= 0 and top-aligned
187 (truncated at the bottom) when dy < 0. Return 0 on success, or 1 on
188 error with errno set. If the new height is <= the old one, no error
189 should occur. If the new height is larger, the additional bitmap
190 data is *not* initialized. */
bm_resize(potrace_bitmap_t * bm,int h)191 static inline int bm_resize(potrace_bitmap_t *bm, int h) {
192 int dy = bm->dy;
193 ptrdiff_t newsize;
194 potrace_word *newmap;
195
196 if (dy < 0) {
197 bm_flip(bm);
198 }
199
200 newsize = getsize(dy, h);
201 if (newsize < 0) {
202 errno = ENOMEM;
203 goto error;
204 }
205 if (newsize == 0) {
206 newsize = 1; /* make sure realloc() doesn't return NULL */
207 }
208
209 newmap = (potrace_word *)realloc(bm->map, newsize);
210 if (newmap == NULL) {
211 goto error;
212 }
213 bm->map = newmap;
214 bm->h = h;
215
216 if (dy < 0) {
217 bm_flip(bm);
218 }
219 return 0;
220
221 error:
222 if (dy < 0) {
223 bm_flip(bm);
224 }
225 return 1;
226 }
227
228 #endif /* BITMAP_H */
229