File: | create.c |
Location: | line 291, column 18 |
Description: | Access to field 'red_closeness' results in a dereference of a null pointer (loaded from variable 'attributes') |
1 | /* | |||
2 | * Copyright (C) 1989-95 GROUPE BULL | |||
3 | * | |||
4 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |||
5 | * of this software and associated documentation files (the "Software"), to | |||
6 | * deal in the Software without restriction, including without limitation the | |||
7 | * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | |||
8 | * sell copies of the Software, and to permit persons to whom the Software is | |||
9 | * furnished to do so, subject to the following conditions: | |||
10 | * | |||
11 | * The above copyright notice and this permission notice shall be included in | |||
12 | * all copies or substantial portions of the Software. | |||
13 | * | |||
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |||
17 | * GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN | |||
18 | * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |||
19 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |||
20 | * | |||
21 | * Except as contained in this notice, the name of GROUPE BULL shall not be | |||
22 | * used in advertising or otherwise to promote the sale, use or other dealings | |||
23 | * in this Software without prior written authorization from GROUPE BULL. | |||
24 | */ | |||
25 | ||||
26 | /*****************************************************************************\ | |||
27 | * create.c: * | |||
28 | * * | |||
29 | * XPM library * | |||
30 | * Create an X image and possibly its related shape mask * | |||
31 | * from the given XpmImage. * | |||
32 | * * | |||
33 | * Developed by Arnaud Le Hors * | |||
34 | \*****************************************************************************/ | |||
35 | ||||
36 | /* | |||
37 | * The code related to FOR_MSW has been added by | |||
38 | * HeDu (hedu@cul-ipn.uni-kiel.de) 4/94 | |||
39 | */ | |||
40 | ||||
41 | /* | |||
42 | * The code related to AMIGA has been added by | |||
43 | * Lorens Younes (d93-hyo@nada.kth.se) 4/96 | |||
44 | */ | |||
45 | ||||
46 | /* October 2004, source code review by Thomas Biege <thomas@suse.de> */ | |||
47 | ||||
48 | #ifdef HAVE_CONFIG_H1 | |||
49 | #include <config.h> | |||
50 | #endif | |||
51 | #include "XpmI.h" | |||
52 | #include <ctype.h> | |||
53 | ||||
54 | LFUNC(xpmVisualType, int, (Visual *visual))static int xpmVisualType (Visual *visual); | |||
55 | ||||
56 | LFUNC(AllocColor, int, (Display *display, Colormap colormap,static int AllocColor (Display *display, Colormap colormap, char *colorname, XColor *xcolor, void *closure) | |||
57 | char *colorname, XColor *xcolor, void *closure))static int AllocColor (Display *display, Colormap colormap, char *colorname, XColor *xcolor, void *closure); | |||
58 | LFUNC(FreeColors, int, (Display *display, Colormap colormap,static int FreeColors (Display *display, Colormap colormap, Pixel *pixels, int n, void *closure) | |||
59 | Pixel *pixels, int n, void *closure))static int FreeColors (Display *display, Colormap colormap, Pixel *pixels, int n, void *closure); | |||
60 | ||||
61 | #ifndef FOR_MSW | |||
62 | LFUNC(SetCloseColor, int, (Display *display, Colormap colormap,static int SetCloseColor (Display *display, Colormap colormap , Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel , Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols, XpmAllocColorFunc allocColor , void *closure) | |||
63 | Visual *visual, XColor *col,static int SetCloseColor (Display *display, Colormap colormap , Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel , Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols, XpmAllocColorFunc allocColor , void *closure) | |||
64 | Pixel *image_pixel, Pixel *mask_pixel,static int SetCloseColor (Display *display, Colormap colormap , Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel , Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols, XpmAllocColorFunc allocColor , void *closure) | |||
65 | Pixel *alloc_pixels, unsigned int *nalloc_pixels,static int SetCloseColor (Display *display, Colormap colormap , Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel , Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols, XpmAllocColorFunc allocColor , void *closure) | |||
66 | XpmAttributes *attributes, XColor *cols, int ncols,static int SetCloseColor (Display *display, Colormap colormap , Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel , Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols, XpmAllocColorFunc allocColor , void *closure) | |||
67 | XpmAllocColorFunc allocColor, void *closure))static int SetCloseColor (Display *display, Colormap colormap , Visual *visual, XColor *col, Pixel *image_pixel, Pixel *mask_pixel , Pixel *alloc_pixels, unsigned int *nalloc_pixels, XpmAttributes *attributes, XColor *cols, int ncols, XpmAllocColorFunc allocColor , void *closure); | |||
68 | #else | |||
69 | /* let the window system take care of close colors */ | |||
70 | #endif | |||
71 | ||||
72 | LFUNC(SetColor, int, (Display *display, Colormap colormap, Visual *visual,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
73 | char *colorname, unsigned int color_index,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
74 | Pixel *image_pixel, Pixel *mask_pixel,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
75 | unsigned int *mask_pixel_index,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
76 | Pixel *alloc_pixels, unsigned int *nalloc_pixels,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
77 | Pixel *used_pixels, unsigned int *nused_pixels,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
78 | XpmAttributes *attributes, XColor *cols, int ncols,static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure) | |||
79 | XpmAllocColorFunc allocColor, void *closure))static int SetColor (Display *display, Colormap colormap, Visual *visual, char *colorname, unsigned int color_index, Pixel *image_pixel , Pixel *mask_pixel, unsigned int *mask_pixel_index, Pixel *alloc_pixels , unsigned int *nalloc_pixels, Pixel *used_pixels, unsigned int *nused_pixels, XpmAttributes *attributes, XColor *cols, int ncols , XpmAllocColorFunc allocColor, void *closure); | |||
80 | ||||
81 | LFUNC(CreateXImage, int, (Display *display, Visual *visual,static int CreateXImage (Display *display, Visual *visual, unsigned int depth, int format, unsigned int width, unsigned int height , XImage **image_return) | |||
82 | unsigned int depth, int format, unsigned int width,static int CreateXImage (Display *display, Visual *visual, unsigned int depth, int format, unsigned int width, unsigned int height , XImage **image_return) | |||
83 | unsigned int height, XImage **image_return))static int CreateXImage (Display *display, Visual *visual, unsigned int depth, int format, unsigned int width, unsigned int height , XImage **image_return); | |||
84 | ||||
85 | LFUNC(CreateColors, int, (Display *display, XpmAttributes *attributes,static int CreateColors (Display *display, XpmAttributes *attributes , XpmColor *colors, unsigned int ncolors, Pixel *image_pixels , Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel * alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels , unsigned int *nused_pixels) | |||
86 | XpmColor *colors, unsigned int ncolors,static int CreateColors (Display *display, XpmAttributes *attributes , XpmColor *colors, unsigned int ncolors, Pixel *image_pixels , Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel * alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels , unsigned int *nused_pixels) | |||
87 | Pixel *image_pixels, Pixel *mask_pixels,static int CreateColors (Display *display, XpmAttributes *attributes , XpmColor *colors, unsigned int ncolors, Pixel *image_pixels , Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel * alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels , unsigned int *nused_pixels) | |||
88 | unsigned int *mask_pixel_index,static int CreateColors (Display *display, XpmAttributes *attributes , XpmColor *colors, unsigned int ncolors, Pixel *image_pixels , Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel * alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels , unsigned int *nused_pixels) | |||
89 | Pixel *alloc_pixels, unsigned int *nalloc_pixels,static int CreateColors (Display *display, XpmAttributes *attributes , XpmColor *colors, unsigned int ncolors, Pixel *image_pixels , Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel * alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels , unsigned int *nused_pixels) | |||
90 | Pixel *used_pixels, unsigned int *nused_pixels))static int CreateColors (Display *display, XpmAttributes *attributes , XpmColor *colors, unsigned int ncolors, Pixel *image_pixels , Pixel *mask_pixels, unsigned int *mask_pixel_index, Pixel * alloc_pixels, unsigned int *nalloc_pixels, Pixel *used_pixels , unsigned int *nused_pixels); | |||
91 | ||||
92 | #ifndef FOR_MSW | |||
93 | LFUNC(ParseAndPutPixels, int, (xpmData *data, unsigned int width,static int ParseAndPutPixels (xpmData *data, unsigned int width , unsigned int height, unsigned int ncolors, unsigned int cpp , XpmColor *colorTable, xpmHashTable *hashtable, XImage *image , Pixel *image_pixels, XImage *mask, Pixel *mask_pixels) | |||
94 | unsigned int height, unsigned int ncolors,static int ParseAndPutPixels (xpmData *data, unsigned int width , unsigned int height, unsigned int ncolors, unsigned int cpp , XpmColor *colorTable, xpmHashTable *hashtable, XImage *image , Pixel *image_pixels, XImage *mask, Pixel *mask_pixels) | |||
95 | unsigned int cpp, XpmColor *colorTable,static int ParseAndPutPixels (xpmData *data, unsigned int width , unsigned int height, unsigned int ncolors, unsigned int cpp , XpmColor *colorTable, xpmHashTable *hashtable, XImage *image , Pixel *image_pixels, XImage *mask, Pixel *mask_pixels) | |||
96 | xpmHashTable *hashtable,static int ParseAndPutPixels (xpmData *data, unsigned int width , unsigned int height, unsigned int ncolors, unsigned int cpp , XpmColor *colorTable, xpmHashTable *hashtable, XImage *image , Pixel *image_pixels, XImage *mask, Pixel *mask_pixels) | |||
97 | XImage *image, Pixel *image_pixels,static int ParseAndPutPixels (xpmData *data, unsigned int width , unsigned int height, unsigned int ncolors, unsigned int cpp , XpmColor *colorTable, xpmHashTable *hashtable, XImage *image , Pixel *image_pixels, XImage *mask, Pixel *mask_pixels) | |||
98 | XImage *mask, Pixel *mask_pixels))static int ParseAndPutPixels (xpmData *data, unsigned int width , unsigned int height, unsigned int ncolors, unsigned int cpp , XpmColor *colorTable, xpmHashTable *hashtable, XImage *image , Pixel *image_pixels, XImage *mask, Pixel *mask_pixels); | |||
99 | #else /* FOR_MSW */ | |||
100 | LFUNC(ParseAndPutPixels, int, (Display *dc, xpmData *data, unsigned int width,static int ParseAndPutPixels (Display *dc, xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors, unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, XImage *image, Pixel *image_pixels, XImage *mask, Pixel *mask_pixels ) | |||
101 | unsigned int height, unsigned int ncolors,static int ParseAndPutPixels (Display *dc, xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors, unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, XImage *image, Pixel *image_pixels, XImage *mask, Pixel *mask_pixels ) | |||
102 | unsigned int cpp, XpmColor *colorTable,static int ParseAndPutPixels (Display *dc, xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors, unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, XImage *image, Pixel *image_pixels, XImage *mask, Pixel *mask_pixels ) | |||
103 | xpmHashTable *hashtable,static int ParseAndPutPixels (Display *dc, xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors, unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, XImage *image, Pixel *image_pixels, XImage *mask, Pixel *mask_pixels ) | |||
104 | XImage *image, Pixel *image_pixels,static int ParseAndPutPixels (Display *dc, xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors, unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, XImage *image, Pixel *image_pixels, XImage *mask, Pixel *mask_pixels ) | |||
105 | XImage *mask, Pixel *mask_pixels))static int ParseAndPutPixels (Display *dc, xpmData *data, unsigned int width, unsigned int height, unsigned int ncolors, unsigned int cpp, XpmColor *colorTable, xpmHashTable *hashtable, XImage *image, Pixel *image_pixels, XImage *mask, Pixel *mask_pixels ); | |||
106 | #endif | |||
107 | ||||
108 | #ifndef FOR_MSW | |||
109 | # ifndef AMIGA | |||
110 | /* XImage pixel routines */ | |||
111 | LFUNC(PutImagePixels, void, (XImage *image, unsigned int width,static void PutImagePixels (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
112 | unsigned int height, unsigned int *pixelindex,static void PutImagePixels (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
113 | Pixel *pixels))static void PutImagePixels (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ); | |||
114 | ||||
115 | LFUNC(PutImagePixels32, void, (XImage *image, unsigned int width,static void PutImagePixels32 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
116 | unsigned int height, unsigned int *pixelindex,static void PutImagePixels32 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
117 | Pixel *pixels))static void PutImagePixels32 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ); | |||
118 | ||||
119 | LFUNC(PutImagePixels16, void, (XImage *image, unsigned int width,static void PutImagePixels16 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
120 | unsigned int height, unsigned int *pixelindex,static void PutImagePixels16 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
121 | Pixel *pixels))static void PutImagePixels16 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ); | |||
122 | ||||
123 | LFUNC(PutImagePixels8, void, (XImage *image, unsigned int width,static void PutImagePixels8 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
124 | unsigned int height, unsigned int *pixelindex,static void PutImagePixels8 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
125 | Pixel *pixels))static void PutImagePixels8 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ); | |||
126 | ||||
127 | LFUNC(PutImagePixels1, void, (XImage *image, unsigned int width,static void PutImagePixels1 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
128 | unsigned int height, unsigned int *pixelindex,static void PutImagePixels1 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
129 | Pixel *pixels))static void PutImagePixels1 (XImage *image, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ); | |||
130 | ||||
131 | LFUNC(PutPixel1, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel1 (XImage *ximage, int x, int y, unsigned long pixel); | |||
132 | LFUNC(PutPixel, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel (XImage *ximage, int x, int y, unsigned long pixel); | |||
133 | #if !defined(WORD64) && !defined(LONG64) | |||
134 | LFUNC(PutPixel32, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel32 (XImage *ximage, int x, int y, unsigned long pixel); | |||
135 | #endif | |||
136 | LFUNC(PutPixel32MSB, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel32MSB (XImage *ximage, int x, int y, unsigned long pixel); | |||
137 | LFUNC(PutPixel32LSB, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel32LSB (XImage *ximage, int x, int y, unsigned long pixel); | |||
138 | LFUNC(PutPixel16MSB, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel16MSB (XImage *ximage, int x, int y, unsigned long pixel); | |||
139 | LFUNC(PutPixel16LSB, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel16LSB (XImage *ximage, int x, int y, unsigned long pixel); | |||
140 | LFUNC(PutPixel8, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel8 (XImage *ximage, int x, int y, unsigned long pixel); | |||
141 | LFUNC(PutPixel1MSB, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel1MSB (XImage *ximage, int x, int y, unsigned long pixel); | |||
142 | LFUNC(PutPixel1LSB, int, (XImage *ximage, int x, int y, unsigned long pixel))static int PutPixel1LSB (XImage *ximage, int x, int y, unsigned long pixel); | |||
143 | ||||
144 | # else /* AMIGA */ | |||
145 | LFUNC(APutImagePixels, void, (XImage *ximage, unsigned int width,static void APutImagePixels (XImage *ximage, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
146 | unsigned int height, unsigned int *pixelindex,static void APutImagePixels (XImage *ximage, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ) | |||
147 | Pixel *pixels))static void APutImagePixels (XImage *ximage, unsigned int width , unsigned int height, unsigned int *pixelindex, Pixel *pixels ); | |||
148 | # endif/* AMIGA */ | |||
149 | #else /* FOR_MSW */ | |||
150 | /* FOR_MSW pixel routine */ | |||
151 | LFUNC(MSWPutImagePixels, void, (Display *dc, XImage *image,static void MSWPutImagePixels (Display *dc, XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) | |||
152 | unsigned int width, unsigned int height,static void MSWPutImagePixels (Display *dc, XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels) | |||
153 | unsigned int *pixelindex, Pixel *pixels))static void MSWPutImagePixels (Display *dc, XImage *image, unsigned int width, unsigned int height, unsigned int *pixelindex, Pixel *pixels); | |||
154 | #endif /* FOR_MSW */ | |||
155 | ||||
156 | #ifdef NEED_STRCASECMP | |||
157 | FUNC(xpmstrcasecmp, int, (char *s1, char *s2))extern int strcasecmp (char *s1, char *s2); | |||
158 | ||||
159 | /* | |||
160 | * in case strcasecmp is not provided by the system here is one | |||
161 | * which does the trick | |||
162 | */ | |||
163 | int | |||
164 | xpmstrcasecmpstrcasecmp( | |||
165 | register char *s1, | |||
166 | register char *s2) | |||
167 | { | |||
168 | register int c1, c2; | |||
169 | ||||
170 | while (*s1 && *s2) { | |||
171 | c1 = tolower(*s1); | |||
172 | c2 = tolower(*s2); | |||
173 | if (c1 != c2) | |||
174 | return (c1 - c2); | |||
175 | s1++; | |||
176 | s2++; | |||
177 | } | |||
178 | return (int) (*s1 - *s2); | |||
179 | } | |||
180 | ||||
181 | #endif | |||
182 | ||||
183 | /* | |||
184 | * return the default color key related to the given visual | |||
185 | */ | |||
186 | static int | |||
187 | xpmVisualType(Visual *visual) | |||
188 | { | |||
189 | #ifndef FOR_MSW | |||
190 | # ifndef AMIGA | |||
191 | switch (visual->class) { | |||
192 | case StaticGray0: | |||
193 | case GrayScale1: | |||
194 | switch (visual->map_entries) { | |||
195 | case 2: | |||
196 | return (XPM_MONO2); | |||
197 | case 4: | |||
198 | return (XPM_GRAY43); | |||
199 | default: | |||
200 | return (XPM_GRAY4); | |||
201 | } | |||
202 | default: | |||
203 | return (XPM_COLOR5); | |||
204 | } | |||
205 | # else | |||
206 | /* set the key explicitly in the XpmAttributes to override this */ | |||
207 | return (XPM_COLOR5); | |||
208 | # endif | |||
209 | #else | |||
210 | /* there should be a similar switch for MSW */ | |||
211 | return (XPM_COLOR5); | |||
212 | #endif | |||
213 | } | |||
214 | ||||
215 | ||||
216 | typedef struct { | |||
217 | int cols_index; | |||
218 | long closeness; | |||
219 | } CloseColor; | |||
220 | ||||
221 | static int | |||
222 | closeness_cmp(const void *a, const void *b) | |||
223 | { | |||
224 | const CloseColor *x = (const CloseColor *) a, *y = (const CloseColor *) b; | |||
225 | ||||
226 | /* cast to int as qsort requires */ | |||
227 | return (int) (x->closeness - y->closeness); | |||
228 | } | |||
229 | ||||
230 | ||||
231 | /* default AllocColor function: | |||
232 | * call XParseColor if colorname is given, return negative value if failure | |||
233 | * call XAllocColor and return 0 if failure, positive otherwise | |||
234 | */ | |||
235 | static int | |||
236 | AllocColor( | |||
237 | Display *display, | |||
238 | Colormap colormap, | |||
239 | char *colorname, | |||
240 | XColor *xcolor, | |||
241 | void *closure) /* not used */ | |||
242 | { | |||
243 | int status; | |||
244 | if (colorname) | |||
245 | if (!XParseColor(display, colormap, colorname, xcolor)) | |||
246 | return -1; | |||
247 | status = XAllocColor(display, colormap, xcolor); | |||
248 | return status != 0 ? 1 : 0; | |||
249 | } | |||
250 | ||||
251 | ||||
252 | #ifndef FOR_MSW | |||
253 | /* | |||
254 | * set a close color in case the exact one can't be set | |||
255 | * return 0 if success, 1 otherwise. | |||
256 | */ | |||
257 | ||||
258 | static int | |||
259 | SetCloseColor( | |||
260 | Display *display, | |||
261 | Colormap colormap, | |||
262 | Visual *visual, | |||
263 | XColor *col, | |||
264 | Pixel *image_pixel, | |||
265 | Pixel *mask_pixel, | |||
266 | Pixel *alloc_pixels, | |||
267 | unsigned int *nalloc_pixels, | |||
268 | XpmAttributes *attributes, | |||
269 | XColor *cols, | |||
270 | int ncols, | |||
271 | XpmAllocColorFunc allocColor, | |||
272 | void *closure) | |||
273 | { | |||
274 | ||||
275 | /* | |||
276 | * Allocation failed, so try close colors. To get here the visual must | |||
277 | * be GreyScale, PseudoColor or DirectColor (or perhaps StaticColor? | |||
278 | * What about sharing systems like QDSS?). Beware: we have to treat | |||
279 | * DirectColor differently. | |||
280 | */ | |||
281 | ||||
282 | ||||
283 | long int red_closeness, green_closeness, blue_closeness; | |||
284 | int n; | |||
285 | Boolint alloc_color; | |||
286 | ||||
287 | if (attributes && (attributes->valuemask & XpmCloseness(1L<<12))) | |||
| ||||
288 | red_closeness = green_closeness = blue_closeness = | |||
289 | attributes->closeness; | |||
290 | else { | |||
291 | red_closeness = attributes->red_closeness; | |||
| ||||
292 | green_closeness = attributes->green_closeness; | |||
293 | blue_closeness = attributes->blue_closeness; | |||
294 | } | |||
295 | if (attributes && (attributes->valuemask & XpmAllocCloseColors(1L<<17))) | |||
296 | alloc_color = attributes->alloc_close_colors; | |||
297 | else | |||
298 | alloc_color = True1; | |||
299 | ||||
300 | /* | |||
301 | * We sort the colormap by closeness and try to allocate the color | |||
302 | * closest to the target. If the allocation of this close color fails, | |||
303 | * which almost never happens, then one of two scenarios is possible. | |||
304 | * Either the colormap must have changed (since the last close color | |||
305 | * allocation or possibly while we were sorting the colormap), or the | |||
306 | * color is allocated as Read/Write by some other client. (Note: X | |||
307 | * _should_ allow clients to check if a particular color is Read/Write, | |||
308 | * but it doesn't! :-( ). We cannot determine which of these scenarios | |||
309 | * occurred, so we try the next closest color, and so on, until no more | |||
310 | * colors are within closeness of the target. If we knew that the | |||
311 | * colormap had changed, we could skip this sequence. | |||
312 | * | |||
313 | * If _none_ of the colors within closeness of the target can be allocated, | |||
314 | * then we can finally be pretty sure that the colormap has actually | |||
315 | * changed. In this case we try to allocate the original color (again), | |||
316 | * then try the closecolor stuff (again)... | |||
317 | * | |||
318 | * In theory it would be possible for an infinite loop to occur if another | |||
319 | * process kept changing the colormap every time we sorted it, so we set | |||
320 | * a maximum on the number of iterations. After this many tries, we use | |||
321 | * XGrabServer() to ensure that the colormap remains unchanged. | |||
322 | * | |||
323 | * This approach gives particularly bad worst case performance - as many as | |||
324 | * <MaximumIterations> colormap reads and sorts may be needed, and as | |||
325 | * many as <MaximumIterations> * <ColormapSize> attempted allocations | |||
326 | * may fail. On an 8-bit system, this means as many as 3 colormap reads, | |||
327 | * 3 sorts and 768 failed allocations per execution of this code! | |||
328 | * Luckily, my experiments show that in general use in a typical 8-bit | |||
329 | * color environment only about 1 in every 10000 allocations fails to | |||
330 | * succeed in the fastest possible time. So virtually every time what | |||
331 | * actually happens is a single sort followed by a successful allocate. | |||
332 | * The very first allocation also costs a colormap read, but no further | |||
333 | * reads are usually necessary. | |||
334 | */ | |||
335 | ||||
336 | #define ITERATIONS2 2 /* more than one is almost never | |||
337 | * necessary */ | |||
338 | ||||
339 | for (n = 0; n <= ITERATIONS2; ++n) { | |||
340 | CloseColor *closenesses = | |||
341 | (CloseColor *) XpmCalloc(ncols, sizeof(CloseColor))calloc((ncols), (sizeof(CloseColor))); | |||
342 | int i, c; | |||
343 | ||||
344 | for (i = 0; i < ncols; ++i) { /* build & sort closenesses table */ | |||
345 | #define COLOR_FACTOR3 3 | |||
346 | #define BRIGHTNESS_FACTOR1 1 | |||
347 | ||||
348 | closenesses[i].cols_index = i; | |||
349 | closenesses[i].closeness = | |||
350 | COLOR_FACTOR3 * (labs((long) col->red - (long) cols[i].red) | |||
351 | + labs((long) col->green - (long) cols[i].green) | |||
352 | + labs((long) col->blue - (long) cols[i].blue)) | |||
353 | + BRIGHTNESS_FACTOR1 * labs(((long) col->red + | |||
354 | (long) col->green + | |||
355 | (long) col->blue) | |||
356 | - ((long) cols[i].red + | |||
357 | (long) cols[i].green + | |||
358 | (long) cols[i].blue)); | |||
359 | } | |||
360 | qsort(closenesses, ncols, sizeof(CloseColor), closeness_cmp); | |||
361 | ||||
362 | i = 0; | |||
363 | c = closenesses[i].cols_index; | |||
364 | while ((long) cols[c].red >= (long) col->red - red_closeness && | |||
365 | (long) cols[c].red <= (long) col->red + red_closeness && | |||
366 | (long) cols[c].green >= (long) col->green - green_closeness && | |||
367 | (long) cols[c].green <= (long) col->green + green_closeness && | |||
368 | (long) cols[c].blue >= (long) col->blue - blue_closeness && | |||
369 | (long) cols[c].blue <= (long) col->blue + blue_closeness) { | |||
370 | if (alloc_color) { | |||
371 | if ((*allocColor)(display, colormap, NULL((void*)0), &cols[c], closure)){ | |||
372 | if (n == ITERATIONS2) | |||
373 | XUngrabServer(display); | |||
374 | XpmFree(closenesses)free(closenesses); | |||
375 | *image_pixel = cols[c].pixel; | |||
376 | *mask_pixel = 1; | |||
377 | alloc_pixels[(*nalloc_pixels)++] = cols[c].pixel; | |||
378 | return (0); | |||
379 | } else { | |||
380 | ++i; | |||
381 | if (i == ncols) | |||
382 | break; | |||
383 | c = closenesses[i].cols_index; | |||
384 | } | |||
385 | } else { | |||
386 | if (n == ITERATIONS2) | |||
387 | XUngrabServer(display); | |||
388 | XpmFree(closenesses)free(closenesses); | |||
389 | *image_pixel = cols[c].pixel; | |||
390 | *mask_pixel = 1; | |||
391 | return (0); | |||
392 | } | |||
393 | } | |||
394 | ||||
395 | /* Couldn't allocate _any_ of the close colors! */ | |||
396 | ||||
397 | if (n == ITERATIONS2) | |||
398 | XUngrabServer(display); | |||
399 | XpmFree(closenesses)free(closenesses); | |||
400 | ||||
401 | if (i == 0 || i == ncols) /* no color close enough or cannot */ | |||
402 | return (1); /* alloc any color (full of r/w's) */ | |||
403 | ||||
404 | if ((*allocColor)(display, colormap, NULL((void*)0), col, closure)) { | |||
405 | *image_pixel = col->pixel; | |||
406 | *mask_pixel = 1; | |||
407 | alloc_pixels[(*nalloc_pixels)++] = col->pixel; | |||
408 | return (0); | |||
409 | } else { /* colormap has probably changed, so | |||
410 | * re-read... */ | |||
411 | if (n == ITERATIONS2 - 1) | |||
412 | XGrabServer(display); | |||
413 | ||||
414 | #if 0 | |||
415 | if (visual->class == DirectColor5) { | |||
416 | /* TODO */ | |||
417 | } else | |||
418 | #endif | |||
419 | XQueryColors(display, colormap, cols, ncols); | |||
420 | } | |||
421 | } | |||
422 | return (1); | |||
423 | } | |||
424 | ||||
425 | #define USE_CLOSECOLORattributes && (((attributes->valuemask & (1L<< 12)) && attributes->closeness != 0) || ((attributes ->valuemask & (1L<<13)) && (attributes-> red_closeness != 0 || attributes->green_closeness != 0 || attributes ->blue_closeness != 0))) attributes && \ | |||
426 | (((attributes->valuemask & XpmCloseness(1L<<12)) && attributes->closeness != 0) \ | |||
427 | || ((attributes->valuemask & XpmRGBCloseness(1L<<13)) && \ | |||
428 | (attributes->red_closeness != 0 \ | |||
429 | || attributes->green_closeness != 0 \ | |||
430 | || attributes->blue_closeness != 0))) | |||
431 | ||||
432 | #else | |||
433 | /* FOR_MSW part */ | |||
434 | /* nothing to do here, the window system does it */ | |||
435 | #endif | |||
436 | ||||
437 | /* | |||
438 | * set the color pixel related to the given colorname, | |||
439 | * return 0 if success, 1 otherwise. | |||
440 | */ | |||
441 | ||||
442 | static int | |||
443 | SetColor( | |||
444 | Display *display, | |||
445 | Colormap colormap, | |||
446 | Visual *visual, | |||
447 | char *colorname, | |||
448 | unsigned int color_index, | |||
449 | Pixel *image_pixel, | |||
450 | Pixel *mask_pixel, | |||
451 | unsigned int *mask_pixel_index, | |||
452 | Pixel *alloc_pixels, | |||
453 | unsigned int *nalloc_pixels, | |||
454 | Pixel *used_pixels, | |||
455 | unsigned int *nused_pixels, | |||
456 | XpmAttributes *attributes, | |||
457 | XColor *cols, | |||
458 | int ncols, | |||
459 | XpmAllocColorFunc allocColor, | |||
460 | void *closure) | |||
461 | { | |||
462 | XColor xcolor; | |||
463 | int status; | |||
464 | ||||
465 | if (xpmstrcasecmpstrcasecmp(colorname, TRANSPARENT_COLOR"None")) { | |||
466 | status = (*allocColor)(display, colormap, colorname, &xcolor, closure); | |||
467 | if (status < 0) /* parse color failed */ | |||
468 | return (1); | |||
469 | ||||
470 | if (status == 0) { | |||
471 | #ifndef FOR_MSW | |||
472 | if (USE_CLOSECOLORattributes && (((attributes->valuemask & (1L<< 12)) && attributes->closeness != 0) || ((attributes ->valuemask & (1L<<13)) && (attributes-> red_closeness != 0 || attributes->green_closeness != 0 || attributes ->blue_closeness != 0)))) | |||
473 | return (SetCloseColor(display, colormap, visual, &xcolor, | |||
474 | image_pixel, mask_pixel, | |||
475 | alloc_pixels, nalloc_pixels, | |||
476 | attributes, cols, ncols, | |||
477 | allocColor, closure)); | |||
478 | else | |||
479 | #endif /* ndef FOR_MSW */ | |||
480 | return (1); | |||
481 | } else | |||
482 | alloc_pixels[(*nalloc_pixels)++] = xcolor.pixel; | |||
483 | *image_pixel = xcolor.pixel; | |||
484 | #ifndef FOR_MSW | |||
485 | *mask_pixel = 1; | |||
486 | #else | |||
487 | *mask_pixel = RGB(0,0,0); | |||
488 | #endif | |||
489 | used_pixels[(*nused_pixels)++] = xcolor.pixel; | |||
490 | } else { | |||
491 | *image_pixel = 0; | |||
492 | #ifndef FOR_MSW | |||
493 | *mask_pixel = 0; | |||
494 | #else | |||
495 | *mask_pixel = RGB(255,255,255); | |||
496 | #endif | |||
497 | /* store the color table index */ | |||
498 | *mask_pixel_index = color_index; | |||
499 | } | |||
500 | return (0); | |||
501 | } | |||
502 | ||||
503 | ||||
504 | static int | |||
505 | CreateColors( | |||
506 | Display *display, | |||
507 | XpmAttributes *attributes, | |||
508 | XpmColor *colors, | |||
509 | unsigned int ncolors, | |||
510 | Pixel *image_pixels, | |||
511 | Pixel *mask_pixels, | |||
512 | unsigned int *mask_pixel_index, | |||
513 | Pixel *alloc_pixels, | |||
514 | unsigned int *nalloc_pixels, | |||
515 | Pixel *used_pixels, | |||
516 | unsigned int *nused_pixels) | |||
517 | { | |||
518 | /* variables stored in the XpmAttributes structure */ | |||
519 | Visual *visual; | |||
520 | Colormap colormap; | |||
521 | XpmColorSymbol *colorsymbols = NULL((void*)0); | |||
522 | unsigned int numsymbols; | |||
523 | XpmAllocColorFunc allocColor; | |||
524 | void *closure; | |||
525 | ||||
526 | char *colorname; | |||
527 | unsigned int color, key; | |||
528 | Boolint pixel_defined; | |||
529 | XpmColorSymbol *symbol = NULL((void*)0); | |||
530 | char **defaults; | |||
531 | int ErrorStatus = XpmSuccess0; | |||
532 | char *s; | |||
533 | int default_index; | |||
534 | ||||
535 | XColor *cols = NULL((void*)0); | |||
536 | unsigned int ncols = 0; | |||
537 | ||||
538 | /* | |||
539 | * retrieve information from the XpmAttributes | |||
540 | */ | |||
541 | if (attributes && attributes->valuemask & XpmColorSymbols(1L<<6)) { | |||
542 | colorsymbols = attributes->colorsymbols; | |||
543 | numsymbols = attributes->numsymbols; | |||
544 | } else | |||
545 | numsymbols = 0; | |||
546 | ||||
547 | if (attributes && attributes->valuemask & XpmVisual(1L<<0)) | |||
548 | visual = attributes->visual; | |||
549 | else | |||
550 | visual = XDefaultVisual(display, XDefaultScreen(display)); | |||
551 | ||||
552 | if (attributes && (attributes->valuemask & XpmColormap(1L<<1))) | |||
553 | colormap = attributes->colormap; | |||
554 | else | |||
555 | colormap = XDefaultColormap(display, XDefaultScreen(display)); | |||
556 | ||||
557 | if (attributes && (attributes->valuemask & XpmColorKey(1L<<14))) | |||
558 | key = attributes->color_key; | |||
559 | else | |||
560 | key = xpmVisualType(visual); | |||
561 | ||||
562 | if (attributes && (attributes->valuemask & XpmAllocColor(1L<<19))) | |||
563 | allocColor = attributes->alloc_color; | |||
564 | else | |||
565 | allocColor = AllocColor; | |||
566 | if (attributes && (attributes->valuemask & XpmColorClosure(1L<<21))) | |||
567 | closure = attributes->color_closure; | |||
568 | else | |||
569 | closure = NULL((void*)0); | |||
570 | ||||
571 | #ifndef FOR_MSW | |||
572 | if (USE_CLOSECOLORattributes && (((attributes->valuemask & (1L<< 12)) && attributes->closeness != 0) || ((attributes ->valuemask & (1L<<13)) && (attributes-> red_closeness != 0 || attributes->green_closeness != 0 || attributes ->blue_closeness != 0)))) { | |||
573 | /* originally from SetCloseColor */ | |||
574 | #if 0 | |||
575 | if (visual->class == DirectColor5) { | |||
576 | ||||
577 | /* | |||
578 | * TODO: Implement close colors for DirectColor visuals. This is | |||
579 | * difficult situation. Chances are that we will never get here, | |||
580 | * because any machine that supports DirectColor will probably | |||
581 | * also support TrueColor (and probably PseudoColor). Also, | |||
582 | * DirectColor colormaps can be very large, so looking for close | |||
583 | * colors may be too slow. | |||
584 | */ | |||
585 | } else { | |||
586 | #endif | |||
587 | unsigned int i; | |||
588 | ||||
589 | #ifndef AMIGA | |||
590 | ncols = visual->map_entries; | |||
591 | #else | |||
592 | ncols = colormap->Count; | |||
593 | #endif | |||
594 | cols = (XColor *) XpmCalloc(ncols, sizeof(XColor))calloc((ncols), (sizeof(XColor))); | |||
595 | for (i = 0; i < ncols; ++i) | |||
596 | cols[i].pixel = i; | |||
597 | XQueryColors(display, colormap, cols, ncols); | |||
598 | #if 0 | |||
599 | } | |||
600 | #endif | |||
601 | } | |||
602 | #endif /* ndef FOR_MSW */ | |||
603 | ||||
604 | switch (key) { | |||
605 | case XPM_MONO2: | |||
606 | default_index = 2; | |||
607 | break; | |||
608 | case XPM_GRAY43: | |||
609 | default_index = 3; | |||
610 | break; | |||
611 | case XPM_GRAY4: | |||
612 | default_index = 4; | |||
613 | break; | |||
614 | case XPM_COLOR5: | |||
615 | default: | |||
616 | default_index = 5; | |||
617 | break; | |||
618 | } | |||
619 | ||||
620 | for (color = 0; color < ncolors; color++, colors++, | |||
621 | image_pixels++, mask_pixels++) { | |||
622 | colorname = NULL((void*)0); | |||
623 | pixel_defined = False0; | |||
624 | defaults = (char **) colors; | |||
625 | ||||
626 | /* | |||
627 | * look for a defined symbol | |||
628 | */ | |||
629 | if (numsymbols) { | |||
630 | ||||
631 | unsigned int n; | |||
632 | ||||
633 | s = defaults[1]; | |||
634 | for (n = 0, symbol = colorsymbols; n < numsymbols; n++, symbol++) { | |||
635 | if (symbol->name && s && !strcmp(symbol->name, s)) | |||
636 | /* override name */ | |||
637 | break; | |||
638 | if (!symbol->name && symbol->value) { /* override value */ | |||
639 | int def_index = default_index; | |||
640 | ||||
641 | while (defaults[def_index] == NULL((void*)0)) /* find defined | |||
642 | * colorname */ | |||
643 | --def_index; | |||
644 | if (def_index < 2) {/* nothing towards mono, so try | |||
645 | * towards color */ | |||
646 | def_index = default_index + 1; | |||
647 | while (def_index <= 5 && defaults[def_index] == NULL((void*)0)) | |||
648 | ++def_index; | |||
649 | } | |||
650 | if (def_index >= 2 && defaults[def_index] != NULL((void*)0) && | |||
651 | !xpmstrcasecmpstrcasecmp(symbol->value, defaults[def_index])) | |||
652 | break; | |||
653 | } | |||
654 | } | |||
655 | if (n != numsymbols) { | |||
656 | if (symbol->name && symbol->value) | |||
657 | colorname = symbol->value; | |||
658 | else | |||
659 | pixel_defined = True1; | |||
660 | } | |||
661 | } | |||
662 | if (!pixel_defined) { /* pixel not given as symbol value */ | |||
663 | ||||
664 | unsigned int k; | |||
665 | ||||
666 | if (colorname) { /* colorname given as symbol value */ | |||
667 | if (!SetColor(display, colormap, visual, colorname, color, | |||
668 | image_pixels, mask_pixels, mask_pixel_index, | |||
669 | alloc_pixels, nalloc_pixels, used_pixels, | |||
670 | nused_pixels, attributes, cols, ncols, | |||
671 | allocColor, closure)) | |||
672 | pixel_defined = True1; | |||
673 | else | |||
674 | ErrorStatus = XpmColorError1; | |||
675 | } | |||
676 | k = key; | |||
677 | while (!pixel_defined && k > 1) { | |||
678 | if (defaults[k]) { | |||
679 | if (!SetColor(display, colormap, visual, defaults[k], | |||
680 | color, image_pixels, mask_pixels, | |||
681 | mask_pixel_index, alloc_pixels, | |||
682 | nalloc_pixels, used_pixels, nused_pixels, | |||
683 | attributes, cols, ncols, | |||
684 | allocColor, closure)) { | |||
685 | pixel_defined = True1; | |||
686 | break; | |||
687 | } else | |||
688 | ErrorStatus = XpmColorError1; | |||
689 | } | |||
690 | k--; | |||
691 | } | |||
692 | k = key + 1; | |||
693 | while (!pixel_defined && k < NKEYS5 + 1) { | |||
694 | if (defaults[k]) { | |||
695 | if (!SetColor(display, colormap, visual, defaults[k], | |||
696 | color, image_pixels, mask_pixels, | |||
697 | mask_pixel_index, alloc_pixels, | |||
698 | nalloc_pixels, used_pixels, nused_pixels, | |||
699 | attributes, cols, ncols, | |||
700 | allocColor, closure)) { | |||
701 | pixel_defined = True1; | |||
702 | break; | |||
703 | } else | |||
704 | ErrorStatus = XpmColorError1; | |||
705 | } | |||
706 | k++; | |||
707 | } | |||
708 | if (!pixel_defined) { | |||
709 | if (cols) | |||
710 | XpmFree(cols)free(cols); | |||
711 | return (XpmColorFailed-4); | |||
712 | } | |||
713 | } else { | |||
714 | /* simply use the given pixel */ | |||
715 | *image_pixels = symbol->pixel; | |||
716 | /* the following makes the mask to be built even if none | |||
717 | is given a particular pixel */ | |||
718 | if (symbol->value | |||
719 | && !xpmstrcasecmpstrcasecmp(symbol->value, TRANSPARENT_COLOR"None")) { | |||
720 | *mask_pixels = 0; | |||
721 | *mask_pixel_index = color; | |||
722 | } else | |||
723 | *mask_pixels = 1; | |||
724 | used_pixels[(*nused_pixels)++] = *image_pixels; | |||
725 | } | |||
726 | } | |||
727 | if (cols) | |||
728 | XpmFree(cols)free(cols); | |||
729 | return (ErrorStatus); | |||
730 | } | |||
731 | ||||
732 | ||||
733 | /* default FreeColors function, simply call XFreeColors */ | |||
734 | static int | |||
735 | FreeColors( | |||
736 | Display *display, | |||
737 | Colormap colormap, | |||
738 | Pixel *pixels, | |||
739 | int n, | |||
740 | void *closure) /* not used */ | |||
741 | { | |||
742 | return XFreeColors(display, colormap, pixels, n, 0); | |||
743 | } | |||
744 | ||||
745 | ||||
746 | /* function call in case of error */ | |||
747 | ||||
748 | #undef RETURN | |||
749 | #define RETURN(status)do { ErrorStatus = status; goto error; } while(0) \ | |||
750 | do \ | |||
751 | { \ | |||
752 | ErrorStatus = status; \ | |||
753 | goto error; \ | |||
754 | } while(0) | |||
755 | ||||
756 | int | |||
757 | XpmCreateImageFromXpmImage( | |||
758 | Display *display, | |||
759 | XpmImage *image, | |||
760 | XImage **image_return, | |||
761 | XImage **shapeimage_return, | |||
762 | XpmAttributes *attributes) | |||
763 | { | |||
764 | /* variables stored in the XpmAttributes structure */ | |||
765 | Visual *visual; | |||
766 | Colormap colormap; | |||
767 | unsigned int depth; | |||
768 | int bitmap_format; | |||
769 | XpmFreeColorsFunc freeColors; | |||
770 | ||||
771 | /* variables to return */ | |||
772 | XImage *ximage = NULL((void*)0); | |||
773 | XImage *shapeimage = NULL((void*)0); | |||
774 | unsigned int mask_pixel_index = XpmUndefPixel0x80000000; | |||
775 | int ErrorStatus; | |||
776 | ||||
777 | /* calculation variables */ | |||
778 | Pixel *image_pixels = NULL((void*)0); | |||
779 | Pixel *mask_pixels = NULL((void*)0); | |||
780 | Pixel *alloc_pixels = NULL((void*)0); | |||
781 | Pixel *used_pixels = NULL((void*)0); | |||
782 | unsigned int nalloc_pixels = 0; | |||
783 | unsigned int nused_pixels = 0; | |||
784 | ||||
785 | /* initialize return values */ | |||
786 | if (image_return) | |||
787 | *image_return = NULL((void*)0); | |||
788 | if (shapeimage_return) | |||
789 | *shapeimage_return = NULL((void*)0); | |||
790 | ||||
791 | /* retrieve information from the XpmAttributes */ | |||
792 | if (attributes && (attributes->valuemask & XpmVisual(1L<<0))) | |||
793 | visual = attributes->visual; | |||
794 | else | |||
795 | visual = XDefaultVisual(display, XDefaultScreen(display)); | |||
796 | ||||
797 | if (attributes && (attributes->valuemask & XpmColormap(1L<<1))) | |||
798 | colormap = attributes->colormap; | |||
799 | else | |||
800 | colormap = XDefaultColormap(display, XDefaultScreen(display)); | |||
801 | ||||
802 | if (attributes && (attributes->valuemask & XpmDepth(1L<<2))) | |||
803 | depth = attributes->depth; | |||
804 | else | |||
805 | depth = XDefaultDepth(display, XDefaultScreen(display)); | |||
806 | ||||
807 | if (attributes && (attributes->valuemask & XpmBitmapFormat(1L<<18))) | |||
808 | bitmap_format = attributes->bitmap_format; | |||
809 | else | |||
810 | bitmap_format = ZPixmap2; | |||
811 | ||||
812 | if (attributes && (attributes->valuemask & XpmFreeColors(1L<<20))) | |||
813 | freeColors = attributes->free_colors; | |||
814 | else | |||
815 | freeColors = FreeColors; | |||
816 | ||||
817 | ErrorStatus = XpmSuccess0; | |||
818 | ||||
819 | if (image->ncolors >= UINT_MAX(2147483647 *2U +1U) / sizeof(Pixel)) | |||
820 | return (XpmNoMemory-3); | |||
821 | ||||
822 | /* malloc pixels index tables */ | |||
823 | image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors)malloc((sizeof(Pixel) * image->ncolors)); | |||
824 | if (!image_pixels) | |||
825 | return (XpmNoMemory-3); | |||
826 | ||||
827 | mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors)malloc((sizeof(Pixel) * image->ncolors)); | |||
828 | if (!mask_pixels) | |||
829 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
830 | ||||
831 | /* maximum of allocated pixels will be the number of colors */ | |||
832 | alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors)malloc((sizeof(Pixel) * image->ncolors)); | |||
833 | if (!alloc_pixels) | |||
834 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
835 | ||||
836 | /* maximum of allocated pixels will be the number of colors */ | |||
837 | used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * image->ncolors)malloc((sizeof(Pixel) * image->ncolors)); | |||
838 | if (!used_pixels) | |||
839 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
840 | ||||
841 | /* get pixel colors, store them in index tables */ | |||
842 | ErrorStatus = CreateColors(display, attributes, image->colorTable, | |||
843 | image->ncolors, image_pixels, mask_pixels, | |||
844 | &mask_pixel_index, alloc_pixels, &nalloc_pixels, | |||
845 | used_pixels, &nused_pixels); | |||
846 | ||||
847 | if (ErrorStatus != XpmSuccess0 | |||
848 | && (ErrorStatus < 0 || (attributes | |||
849 | && (attributes->valuemask & XpmExactColors(1L<<11)) | |||
850 | && attributes->exactColors))) | |||
851 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
852 | ||||
853 | /* create the ximage */ | |||
854 | if (image_return) { | |||
855 | ErrorStatus = CreateXImage(display, visual, depth, | |||
856 | (depth == 1 ? bitmap_format : ZPixmap2), | |||
857 | image->width, image->height, &ximage); | |||
858 | if (ErrorStatus != XpmSuccess0) | |||
859 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
860 | ||||
861 | #ifndef FOR_MSW | |||
862 | # ifndef AMIGA | |||
863 | ||||
864 | /* | |||
865 | * set the ximage data using optimized functions for ZPixmap | |||
866 | */ | |||
867 | ||||
868 | if (ximage->bits_per_pixel == 8) | |||
869 | PutImagePixels8(ximage, image->width, image->height, | |||
870 | image->data, image_pixels); | |||
871 | else if (((ximage->bits_per_pixel | ximage->depth) == 1) && | |||
872 | (ximage->byte_order == ximage->bitmap_bit_order)) | |||
873 | PutImagePixels1(ximage, image->width, image->height, | |||
874 | image->data, image_pixels); | |||
875 | else if (ximage->bits_per_pixel == 16) | |||
876 | PutImagePixels16(ximage, image->width, image->height, | |||
877 | image->data, image_pixels); | |||
878 | else if (ximage->bits_per_pixel == 32) | |||
879 | PutImagePixels32(ximage, image->width, image->height, | |||
880 | image->data, image_pixels); | |||
881 | else | |||
882 | PutImagePixels(ximage, image->width, image->height, | |||
883 | image->data, image_pixels); | |||
884 | # else /* AMIGA */ | |||
885 | APutImagePixels(ximage, image->width, image->height, | |||
886 | image->data, image_pixels); | |||
887 | # endif | |||
888 | #else /* FOR_MSW */ | |||
889 | MSWPutImagePixels(display, ximage, image->width, image->height, | |||
890 | image->data, image_pixels); | |||
891 | #endif | |||
892 | } | |||
893 | /* create the shape mask image */ | |||
894 | if (mask_pixel_index != XpmUndefPixel0x80000000 && shapeimage_return) { | |||
895 | ErrorStatus = CreateXImage(display, visual, 1, bitmap_format, | |||
896 | image->width, image->height, &shapeimage); | |||
897 | if (ErrorStatus != XpmSuccess0) | |||
898 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
899 | ||||
900 | #ifndef FOR_MSW | |||
901 | # ifndef AMIGA | |||
902 | PutImagePixels1(shapeimage, image->width, image->height, | |||
903 | image->data, mask_pixels); | |||
904 | # else /* AMIGA */ | |||
905 | APutImagePixels(shapeimage, image->width, image->height, | |||
906 | image->data, mask_pixels); | |||
907 | # endif | |||
908 | #else /* FOR_MSW */ | |||
909 | MSWPutImagePixels(display, shapeimage, image->width, image->height, | |||
910 | image->data, mask_pixels); | |||
911 | #endif | |||
912 | ||||
913 | } | |||
914 | XpmFree(image_pixels)free(image_pixels); | |||
915 | XpmFree(mask_pixels)free(mask_pixels); | |||
916 | ||||
917 | /* if requested return used pixels in the XpmAttributes structure */ | |||
918 | if (attributes && (attributes->valuemask & XpmReturnPixels(1L<<9) || | |||
919 | /* 3.2 backward compatibility code */ | |||
920 | attributes->valuemask & XpmReturnInfos(1L<<8))) { | |||
921 | /* end 3.2 bc */ | |||
922 | attributes->pixels = used_pixels; | |||
923 | attributes->npixels = nused_pixels; | |||
924 | attributes->mask_pixel = mask_pixel_index; | |||
925 | } else | |||
926 | XpmFree(used_pixels)free(used_pixels); | |||
927 | ||||
928 | /* if requested return alloc'ed pixels in the XpmAttributes structure */ | |||
929 | if (attributes && (attributes->valuemask & XpmReturnAllocPixels(1L<<16))) { | |||
930 | attributes->alloc_pixels = alloc_pixels; | |||
931 | attributes->nalloc_pixels = nalloc_pixels; | |||
932 | } else | |||
933 | XpmFree(alloc_pixels)free(alloc_pixels); | |||
934 | ||||
935 | /* return created images */ | |||
936 | if (image_return) | |||
937 | *image_return = ximage; | |||
938 | if (shapeimage_return) | |||
939 | *shapeimage_return = shapeimage; | |||
940 | ||||
941 | return (ErrorStatus); | |||
942 | ||||
943 | /* exit point in case of error, free only locally allocated variables */ | |||
944 | error: | |||
945 | if (ximage) | |||
946 | XDestroyImage(ximage)((*((ximage)->f.destroy_image))((ximage))); | |||
947 | if (shapeimage) | |||
948 | XDestroyImage(shapeimage)((*((shapeimage)->f.destroy_image))((shapeimage))); | |||
949 | if (image_pixels) | |||
950 | XpmFree(image_pixels)free(image_pixels); | |||
951 | if (mask_pixels) | |||
952 | XpmFree(mask_pixels)free(mask_pixels); | |||
953 | if (nalloc_pixels) | |||
954 | (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL((void*)0)); | |||
955 | if (alloc_pixels) | |||
956 | XpmFree(alloc_pixels)free(alloc_pixels); | |||
957 | if (used_pixels) | |||
958 | XpmFree(used_pixels)free(used_pixels); | |||
959 | ||||
960 | return (ErrorStatus); | |||
961 | } | |||
962 | ||||
963 | ||||
964 | /* | |||
965 | * Create an XImage with its data | |||
966 | */ | |||
967 | static int | |||
968 | CreateXImage( | |||
969 | Display *display, | |||
970 | Visual *visual, | |||
971 | unsigned int depth, | |||
972 | int format, | |||
973 | unsigned int width, | |||
974 | unsigned int height, | |||
975 | XImage **image_return) | |||
976 | { | |||
977 | int bitmap_pad; | |||
978 | ||||
979 | /* first get bitmap_pad */ | |||
980 | if (depth > 16) | |||
981 | bitmap_pad = 32; | |||
982 | else if (depth > 8) | |||
983 | bitmap_pad = 16; | |||
984 | else | |||
985 | bitmap_pad = 8; | |||
986 | ||||
987 | /* then create the XImage with data = NULL and bytes_per_line = 0 */ | |||
988 | *image_return = XCreateImage(display, visual, depth, format, 0, 0, | |||
989 | width, height, bitmap_pad, 0); | |||
990 | if (!*image_return) | |||
991 | return (XpmNoMemory-3); | |||
992 | ||||
993 | #if !defined(FOR_MSW) && !defined(AMIGA) | |||
994 | if (height != 0 && (*image_return)->bytes_per_line >= INT_MAX2147483647 / height) { | |||
995 | XDestroyImage(*image_return)((*((*image_return)->f.destroy_image))((*image_return))); | |||
996 | return XpmNoMemory-3; | |||
997 | } | |||
998 | /* now that bytes_per_line must have been set properly alloc data */ | |||
999 | if((*image_return)->bytes_per_line == 0 || height == 0) | |||
1000 | return XpmNoMemory-3; | |||
1001 | (*image_return)->data = | |||
1002 | (char *) XpmMalloc((*image_return)->bytes_per_line * height)malloc(((*image_return)->bytes_per_line * height)); | |||
1003 | ||||
1004 | if (!(*image_return)->data) { | |||
1005 | XDestroyImage(*image_return)((*((*image_return)->f.destroy_image))((*image_return))); | |||
1006 | *image_return = NULL((void*)0); | |||
1007 | return (XpmNoMemory-3); | |||
1008 | } | |||
1009 | #else | |||
1010 | /* under FOR_MSW and AMIGA XCreateImage has done it all */ | |||
1011 | #endif | |||
1012 | return (XpmSuccess0); | |||
1013 | } | |||
1014 | ||||
1015 | #ifndef FOR_MSW | |||
1016 | # ifndef AMIGA | |||
1017 | /* | |||
1018 | * The functions below are written from X11R5 MIT's code (XImUtil.c) | |||
1019 | * | |||
1020 | * The idea is to have faster functions than the standard XPutPixel function | |||
1021 | * to build the image data. Indeed we can speed up things by suppressing tests | |||
1022 | * performed for each pixel. We do the same tests but at the image level. | |||
1023 | * We also assume that we use only ZPixmap images with null offsets. | |||
1024 | */ | |||
1025 | ||||
1026 | LFUNC(_putbits, void, (register char *src, int dstoffset,static void _putbits (register char *src, int dstoffset, register int numbits, register char *dst) | |||
1027 | register int numbits, register char *dst))static void _putbits (register char *src, int dstoffset, register int numbits, register char *dst); | |||
1028 | ||||
1029 | LFUNC(_XReverse_Bytes, int, (register unsigned char *bpt, register unsigned int nb))static int _XReverse_Bytes (register unsigned char *bpt, register unsigned int nb); | |||
1030 | ||||
1031 | static unsigned char const _reverse_byte[0x100] = { | |||
1032 | 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, | |||
1033 | 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, | |||
1034 | 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, | |||
1035 | 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, | |||
1036 | 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, | |||
1037 | 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, | |||
1038 | 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, | |||
1039 | 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, | |||
1040 | 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, | |||
1041 | 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, | |||
1042 | 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, | |||
1043 | 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, | |||
1044 | 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, | |||
1045 | 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, | |||
1046 | 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, | |||
1047 | 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, | |||
1048 | 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, | |||
1049 | 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, | |||
1050 | 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, | |||
1051 | 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, | |||
1052 | 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, | |||
1053 | 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, | |||
1054 | 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, | |||
1055 | 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, | |||
1056 | 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, | |||
1057 | 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, | |||
1058 | 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, | |||
1059 | 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, | |||
1060 | 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, | |||
1061 | 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, | |||
1062 | 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, | |||
1063 | 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff | |||
1064 | }; | |||
1065 | ||||
1066 | static int | |||
1067 | _XReverse_Bytes( | |||
1068 | register unsigned char *bpt, | |||
1069 | register unsigned int nb) | |||
1070 | { | |||
1071 | do { | |||
1072 | *bpt = _reverse_byte[*bpt]; | |||
1073 | bpt++; | |||
1074 | } while (--nb > 0); /* is nb user-controled? */ | |||
1075 | return 0; | |||
1076 | } | |||
1077 | ||||
1078 | ||||
1079 | void | |||
1080 | xpm_xynormalizeimagebits( | |||
1081 | register unsigned char *bp, | |||
1082 | register XImage *img) | |||
1083 | { | |||
1084 | register unsigned char c; | |||
1085 | ||||
1086 | if (img->byte_order != img->bitmap_bit_order) { | |||
1087 | switch (img->bitmap_unit) { | |||
1088 | ||||
1089 | case 16: | |||
1090 | c = *bp; | |||
1091 | *bp = *(bp + 1); | |||
1092 | *(bp + 1) = c; | |||
1093 | break; | |||
1094 | ||||
1095 | case 32: | |||
1096 | c = *(bp + 3); | |||
1097 | *(bp + 3) = *bp; | |||
1098 | *bp = c; | |||
1099 | c = *(bp + 2); | |||
1100 | *(bp + 2) = *(bp + 1); | |||
1101 | *(bp + 1) = c; | |||
1102 | break; | |||
1103 | } | |||
1104 | } | |||
1105 | if (img->bitmap_bit_order == MSBFirst1) | |||
1106 | _XReverse_Bytes(bp, img->bitmap_unit >> 3); | |||
1107 | } | |||
1108 | ||||
1109 | void | |||
1110 | xpm_znormalizeimagebits( | |||
1111 | register unsigned char *bp, | |||
1112 | register XImage *img) | |||
1113 | { | |||
1114 | register unsigned char c; | |||
1115 | ||||
1116 | switch (img->bits_per_pixel) { | |||
1117 | ||||
1118 | case 2: | |||
1119 | _XReverse_Bytes(bp, 1); | |||
1120 | break; | |||
1121 | ||||
1122 | case 4: | |||
1123 | *bp = ((*bp >> 4) & 0xF) | ((*bp << 4) & ~0xF); | |||
1124 | break; | |||
1125 | ||||
1126 | case 16: | |||
1127 | c = *bp; | |||
1128 | *bp = *(bp + 1); | |||
1129 | *(bp + 1) = c; | |||
1130 | break; | |||
1131 | ||||
1132 | case 24: | |||
1133 | c = *(bp + 2); | |||
1134 | *(bp + 2) = *bp; | |||
1135 | *bp = c; | |||
1136 | break; | |||
1137 | ||||
1138 | case 32: | |||
1139 | c = *(bp + 3); | |||
1140 | *(bp + 3) = *bp; | |||
1141 | *bp = c; | |||
1142 | c = *(bp + 2); | |||
1143 | *(bp + 2) = *(bp + 1); | |||
1144 | *(bp + 1) = c; | |||
1145 | break; | |||
1146 | } | |||
1147 | } | |||
1148 | ||||
1149 | static unsigned char const _lomask[0x09] = { | |||
1150 | 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff}; | |||
1151 | static unsigned char const _himask[0x09] = { | |||
1152 | 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00}; | |||
1153 | ||||
1154 | static void | |||
1155 | _putbits( | |||
1156 | register char *src, /* address of source bit string */ | |||
1157 | int dstoffset, /* bit offset into destination; | |||
1158 | * range is 0-31 */ | |||
1159 | register int numbits, /* number of bits to copy to | |||
1160 | * destination */ | |||
1161 | register char *dst) /* address of destination bit string */ | |||
1162 | { | |||
1163 | register unsigned char chlo, chhi; | |||
1164 | int hibits; | |||
1165 | ||||
1166 | dst = dst + (dstoffset >> 3); | |||
1167 | dstoffset = dstoffset & 7; | |||
1168 | hibits = 8 - dstoffset; | |||
1169 | chlo = *dst & _lomask[dstoffset]; | |||
1170 | for (;;) { | |||
1171 | chhi = (*src << dstoffset) & _himask[dstoffset]; | |||
1172 | if (numbits <= hibits) { | |||
1173 | chhi = chhi & _lomask[dstoffset + numbits]; | |||
1174 | *dst = (*dst & _himask[dstoffset + numbits]) | chlo | chhi; | |||
1175 | break; | |||
1176 | } | |||
1177 | *dst = chhi | chlo; | |||
1178 | dst++; | |||
1179 | numbits = numbits - hibits; | |||
1180 | chlo = (unsigned char) (*src & _himask[hibits]) >> hibits; | |||
1181 | src++; | |||
1182 | if (numbits <= dstoffset) { | |||
1183 | chlo = chlo & _lomask[numbits]; | |||
1184 | *dst = (*dst & _himask[numbits]) | chlo; | |||
1185 | break; | |||
1186 | } | |||
1187 | numbits = numbits - dstoffset; | |||
1188 | } | |||
1189 | } | |||
1190 | ||||
1191 | /* | |||
1192 | * Default method to write pixels into a Z image data structure. | |||
1193 | * The algorithm used is: | |||
1194 | * | |||
1195 | * copy the destination bitmap_unit or Zpixel to temp | |||
1196 | * normalize temp if needed | |||
1197 | * copy the pixel bits into the temp | |||
1198 | * renormalize temp if needed | |||
1199 | * copy the temp back into the destination image data | |||
1200 | */ | |||
1201 | ||||
1202 | static void | |||
1203 | PutImagePixels( | |||
1204 | XImage *image, | |||
1205 | unsigned int width, | |||
1206 | unsigned int height, | |||
1207 | unsigned int *pixelindex, | |||
1208 | Pixel *pixels) | |||
1209 | { | |||
1210 | register char *src; | |||
1211 | register char *dst; | |||
1212 | register unsigned int *iptr; | |||
1213 | register unsigned int x, y; | |||
1214 | register char *data; | |||
1215 | Pixel pixel, px; | |||
1216 | int nbytes, depth, ibu, ibpp, i; | |||
1217 | ||||
1218 | data = image->data; | |||
1219 | iptr = pixelindex; | |||
1220 | depth = image->depth; | |||
1221 | if (depth == 1) { | |||
1222 | ibu = image->bitmap_unit; | |||
1223 | for (y = 0; y < height; y++) /* how can we trust height */ | |||
1224 | for (x = 0; x < width; x++, iptr++) { /* how can we trust width */ | |||
1225 | pixel = pixels[*iptr]; | |||
1226 | for (i = 0, px = pixel; i < sizeof(unsigned long); | |||
1227 | i++, px >>= 8) | |||
1228 | ((unsigned char *) &pixel)[i] = px; | |||
1229 | src = &data[XYINDEX(x, y, image)((y) * image->bytes_per_line) + (((x) + image->xoffset) / image->bitmap_unit) * (image->bitmap_unit >> 3 )]; | |||
1230 | dst = (char *) &px; | |||
1231 | px = 0; | |||
1232 | nbytes = ibu >> 3; | |||
1233 | for (i = nbytes; --i >= 0;) | |||
1234 | *dst++ = *src++; | |||
1235 | XYNORMALIZE(&px, image)if ((image->byte_order == 1) || (image->bitmap_bit_order == 1)) xpm_xynormalizeimagebits((unsigned char *)(&px), image ); | |||
1236 | _putbits((char *) &pixel, (x % ibu), 1, (char *) &px); | |||
1237 | XYNORMALIZE(&px, image)if ((image->byte_order == 1) || (image->bitmap_bit_order == 1)) xpm_xynormalizeimagebits((unsigned char *)(&px), image ); | |||
1238 | src = (char *) &px; | |||
1239 | dst = &data[XYINDEX(x, y, image)((y) * image->bytes_per_line) + (((x) + image->xoffset) / image->bitmap_unit) * (image->bitmap_unit >> 3 )]; | |||
1240 | for (i = nbytes; --i >= 0;) | |||
1241 | *dst++ = *src++; | |||
1242 | } | |||
1243 | } else { | |||
1244 | ibpp = image->bits_per_pixel; | |||
1245 | for (y = 0; y < height; y++) | |||
1246 | for (x = 0; x < width; x++, iptr++) { | |||
1247 | pixel = pixels[*iptr]; | |||
1248 | if (depth == 4) | |||
1249 | pixel &= 0xf; | |||
1250 | for (i = 0, px = pixel; i < sizeof(unsigned long); i++, | |||
1251 | px >>= 8) | |||
1252 | ((unsigned char *) &pixel)[i] = px; | |||
1253 | src = &data[ZINDEX(x, y, image)((y) * image->bytes_per_line) + (((x) * image->bits_per_pixel ) >> 3)]; | |||
1254 | dst = (char *) &px; | |||
1255 | px = 0; | |||
1256 | nbytes = (ibpp + 7) >> 3; | |||
1257 | for (i = nbytes; --i >= 0;) | |||
1258 | *dst++ = *src++; | |||
1259 | ZNORMALIZE(&px, image)if (image->byte_order == 1) xpm_znormalizeimagebits((unsigned char *)(&px), image); | |||
1260 | _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px); | |||
1261 | ZNORMALIZE(&px, image)if (image->byte_order == 1) xpm_znormalizeimagebits((unsigned char *)(&px), image); | |||
1262 | src = (char *) &px; | |||
1263 | dst = &data[ZINDEX(x, y, image)((y) * image->bytes_per_line) + (((x) * image->bits_per_pixel ) >> 3)]; | |||
1264 | for (i = nbytes; --i >= 0;) | |||
1265 | *dst++ = *src++; | |||
1266 | } | |||
1267 | } | |||
1268 | } | |||
1269 | ||||
1270 | /* | |||
1271 | * write pixels into a 32-bits Z image data structure | |||
1272 | */ | |||
1273 | ||||
1274 | #if !defined(WORD64) && !defined(LONG64) | |||
1275 | /* this item is static but deterministic so let it slide; doesn't | |||
1276 | * hurt re-entrancy of this library. Note if it is actually const then would | |||
1277 | * be OK under rules of ANSI-C but probably not C++ which may not | |||
1278 | * want to allocate space for it. | |||
1279 | */ | |||
1280 | static unsigned long byteorderpixel = MSBFirst1 << 24; | |||
1281 | ||||
1282 | #endif | |||
1283 | ||||
1284 | /* | |||
1285 | WITHOUT_SPEEDUPS is a flag to be turned on if you wish to use the original | |||
1286 | 3.2e code - by default you get the speeded-up version. | |||
1287 | */ | |||
1288 | ||||
1289 | static void | |||
1290 | PutImagePixels32( | |||
1291 | XImage *image, | |||
1292 | unsigned int width, | |||
1293 | unsigned int height, | |||
1294 | unsigned int *pixelindex, | |||
1295 | Pixel *pixels) | |||
1296 | { | |||
1297 | unsigned char *data; | |||
1298 | unsigned int *iptr; | |||
1299 | unsigned int y; | |||
1300 | Pixel pixel; | |||
1301 | ||||
1302 | #ifdef WITHOUT_SPEEDUPS | |||
1303 | ||||
1304 | unsigned int x; | |||
1305 | unsigned char *addr; | |||
1306 | ||||
1307 | data = (unsigned char *) image->data; | |||
1308 | iptr = pixelindex; | |||
1309 | #if !defined(WORD64) && !defined(LONG64) | |||
1310 | if (*((char *) &byteorderpixel) == image->byte_order) { | |||
1311 | for (y = 0; y < height; y++) | |||
1312 | for (x = 0; x < width; x++, iptr++) { | |||
1313 | addr = &data[ZINDEX32(x, y, image)((y) * image->bytes_per_line) + ((x) << 2)]; | |||
1314 | *((unsigned long *) addr) = pixels[*iptr]; | |||
1315 | } | |||
1316 | } else | |||
1317 | #endif | |||
1318 | if (image->byte_order == MSBFirst1) | |||
1319 | for (y = 0; y < height; y++) | |||
1320 | for (x = 0; x < width; x++, iptr++) { | |||
1321 | addr = &data[ZINDEX32(x, y, image)((y) * image->bytes_per_line) + ((x) << 2)]; | |||
1322 | pixel = pixels[*iptr]; | |||
1323 | addr[0] = pixel >> 24; | |||
1324 | addr[1] = pixel >> 16; | |||
1325 | addr[2] = pixel >> 8; | |||
1326 | addr[3] = pixel; | |||
1327 | } | |||
1328 | else | |||
1329 | for (y = 0; y < height; y++) | |||
1330 | for (x = 0; x < width; x++, iptr++) { | |||
1331 | addr = &data[ZINDEX32(x, y, image)((y) * image->bytes_per_line) + ((x) << 2)]; | |||
1332 | pixel = pixels[*iptr]; | |||
1333 | addr[0] = pixel; | |||
1334 | addr[1] = pixel >> 8; | |||
1335 | addr[2] = pixel >> 16; | |||
1336 | addr[3] = pixel >> 24; | |||
1337 | } | |||
1338 | ||||
1339 | #else /* WITHOUT_SPEEDUPS */ | |||
1340 | ||||
1341 | unsigned int bpl = image->bytes_per_line; | |||
1342 | unsigned char *data_ptr, *max_data; | |||
1343 | ||||
1344 | data = (unsigned char *) image->data; | |||
1345 | iptr = pixelindex; | |||
1346 | #if !defined(WORD64) && !defined(LONG64) | |||
1347 | if (*((char *) &byteorderpixel) == image->byte_order) { | |||
1348 | for (y = 0; y < height; y++) { | |||
1349 | data_ptr = data; | |||
1350 | max_data = data_ptr + (width << 2); | |||
1351 | ||||
1352 | while (data_ptr < max_data) { | |||
1353 | *((unsigned long *) data_ptr) = pixels[*(iptr++)]; | |||
1354 | data_ptr += (1 << 2); | |||
1355 | } | |||
1356 | data += bpl; | |||
1357 | } | |||
1358 | } else | |||
1359 | #endif | |||
1360 | if (image->byte_order == MSBFirst1) | |||
1361 | for (y = 0; y < height; y++) { | |||
1362 | data_ptr = data; | |||
1363 | max_data = data_ptr + (width << 2); | |||
1364 | ||||
1365 | while (data_ptr < max_data) { | |||
1366 | pixel = pixels[*(iptr++)]; | |||
1367 | ||||
1368 | *data_ptr++ = pixel >> 24; | |||
1369 | *data_ptr++ = pixel >> 16; | |||
1370 | *data_ptr++ = pixel >> 8; | |||
1371 | *data_ptr++ = pixel; | |||
1372 | ||||
1373 | } | |||
1374 | data += bpl; | |||
1375 | } | |||
1376 | else | |||
1377 | for (y = 0; y < height; y++) { | |||
1378 | data_ptr = data; | |||
1379 | max_data = data_ptr + (width << 2); | |||
1380 | ||||
1381 | while (data_ptr < max_data) { | |||
1382 | pixel = pixels[*(iptr++)]; | |||
1383 | ||||
1384 | *data_ptr++ = pixel; | |||
1385 | *data_ptr++ = pixel >> 8; | |||
1386 | *data_ptr++ = pixel >> 16; | |||
1387 | *data_ptr++ = pixel >> 24; | |||
1388 | } | |||
1389 | data += bpl; | |||
1390 | } | |||
1391 | ||||
1392 | #endif /* WITHOUT_SPEEDUPS */ | |||
1393 | } | |||
1394 | ||||
1395 | /* | |||
1396 | * write pixels into a 16-bits Z image data structure | |||
1397 | */ | |||
1398 | ||||
1399 | static void | |||
1400 | PutImagePixels16( | |||
1401 | XImage *image, | |||
1402 | unsigned int width, | |||
1403 | unsigned int height, | |||
1404 | unsigned int *pixelindex, | |||
1405 | Pixel *pixels) | |||
1406 | { | |||
1407 | unsigned char *data; | |||
1408 | unsigned int *iptr; | |||
1409 | unsigned int y; | |||
1410 | ||||
1411 | #ifdef WITHOUT_SPEEDUPS | |||
1412 | ||||
1413 | unsigned int x; | |||
1414 | unsigned char *addr; | |||
1415 | ||||
1416 | data = (unsigned char *) image->data; | |||
1417 | iptr = pixelindex; | |||
1418 | if (image->byte_order == MSBFirst1) | |||
1419 | for (y = 0; y < height; y++) | |||
1420 | for (x = 0; x < width; x++, iptr++) { | |||
1421 | addr = &data[ZINDEX16(x, y, image)((y) * image->bytes_per_line) + ((x) << 1)]; | |||
1422 | addr[0] = pixels[*iptr] >> 8; | |||
1423 | addr[1] = pixels[*iptr]; | |||
1424 | } | |||
1425 | else | |||
1426 | for (y = 0; y < height; y++) | |||
1427 | for (x = 0; x < width; x++, iptr++) { | |||
1428 | addr = &data[ZINDEX16(x, y, image)((y) * image->bytes_per_line) + ((x) << 1)]; | |||
1429 | addr[0] = pixels[*iptr]; | |||
1430 | addr[1] = pixels[*iptr] >> 8; | |||
1431 | } | |||
1432 | ||||
1433 | #else /* WITHOUT_SPEEDUPS */ | |||
1434 | ||||
1435 | Pixel pixel; | |||
1436 | ||||
1437 | unsigned int bpl = image->bytes_per_line; | |||
1438 | unsigned char *data_ptr, *max_data; | |||
1439 | ||||
1440 | data = (unsigned char *) image->data; | |||
1441 | iptr = pixelindex; | |||
1442 | if (image->byte_order == MSBFirst1) | |||
1443 | for (y = 0; y < height; y++) { | |||
1444 | data_ptr = data; | |||
1445 | max_data = data_ptr + (width << 1); | |||
1446 | ||||
1447 | while (data_ptr < max_data) { | |||
1448 | pixel = pixels[*(iptr++)]; | |||
1449 | ||||
1450 | data_ptr[0] = pixel >> 8; | |||
1451 | data_ptr[1] = pixel; | |||
1452 | ||||
1453 | data_ptr += (1 << 1); | |||
1454 | } | |||
1455 | data += bpl; | |||
1456 | } | |||
1457 | else | |||
1458 | for (y = 0; y < height; y++) { | |||
1459 | data_ptr = data; | |||
1460 | max_data = data_ptr + (width << 1); | |||
1461 | ||||
1462 | while (data_ptr < max_data) { | |||
1463 | pixel = pixels[*(iptr++)]; | |||
1464 | ||||
1465 | data_ptr[0] = pixel; | |||
1466 | data_ptr[1] = pixel >> 8; | |||
1467 | ||||
1468 | data_ptr += (1 << 1); | |||
1469 | } | |||
1470 | data += bpl; | |||
1471 | } | |||
1472 | ||||
1473 | #endif /* WITHOUT_SPEEDUPS */ | |||
1474 | } | |||
1475 | ||||
1476 | /* | |||
1477 | * write pixels into a 8-bits Z image data structure | |||
1478 | */ | |||
1479 | ||||
1480 | static void | |||
1481 | PutImagePixels8( | |||
1482 | XImage *image, | |||
1483 | unsigned int width, | |||
1484 | unsigned int height, | |||
1485 | unsigned int *pixelindex, | |||
1486 | Pixel *pixels) | |||
1487 | { | |||
1488 | char *data; | |||
1489 | unsigned int *iptr; | |||
1490 | unsigned int y; | |||
1491 | ||||
1492 | #ifdef WITHOUT_SPEEDUPS | |||
1493 | ||||
1494 | unsigned int x; | |||
1495 | ||||
1496 | data = image->data; | |||
1497 | iptr = pixelindex; | |||
1498 | for (y = 0; y < height; y++) | |||
1499 | for (x = 0; x < width; x++, iptr++) | |||
1500 | data[ZINDEX8(x, y, image)((y) * image->bytes_per_line) + (x)] = pixels[*iptr]; | |||
1501 | ||||
1502 | #else /* WITHOUT_SPEEDUPS */ | |||
1503 | ||||
1504 | unsigned int bpl = image->bytes_per_line; | |||
1505 | char *data_ptr, *max_data; | |||
1506 | ||||
1507 | data = image->data; | |||
1508 | iptr = pixelindex; | |||
1509 | ||||
1510 | for (y = 0; y < height; y++) { | |||
1511 | data_ptr = data; | |||
1512 | max_data = data_ptr + width; | |||
1513 | ||||
1514 | while (data_ptr < max_data) | |||
1515 | *(data_ptr++) = pixels[*(iptr++)]; | |||
1516 | ||||
1517 | data += bpl; | |||
1518 | } | |||
1519 | ||||
1520 | #endif /* WITHOUT_SPEEDUPS */ | |||
1521 | } | |||
1522 | ||||
1523 | /* | |||
1524 | * write pixels into a 1-bit depth image data structure and **offset null** | |||
1525 | */ | |||
1526 | ||||
1527 | static void | |||
1528 | PutImagePixels1( | |||
1529 | XImage *image, | |||
1530 | unsigned int width, | |||
1531 | unsigned int height, | |||
1532 | unsigned int *pixelindex, | |||
1533 | Pixel *pixels) | |||
1534 | { | |||
1535 | if (image->byte_order != image->bitmap_bit_order) | |||
1536 | PutImagePixels(image, width, height, pixelindex, pixels); | |||
1537 | else { | |||
1538 | unsigned int *iptr; | |||
1539 | unsigned int y; | |||
1540 | char *data; | |||
1541 | ||||
1542 | #ifdef WITHOUT_SPEEDUPS | |||
1543 | ||||
1544 | unsigned int x; | |||
1545 | ||||
1546 | data = image->data; | |||
1547 | iptr = pixelindex; | |||
1548 | if (image->bitmap_bit_order == MSBFirst1) | |||
1549 | for (y = 0; y < height; y++) | |||
1550 | for (x = 0; x < width; x++, iptr++) { | |||
1551 | if (pixels[*iptr] & 1) | |||
1552 | data[ZINDEX1(x, y, image)((y) * image->bytes_per_line) + ((x) >> 3)] |= 0x80 >> (x & 7); | |||
1553 | else | |||
1554 | data[ZINDEX1(x, y, image)((y) * image->bytes_per_line) + ((x) >> 3)] &= ~(0x80 >> (x & 7)); | |||
1555 | } | |||
1556 | else | |||
1557 | for (y = 0; y < height; y++) | |||
1558 | for (x = 0; x < width; x++, iptr++) { | |||
1559 | if (pixels[*iptr] & 1) | |||
1560 | data[ZINDEX1(x, y, image)((y) * image->bytes_per_line) + ((x) >> 3)] |= 1 << (x & 7); | |||
1561 | else | |||
1562 | data[ZINDEX1(x, y, image)((y) * image->bytes_per_line) + ((x) >> 3)] &= ~(1 << (x & 7)); | |||
1563 | } | |||
1564 | ||||
1565 | #else /* WITHOUT_SPEEDUPS */ | |||
1566 | ||||
1567 | char value; | |||
1568 | char *data_ptr, *max_data; | |||
1569 | int bpl = image->bytes_per_line; | |||
1570 | int diff, count; | |||
1571 | ||||
1572 | data = image->data; | |||
1573 | iptr = pixelindex; | |||
1574 | ||||
1575 | diff = width & 7; | |||
1576 | width >>= 3; | |||
1577 | ||||
1578 | if (image->bitmap_bit_order == MSBFirst1) | |||
1579 | for (y = 0; y < height; y++) { | |||
1580 | data_ptr = data; | |||
1581 | max_data = data_ptr + width; | |||
1582 | while (data_ptr < max_data) { | |||
1583 | value = 0; | |||
1584 | ||||
1585 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1586 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1587 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1588 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1589 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1590 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1591 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1592 | value = (value << 1) | (pixels[*(iptr++)] & 1); | |||
1593 | ||||
1594 | *(data_ptr++) = value; | |||
1595 | } | |||
1596 | if (diff) { | |||
1597 | value = 0; | |||
1598 | for (count = 0; count < diff; count++) { | |||
1599 | if (pixels[*(iptr++)] & 1) | |||
1600 | value |= (0x80 >> count); | |||
1601 | } | |||
1602 | *(data_ptr) = value; | |||
1603 | } | |||
1604 | data += bpl; | |||
1605 | } | |||
1606 | else | |||
1607 | for (y = 0; y < height; y++) { | |||
1608 | data_ptr = data; | |||
1609 | max_data = data_ptr + width; | |||
1610 | while (data_ptr < max_data) { | |||
1611 | value = 0; | |||
1612 | iptr += 8; | |||
1613 | ||||
1614 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1615 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1616 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1617 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1618 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1619 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1620 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1621 | value = (value << 1) | (pixels[*(--iptr)] & 1); | |||
1622 | ||||
1623 | iptr += 8; | |||
1624 | *(data_ptr++) = value; | |||
1625 | } | |||
1626 | if (diff) { | |||
1627 | value = 0; | |||
1628 | for (count = 0; count < diff; count++) { | |||
1629 | if (pixels[*(iptr++)] & 1) | |||
1630 | value |= (1 << count); | |||
1631 | } | |||
1632 | *(data_ptr) = value; | |||
1633 | } | |||
1634 | data += bpl; | |||
1635 | } | |||
1636 | ||||
1637 | #endif /* WITHOUT_SPEEDUPS */ | |||
1638 | } | |||
1639 | } | |||
1640 | ||||
1641 | int | |||
1642 | XpmCreatePixmapFromXpmImage( | |||
1643 | Display *display, | |||
1644 | Drawable d, | |||
1645 | XpmImage *image, | |||
1646 | Pixmap *pixmap_return, | |||
1647 | Pixmap *shapemask_return, | |||
1648 | XpmAttributes *attributes) | |||
1649 | { | |||
1650 | XImage *ximage, *shapeimage; | |||
1651 | int ErrorStatus; | |||
1652 | ||||
1653 | /* initialize return values */ | |||
1654 | if (pixmap_return) | |||
1655 | *pixmap_return = 0; | |||
1656 | if (shapemask_return) | |||
1657 | *shapemask_return = 0; | |||
1658 | ||||
1659 | /* create the ximages */ | |||
1660 | ErrorStatus = XpmCreateImageFromXpmImage(display, image, | |||
1661 | (pixmap_return ? &ximage : NULL((void*)0)), | |||
1662 | (shapemask_return ? | |||
1663 | &shapeimage : NULL((void*)0)), | |||
1664 | attributes); | |||
1665 | if (ErrorStatus < 0) | |||
1666 | return (ErrorStatus); | |||
1667 | ||||
1668 | /* create the pixmaps and destroy images */ | |||
1669 | if (pixmap_return && ximage) { | |||
1670 | xpmCreatePixmapFromImage(display, d, ximage, pixmap_return); | |||
1671 | XDestroyImage(ximage)((*((ximage)->f.destroy_image))((ximage))); | |||
1672 | } | |||
1673 | if (shapemask_return && shapeimage) { | |||
1674 | xpmCreatePixmapFromImage(display, d, shapeimage, shapemask_return); | |||
1675 | XDestroyImage(shapeimage)((*((shapeimage)->f.destroy_image))((shapeimage))); | |||
1676 | } | |||
1677 | return (ErrorStatus); | |||
1678 | } | |||
1679 | ||||
1680 | # else /* AMIGA */ | |||
1681 | ||||
1682 | static void | |||
1683 | APutImagePixels ( | |||
1684 | XImage *image, | |||
1685 | unsigned int width, | |||
1686 | unsigned int height, | |||
1687 | unsigned int *pixelindex, | |||
1688 | Pixel *pixels) | |||
1689 | { | |||
1690 | unsigned int *data = pixelindex; | |||
1691 | unsigned int x, y; | |||
1692 | unsigned char *array; | |||
1693 | XImage *tmp_img; | |||
1694 | BOOL success = FALSE; | |||
1695 | ||||
1696 | array = XpmMalloc ((((width+15)>>4)<<4)*sizeof (*array))malloc(((((width+15)>>4)<<4)*sizeof (*array))); | |||
1697 | if (array != NULL((void*)0)) | |||
1698 | { | |||
1699 | tmp_img = AllocXImage ((((width+15)>>4)<<4), 1, | |||
1700 | image->rp->BitMap->Depth); | |||
1701 | if (tmp_img != NULL((void*)0)) | |||
1702 | { | |||
1703 | for (y = 0; y < height; ++y) | |||
1704 | { | |||
1705 | for (x = 0; x < width; ++x) | |||
1706 | array[x] = pixels[*(data++)]; | |||
1707 | WritePixelLine8 (image->rp, 0, y, width, array, tmp_img->rp); | |||
1708 | } | |||
1709 | FreeXImage (tmp_img); | |||
1710 | success = TRUE; | |||
1711 | } | |||
1712 | XpmFree (array)free(array); | |||
1713 | } | |||
1714 | ||||
1715 | if (!success) | |||
1716 | { | |||
1717 | for (y = 0; y < height; ++y) | |||
1718 | for (x = 0; x < width; ++x) | |||
1719 | XPutPixel (image, x, y, pixels[*(data++)])((*((image)->f.put_pixel))((image), (x), (y), (pixels[*(data ++)]))); | |||
1720 | } | |||
1721 | } | |||
1722 | ||||
1723 | # endif/* AMIGA */ | |||
1724 | #else /* FOR_MSW part follows */ | |||
1725 | static void | |||
1726 | MSWPutImagePixels( | |||
1727 | Display *dc, | |||
1728 | XImage *image, | |||
1729 | unsigned int width, | |||
1730 | unsigned int height, | |||
1731 | unsigned int *pixelindex, | |||
1732 | Pixel *pixels) | |||
1733 | { | |||
1734 | unsigned int *data = pixelindex; | |||
1735 | unsigned int x, y; | |||
1736 | HBITMAP obm; | |||
1737 | ||||
1738 | obm = SelectObject(*dc, image->bitmap); | |||
1739 | for (y = 0; y < height; y++) { | |||
1740 | for (x = 0; x < width; x++) { | |||
1741 | SetPixel(*dc, x, y, pixels[*(data++)]); /* data is [x+y*width] */ | |||
1742 | } | |||
1743 | } | |||
1744 | SelectObject(*dc, obm); | |||
1745 | } | |||
1746 | ||||
1747 | #endif /* FOR_MSW */ | |||
1748 | ||||
1749 | ||||
1750 | ||||
1751 | #if !defined(FOR_MSW) && !defined(AMIGA) | |||
1752 | ||||
1753 | static int | |||
1754 | PutPixel1( | |||
1755 | register XImage *ximage, | |||
1756 | int x, | |||
1757 | int y, | |||
1758 | unsigned long pixel) | |||
1759 | { | |||
1760 | register char *src; | |||
1761 | register char *dst; | |||
1762 | register int i; | |||
1763 | Pixel px; | |||
1764 | int nbytes; | |||
1765 | ||||
1766 | if(x < 0 || y < 0) | |||
1767 | return 0; | |||
1768 | ||||
1769 | for (i=0, px=pixel; i<sizeof(unsigned long); i++, px>>=8) | |||
1770 | ((unsigned char *)&pixel)[i] = px; | |||
1771 | src = &ximage->data[XYINDEX(x, y, ximage)((y) * ximage->bytes_per_line) + (((x) + ximage->xoffset ) / ximage->bitmap_unit) * (ximage->bitmap_unit >> 3)]; | |||
1772 | dst = (char *)&px; | |||
1773 | px = 0; | |||
1774 | nbytes = ximage->bitmap_unit >> 3; | |||
1775 | for (i = nbytes; --i >= 0; ) *dst++ = *src++; | |||
1776 | XYNORMALIZE(&px, ximage)if ((ximage->byte_order == 1) || (ximage->bitmap_bit_order == 1)) xpm_xynormalizeimagebits((unsigned char *)(&px), ximage ); | |||
1777 | i = ((x + ximage->xoffset) % ximage->bitmap_unit); | |||
1778 | _putbits ((char *)&pixel, i, 1, (char *)&px); | |||
1779 | XYNORMALIZE(&px, ximage)if ((ximage->byte_order == 1) || (ximage->bitmap_bit_order == 1)) xpm_xynormalizeimagebits((unsigned char *)(&px), ximage ); | |||
1780 | src = (char *) &px; | |||
1781 | dst = &ximage->data[XYINDEX(x, y, ximage)((y) * ximage->bytes_per_line) + (((x) + ximage->xoffset ) / ximage->bitmap_unit) * (ximage->bitmap_unit >> 3)]; | |||
1782 | for (i = nbytes; --i >= 0; ) | |||
1783 | *dst++ = *src++; | |||
1784 | ||||
1785 | return 1; | |||
1786 | } | |||
1787 | ||||
1788 | static int | |||
1789 | PutPixel( | |||
1790 | register XImage *ximage, | |||
1791 | int x, | |||
1792 | int y, | |||
1793 | unsigned long pixel) | |||
1794 | { | |||
1795 | register char *src; | |||
1796 | register char *dst; | |||
1797 | register int i; | |||
1798 | Pixel px; | |||
1799 | unsigned int nbytes, ibpp; | |||
1800 | ||||
1801 | if(x < 0 || y < 0) | |||
1802 | return 0; | |||
1803 | ||||
1804 | ibpp = ximage->bits_per_pixel; | |||
1805 | if (ximage->depth == 4) | |||
1806 | pixel &= 0xf; | |||
1807 | for (i = 0, px = pixel; i < sizeof(unsigned long); i++, px >>= 8) | |||
1808 | ((unsigned char *) &pixel)[i] = px; | |||
1809 | src = &ximage->data[ZINDEX(x, y, ximage)((y) * ximage->bytes_per_line) + (((x) * ximage->bits_per_pixel ) >> 3)]; | |||
1810 | dst = (char *) &px; | |||
1811 | px = 0; | |||
1812 | nbytes = (ibpp + 7) >> 3; | |||
1813 | for (i = nbytes; --i >= 0;) | |||
1814 | *dst++ = *src++; | |||
1815 | ZNORMALIZE(&px, ximage)if (ximage->byte_order == 1) xpm_znormalizeimagebits((unsigned char *)(&px), ximage); | |||
1816 | _putbits((char *) &pixel, (x * ibpp) & 7, ibpp, (char *) &px); | |||
1817 | ZNORMALIZE(&px, ximage)if (ximage->byte_order == 1) xpm_znormalizeimagebits((unsigned char *)(&px), ximage); | |||
1818 | src = (char *) &px; | |||
1819 | dst = &ximage->data[ZINDEX(x, y, ximage)((y) * ximage->bytes_per_line) + (((x) * ximage->bits_per_pixel ) >> 3)]; | |||
1820 | for (i = nbytes; --i >= 0;) | |||
1821 | *dst++ = *src++; | |||
1822 | ||||
1823 | return 1; | |||
1824 | } | |||
1825 | ||||
1826 | #if !defined(WORD64) && !defined(LONG64) | |||
1827 | static int | |||
1828 | PutPixel32( | |||
1829 | register XImage *ximage, | |||
1830 | int x, | |||
1831 | int y, | |||
1832 | unsigned long pixel) | |||
1833 | { | |||
1834 | unsigned char *addr; | |||
1835 | ||||
1836 | if(x < 0 || y < 0) | |||
1837 | return 0; | |||
1838 | ||||
1839 | addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) << 2)]; | |||
1840 | *((unsigned long *)addr) = pixel; | |||
1841 | return 1; | |||
1842 | } | |||
1843 | #endif | |||
1844 | ||||
1845 | static int | |||
1846 | PutPixel32MSB( | |||
1847 | register XImage *ximage, | |||
1848 | int x, | |||
1849 | int y, | |||
1850 | unsigned long pixel) | |||
1851 | { | |||
1852 | unsigned char *addr; | |||
1853 | ||||
1854 | if(x < 0 || y < 0) | |||
1855 | return 0; | |||
1856 | ||||
1857 | addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) << 2)]; | |||
1858 | addr[0] = pixel >> 24; | |||
1859 | addr[1] = pixel >> 16; | |||
1860 | addr[2] = pixel >> 8; | |||
1861 | addr[3] = pixel; | |||
1862 | return 1; | |||
1863 | } | |||
1864 | ||||
1865 | static int | |||
1866 | PutPixel32LSB( | |||
1867 | register XImage *ximage, | |||
1868 | int x, | |||
1869 | int y, | |||
1870 | unsigned long pixel) | |||
1871 | { | |||
1872 | unsigned char *addr; | |||
1873 | ||||
1874 | if(x < 0 || y < 0) | |||
1875 | return 0; | |||
1876 | ||||
1877 | addr = &((unsigned char *)ximage->data) [ZINDEX32(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) << 2)]; | |||
1878 | addr[3] = pixel >> 24; | |||
1879 | addr[2] = pixel >> 16; | |||
1880 | addr[1] = pixel >> 8; | |||
1881 | addr[0] = pixel; | |||
1882 | return 1; | |||
1883 | } | |||
1884 | ||||
1885 | static int | |||
1886 | PutPixel16MSB( | |||
1887 | register XImage *ximage, | |||
1888 | int x, | |||
1889 | int y, | |||
1890 | unsigned long pixel) | |||
1891 | { | |||
1892 | unsigned char *addr; | |||
1893 | ||||
1894 | if(x < 0 || y < 0) | |||
1895 | return 0; | |||
1896 | ||||
1897 | addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) << 1)]; | |||
1898 | addr[0] = pixel >> 8; | |||
1899 | addr[1] = pixel; | |||
1900 | return 1; | |||
1901 | } | |||
1902 | ||||
1903 | static int | |||
1904 | PutPixel16LSB( | |||
1905 | register XImage *ximage, | |||
1906 | int x, | |||
1907 | int y, | |||
1908 | unsigned long pixel) | |||
1909 | { | |||
1910 | unsigned char *addr; | |||
1911 | ||||
1912 | if(x < 0 || y < 0) | |||
1913 | return 0; | |||
1914 | ||||
1915 | addr = &((unsigned char *)ximage->data) [ZINDEX16(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) << 1)]; | |||
1916 | addr[1] = pixel >> 8; | |||
1917 | addr[0] = pixel; | |||
1918 | return 1; | |||
1919 | } | |||
1920 | ||||
1921 | static int | |||
1922 | PutPixel8( | |||
1923 | register XImage *ximage, | |||
1924 | int x, | |||
1925 | int y, | |||
1926 | unsigned long pixel) | |||
1927 | { | |||
1928 | if(x < 0 || y < 0) | |||
1929 | return 0; | |||
1930 | ||||
1931 | ximage->data[ZINDEX8(x, y, ximage)((y) * ximage->bytes_per_line) + (x)] = pixel; | |||
1932 | return 1; | |||
1933 | } | |||
1934 | ||||
1935 | static int | |||
1936 | PutPixel1MSB( | |||
1937 | register XImage *ximage, | |||
1938 | int x, | |||
1939 | int y, | |||
1940 | unsigned long pixel) | |||
1941 | { | |||
1942 | if(x < 0 || y < 0) | |||
1943 | return 0; | |||
1944 | ||||
1945 | if (pixel & 1) | |||
1946 | ximage->data[ZINDEX1(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) >> 3)] |= 0x80 >> (x & 7); | |||
1947 | else | |||
1948 | ximage->data[ZINDEX1(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) >> 3)] &= ~(0x80 >> (x & 7)); | |||
1949 | return 1; | |||
1950 | } | |||
1951 | ||||
1952 | static int | |||
1953 | PutPixel1LSB( | |||
1954 | register XImage *ximage, | |||
1955 | int x, | |||
1956 | int y, | |||
1957 | unsigned long pixel) | |||
1958 | { | |||
1959 | if(x < 0 || y < 0) | |||
1960 | return 0; | |||
1961 | ||||
1962 | if (pixel & 1) | |||
1963 | ximage->data[ZINDEX1(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) >> 3)] |= 1 << (x & 7); | |||
1964 | else | |||
1965 | ximage->data[ZINDEX1(x, y, ximage)((y) * ximage->bytes_per_line) + ((x) >> 3)] &= ~(1 << (x & 7)); | |||
1966 | return 1; | |||
1967 | } | |||
1968 | ||||
1969 | #endif /* not FOR_MSW && not AMIGA */ | |||
1970 | ||||
1971 | /* | |||
1972 | * This function parses an Xpm file or data and directly create an XImage | |||
1973 | */ | |||
1974 | int | |||
1975 | xpmParseDataAndCreate( | |||
1976 | Display *display, | |||
1977 | xpmData *data, | |||
1978 | XImage **image_return, | |||
1979 | XImage **shapeimage_return, | |||
1980 | XpmImage *image, | |||
1981 | XpmInfo *info, | |||
1982 | XpmAttributes *attributes) | |||
1983 | { | |||
1984 | /* variables stored in the XpmAttributes structure */ | |||
1985 | Visual *visual; | |||
1986 | Colormap colormap; | |||
1987 | unsigned int depth; | |||
1988 | int bitmap_format; | |||
1989 | XpmFreeColorsFunc freeColors; | |||
1990 | ||||
1991 | /* variables to return */ | |||
1992 | XImage *ximage = NULL((void*)0); | |||
1993 | XImage *shapeimage = NULL((void*)0); | |||
1994 | unsigned int mask_pixel_index = XpmUndefPixel0x80000000; | |||
1995 | ||||
1996 | /* calculation variables */ | |||
1997 | Pixel *image_pixels = NULL((void*)0); | |||
1998 | Pixel *mask_pixels = NULL((void*)0); | |||
1999 | Pixel *alloc_pixels = NULL((void*)0); | |||
2000 | Pixel *used_pixels = NULL((void*)0); | |||
2001 | unsigned int nalloc_pixels = 0; | |||
2002 | unsigned int nused_pixels = 0; | |||
2003 | unsigned int width, height, ncolors, cpp; | |||
2004 | unsigned int x_hotspot, y_hotspot, hotspot = 0, extensions = 0; | |||
2005 | XpmColor *colorTable = NULL((void*)0); | |||
2006 | char *hints_cmt = NULL((void*)0); | |||
2007 | char *colors_cmt = NULL((void*)0); | |||
2008 | char *pixels_cmt = NULL((void*)0); | |||
2009 | ||||
2010 | unsigned int cmts; | |||
2011 | int ErrorStatus; | |||
2012 | xpmHashTable hashtable; | |||
2013 | ||||
2014 | ||||
2015 | /* initialize return values */ | |||
2016 | if (image_return) | |||
2017 | *image_return = NULL((void*)0); | |||
2018 | if (shapeimage_return) | |||
2019 | *shapeimage_return = NULL((void*)0); | |||
2020 | ||||
2021 | ||||
2022 | /* retrieve information from the XpmAttributes */ | |||
2023 | if (attributes && (attributes->valuemask & XpmVisual(1L<<0))) | |||
2024 | visual = attributes->visual; | |||
2025 | else | |||
2026 | visual = XDefaultVisual(display, XDefaultScreen(display)); | |||
2027 | ||||
2028 | if (attributes && (attributes->valuemask & XpmColormap(1L<<1))) | |||
2029 | colormap = attributes->colormap; | |||
2030 | else | |||
2031 | colormap = XDefaultColormap(display, XDefaultScreen(display)); | |||
2032 | ||||
2033 | if (attributes && (attributes->valuemask & XpmDepth(1L<<2))) | |||
2034 | depth = attributes->depth; | |||
2035 | else | |||
2036 | depth = XDefaultDepth(display, XDefaultScreen(display)); | |||
2037 | ||||
2038 | if (attributes && (attributes->valuemask & XpmBitmapFormat(1L<<18))) | |||
2039 | bitmap_format = attributes->bitmap_format; | |||
2040 | else | |||
2041 | bitmap_format = ZPixmap2; | |||
2042 | ||||
2043 | if (attributes && (attributes->valuemask & XpmFreeColors(1L<<20))) | |||
2044 | freeColors = attributes->free_colors; | |||
2045 | else | |||
2046 | freeColors = FreeColors; | |||
2047 | ||||
2048 | cmts = info && (info->valuemask & XpmReturnComments(1L<<8)); | |||
2049 | ||||
2050 | /* | |||
2051 | * parse the header | |||
2052 | */ | |||
2053 | ErrorStatus = xpmParseHeader(data); | |||
2054 | if (ErrorStatus != XpmSuccess0) | |||
2055 | return (ErrorStatus); | |||
2056 | ||||
2057 | /* | |||
2058 | * read values | |||
2059 | */ | |||
2060 | ErrorStatus = xpmParseValues(data, &width, &height, &ncolors, &cpp, | |||
2061 | &x_hotspot, &y_hotspot, &hotspot, | |||
2062 | &extensions); | |||
2063 | if (ErrorStatus != XpmSuccess0) | |||
2064 | return (ErrorStatus); | |||
2065 | ||||
2066 | /* | |||
2067 | * store the hints comment line | |||
2068 | */ | |||
2069 | if (cmts) | |||
2070 | xpmGetCmt(data, &hints_cmt); | |||
2071 | ||||
2072 | /* | |||
2073 | * init the hashtable | |||
2074 | */ | |||
2075 | if (USE_HASHTABLE(cpp > 2 && ncolors > 4)) { | |||
2076 | ErrorStatus = xpmHashTableInit(&hashtable); | |||
2077 | if (ErrorStatus != XpmSuccess0) | |||
2078 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2079 | } | |||
2080 | ||||
2081 | /* | |||
2082 | * read colors | |||
2083 | */ | |||
2084 | ErrorStatus = xpmParseColors(data, ncolors, cpp, &colorTable, &hashtable); | |||
2085 | if (ErrorStatus != XpmSuccess0) | |||
2086 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2087 | ||||
2088 | /* | |||
2089 | * store the colors comment line | |||
2090 | */ | |||
2091 | if (cmts) | |||
2092 | xpmGetCmt(data, &colors_cmt); | |||
2093 | ||||
2094 | /* malloc pixels index tables */ | |||
2095 | if (ncolors >= UINT_MAX(2147483647 *2U +1U) / sizeof(Pixel)) | |||
2096 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
2097 | ||||
2098 | image_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors)malloc((sizeof(Pixel) * ncolors)); | |||
2099 | if (!image_pixels) | |||
2100 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
2101 | ||||
2102 | mask_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors)malloc((sizeof(Pixel) * ncolors)); | |||
2103 | if (!mask_pixels) | |||
2104 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
2105 | ||||
2106 | /* maximum of allocated pixels will be the number of colors */ | |||
2107 | alloc_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors)malloc((sizeof(Pixel) * ncolors)); | |||
2108 | if (!alloc_pixels) | |||
2109 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
2110 | ||||
2111 | /* maximum of allocated pixels will be the number of colors */ | |||
2112 | used_pixels = (Pixel *) XpmMalloc(sizeof(Pixel) * ncolors)malloc((sizeof(Pixel) * ncolors)); | |||
2113 | if (!used_pixels) | |||
2114 | RETURN(XpmNoMemory)do { ErrorStatus = -3; goto error; } while(0); | |||
2115 | ||||
2116 | /* get pixel colors, store them in index tables */ | |||
2117 | ErrorStatus = CreateColors(display, attributes, colorTable, ncolors, | |||
2118 | image_pixels, mask_pixels, &mask_pixel_index, | |||
2119 | alloc_pixels, &nalloc_pixels, used_pixels, | |||
2120 | &nused_pixels); | |||
2121 | ||||
2122 | if (ErrorStatus != XpmSuccess0 | |||
2123 | && (ErrorStatus < 0 || (attributes | |||
2124 | && (attributes->valuemask & XpmExactColors(1L<<11)) | |||
2125 | && attributes->exactColors))) | |||
2126 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2127 | ||||
2128 | /* now create the ximage */ | |||
2129 | if (image_return) { | |||
2130 | ErrorStatus = CreateXImage(display, visual, depth, | |||
2131 | (depth == 1 ? bitmap_format : ZPixmap2), | |||
2132 | width, height, &ximage); | |||
2133 | if (ErrorStatus != XpmSuccess0) | |||
2134 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2135 | ||||
2136 | #if !defined(FOR_MSW) && !defined(AMIGA) | |||
2137 | ||||
2138 | /* | |||
2139 | * set the XImage pointer function, to be used with XPutPixel, | |||
2140 | * to an internal optimized function | |||
2141 | */ | |||
2142 | ||||
2143 | if (ximage->bits_per_pixel == 8) | |||
2144 | ximage->f.put_pixel = PutPixel8; | |||
2145 | else if (((ximage->bits_per_pixel | ximage->depth) == 1) && | |||
2146 | (ximage->byte_order == ximage->bitmap_bit_order)) | |||
2147 | if (ximage->bitmap_bit_order == MSBFirst1) | |||
2148 | ximage->f.put_pixel = PutPixel1MSB; | |||
2149 | else | |||
2150 | ximage->f.put_pixel = PutPixel1LSB; | |||
2151 | else if (ximage->bits_per_pixel == 16) | |||
2152 | if (ximage->bitmap_bit_order == MSBFirst1) | |||
2153 | ximage->f.put_pixel = PutPixel16MSB; | |||
2154 | else | |||
2155 | ximage->f.put_pixel = PutPixel16LSB; | |||
2156 | else if (ximage->bits_per_pixel == 32) | |||
2157 | #if !defined(WORD64) && !defined(LONG64) | |||
2158 | if (*((char *)&byteorderpixel) == ximage->byte_order) | |||
2159 | ximage->f.put_pixel = PutPixel32; | |||
2160 | else | |||
2161 | #endif | |||
2162 | if (ximage->bitmap_bit_order == MSBFirst1) | |||
2163 | ximage->f.put_pixel = PutPixel32MSB; | |||
2164 | else | |||
2165 | ximage->f.put_pixel = PutPixel32LSB; | |||
2166 | else if ((ximage->bits_per_pixel | ximage->depth) == 1) | |||
2167 | ximage->f.put_pixel = PutPixel1; | |||
2168 | else | |||
2169 | ximage->f.put_pixel = PutPixel; | |||
2170 | #endif /* not FOR_MSW && not AMIGA */ | |||
2171 | } | |||
2172 | ||||
2173 | /* create the shape mask image */ | |||
2174 | if (mask_pixel_index != XpmUndefPixel0x80000000 && shapeimage_return) { | |||
2175 | ErrorStatus = CreateXImage(display, visual, 1, bitmap_format, | |||
2176 | width, height, &shapeimage); | |||
2177 | if (ErrorStatus != XpmSuccess0) | |||
2178 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2179 | ||||
2180 | #if !defined(FOR_MSW) && !defined(AMIGA) | |||
2181 | if (shapeimage->bitmap_bit_order == MSBFirst1) | |||
2182 | shapeimage->f.put_pixel = PutPixel1MSB; | |||
2183 | else | |||
2184 | shapeimage->f.put_pixel = PutPixel1LSB; | |||
2185 | #endif | |||
2186 | } | |||
2187 | ||||
2188 | /* | |||
2189 | * read pixels and put them in the XImage | |||
2190 | */ | |||
2191 | ErrorStatus = ParseAndPutPixels( | |||
2192 | #ifdef FOR_MSW | |||
2193 | display, | |||
2194 | #endif | |||
2195 | data, width, height, ncolors, cpp, | |||
2196 | colorTable, &hashtable, | |||
2197 | ximage, image_pixels, | |||
2198 | shapeimage, mask_pixels); | |||
2199 | XpmFree(image_pixels)free(image_pixels); | |||
2200 | image_pixels = NULL((void*)0); | |||
2201 | XpmFree(mask_pixels)free(mask_pixels); | |||
2202 | mask_pixels = NULL((void*)0); | |||
2203 | ||||
2204 | /* | |||
2205 | * free the hastable | |||
2206 | */ | |||
2207 | if (ErrorStatus != XpmSuccess0) | |||
2208 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2209 | else if (USE_HASHTABLE(cpp > 2 && ncolors > 4)) | |||
2210 | xpmHashTableFree(&hashtable); | |||
2211 | ||||
2212 | /* | |||
2213 | * store the pixels comment line | |||
2214 | */ | |||
2215 | if (cmts) | |||
2216 | xpmGetCmt(data, &pixels_cmt); | |||
2217 | ||||
2218 | /* | |||
2219 | * parse extensions | |||
2220 | */ | |||
2221 | if (info && (info->valuemask & XpmReturnExtensions(1L<<10))) { | |||
2222 | if (extensions) { | |||
2223 | ErrorStatus = xpmParseExtensions(data, &info->extensions, | |||
2224 | &info->nextensions); | |||
2225 | if (ErrorStatus != XpmSuccess0) | |||
2226 | RETURN(ErrorStatus)do { ErrorStatus = ErrorStatus; goto error; } while(0); | |||
2227 | } else { | |||
2228 | info->extensions = NULL((void*)0); | |||
2229 | info->nextensions = 0; | |||
2230 | } | |||
2231 | } | |||
2232 | /* | |||
2233 | * store found informations in the XpmImage structure | |||
2234 | */ | |||
2235 | image->width = width; | |||
2236 | image->height = height; | |||
2237 | image->cpp = cpp; | |||
2238 | image->ncolors = ncolors; | |||
2239 | image->colorTable = colorTable; | |||
2240 | image->data = NULL((void*)0); | |||
2241 | ||||
2242 | if (info) { | |||
2243 | if (cmts) { | |||
2244 | info->hints_cmt = hints_cmt; | |||
2245 | info->colors_cmt = colors_cmt; | |||
2246 | info->pixels_cmt = pixels_cmt; | |||
2247 | } | |||
2248 | if (hotspot) { | |||
2249 | info->x_hotspot = x_hotspot; | |||
2250 | info->y_hotspot = y_hotspot; | |||
2251 | info->valuemask |= XpmHotspot(1L<<4); | |||
2252 | } | |||
2253 | } | |||
2254 | /* if requested return used pixels in the XpmAttributes structure */ | |||
2255 | if (attributes && (attributes->valuemask & XpmReturnPixels(1L<<9) || | |||
2256 | /* 3.2 backward compatibility code */ | |||
2257 | attributes->valuemask & XpmReturnInfos(1L<<8))) { | |||
2258 | /* end 3.2 bc */ | |||
2259 | attributes->pixels = used_pixels; | |||
2260 | attributes->npixels = nused_pixels; | |||
2261 | attributes->mask_pixel = mask_pixel_index; | |||
2262 | } else | |||
2263 | XpmFree(used_pixels)free(used_pixels); | |||
2264 | ||||
2265 | /* if requested return alloc'ed pixels in the XpmAttributes structure */ | |||
2266 | if (attributes && (attributes->valuemask & XpmReturnAllocPixels(1L<<16))) { | |||
2267 | attributes->alloc_pixels = alloc_pixels; | |||
2268 | attributes->nalloc_pixels = nalloc_pixels; | |||
2269 | } else | |||
2270 | XpmFree(alloc_pixels)free(alloc_pixels); | |||
2271 | ||||
2272 | /* return created images */ | |||
2273 | if (image_return) | |||
2274 | *image_return = ximage; | |||
2275 | if (shapeimage_return) | |||
2276 | *shapeimage_return = shapeimage; | |||
2277 | ||||
2278 | return (XpmSuccess0); | |||
2279 | ||||
2280 | /* exit point in case of error, free only locally allocated variables */ | |||
2281 | error: | |||
2282 | if (USE_HASHTABLE(cpp > 2 && ncolors > 4)) | |||
2283 | xpmHashTableFree(&hashtable); | |||
2284 | if (colorTable) | |||
2285 | xpmFreeColorTable(colorTable, ncolors); | |||
2286 | if (hints_cmt) | |||
2287 | XpmFree(hints_cmt)free(hints_cmt); | |||
2288 | if (colors_cmt) | |||
2289 | XpmFree(colors_cmt)free(colors_cmt); | |||
2290 | if (pixels_cmt) | |||
2291 | XpmFree(pixels_cmt)free(pixels_cmt); | |||
2292 | if (ximage) | |||
2293 | XDestroyImage(ximage)((*((ximage)->f.destroy_image))((ximage))); | |||
2294 | if (shapeimage) | |||
2295 | XDestroyImage(shapeimage)((*((shapeimage)->f.destroy_image))((shapeimage))); | |||
2296 | if (image_pixels) | |||
2297 | XpmFree(image_pixels)free(image_pixels); | |||
2298 | if (mask_pixels) | |||
2299 | XpmFree(mask_pixels)free(mask_pixels); | |||
2300 | if (nalloc_pixels) | |||
2301 | (*freeColors)(display, colormap, alloc_pixels, nalloc_pixels, NULL((void*)0)); | |||
2302 | if (alloc_pixels) | |||
2303 | XpmFree(alloc_pixels)free(alloc_pixels); | |||
2304 | if (used_pixels) | |||
2305 | XpmFree(used_pixels)free(used_pixels); | |||
2306 | ||||
2307 | return (ErrorStatus); | |||
2308 | } | |||
2309 | ||||
2310 | static int | |||
2311 | ParseAndPutPixels( | |||
2312 | #ifdef FOR_MSW | |||
2313 | Display *dc, | |||
2314 | #endif | |||
2315 | xpmData *data, | |||
2316 | unsigned int width, | |||
2317 | unsigned int height, | |||
2318 | unsigned int ncolors, | |||
2319 | unsigned int cpp, | |||
2320 | XpmColor *colorTable, | |||
2321 | xpmHashTable *hashtable, | |||
2322 | XImage *image, | |||
2323 | Pixel *image_pixels, | |||
2324 | XImage *shapeimage, | |||
2325 | Pixel *shape_pixels) | |||
2326 | { | |||
2327 | unsigned int a, x, y; | |||
2328 | ||||
2329 | switch (cpp) { | |||
2330 | ||||
2331 | case (1): /* Optimize for single character | |||
2332 | * colors */ | |||
2333 | { | |||
2334 | unsigned short colidx[256]; | |||
2335 | #ifdef FOR_MSW | |||
2336 | HDC shapedc; | |||
2337 | HBITMAP obm, sobm; | |||
2338 | ||||
2339 | if ( shapeimage ) { | |||
2340 | shapedc = CreateCompatibleDC(*dc); | |||
2341 | sobm = SelectObject(shapedc, shapeimage->bitmap); | |||
2342 | } else { | |||
2343 | shapedc = NULL((void*)0); | |||
2344 | } | |||
2345 | obm = SelectObject(*dc, image->bitmap); | |||
2346 | #endif | |||
2347 | if (ncolors > 256) | |||
2348 | return (XpmFileInvalid-2); | |||
2349 | ||||
2350 | bzero((char *)colidx, 256 * sizeof(short))__builtin___memset_chk ((char *)colidx, 0, 256 * sizeof(short ), __builtin_object_size ((char *)colidx, 0)); | |||
2351 | for (a = 0; a < ncolors; a++) | |||
2352 | colidx[(unsigned char)colorTable[a].string[0]] = a + 1; | |||
2353 | ||||
2354 | for (y = 0; y < height; y++) { | |||
2355 | xpmNextString(data); | |||
2356 | for (x = 0; x < width; x++) { | |||
2357 | int c = xpmGetC(data)((!data->type || data->type == 3) ? (*data->cptr++) : (getc(data->stream.file))); | |||
2358 | ||||
2359 | if (c > 0 && c < 256 && colidx[c] != 0) { | |||
2360 | #ifndef FOR_MSW | |||
2361 | XPutPixel(image, x, y, image_pixels[colidx[c] - 1])((*((image)->f.put_pixel))((image), (x), (y), (image_pixels [colidx[c] - 1]))); | |||
2362 | if (shapeimage) | |||
2363 | XPutPixel(shapeimage, x, y,((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [colidx[c] - 1]))) | |||
2364 | shape_pixels[colidx[c] - 1])((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [colidx[c] - 1]))); | |||
2365 | #else | |||
2366 | SetPixel(*dc, x, y, image_pixels[colidx[c] - 1]); | |||
2367 | if (shapedc) { | |||
2368 | SetPixel(shapedc, x, y, shape_pixels[colidx[c] - 1]); | |||
2369 | } | |||
2370 | #endif | |||
2371 | } else | |||
2372 | return (XpmFileInvalid-2); | |||
2373 | } | |||
2374 | } | |||
2375 | #ifdef FOR_MSW | |||
2376 | if ( shapedc ) { | |||
2377 | SelectObject(shapedc, sobm); | |||
2378 | DeleteDC(shapedc); | |||
2379 | } | |||
2380 | SelectObject(*dc, obm); | |||
2381 | #endif | |||
2382 | } | |||
2383 | break; | |||
2384 | ||||
2385 | case (2): /* Optimize for double character | |||
2386 | * colors */ | |||
2387 | { | |||
2388 | ||||
2389 | /* free all allocated pointers at all exits */ | |||
2390 | #define FREE_CIDX{int f; for (f = 0; f < 256; f++) if (cidx[f]) free(cidx[f ]);} {int f; for (f = 0; f < 256; f++) \ | |||
2391 | if (cidx[f]) XpmFree(cidx[f])free(cidx[f]);} | |||
2392 | ||||
2393 | /* array of pointers malloced by need */ | |||
2394 | unsigned short *cidx[256]; | |||
2395 | unsigned int char1; | |||
2396 | ||||
2397 | bzero((char *)cidx, 256 * sizeof(unsigned short *))__builtin___memset_chk ((char *)cidx, 0, 256 * sizeof(unsigned short *), __builtin_object_size ((char *)cidx, 0)); /* init */ | |||
2398 | for (a = 0; a < ncolors; a++) { | |||
2399 | char1 = (unsigned char) colorTable[a].string[0]; | |||
2400 | if (cidx[char1] == NULL((void*)0)) { /* get new memory */ | |||
2401 | cidx[char1] = (unsigned short *) | |||
2402 | XpmCalloc(256, sizeof(unsigned short))calloc((256), (sizeof(unsigned short))); | |||
2403 | if (cidx[char1] == NULL((void*)0)) { /* new block failed */ | |||
2404 | FREE_CIDX{int f; for (f = 0; f < 256; f++) if (cidx[f]) free(cidx[f ]);}; | |||
2405 | return (XpmNoMemory-3); | |||
2406 | } | |||
2407 | } | |||
2408 | cidx[char1][(unsigned char)colorTable[a].string[1]] = a + 1; | |||
2409 | } | |||
2410 | ||||
2411 | for (y = 0; y < height; y++) { | |||
2412 | xpmNextString(data); | |||
2413 | for (x = 0; x < width; x++) { | |||
2414 | int cc1 = xpmGetC(data)((!data->type || data->type == 3) ? (*data->cptr++) : (getc(data->stream.file))); | |||
2415 | if (cc1 > 0 && cc1 < 256) { | |||
2416 | int cc2 = xpmGetC(data)((!data->type || data->type == 3) ? (*data->cptr++) : (getc(data->stream.file))); | |||
2417 | if (cc2 > 0 && cc2 < 256 && | |||
2418 | cidx[cc1] && cidx[cc1][cc2] != 0) { | |||
2419 | #ifndef FOR_MSW | |||
2420 | XPutPixel(image, x, y,((*((image)->f.put_pixel))((image), (x), (y), (image_pixels [cidx[cc1][cc2] - 1]))) | |||
2421 | image_pixels[cidx[cc1][cc2] - 1])((*((image)->f.put_pixel))((image), (x), (y), (image_pixels [cidx[cc1][cc2] - 1]))); | |||
2422 | if (shapeimage) | |||
2423 | XPutPixel(shapeimage, x, y,((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [cidx[cc1][cc2] - 1]))) | |||
2424 | shape_pixels[cidx[cc1][cc2] - 1])((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [cidx[cc1][cc2] - 1]))); | |||
2425 | #else | |||
2426 | SelectObject(*dc, image->bitmap); | |||
2427 | SetPixel(*dc, x, y, image_pixels[cidx[cc1][cc2] - 1]); | |||
2428 | if (shapeimage) { | |||
2429 | SelectObject(*dc, shapeimage->bitmap); | |||
2430 | SetPixel(*dc, x, y, | |||
2431 | shape_pixels[cidx[cc1][cc2] - 1]); | |||
2432 | } | |||
2433 | #endif | |||
2434 | } else { | |||
2435 | FREE_CIDX{int f; for (f = 0; f < 256; f++) if (cidx[f]) free(cidx[f ]);}; | |||
2436 | return (XpmFileInvalid-2); | |||
2437 | } | |||
2438 | } else { | |||
2439 | FREE_CIDX{int f; for (f = 0; f < 256; f++) if (cidx[f]) free(cidx[f ]);}; | |||
2440 | return (XpmFileInvalid-2); | |||
2441 | } | |||
2442 | } | |||
2443 | } | |||
2444 | FREE_CIDX{int f; for (f = 0; f < 256; f++) if (cidx[f]) free(cidx[f ]);}; | |||
2445 | } | |||
2446 | break; | |||
2447 | ||||
2448 | default: /* Non-optimized case of long color | |||
2449 | * names */ | |||
2450 | { | |||
2451 | char *s; | |||
2452 | char buf[BUFSIZ1024]; | |||
2453 | ||||
2454 | if (cpp >= sizeof(buf)) | |||
2455 | return (XpmFileInvalid-2); | |||
2456 | ||||
2457 | buf[cpp] = '\0'; | |||
2458 | if (USE_HASHTABLE(cpp > 2 && ncolors > 4)) { | |||
2459 | xpmHashAtom *slot; | |||
2460 | ||||
2461 | for (y = 0; y < height; y++) { | |||
2462 | xpmNextString(data); | |||
2463 | for (x = 0; x < width; x++) { | |||
2464 | for (a = 0, s = buf; a < cpp; a++, s++) | |||
2465 | *s = xpmGetC(data)((!data->type || data->type == 3) ? (*data->cptr++) : (getc(data->stream.file))); | |||
2466 | slot = xpmHashSlot(hashtable, buf); | |||
2467 | if (!*slot) /* no color matches */ | |||
2468 | return (XpmFileInvalid-2); | |||
2469 | #ifndef FOR_MSW | |||
2470 | XPutPixel(image, x, y,((*((image)->f.put_pixel))((image), (x), (y), (image_pixels [((unsigned long)((*slot)->data))]))) | |||
2471 | image_pixels[HashColorIndex(slot)])((*((image)->f.put_pixel))((image), (x), (y), (image_pixels [((unsigned long)((*slot)->data))]))); | |||
2472 | if (shapeimage) | |||
2473 | XPutPixel(shapeimage, x, y,((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [((unsigned long)((*slot)->data))]))) | |||
2474 | shape_pixels[HashColorIndex(slot)])((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [((unsigned long)((*slot)->data))]))); | |||
2475 | #else | |||
2476 | SelectObject(*dc, image->bitmap); | |||
2477 | SetPixel(*dc, x, y, | |||
2478 | image_pixels[HashColorIndex(slot)((unsigned long)((*slot)->data))]); | |||
2479 | if (shapeimage) { | |||
2480 | SelectObject(*dc, shapeimage->bitmap); | |||
2481 | SetPixel(*dc, x, y, | |||
2482 | shape_pixels[HashColorIndex(slot)((unsigned long)((*slot)->data))]); | |||
2483 | } | |||
2484 | #endif | |||
2485 | } | |||
2486 | } | |||
2487 | } else { | |||
2488 | for (y = 0; y < height; y++) { | |||
2489 | xpmNextString(data); | |||
2490 | for (x = 0; x < width; x++) { | |||
2491 | for (a = 0, s = buf; a < cpp; a++, s++) | |||
2492 | *s = xpmGetC(data)((!data->type || data->type == 3) ? (*data->cptr++) : (getc(data->stream.file))); | |||
2493 | for (a = 0; a < ncolors; a++) | |||
2494 | if (!strcmp(colorTable[a].string, buf)) | |||
2495 | break; | |||
2496 | if (a == ncolors) /* no color matches */ | |||
2497 | return (XpmFileInvalid-2); | |||
2498 | #ifndef FOR_MSW | |||
2499 | XPutPixel(image, x, y, image_pixels[a])((*((image)->f.put_pixel))((image), (x), (y), (image_pixels [a]))); | |||
2500 | if (shapeimage) | |||
2501 | XPutPixel(shapeimage, x, y, shape_pixels[a])((*((shapeimage)->f.put_pixel))((shapeimage), (x), (y), (shape_pixels [a]))); | |||
2502 | #else | |||
2503 | SelectObject(*dc, image->bitmap); | |||
2504 | SetPixel(*dc, x, y, image_pixels[a]); | |||
2505 | if (shapeimage) { | |||
2506 | SelectObject(*dc, shapeimage->bitmap); | |||
2507 | SetPixel(*dc, x, y, shape_pixels[a]); | |||
2508 | } | |||
2509 | #endif | |||
2510 | } | |||
2511 | } | |||
2512 | } | |||
2513 | } | |||
2514 | break; | |||
2515 | } | |||
2516 | return (XpmSuccess0); | |||
2517 | } |