diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/evas/src/modules/loaders/bmp/evas_image_load_bmp.c | 1498 |
1 files changed, 0 insertions, 1498 deletions
diff --git a/libraries/evas/src/modules/loaders/bmp/evas_image_load_bmp.c b/libraries/evas/src/modules/loaders/bmp/evas_image_load_bmp.c deleted file mode 100644 index 9453ceb..0000000 --- a/libraries/evas/src/modules/loaders/bmp/evas_image_load_bmp.c +++ /dev/null | |||
@@ -1,1498 +0,0 @@ | |||
1 | #ifdef HAVE_CONFIG_H | ||
2 | # include <config.h> | ||
3 | #endif | ||
4 | |||
5 | #include <stdio.h> | ||
6 | |||
7 | #ifdef HAVE_EVIL | ||
8 | # include <Evil.h> | ||
9 | #endif | ||
10 | |||
11 | #include <math.h> | ||
12 | |||
13 | #include "evas_common.h" | ||
14 | #include "evas_private.h" | ||
15 | |||
16 | static Eina_Bool evas_image_load_file_head_bmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4); | ||
17 | static Eina_Bool evas_image_load_file_data_bmp(Image_Entry *ie, const char *file, const char *key, int *error) EINA_ARG_NONNULL(1, 2, 4); | ||
18 | |||
19 | static Evas_Image_Load_Func evas_image_load_bmp_func = | ||
20 | { | ||
21 | EINA_TRUE, | ||
22 | evas_image_load_file_head_bmp, | ||
23 | evas_image_load_file_data_bmp, | ||
24 | NULL, | ||
25 | EINA_FALSE | ||
26 | }; | ||
27 | |||
28 | static Eina_Bool | ||
29 | read_short(unsigned char *map, size_t length, size_t *position, short *ret) | ||
30 | { | ||
31 | unsigned char b[2]; | ||
32 | |||
33 | if (*position + 2 > length) return EINA_FALSE; | ||
34 | b[0] = map[(*position)++]; | ||
35 | b[1] = map[(*position)++]; | ||
36 | *ret = (b[1] << 8) | b[0]; | ||
37 | return EINA_TRUE; | ||
38 | } | ||
39 | |||
40 | static Eina_Bool | ||
41 | read_ushort(unsigned char *map, size_t length, size_t *position, unsigned short *ret) | ||
42 | { | ||
43 | unsigned char b[2]; | ||
44 | |||
45 | if (*position + 2 > length) return EINA_FALSE; | ||
46 | b[0] = map[(*position)++]; | ||
47 | b[1] = map[(*position)++]; | ||
48 | *ret = (b[1] << 8) | b[0]; | ||
49 | return EINA_TRUE; | ||
50 | } | ||
51 | |||
52 | static Eina_Bool | ||
53 | read_int(unsigned char *map, size_t length, size_t *position, int *ret) | ||
54 | { | ||
55 | unsigned char b[4]; | ||
56 | int i; | ||
57 | |||
58 | if (*position + 4 > length) return EINA_FALSE; | ||
59 | for (i = 0; i < 4; i++) | ||
60 | b[i] = map[(*position)++]; | ||
61 | *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]); | ||
62 | return EINA_TRUE; | ||
63 | } | ||
64 | |||
65 | static Eina_Bool | ||
66 | read_uint(unsigned char *map, size_t length, size_t *position, unsigned int *ret) | ||
67 | { | ||
68 | unsigned char b[4]; | ||
69 | int i; | ||
70 | |||
71 | if (*position + 4 > length) return EINA_FALSE; | ||
72 | for (i = 0; i < 4; i++) | ||
73 | b[i] = map[(*position)++]; | ||
74 | *ret = ARGB_JOIN(b[3], b[2], b[1], b[0]); | ||
75 | return EINA_TRUE; | ||
76 | } | ||
77 | |||
78 | static Eina_Bool | ||
79 | read_uchar(unsigned char *map, size_t length, size_t *position, unsigned char *ret) | ||
80 | { | ||
81 | if (*position + 1 > length) return EINA_FALSE; | ||
82 | *ret = map[(*position)++]; | ||
83 | return EINA_TRUE; | ||
84 | } | ||
85 | |||
86 | static Eina_Bool | ||
87 | read_skip(size_t length, size_t *position, int skip) | ||
88 | { | ||
89 | if (*position + skip > length) return EINA_FALSE; | ||
90 | *position += skip; | ||
91 | return EINA_TRUE; | ||
92 | } | ||
93 | |||
94 | static Eina_Bool | ||
95 | read_mem(unsigned char *map, size_t length, size_t *position, void *buffer, int size) | ||
96 | { | ||
97 | if (*position + size > length) return EINA_FALSE; | ||
98 | memcpy(buffer, map + *position, size); | ||
99 | *position += size; | ||
100 | return EINA_TRUE; | ||
101 | } | ||
102 | |||
103 | static Eina_Bool | ||
104 | evas_image_load_file_head_bmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error) | ||
105 | { | ||
106 | Eina_File *f; | ||
107 | void *map = NULL; | ||
108 | size_t position = 0; | ||
109 | char hasa = 0; | ||
110 | int w = 0, h = 0, bit_count = 0, image_size = 0, comp = 0; | ||
111 | unsigned int offset, head_size, amask = 0; | ||
112 | int fsize = 0; | ||
113 | unsigned int bmpsize; | ||
114 | unsigned short res1, res2; | ||
115 | |||
116 | f = eina_file_open(file, 0); | ||
117 | if (!f) | ||
118 | { | ||
119 | *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST; | ||
120 | return EINA_FALSE; | ||
121 | } | ||
122 | |||
123 | *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT; | ||
124 | fsize = eina_file_size_get(f); | ||
125 | if (fsize < 2) goto close_file; | ||
126 | |||
127 | map = eina_file_map_all(f, EINA_FILE_SEQUENTIAL); | ||
128 | if (!map) goto close_file; | ||
129 | |||
130 | if (strncmp(map, "BM", 2)) goto close_file; // magic number | ||
131 | position += 2; | ||
132 | *error = EVAS_LOAD_ERROR_CORRUPT_FILE; | ||
133 | if (!read_uint(map, fsize, &position, &bmpsize)) goto close_file; | ||
134 | if (!read_ushort(map, fsize, &position, &res1)) goto close_file; | ||
135 | if (!read_ushort(map, fsize, &position, &res2)) goto close_file; | ||
136 | if (!read_uint(map, fsize, &position, &offset)) goto close_file; | ||
137 | if (!read_uint(map, fsize, &position, &head_size)) goto close_file; | ||
138 | if (head_size == 12) // OS/2 V1 + Windows 3.0 | ||
139 | { | ||
140 | short tmp; | ||
141 | |||
142 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
143 | w = tmp; // width | ||
144 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
145 | h = tmp; // height | ||
146 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
147 | //planes = tmp; // must be 1 | ||
148 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
149 | bit_count = tmp; // bits per pixel: 1, 4, 8 & 24 | ||
150 | } | ||
151 | else if (head_size == 64) // OS/2 V2 | ||
152 | { | ||
153 | short tmp; | ||
154 | int tmp2; | ||
155 | |||
156 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
157 | w = tmp2; // width | ||
158 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
159 | h = tmp2; // height | ||
160 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
161 | //planes = tmp; // must be 1 | ||
162 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
163 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
164 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
165 | comp = tmp2; // compression method | ||
166 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
167 | image_size = tmp2; // bitmap data size | ||
168 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
169 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
170 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
171 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
172 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
173 | //palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
174 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
175 | //important_colors = tmp2; // number of important colors - 0 if all | ||
176 | if (!read_skip(fsize, &position, 24)) goto close_file; // skip unused header | ||
177 | if (image_size == 0) image_size = fsize - offset; | ||
178 | } | ||
179 | else if (head_size == 40) // Windows 3.0 + (v3) | ||
180 | { | ||
181 | short tmp; | ||
182 | int tmp2; | ||
183 | |||
184 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
185 | w = tmp2; // width | ||
186 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
187 | h = tmp2; // height | ||
188 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
189 | //planes = tmp; // must be 1 | ||
190 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
191 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
192 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
193 | comp = tmp2; // compression method | ||
194 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
195 | image_size = tmp2; // bitmap data size | ||
196 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
197 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
198 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
199 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
200 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
201 | //palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
202 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
203 | //important_colors = tmp2; // number of important colors - 0 if all | ||
204 | if (image_size == 0) image_size = fsize - offset; | ||
205 | if ((comp == 0) && (bit_count == 32)) hasa = 1; // GIMP seems to store it this way | ||
206 | } | ||
207 | else if (head_size == 108) // Windows 95/NT4 + (v4) | ||
208 | { | ||
209 | short tmp; | ||
210 | int tmp2; | ||
211 | |||
212 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
213 | w = tmp2; // width | ||
214 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
215 | h = tmp2; // height | ||
216 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
217 | //planes = tmp; // must be 1 | ||
218 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
219 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
220 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
221 | comp = tmp2; // compression method | ||
222 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
223 | image_size = tmp2; // bitmap data size | ||
224 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
225 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
226 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
227 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
228 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
229 | //palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
230 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
231 | //important_colors = tmp2; // number of important colors - 0 if all | ||
232 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
233 | //rmask = tmp2; // red mask | ||
234 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
235 | //gmask = tmp2; // green mask | ||
236 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
237 | //bmask = tmp2; // blue mask | ||
238 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
239 | amask = tmp2; // alpha mask | ||
240 | if (!read_skip(fsize, &position, 36)) goto close_file; // skip unused cie | ||
241 | if (!read_skip(fsize, &position, 12)) goto close_file; // skip unused gamma | ||
242 | if (image_size == 0) image_size = fsize - offset; | ||
243 | if ((amask) && (bit_count == 32)) hasa = 1; | ||
244 | } | ||
245 | else if (head_size == 124) // Windows 98/2000 + (v5) | ||
246 | { | ||
247 | short tmp; | ||
248 | int tmp2; | ||
249 | |||
250 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
251 | w = tmp2; // width | ||
252 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
253 | h = tmp2; // height | ||
254 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
255 | //planes = tmp; // must be 1 | ||
256 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
257 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
258 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
259 | comp = tmp2; // compression method | ||
260 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
261 | //image_size = tmp2; // bitmap data size | ||
262 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
263 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
264 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
265 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
266 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
267 | //palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
268 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
269 | //important_colors = tmp2; // number of important colors - 0 if all | ||
270 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
271 | //rmask = tmp2; // red mask | ||
272 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
273 | //gmask = tmp2; // green mask | ||
274 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
275 | //bmask = tmp2; // blue mask | ||
276 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
277 | amask = tmp2; // alpha mask | ||
278 | if (!read_skip(fsize, &position, 36)) goto close_file; // skip unused cie | ||
279 | if (!read_skip(fsize, &position, 12)) goto close_file; // skip unused gamma | ||
280 | if (!read_skip(fsize, &position, 16)) goto close_file; // skip others | ||
281 | if (image_size == 0) image_size = fsize - offset; | ||
282 | if ((amask) && (bit_count == 32)) hasa = 1; | ||
283 | } | ||
284 | else | ||
285 | goto close_file; | ||
286 | |||
287 | if (h < 0) | ||
288 | { | ||
289 | h = -h; | ||
290 | //right_way_up = 1; | ||
291 | } | ||
292 | |||
293 | if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) || | ||
294 | IMG_TOO_BIG(w, h)) | ||
295 | { | ||
296 | if (IMG_TOO_BIG(w, h)) | ||
297 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
298 | else | ||
299 | *error = EVAS_LOAD_ERROR_GENERIC; | ||
300 | goto close_file; | ||
301 | } | ||
302 | /* It is not bad idea that bmp loader support scale down decoding | ||
303 | * because of memory issue in mobile world.*/ | ||
304 | if (ie->load_opts.scale_down_by > 1) | ||
305 | { | ||
306 | w /= ie->load_opts.scale_down_by; | ||
307 | h /= ie->load_opts.scale_down_by; | ||
308 | } | ||
309 | |||
310 | if (bit_count < 16) | ||
311 | { | ||
312 | //if ((palette_size < 0) || (palette_size > 256)) pal_num = 256; | ||
313 | //else pal_num = palette_size; | ||
314 | if (bit_count == 1) | ||
315 | { | ||
316 | if (comp == 0) // no compression | ||
317 | { | ||
318 | } | ||
319 | else | ||
320 | goto close_file; | ||
321 | } | ||
322 | else if (bit_count == 4) | ||
323 | { | ||
324 | if (comp == 0) // no compression | ||
325 | { | ||
326 | } | ||
327 | else if (comp == 2) // rle 4bit/pixel | ||
328 | { | ||
329 | } | ||
330 | else | ||
331 | goto close_file; | ||
332 | } | ||
333 | else if (bit_count == 8) | ||
334 | { | ||
335 | if (comp == 0) // no compression | ||
336 | { | ||
337 | } | ||
338 | else if (comp == 1) // rle 8bit/pixel | ||
339 | { | ||
340 | } | ||
341 | else | ||
342 | goto close_file; | ||
343 | } | ||
344 | } | ||
345 | else if ((bit_count == 16) || (bit_count == 24) || (bit_count == 32)) | ||
346 | { | ||
347 | if (comp == 0) // no compression | ||
348 | { | ||
349 | // handled | ||
350 | } | ||
351 | else if (comp == 3) // bit field | ||
352 | { | ||
353 | // handled | ||
354 | } | ||
355 | else if (comp == 4) // jpeg - only printer drivers | ||
356 | goto close_file; | ||
357 | else if (comp == 3) // png - only printer drivers | ||
358 | goto close_file; | ||
359 | else | ||
360 | goto close_file; | ||
361 | } | ||
362 | else | ||
363 | goto close_file; | ||
364 | |||
365 | ie->w = w; | ||
366 | ie->h = h; | ||
367 | if (hasa) ie->flags.alpha = 1; | ||
368 | |||
369 | eina_file_map_free(f, map); | ||
370 | eina_file_close(f); | ||
371 | *error = EVAS_LOAD_ERROR_NONE; | ||
372 | return EINA_TRUE; | ||
373 | |||
374 | close_file: | ||
375 | if (map) eina_file_map_free(f, map); | ||
376 | eina_file_close(f); | ||
377 | return EINA_FALSE; | ||
378 | } | ||
379 | |||
380 | static Eina_Bool | ||
381 | evas_image_load_file_data_bmp(Image_Entry *ie, const char *file, const char *key __UNUSED__, int *error) | ||
382 | { | ||
383 | Eina_File *f; | ||
384 | void *map = NULL; | ||
385 | size_t position = 0; | ||
386 | unsigned char *buffer = NULL, *buffer_end = NULL, *p; | ||
387 | char hasa = 0; | ||
388 | int x = 0, y = 0, w = 0, h = 0, bit_count = 0, image_size = 0, | ||
389 | comp = 0, palette_size = -1; | ||
390 | unsigned int offset = 0, head_size = 0; | ||
391 | unsigned int *pal = NULL, pal_num = 0, *pix = NULL, *surface = NULL, fix, | ||
392 | rmask = 0, gmask = 0, bmask = 0, amask = 0; | ||
393 | int right_way_up = 0; | ||
394 | unsigned char r, g, b, a; | ||
395 | int fsize = 0; | ||
396 | unsigned int bmpsize; | ||
397 | unsigned short res1, res2; | ||
398 | |||
399 | /* for scale decoding */ | ||
400 | unsigned int *scale_surface = NULL, *scale_pix = NULL; | ||
401 | int scale_ratio = 1, image_w = 0, image_h = 0; | ||
402 | int row_size = 0; /* Row size is rounded up to a multiple of 4bytes */ | ||
403 | int read_line = 0; /* total read line */ | ||
404 | |||
405 | f = eina_file_open(file, 0); | ||
406 | if (!f) | ||
407 | { | ||
408 | *error = EVAS_LOAD_ERROR_DOES_NOT_EXIST; | ||
409 | return EINA_FALSE; | ||
410 | } | ||
411 | |||
412 | *error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT; | ||
413 | fsize = eina_file_size_get(f); | ||
414 | if (fsize < 2) goto close_file; | ||
415 | |||
416 | map = eina_file_map_all(f, EINA_FILE_SEQUENTIAL); | ||
417 | if (!map) goto close_file; | ||
418 | |||
419 | if (strncmp(map, "BM", 2)) goto close_file; // magic number | ||
420 | position += 2; | ||
421 | *error = EVAS_LOAD_ERROR_CORRUPT_FILE; | ||
422 | if (!read_uint(map, fsize, &position, &bmpsize)) goto close_file; | ||
423 | if (!read_ushort(map, fsize, &position, &res1)) goto close_file; | ||
424 | if (!read_ushort(map, fsize, &position, &res2)) goto close_file; | ||
425 | if (!read_uint(map, fsize, &position, &offset)) goto close_file; | ||
426 | if (!read_uint(map, fsize, &position, &head_size)) goto close_file; | ||
427 | image_size = fsize - offset; | ||
428 | if (image_size < 1) goto close_file; | ||
429 | |||
430 | if (head_size == 12) // OS/2 V1 + Windows 3.0 | ||
431 | { | ||
432 | short tmp; | ||
433 | |||
434 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
435 | w = tmp; // width | ||
436 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
437 | h = tmp; // height | ||
438 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
439 | //planes = tmp; // must be 1 | ||
440 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
441 | bit_count = tmp; // bits per pixel: 1, 4, 8 & 24 | ||
442 | } | ||
443 | else if (head_size == 64) // OS/2 V2 | ||
444 | { | ||
445 | short tmp; | ||
446 | int tmp2; | ||
447 | |||
448 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
449 | w = tmp2; // width | ||
450 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
451 | h = tmp2; // height | ||
452 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
453 | //planes = tmp; // must be 1 | ||
454 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
455 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
456 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
457 | comp = tmp2; // compression method | ||
458 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
459 | image_size = tmp2; // bitmap data size | ||
460 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
461 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
462 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
463 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
464 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
465 | palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
466 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
467 | //important_colors = tmp2; // number of important colors - 0 if all | ||
468 | if (!read_skip(fsize, &position, 24)) goto close_file; // skip unused header | ||
469 | if (image_size == 0) image_size = fsize - offset; | ||
470 | } | ||
471 | else if (head_size == 40) // Windows 3.0 + (v3) | ||
472 | { | ||
473 | short tmp; | ||
474 | int tmp2; | ||
475 | |||
476 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
477 | w = tmp2; // width | ||
478 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
479 | h = tmp2; // height | ||
480 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
481 | //planes = tmp; // must be 1 | ||
482 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
483 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
484 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
485 | comp = tmp2; // compression method | ||
486 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
487 | image_size = tmp2; // bitmap data size | ||
488 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
489 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
490 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
491 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
492 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
493 | palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
494 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
495 | //important_colors = tmp2; // number of important colors - 0 if all | ||
496 | if (image_size == 0) image_size = fsize - offset; | ||
497 | if ((comp == 0) && (bit_count == 32)) hasa = 1; // GIMP seems to store it this way | ||
498 | } | ||
499 | else if (head_size == 108) // Windows 95/NT4 + (v4) | ||
500 | { | ||
501 | short tmp; | ||
502 | int tmp2; | ||
503 | |||
504 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
505 | w = tmp2; // width | ||
506 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
507 | h = tmp2; // height | ||
508 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
509 | //planes = tmp; // must be 1 | ||
510 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
511 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
512 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
513 | comp = tmp2; // compression method | ||
514 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
515 | image_size = tmp2; // bitmap data size | ||
516 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
517 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
518 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
519 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
520 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
521 | palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
522 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
523 | //important_colors = tmp2; // number of important colors - 0 if all | ||
524 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
525 | rmask = tmp2; // red mask | ||
526 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
527 | gmask = tmp2; // green mask | ||
528 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
529 | bmask = tmp2; // blue mask | ||
530 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
531 | amask = tmp2; // alpha mask | ||
532 | if (!read_skip(fsize, &position, 36)) goto close_file; // skip unused cie | ||
533 | if (!read_skip(fsize, &position, 12)) goto close_file; // skip unused gamma | ||
534 | if (image_size == 0) image_size = fsize - offset; | ||
535 | if ((amask) && (bit_count == 32)) hasa = 1; | ||
536 | } | ||
537 | else if (head_size == 124) // Windows 98/2000 + (v5) | ||
538 | { | ||
539 | short tmp; | ||
540 | int tmp2; | ||
541 | |||
542 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
543 | w = tmp2; // width | ||
544 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
545 | h = tmp2; // height | ||
546 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
547 | //planes = tmp; // must be 1 | ||
548 | if (!read_short(map, fsize, &position, &tmp)) goto close_file; | ||
549 | bit_count = tmp; // bits per pixel: 1, 4, 8, 16, 24 & 32 | ||
550 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
551 | comp = tmp2; // compression method | ||
552 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
553 | image_size = tmp2; // bitmap data size | ||
554 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
555 | //hdpi = (tmp2 * 254) / 10000; // horizontal pixels/meter | ||
556 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
557 | //vdpi = (tmp2 * 254) / 10000; // vertical pixles/meter | ||
558 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
559 | palette_size = tmp2; // number of palette colors power (2^n - so 0 - 8) | ||
560 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
561 | //important_colors = tmp2; // number of important colors - 0 if all | ||
562 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
563 | rmask = tmp2; // red mask | ||
564 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
565 | gmask = tmp2; // green mask | ||
566 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
567 | bmask = tmp2; // blue mask | ||
568 | if (!read_int(map, fsize, &position, &tmp2)) goto close_file; | ||
569 | amask = tmp2; // alpha mask | ||
570 | if (!read_skip(fsize, &position, 36)) goto close_file; // skip unused cie | ||
571 | if (!read_skip(fsize, &position, 12)) goto close_file; // skip unused gamma | ||
572 | if (!read_skip(fsize, &position, 16)) goto close_file; // skip others | ||
573 | if (image_size == 0) image_size = fsize - offset; | ||
574 | if ((amask) && (bit_count == 32)) hasa = 1; | ||
575 | } | ||
576 | else | ||
577 | goto close_file; | ||
578 | |||
579 | if (h < 0) | ||
580 | { | ||
581 | h = -h; | ||
582 | right_way_up = 1; | ||
583 | } | ||
584 | if ((w < 1) || (h < 1) || (w > IMG_MAX_SIZE) || (h > IMG_MAX_SIZE) || | ||
585 | IMG_TOO_BIG(w, h)) | ||
586 | { | ||
587 | if (IMG_TOO_BIG(w, h)) | ||
588 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
589 | else | ||
590 | *error = EVAS_LOAD_ERROR_GENERIC; | ||
591 | goto close_file; | ||
592 | } | ||
593 | /* It is not bad idea that bmp loader support scale down decoding | ||
594 | * because of memory issue in mobile world. */ | ||
595 | if (ie->load_opts.scale_down_by > 1) | ||
596 | scale_ratio = ie->load_opts.scale_down_by; | ||
597 | image_w = w; | ||
598 | image_h = h; | ||
599 | |||
600 | if (scale_ratio > 1) | ||
601 | { | ||
602 | w /= scale_ratio; | ||
603 | h /= scale_ratio; | ||
604 | |||
605 | if ((w < 1) || (h < 1) ) | ||
606 | { | ||
607 | *error = EVAS_LOAD_ERROR_GENERIC; | ||
608 | goto close_file; | ||
609 | } | ||
610 | } | ||
611 | |||
612 | if ((w != (int)ie->w) || (h != (int)ie->h)) | ||
613 | { | ||
614 | *error = EVAS_LOAD_ERROR_GENERIC; | ||
615 | goto close_file; | ||
616 | } | ||
617 | evas_cache_image_surface_alloc(ie, ie->w, ie->h); | ||
618 | surface = evas_cache_image_pixels(ie); | ||
619 | if (!surface) | ||
620 | { | ||
621 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
622 | goto close_file; | ||
623 | } | ||
624 | |||
625 | row_size = ceil((double)(image_w * bit_count) / 32) * 4; | ||
626 | |||
627 | if (bit_count < 16) | ||
628 | { | ||
629 | unsigned int i; | ||
630 | |||
631 | if (bit_count == 1) | ||
632 | { | ||
633 | if ((palette_size <= 0) || (palette_size > 2)) pal_num = 2; | ||
634 | else pal_num = palette_size; | ||
635 | } | ||
636 | else if (bit_count == 4) | ||
637 | { | ||
638 | if ((palette_size <= 0) || (palette_size > 16)) pal_num = 16; | ||
639 | else pal_num = palette_size; | ||
640 | } | ||
641 | else if (bit_count == 8) | ||
642 | { | ||
643 | if ((palette_size <= 0) || (palette_size > 256)) pal_num = 256; | ||
644 | else pal_num = palette_size; | ||
645 | } | ||
646 | pal = alloca(256 * 4); | ||
647 | for (i = 0; i < pal_num; i++) | ||
648 | { | ||
649 | if (!read_uchar(map, fsize, &position, &b)) goto close_file; | ||
650 | if (!read_uchar(map, fsize, &position, &g)) goto close_file; | ||
651 | if (!read_uchar(map, fsize, &position, &r)) goto close_file; | ||
652 | if ((head_size != 12) /*&& (palette_size != 0)*/) | ||
653 | { // OS/2 V1 doesn't do the pad byte | ||
654 | if (!read_uchar(map, fsize, &position, &a)) goto close_file; | ||
655 | } | ||
656 | a = 0xff; // fillin a as solid for paletted images | ||
657 | pal[i] = ARGB_JOIN(a, r, g, b); | ||
658 | } | ||
659 | position = offset; | ||
660 | |||
661 | if ((scale_ratio == 1) || (comp !=0)) | ||
662 | buffer = malloc(image_size + 8); // add 8 for padding to avoid checks | ||
663 | else | ||
664 | { | ||
665 | scale_surface = malloc(image_w * sizeof(DATA32)); //for one line decoding | ||
666 | if (!scale_surface) | ||
667 | { | ||
668 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
669 | goto close_file; | ||
670 | } | ||
671 | buffer = malloc(row_size); // scale down is usually set because of memory issue, so read line by line | ||
672 | } | ||
673 | |||
674 | if (!buffer) | ||
675 | { | ||
676 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
677 | goto close_file; | ||
678 | } | ||
679 | if ((scale_ratio == 1) || (comp !=0)) | ||
680 | buffer_end = buffer + image_size; | ||
681 | else | ||
682 | buffer_end = buffer + row_size; | ||
683 | p = buffer; | ||
684 | |||
685 | if ((scale_ratio == 1) || (comp !=0)) | ||
686 | { | ||
687 | if (!read_mem(map, fsize, &position, buffer, image_size)) goto close_file; | ||
688 | } | ||
689 | else | ||
690 | { | ||
691 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
692 | } | ||
693 | |||
694 | if (bit_count == 1) | ||
695 | { | ||
696 | if (comp == 0) // no compression | ||
697 | { | ||
698 | pix = surface; | ||
699 | |||
700 | for (y = 0; y < h; y++) | ||
701 | { | ||
702 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
703 | if (scale_ratio > 1) pix = scale_surface; // one line decoding | ||
704 | |||
705 | for (x = 0; x < image_w; x++) | ||
706 | { | ||
707 | if ((x & 0x7) == 0x0) | ||
708 | { | ||
709 | *pix = pal[*p >> 7]; | ||
710 | } | ||
711 | else if ((x & 0x7) == 0x1) | ||
712 | { | ||
713 | *pix = pal[(*p >> 6) & 0x1]; | ||
714 | } | ||
715 | else if ((x & 0x7) == 0x2) | ||
716 | { | ||
717 | *pix = pal[(*p >> 5) & 0x1]; | ||
718 | } | ||
719 | else if ((x & 0x7) == 0x3) | ||
720 | { | ||
721 | *pix = pal[(*p >> 4) & 0x1]; | ||
722 | } | ||
723 | else if ((x & 0x7) == 0x4) | ||
724 | { | ||
725 | *pix = pal[(*p >> 3) & 0x1]; | ||
726 | } | ||
727 | else if ((x & 0x7) == 0x5) | ||
728 | { | ||
729 | *pix = pal[(*p >> 2) & 0x1]; | ||
730 | } | ||
731 | else if ((x & 0x7) == 0x6) | ||
732 | { | ||
733 | *pix = pal[(*p >> 1) & 0x1]; | ||
734 | } | ||
735 | else | ||
736 | { | ||
737 | *pix = pal[*p & 0x1]; | ||
738 | p++; | ||
739 | } | ||
740 | if (p >= buffer_end) break; | ||
741 | pix++; | ||
742 | } | ||
743 | |||
744 | if (scale_ratio > 1) | ||
745 | { | ||
746 | if (!right_way_up) scale_pix = surface + ((h - 1 - y) * w); | ||
747 | else scale_pix = surface + (y * w); | ||
748 | |||
749 | pix = scale_surface; | ||
750 | for (x = 0; x < w; x++) | ||
751 | { | ||
752 | *scale_pix = *pix; | ||
753 | scale_pix ++; | ||
754 | pix += scale_ratio; | ||
755 | } | ||
756 | read_line += scale_ratio; | ||
757 | if (read_line >= image_h) break; | ||
758 | |||
759 | position += row_size * (scale_ratio - 1); | ||
760 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
761 | p = buffer; | ||
762 | buffer_end = buffer + row_size; | ||
763 | } | ||
764 | else | ||
765 | { | ||
766 | if ((x & 0x7) != 0) p++; | ||
767 | fix = (int)(((unsigned long)p) & 0x3); | ||
768 | if (fix > 0) p += 4 - fix; // align row read | ||
769 | if (p >= buffer_end) break; | ||
770 | } | ||
771 | } | ||
772 | } | ||
773 | else | ||
774 | goto close_file; | ||
775 | } | ||
776 | else if (bit_count == 4) | ||
777 | { | ||
778 | if (comp == 0) // no compression | ||
779 | { | ||
780 | pix = surface; | ||
781 | for (y = 0; y < h; y++) | ||
782 | { | ||
783 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
784 | if (scale_ratio > 1) pix = scale_surface; // one line decoding | ||
785 | for (x = 0; x < image_w; x++) | ||
786 | { | ||
787 | if ((x & 0x1) == 0x1) | ||
788 | { | ||
789 | *pix = pal[*p & 0x0f]; | ||
790 | p++; | ||
791 | } | ||
792 | else | ||
793 | { | ||
794 | *pix = pal[*p >> 4]; | ||
795 | } | ||
796 | if (p >= buffer_end) break; | ||
797 | pix++; | ||
798 | } | ||
799 | if (scale_ratio > 1) | ||
800 | { | ||
801 | if (!right_way_up) scale_pix = surface + ((h - 1 - y) * w); | ||
802 | else scale_pix = surface + (y * w); | ||
803 | |||
804 | pix = scale_surface; | ||
805 | for (x = 0; x < w; x++) | ||
806 | { | ||
807 | *scale_pix = *pix; | ||
808 | scale_pix ++; | ||
809 | pix += scale_ratio; | ||
810 | } | ||
811 | read_line += scale_ratio; | ||
812 | if (read_line >= image_h) break; | ||
813 | |||
814 | position += row_size * (scale_ratio - 1); | ||
815 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
816 | p = buffer; | ||
817 | buffer_end = buffer + row_size; | ||
818 | } | ||
819 | else | ||
820 | { | ||
821 | if ((x & 0x1) != 0) p++; | ||
822 | fix = (int)(((unsigned long)p) & 0x3); | ||
823 | if (fix > 0) p += 4 - fix; // align row read | ||
824 | if (p >= buffer_end) break; | ||
825 | } | ||
826 | } | ||
827 | } | ||
828 | else if (comp == 2) // rle 4bit/pixel | ||
829 | { | ||
830 | int count = 0, done = 0, wpad; | ||
831 | int scale_x = 0, scale_y = 0; | ||
832 | Eina_Bool scale_down_line = EINA_TRUE; | ||
833 | |||
834 | pix = surface; | ||
835 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
836 | wpad = ((image_w + 1) / 2) * 2; | ||
837 | while (p < buffer_end) | ||
838 | { | ||
839 | if (p[0]) | ||
840 | { | ||
841 | if (scale_down_line) | ||
842 | { | ||
843 | if ((x + p[0]) <= wpad) | ||
844 | { | ||
845 | unsigned int col1 = pal[p[1] >> 4]; | ||
846 | unsigned int col2 = pal[p[1] & 0xf]; | ||
847 | |||
848 | count = p[0] / 2; | ||
849 | while (count > 0) | ||
850 | { | ||
851 | if (x < w) | ||
852 | { | ||
853 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
854 | { | ||
855 | *pix = col1; | ||
856 | pix++; | ||
857 | scale_x++; | ||
858 | } | ||
859 | x++; | ||
860 | } | ||
861 | if (x < w) | ||
862 | { | ||
863 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
864 | { | ||
865 | *pix = col2; | ||
866 | pix++; | ||
867 | scale_x++; | ||
868 | } | ||
869 | x++; | ||
870 | } | ||
871 | count--; | ||
872 | } | ||
873 | if (p[0] & 0x1) | ||
874 | { | ||
875 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
876 | { | ||
877 | *pix = col1; | ||
878 | pix++; | ||
879 | scale_x++; | ||
880 | } | ||
881 | x++; | ||
882 | } | ||
883 | } | ||
884 | } | ||
885 | p += 2; | ||
886 | } | ||
887 | else | ||
888 | { | ||
889 | switch (p[1]) | ||
890 | { | ||
891 | case 0: // EOL | ||
892 | x = 0; | ||
893 | scale_x = 0; | ||
894 | y++; | ||
895 | if ((y % scale_ratio) == 0) | ||
896 | { | ||
897 | scale_y++; | ||
898 | scale_down_line = EINA_TRUE; | ||
899 | if (!right_way_up) | ||
900 | pix = surface + ((h - 1 - scale_y) * w); | ||
901 | else | ||
902 | pix = surface + (scale_y * w); | ||
903 | } | ||
904 | else | ||
905 | scale_down_line = EINA_FALSE; | ||
906 | if (scale_y >= h) | ||
907 | { | ||
908 | p = buffer_end; | ||
909 | } | ||
910 | p += 2; | ||
911 | break; | ||
912 | case 1: // EOB | ||
913 | p = buffer_end; | ||
914 | break; | ||
915 | case 2: // DELTA | ||
916 | x += p[2]; | ||
917 | y += p[3]; | ||
918 | scale_x = x / scale_ratio; | ||
919 | scale_y = y / scale_ratio; | ||
920 | if ((scale_x >= w) || (scale_y >= h)) | ||
921 | { | ||
922 | p = buffer_end; | ||
923 | } | ||
924 | if (!right_way_up) | ||
925 | pix = surface + scale_x + ((h - 1 - scale_y) * w); | ||
926 | else | ||
927 | pix = surface + scale_x + (scale_y * w); | ||
928 | p += 4; | ||
929 | break; | ||
930 | default: | ||
931 | count = p[1]; | ||
932 | if (((p + count) > buffer_end) || | ||
933 | ((x + count) > w)) | ||
934 | { | ||
935 | p = buffer_end; | ||
936 | break; | ||
937 | } | ||
938 | p += 2; | ||
939 | done = count; | ||
940 | count /= 2; | ||
941 | while (count > 0) | ||
942 | { | ||
943 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
944 | { | ||
945 | *pix = pal[*p >> 4]; | ||
946 | pix++; | ||
947 | scale_x++; | ||
948 | } | ||
949 | x++; | ||
950 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
951 | { | ||
952 | *pix = pal[*p & 0xf]; | ||
953 | pix++; | ||
954 | scale_x++; | ||
955 | } | ||
956 | x++; | ||
957 | |||
958 | p++; | ||
959 | count--; | ||
960 | } | ||
961 | |||
962 | if (done & 0x1) | ||
963 | { | ||
964 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
965 | { | ||
966 | *pix = pal[*p >> 4]; | ||
967 | scale_x++; | ||
968 | } | ||
969 | x++; | ||
970 | p++; | ||
971 | } | ||
972 | if ((done & 0x3) == 0x1) | ||
973 | p += 2; | ||
974 | else if ((done & 0x3) == 0x2) | ||
975 | p += 1; | ||
976 | break; | ||
977 | } | ||
978 | } | ||
979 | } | ||
980 | } | ||
981 | else | ||
982 | goto close_file; | ||
983 | } | ||
984 | else if (bit_count == 8) | ||
985 | { | ||
986 | if (comp == 0) // no compression | ||
987 | { | ||
988 | pix = surface; | ||
989 | for (y = 0; y < h; y++) | ||
990 | { | ||
991 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
992 | for (x = 0; x < w; x++) | ||
993 | { | ||
994 | *pix = pal[*p]; | ||
995 | p += scale_ratio; | ||
996 | if (p >= buffer_end) break; | ||
997 | pix++; | ||
998 | } | ||
999 | if (scale_ratio > 1) | ||
1000 | { | ||
1001 | read_line += scale_ratio; | ||
1002 | if (read_line >= image_h) break; | ||
1003 | |||
1004 | position += row_size * (scale_ratio - 1); | ||
1005 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1006 | p = buffer; | ||
1007 | buffer_end = buffer + row_size; | ||
1008 | } | ||
1009 | else | ||
1010 | { | ||
1011 | fix = (int)(((unsigned long)p) & 0x3); | ||
1012 | if (fix > 0) p += 4 - fix; // align row read | ||
1013 | if (p >= buffer_end) break; | ||
1014 | } | ||
1015 | } | ||
1016 | } | ||
1017 | else if (comp == 1) // rle 8bit/pixel | ||
1018 | { | ||
1019 | int count = 0, done = 0; | ||
1020 | int scale_x = 0, scale_y = 0; | ||
1021 | Eina_Bool scale_down_line = EINA_TRUE; | ||
1022 | |||
1023 | pix = surface; | ||
1024 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1025 | |||
1026 | while (p < buffer_end) | ||
1027 | { | ||
1028 | if (p[0]) | ||
1029 | { | ||
1030 | if (scale_down_line) | ||
1031 | { | ||
1032 | if ((x + p[0]) <= image_w) | ||
1033 | { | ||
1034 | unsigned int col = pal[p[1]]; | ||
1035 | |||
1036 | count = p[0]; | ||
1037 | while (count > 0) | ||
1038 | { | ||
1039 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
1040 | { | ||
1041 | *pix = col; | ||
1042 | pix++; | ||
1043 | scale_x ++; | ||
1044 | } | ||
1045 | x++; | ||
1046 | count--; | ||
1047 | } | ||
1048 | } | ||
1049 | } | ||
1050 | p += 2; | ||
1051 | } | ||
1052 | else | ||
1053 | { | ||
1054 | switch (p[1]) | ||
1055 | { | ||
1056 | case 0: // EOL | ||
1057 | x = 0; | ||
1058 | scale_x = 0; | ||
1059 | y++; | ||
1060 | if ((y % scale_ratio) == 0) | ||
1061 | { | ||
1062 | scale_y++; | ||
1063 | scale_down_line = EINA_TRUE; | ||
1064 | if (!right_way_up) | ||
1065 | pix = surface + ((h - 1 - scale_y) * w); | ||
1066 | else | ||
1067 | pix = surface + (scale_y * w); | ||
1068 | } | ||
1069 | else | ||
1070 | scale_down_line = EINA_FALSE; | ||
1071 | |||
1072 | if (scale_y >= h) | ||
1073 | { | ||
1074 | p = buffer_end; | ||
1075 | } | ||
1076 | p += 2; | ||
1077 | break; | ||
1078 | case 1: // EOB | ||
1079 | p = buffer_end; | ||
1080 | break; | ||
1081 | case 2: // DELTA | ||
1082 | x += p[2]; | ||
1083 | y += p[3]; | ||
1084 | scale_x = x / scale_ratio; | ||
1085 | scale_y = y / scale_ratio; | ||
1086 | if ((scale_x >= w) || (scale_y >= h)) | ||
1087 | { | ||
1088 | p = buffer_end; | ||
1089 | } | ||
1090 | if (!right_way_up) | ||
1091 | pix = surface + scale_x + ((h - 1 - scale_y) * w); | ||
1092 | else | ||
1093 | pix = surface + scale_x + (scale_y * w); | ||
1094 | p += 4; | ||
1095 | break; | ||
1096 | default: | ||
1097 | count = p[1]; | ||
1098 | if (((p + count) > buffer_end) || | ||
1099 | ((x + count) > image_w)) | ||
1100 | { | ||
1101 | p = buffer_end; | ||
1102 | break; | ||
1103 | } | ||
1104 | p += 2; | ||
1105 | done = count; | ||
1106 | while (count > 0) | ||
1107 | { | ||
1108 | if (((x % scale_ratio) == 0) && (scale_x < w)) | ||
1109 | { | ||
1110 | *pix = pal[*p]; | ||
1111 | pix++; | ||
1112 | scale_x ++; | ||
1113 | } | ||
1114 | p++; | ||
1115 | x++; | ||
1116 | count--; | ||
1117 | } | ||
1118 | if (done & 0x1) p++; | ||
1119 | break; | ||
1120 | } | ||
1121 | } | ||
1122 | } | ||
1123 | } | ||
1124 | else | ||
1125 | goto close_file; | ||
1126 | } | ||
1127 | } | ||
1128 | else if ((bit_count == 16) || (bit_count == 24) || (bit_count == 32)) | ||
1129 | { | ||
1130 | if (comp == 0) // no compression | ||
1131 | { | ||
1132 | position = offset; | ||
1133 | if (scale_ratio == 1) | ||
1134 | buffer = malloc(image_size + 8); // add 8 for padding to avoid checks | ||
1135 | else | ||
1136 | buffer = malloc(row_size); // scale down is usually set because of memory issue, so read line by line | ||
1137 | if (!buffer) | ||
1138 | { | ||
1139 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
1140 | goto close_file; | ||
1141 | } | ||
1142 | if (scale_ratio == 1) | ||
1143 | buffer_end = buffer + image_size; | ||
1144 | else | ||
1145 | buffer_end = buffer + row_size; | ||
1146 | |||
1147 | p = buffer; | ||
1148 | if (scale_ratio == 1) | ||
1149 | { | ||
1150 | if (!read_mem(map, fsize, &position, buffer, image_size)) goto close_file; | ||
1151 | } | ||
1152 | else | ||
1153 | { | ||
1154 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1155 | } | ||
1156 | if (bit_count == 16) | ||
1157 | { | ||
1158 | unsigned short tmp; | ||
1159 | |||
1160 | pix = surface; | ||
1161 | for (y = 0; y < h; y++) | ||
1162 | { | ||
1163 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1164 | for (x = 0; x < w; x++) | ||
1165 | { | ||
1166 | tmp = *((unsigned short *)(p)); | ||
1167 | |||
1168 | r = (tmp >> 7) & 0xf8; r |= r >> 5; | ||
1169 | g = (tmp >> 2) & 0xf8; g |= g >> 5; | ||
1170 | b = (tmp << 3) & 0xf8; b |= b >> 5; | ||
1171 | *pix = ARGB_JOIN(0xff, r, g, b); | ||
1172 | |||
1173 | p += 2 * scale_ratio; | ||
1174 | |||
1175 | if (p >= buffer_end) break; | ||
1176 | pix++; | ||
1177 | } | ||
1178 | if (scale_ratio > 1) | ||
1179 | { | ||
1180 | read_line += scale_ratio; | ||
1181 | if (read_line >= image_h) break; | ||
1182 | |||
1183 | position += row_size * (scale_ratio - 1); | ||
1184 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1185 | p = buffer; | ||
1186 | buffer_end = buffer + row_size; | ||
1187 | } | ||
1188 | else | ||
1189 | { | ||
1190 | fix = (int)(((unsigned long)p) & 0x3); | ||
1191 | if (fix > 0) p += 4 - fix; // align row read | ||
1192 | if (p >= buffer_end) break; | ||
1193 | } | ||
1194 | } | ||
1195 | } | ||
1196 | else if (bit_count == 24) | ||
1197 | { | ||
1198 | pix = surface; | ||
1199 | for (y = 0; y < h; y++) | ||
1200 | { | ||
1201 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1202 | for (x = 0; x < w; x++) | ||
1203 | { | ||
1204 | b = p[0]; | ||
1205 | g = p[1]; | ||
1206 | r = p[2]; | ||
1207 | *pix = ARGB_JOIN(0xff, r, g, b); | ||
1208 | p += 3 * scale_ratio; | ||
1209 | if (p >= buffer_end) break; | ||
1210 | pix++; | ||
1211 | } | ||
1212 | if (scale_ratio > 1) | ||
1213 | { | ||
1214 | read_line += scale_ratio; | ||
1215 | if (read_line >= image_h) break; | ||
1216 | |||
1217 | position += row_size * (scale_ratio - 1); | ||
1218 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1219 | p = buffer; | ||
1220 | buffer_end = buffer + row_size; | ||
1221 | } | ||
1222 | else | ||
1223 | { | ||
1224 | fix = (int)(((unsigned long)p) & 0x3); | ||
1225 | if (fix > 0) p += 4 - fix; // align row read | ||
1226 | if (p >= buffer_end) break; | ||
1227 | } | ||
1228 | } | ||
1229 | } | ||
1230 | else if (bit_count == 32) | ||
1231 | { | ||
1232 | int none_zero_alpha = 0; | ||
1233 | pix = surface; | ||
1234 | for (y = 0; y < h; y++) | ||
1235 | { | ||
1236 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1237 | for (x = 0; x < w; x++) | ||
1238 | { | ||
1239 | b = p[0]; | ||
1240 | g = p[1]; | ||
1241 | r = p[2]; | ||
1242 | a = p[3]; | ||
1243 | if (a) none_zero_alpha = 1; | ||
1244 | if (!hasa) a = 0xff; | ||
1245 | *pix = ARGB_JOIN(a, r, g, b); | ||
1246 | p += 4 * scale_ratio; | ||
1247 | |||
1248 | if (p >= buffer_end) break; | ||
1249 | pix++; | ||
1250 | } | ||
1251 | if (scale_ratio > 1) | ||
1252 | { | ||
1253 | read_line += scale_ratio; | ||
1254 | if (read_line >= image_h) break; | ||
1255 | |||
1256 | position += row_size * (scale_ratio - 1); | ||
1257 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1258 | p = buffer; | ||
1259 | buffer_end = buffer + row_size; | ||
1260 | } | ||
1261 | else | ||
1262 | { | ||
1263 | fix = (int)(((unsigned long)p) & 0x3); | ||
1264 | if (fix > 0) p += 4 - fix; // align row read | ||
1265 | if (p >= buffer_end) break; | ||
1266 | } | ||
1267 | } | ||
1268 | if (!none_zero_alpha) | ||
1269 | { | ||
1270 | ie->flags.alpha = 0; | ||
1271 | if (hasa) | ||
1272 | { | ||
1273 | unsigned int *pixend = surface + (w * h); | ||
1274 | |||
1275 | for (pix = surface; pix < pixend; pix++) | ||
1276 | A_VAL(pix) = 0xff; | ||
1277 | } | ||
1278 | } | ||
1279 | } | ||
1280 | else | ||
1281 | goto close_file; | ||
1282 | } | ||
1283 | else if (comp == 3) // bit field | ||
1284 | { | ||
1285 | if (!read_uint(map, fsize, &position, &rmask)) goto close_file; | ||
1286 | if (!read_uint(map, fsize, &position, &gmask)) goto close_file; | ||
1287 | if (!read_uint(map, fsize, &position, &bmask)) goto close_file; | ||
1288 | |||
1289 | position = offset; | ||
1290 | if (scale_ratio == 1) | ||
1291 | buffer = malloc(image_size + 8); // add 8 for padding to avoid checks | ||
1292 | else | ||
1293 | buffer = malloc(row_size); // scale down is usually set because of memory issue, so read line by line | ||
1294 | |||
1295 | if (!buffer) | ||
1296 | { | ||
1297 | *error = EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED; | ||
1298 | goto close_file; | ||
1299 | } | ||
1300 | if (scale_ratio == 1) | ||
1301 | buffer_end = buffer + image_size; | ||
1302 | else | ||
1303 | buffer_end = buffer + row_size; | ||
1304 | |||
1305 | p = buffer; | ||
1306 | if (scale_ratio == 1) | ||
1307 | { | ||
1308 | if (!read_mem(map, fsize, &position, buffer, image_size)) goto close_file; | ||
1309 | } | ||
1310 | else | ||
1311 | { | ||
1312 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1313 | } | ||
1314 | |||
1315 | if ((bit_count == 16) && | ||
1316 | (rmask == 0xf800) && (gmask == 0x07e0) && (bmask == 0x001f) | ||
1317 | ) | ||
1318 | { | ||
1319 | unsigned short tmp; | ||
1320 | |||
1321 | pix = surface; | ||
1322 | for (y = 0; y < h; y++) | ||
1323 | { | ||
1324 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1325 | for (x = 0; x < w; x++) | ||
1326 | { | ||
1327 | tmp = *((unsigned short *)(p)); | ||
1328 | |||
1329 | r = (tmp >> 8) & 0xf8; r |= r >> 5; | ||
1330 | g = (tmp >> 3) & 0xfc; g |= g >> 6; | ||
1331 | b = (tmp << 3) & 0xf8; b |= b >> 5; | ||
1332 | *pix = ARGB_JOIN(0xff, r, g, b); | ||
1333 | |||
1334 | p += 2 * scale_ratio; | ||
1335 | |||
1336 | if (p >= buffer_end) break; | ||
1337 | pix++; | ||
1338 | } | ||
1339 | if (scale_ratio > 1) | ||
1340 | { | ||
1341 | read_line += scale_ratio; | ||
1342 | if (read_line >= image_h) break; | ||
1343 | |||
1344 | position += row_size * (scale_ratio - 1); | ||
1345 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1346 | p = buffer; | ||
1347 | buffer_end = buffer + row_size; | ||
1348 | } | ||
1349 | else | ||
1350 | { | ||
1351 | fix = (int)(((unsigned long)p) & 0x3); | ||
1352 | if (fix > 0) p += 4 - fix; // align row read | ||
1353 | if (p >= buffer_end) break; | ||
1354 | } | ||
1355 | } | ||
1356 | } | ||
1357 | else if ((bit_count == 16) && | ||
1358 | (rmask == 0x7c00) && (gmask == 0x03e0) && (bmask == 0x001f) | ||
1359 | ) | ||
1360 | { | ||
1361 | unsigned short tmp; | ||
1362 | pix = surface; | ||
1363 | for (y = 0; y < h; y++) | ||
1364 | { | ||
1365 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1366 | for (x = 0; x < w; x++) | ||
1367 | { | ||
1368 | tmp = *((unsigned short *)(p)); | ||
1369 | |||
1370 | r = (tmp >> 7) & 0xf8; r |= r >> 5; | ||
1371 | g = (tmp >> 2) & 0xf8; g |= g >> 5; | ||
1372 | b = (tmp << 3) & 0xf8; b |= b >> 5; | ||
1373 | *pix = ARGB_JOIN(0xff, r, g, b); | ||
1374 | p += 2 * scale_ratio; | ||
1375 | |||
1376 | if (p >= buffer_end) break; | ||
1377 | pix++; | ||
1378 | } | ||
1379 | if (scale_ratio > 1) | ||
1380 | { | ||
1381 | read_line += scale_ratio; | ||
1382 | if (read_line >= image_h) break; | ||
1383 | |||
1384 | position += row_size * (scale_ratio - 1); | ||
1385 | if (!read_mem(map, fsize, &position, buffer_end, row_size)) goto close_file; | ||
1386 | p = buffer; | ||
1387 | buffer_end = buffer + row_size; | ||
1388 | } | ||
1389 | else | ||
1390 | { | ||
1391 | fix = (int)(((unsigned long)p) & 0x3); | ||
1392 | if (fix > 0) p += 4 - fix; // align row read | ||
1393 | if (p >= buffer_end) break; | ||
1394 | } | ||
1395 | } | ||
1396 | } | ||
1397 | else if (bit_count == 32) | ||
1398 | { | ||
1399 | pix = surface; | ||
1400 | for (y = 0; y < h; y++) | ||
1401 | { | ||
1402 | if (!right_way_up) pix = surface + ((h - 1 - y) * w); | ||
1403 | for (x = 0; x < w; x++) | ||
1404 | { | ||
1405 | b = p[0]; | ||
1406 | g = p[1]; | ||
1407 | r = p[2]; | ||
1408 | a = p[3]; | ||
1409 | if (!hasa) a = 0xff; | ||
1410 | *pix = ARGB_JOIN(a, r, g, b); | ||
1411 | |||
1412 | p += 4 * scale_ratio; | ||
1413 | |||
1414 | if (p >= buffer_end) break; | ||
1415 | pix++; | ||
1416 | } | ||
1417 | if (scale_ratio > 1) | ||
1418 | { | ||
1419 | read_line += scale_ratio; | ||
1420 | if (read_line >= image_h) break; | ||
1421 | |||
1422 | position += row_size * (scale_ratio - 1); | ||
1423 | if (!read_mem(map, fsize, &position, buffer, row_size)) goto close_file; | ||
1424 | p = buffer; | ||
1425 | buffer_end = buffer + row_size; | ||
1426 | } | ||
1427 | else | ||
1428 | { | ||
1429 | fix = (int)(((unsigned long)p) & 0x3); | ||
1430 | if (fix > 0) p += 4 - fix; // align row read | ||
1431 | if (p >= buffer_end) break; | ||
1432 | } | ||
1433 | } | ||
1434 | } | ||
1435 | else | ||
1436 | goto close_file; | ||
1437 | } | ||
1438 | else if (comp == 4) // jpeg - only printer drivers | ||
1439 | { | ||
1440 | goto close_file; | ||
1441 | } | ||
1442 | else if (comp == 3) // png - only printer drivers | ||
1443 | { | ||
1444 | goto close_file; | ||
1445 | } | ||
1446 | else | ||
1447 | goto close_file; | ||
1448 | } | ||
1449 | else | ||
1450 | goto close_file; | ||
1451 | |||
1452 | if (buffer) free(buffer); | ||
1453 | if (scale_surface) free(scale_surface); | ||
1454 | |||
1455 | eina_file_map_free(f, map); | ||
1456 | eina_file_close(f); | ||
1457 | |||
1458 | evas_common_image_premul(ie); | ||
1459 | *error = EVAS_LOAD_ERROR_NONE; | ||
1460 | return EINA_TRUE; | ||
1461 | |||
1462 | close_file: | ||
1463 | if (buffer) free(buffer); | ||
1464 | if (scale_surface) free(scale_surface); | ||
1465 | if (map) eina_file_map_free(f, map); | ||
1466 | eina_file_close(f); | ||
1467 | return EINA_FALSE; | ||
1468 | } | ||
1469 | |||
1470 | static int | ||
1471 | module_open(Evas_Module *em) | ||
1472 | { | ||
1473 | if (!em) return 0; | ||
1474 | em->functions = (void *)(&evas_image_load_bmp_func); | ||
1475 | return 1; | ||
1476 | } | ||
1477 | |||
1478 | static void | ||
1479 | module_close(Evas_Module *em __UNUSED__) | ||
1480 | { | ||
1481 | } | ||
1482 | |||
1483 | static Evas_Module_Api evas_modapi = | ||
1484 | { | ||
1485 | EVAS_MODULE_API_VERSION, | ||
1486 | "bmp", | ||
1487 | "none", | ||
1488 | { | ||
1489 | module_open, | ||
1490 | module_close | ||
1491 | } | ||
1492 | }; | ||
1493 | |||
1494 | EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_IMAGE_LOADER, image_loader, bmp); | ||
1495 | |||
1496 | #ifndef EVAS_STATIC_BUILD_BMP | ||
1497 | EVAS_EINA_MODULE_DEFINE(image_loader, bmp); | ||
1498 | #endif | ||