1 #ifndef UNSUPPORTED
2 
hline(struct image * img,int x,int y,int length,int fgcolor)3 static inline void hline(struct image *img, int x, int y, int length,
4                          int fgcolor)
5 {
6     cpixel_t *current = (cpixel_t *)img->currlines[y],
7              *end = (cpixel_t *)img->currlines[y];
8     p_inc(current, x);
9     p_inc(end, x + length);
10 #ifdef bpp1
11     memset(current, fgcolor, end - current + 1);
12 #else
13     while (current <= end) {
14         p_set(current, fgcolor);
15         p_inc(current, 1);
16     }
17 #endif
18 }
19 
vline(struct image * img,int x,int y,int length,int fgcolor)20 static inline void vline(struct image *img, int x, int y, int length,
21                          int fgcolor)
22 {
23     length += y;
24     while (y <= length) {
25         cpixel_t *current = (cpixel_t *)img->currlines[y];
26         p_inc(current, x);
27         p_set(current, fgcolor);
28         y++;
29     }
30 }
31 
rectangle(struct image * img,int x,int y,int width,int height,int fgcolor)32 static inline void rectangle(struct image *img, int x, int y, int width,
33                              int height, int fgcolor)
34 {
35     height += y;
36     while (y < height)
37         hline(img, x, y, width - 1, fgcolor), y++;
38 }
39 
savevline(struct image * img,int x,int y,int length)40 static inline char *savevline(struct image *img, int x, int y, int length)
41 {
42     cpixel_t *saved = (cpixel_t *)malloc(length * bpp + bpp), *s = saved;
43     length += y;
44     while (y <= length) {
45         cpixel_t *current = (cpixel_t *)img->currlines[y];
46         p_copy(s, 0, current, x);
47         p_inc(s, 1);
48         y++;
49     }
50     return (char *)saved;
51 }
52 
restorevline(struct image * img,char * saved,int x,int y,int length)53 static inline void restorevline(struct image *img, char *saved, int x, int y,
54                                 int length)
55 {
56     cpixel_t *s = (cpixel_t *)saved;
57     length += y;
58     while (y <= length) {
59         cpixel_t *current = (cpixel_t *)img->currlines[y];
60         p_copy(current, x, s, 0);
61         p_inc(s, 1);
62         y++;
63     }
64 }
65 
saveline(struct image * img,int x,int y,int x2,int y2)66 static inline char *saveline(struct image *img, int x, int y, int x2, int y2)
67 {
68     int dx = x2 - x;
69     int dy = y2 - y;
70     int ady = abs(dy);
71     if (dx < ady) {
72         cpixel_t *saved = (cpixel_t *)malloc((ady + 1) * bpp * 2), *s = saved;
73         int plus = (dx << 16) / ady;
74         if (dy < 0) {
75             int dy = (x << 16) /*| (65536 / 2) */;
76             ady = y;
77             while (ady >= y2) {
78                 cpixel_t *current = (cpixel_t *)img->currlines[ady];
79                 p_inc(current, (dy >> 16));
80                 p_copy(s, 0, current, 0);
81                 p_copy(s, 1, current, 1);
82                 p_inc(s, 2);
83                 dy += plus;
84                 ady--;
85             }
86         } else {
87             int dy = (x << 16) /*| (65536 / 2) */;
88             ady = y;
89             while (ady <= y2) {
90                 cpixel_t *current = (cpixel_t *)img->currlines[ady];
91                 p_inc(current, (dy >> 16));
92                 p_copy(s, 0, current, 0);
93                 p_copy(s, 1, current, 1);
94                 p_inc(s, 2);
95                 dy += plus;
96                 ady++;
97             }
98         }
99         return ((char *)saved);
100     } else {
101         cpixel_t *saved = (cpixel_t *)malloc((dx + 1) * bpp * 2), *s = saved;
102         int plus = (dy << 16) / dx;
103         ady = x;
104         dy = (y << 16);
105         while (ady <= x2) {
106             cpixel_t *current = (cpixel_t *)img->currlines[dy >> 16];
107             p_copy(s, 0, current, ady);
108             current = (cpixel_t *)img->currlines[(dy >> 16) + 1];
109             p_copy(s, 1, current, ady);
110             p_inc(s, 2);
111             dy += plus;
112             ady++;
113         }
114         return ((char *)saved);
115     }
116 }
117 
restoreline(struct image * img,char * saved,int x,int y,int x2,int y2)118 static inline void restoreline(struct image *img, char *saved, int x, int y,
119                                int x2, int y2)
120 {
121     int dx = x2 - x;
122     int dy = y2 - y;
123     int ady = abs(dy);
124     if (dx < ady) {
125         cpixel_t *s = (cpixel_t *)saved;
126         int plus = (dx << 16) / ady;
127         if (dy < 0) {
128             int dy = (x << 16) /*| (65536 / 2) */;
129             ady = y;
130             while (ady >= y2) {
131                 cpixel_t *current = (cpixel_t *)img->currlines[ady];
132                 p_inc(current, (dy >> 16));
133                 p_copy(current, 0, s, 0);
134                 p_copy(current, 1, s, 1);
135                 p_inc(s, 2);
136                 dy += plus;
137                 ady--;
138             }
139         } else {
140             int dy = (x << 16) /*| (65536 / 2) */;
141             ady = y;
142             while (ady <= y2) {
143                 cpixel_t *current = (cpixel_t *)img->currlines[ady];
144                 p_inc(current, (dy >> 16));
145                 p_copy(current, 0, s, 0);
146                 p_copy(current, 1, s, 1);
147                 p_inc(s, 2);
148                 dy += plus;
149                 ady++;
150             }
151         }
152     } else {
153         cpixel_t *s = (cpixel_t *)saved;
154         int plus = (dy << 16) / dx;
155         ady = x;
156         dy = (y << 16);
157         while (ady <= x2) {
158             cpixel_t *current = (cpixel_t *)img->currlines[dy >> 16];
159             p_copy(current, ady, s, 0);
160             current = (cpixel_t *)img->currlines[(dy >> 16) + 1];
161             p_copy(current, ady, s, 1);
162             p_inc(s, 2);
163             dy += plus;
164             ady++;
165         }
166     }
167 }
168 
169 #ifdef bpp1
170 #define myinterpol(a, b, n) intergray(a, b, n)
171 #else
172 #define myinterpol(a, b, n) interpol(a, b, n, rmask, gmask, bmask)
173 #endif
line(struct image * img,int x,int y,int x2,int y2,int color)174 static inline void line(struct image *img, int x, int y, int x2, int y2,
175                         int color)
176 {
177     int dx = x2 - x;
178     int dy = y2 - y;
179     int ady = abs(dy);
180 #ifndef bpp1
181     int rmask = img->palette->info.truec.rmask;
182     int gmask = img->palette->info.truec.gmask;
183     int bmask = img->palette->info.truec.bmask;
184 #endif
185 #ifdef bpp1
186     if (img->palette->type &= (C256 | FIXEDCOLOR)) {
187         if (dx < ady) {
188             int plus = (dx << 16) / ady;
189             if (dy < 0) {
190                 int dy = (x << 16) | (65536 / 2);
191                 ady = y;
192                 while (ady >= y2) {
193                     cpixel_t *current = (cpixel_t *)img->currlines[ady];
194                     p_inc(current, (dy >> 16));
195                     p_set(current, color);
196                     dy += plus;
197                     ady--;
198                 }
199             } else {
200                 int dy = (x << 16) | (65536 / 2);
201                 ady = y;
202                 while (ady <= y2) {
203                     cpixel_t *current = (cpixel_t *)img->currlines[ady];
204                     p_inc(current, (dy >> 16));
205                     p_set(current, color);
206                     dy += plus;
207                     ady++;
208                 }
209             }
210         } else {
211             int plus = (dy << 16) / dx;
212             ady = x;
213             dy = (y << 16) | (65536 / 2);
214             while (ady <= x2) {
215                 cpixel_t *current = (cpixel_t *)img->currlines[dy >> 16];
216                 p_setp(current, ady, color);
217                 dy += plus;
218                 ady++;
219             }
220         }
221         return;
222     }
223 #endif
224 
225     if (dx < ady) {
226         int plus = (dx << 16) / ady;
227         if (dy < 0) {
228             int dy = (x << 16);
229             ady = y;
230             while (ady >= y2) {
231                 cpixel_t *current = (cpixel_t *)img->currlines[ady];
232                 p_inc(current, (dy >> 16));
233                 p_set(current,
234                       myinterpol(p_get(current), color, ((dy & 65535) >> 8)));
235                 p_setp(
236                     current, 1,
237                     myinterpol(color, p_getp(current, 1), ((dy & 65535) >> 8)));
238                 dy += plus;
239                 ady--;
240             }
241         } else {
242             int dy = (x << 16);
243             ady = y;
244             while (ady <= y2) {
245                 cpixel_t *current = (cpixel_t *)img->currlines[ady];
246                 p_inc(current, (dy >> 16));
247                 p_set(current,
248                       myinterpol(p_get(current), color, ((dy & 65535) >> 8)));
249                 p_setp(
250                     current, 1,
251                     myinterpol(color, p_getp(current, 1), ((dy & 65535) >> 8)));
252                 dy += plus;
253                 ady++;
254             }
255         }
256     } else {
257         int plus = (dy << 16) / dx;
258         ady = x;
259         dy = (y << 16);
260         while (ady <= x2) {
261             cpixel_t *current = (cpixel_t *)img->currlines[dy >> 16];
262             p_setp(
263                 current, ady,
264                 myinterpol(p_getp(current, ady), color, ((dy & 65535) >> 8)));
265             current = (cpixel_t *)img->currlines[(dy >> 16) + 1];
266             p_setp(
267                 current, ady,
268                 myinterpol(color, p_getp(current, ady), ((dy & 65535) >> 8)));
269             dy += plus;
270             ady++;
271         }
272     }
273 }
274 
275 #undef myinterpol
276 #endif
277 
278 #undef drawchar
279 #undef hline
280 #undef vline
281 #undef rectangle
282 #undef line
283 #undef restoreline
284 #undef saveline
285 #undef savevline
286 #undef restorevline
287