/
IMG_xcf.c
898 lines (764 loc) · 22.3 KB
1
/*
2
SDL_image: An example image loading library for use with SDL
3
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
8
9
10
11
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
12
13
14
15
16
17
18
19
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
22
23
*/
/* This is a XCF image file loading framework */
24
#include "SDL_endian.h"
25
26
27
28
#include "SDL_image.h"
#ifdef LOAD_XCF
29
#if DEBUG
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
static char prop_names [][30] = {
"end",
"colormap",
"active_layer",
"active_channel",
"selection",
"floating_selection",
"opacity",
"mode",
"visible",
"linked",
"preserve_transparency",
"apply_mask",
"edit_mask",
"show_mask",
"show_masked",
"offsets",
"color",
"compression",
"guides",
"resolution",
"tattoo",
"parasites",
"unit",
"paths",
"user_unit"
};
57
58
#endif
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
typedef enum
{
PROP_END = 0,
PROP_COLORMAP = 1,
PROP_ACTIVE_LAYER = 2,
PROP_ACTIVE_CHANNEL = 3,
PROP_SELECTION = 4,
PROP_FLOATING_SELECTION = 5,
PROP_OPACITY = 6,
PROP_MODE = 7,
PROP_VISIBLE = 8,
PROP_LINKED = 9,
PROP_PRESERVE_TRANSPARENCY = 10,
PROP_APPLY_MASK = 11,
PROP_EDIT_MASK = 12,
PROP_SHOW_MASK = 13,
PROP_SHOW_MASKED = 14,
PROP_OFFSETS = 15,
PROP_COLOR = 16,
PROP_COMPRESSION = 17,
PROP_GUIDES = 18,
PROP_RESOLUTION = 19,
PROP_TATTOO = 20,
PROP_PARASITES = 21,
PROP_UNIT = 22,
PROP_PATHS = 23,
PROP_USER_UNIT = 24
} xcf_prop_type;
typedef enum {
COMPR_NONE = 0,
COMPR_RLE = 1,
COMPR_ZLIB = 2,
COMPR_FRACTAL = 3
} xcf_compr_type;
typedef enum {
IMAGE_RGB = 0,
IMAGE_GREYSCALE = 1,
IMAGE_INDEXED = 2
} xcf_image_type;
typedef struct {
Uint32 id;
Uint32 length;
union {
struct {
Uint32 num;
char * cmap;
} colormap; // 1
struct {
Uint32 drawable_offset;
} floating_selection; // 5
Sint32 opacity;
Sint32 mode;
int visible;
int linked;
int preserve_transparency;
int apply_mask;
int show_mask;
struct {
Sint32 x;
Sint32 y;
} offset;
unsigned char color [3];
Uint8 compression;
struct {
Sint32 x;
Sint32 y;
} resolution;
struct {
char * name;
Uint32 flags;
Uint32 size;
char * data;
} parasite;
} data;
} xcf_prop;
typedef struct {
char sign [14];
Uint32 width;
Uint32 height;
Sint32 image_type;
xcf_prop * properties;
Uint32 * layer_file_offsets;
Uint32 * channel_file_offsets;
xcf_compr_type compr;
Uint32 cm_num;
unsigned char * cm_map;
} xcf_header;
typedef struct {
Uint32 width;
Uint32 height;
Sint32 layer_type;
char * name;
xcf_prop * properties;
Uint32 hierarchy_file_offset;
Uint32 layer_mask_offset;
Uint32 offset_x;
Uint32 offset_y;
166
int visible;
167
168
169
170
171
172
173
174
175
176
177
178
} xcf_layer;
typedef struct {
Uint32 width;
Uint32 height;
char * name;
xcf_prop * properties;
Uint32 hierarchy_file_offset;
Uint32 color;
Uint32 opacity;
179
180
int selection;
int visible;
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
} xcf_channel;
typedef struct {
Uint32 width;
Uint32 height;
Uint32 bpp;
Uint32 * level_file_offsets;
} xcf_hierarchy;
typedef struct {
Uint32 width;
Uint32 height;
Uint32 * tile_file_offsets;
} xcf_level;
typedef unsigned char * xcf_tile;
typedef unsigned char * (* load_tile_type) (SDL_RWops *, Uint32, int, int, int);
/* See if an image is contained in a data source */
204
205
int IMG_isXCF(SDL_RWops *src)
{
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
Sint64 start;
int is_XCF;
char magic[14];
if ( !src )
return 0;
start = SDL_RWtell(src);
is_XCF = 0;
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
if (SDL_strncmp(magic, "gimp xcf ", 9) == 0) {
is_XCF = 1;
}
}
SDL_RWseek(src, start, RW_SEEK_SET);
return(is_XCF);
221
222
223
224
225
226
}
static char * read_string (SDL_RWops * src) {
Uint32 tmp;
char * data;
227
tmp = SDL_ReadBE32(src);
228
Sint64 remaining = SDL_RWsize(src) - SDL_RWtell(src);
229
if (tmp > 0 && tmp <= remaining) {
230
data = (char *) SDL_malloc (sizeof (char) * tmp);
231
232
233
234
235
if (data) {
SDL_RWread(src, data, tmp, 1);
data[tmp - 1] = '\0';
}
} else {
236
237
238
239
240
241
242
243
244
245
246
247
248
249
data = NULL;
}
return data;
}
static Uint32 Swap32 (Uint32 v) {
return
((v & 0x000000FF) << 16)
| ((v & 0x0000FF00))
| ((v & 0x00FF0000) >> 16)
| ((v & 0xFF000000));
}
250
static void xcf_read_property (SDL_RWops * src, xcf_prop * prop) {
251
Uint32 len;
252
253
254
prop->id = SDL_ReadBE32 (src);
prop->length = SDL_ReadBE32 (src);
255
#if DEBUG
256
printf ("%.8X: %s: %d\n", SDL_RWtell (src), prop->id < 25 ? prop_names [prop->id] : "unknown", prop->length);
257
#endif
258
259
260
261
switch (prop->id) {
case PROP_COLORMAP:
prop->data.colormap.num = SDL_ReadBE32 (src);
262
prop->data.colormap.cmap = (char *) SDL_malloc (sizeof (char) * prop->data.colormap.num * 3);
263
264
265
266
267
268
269
270
271
272
273
274
SDL_RWread (src, prop->data.colormap.cmap, prop->data.colormap.num*3, 1);
break;
case PROP_OFFSETS:
prop->data.offset.x = SDL_ReadBE32 (src);
prop->data.offset.y = SDL_ReadBE32 (src);
break;
case PROP_OPACITY:
prop->data.opacity = SDL_ReadBE32 (src);
break;
case PROP_COMPRESSION:
case PROP_COLOR:
275
276
277
278
279
280
if (prop->length > sizeof(prop->data)) {
len = sizeof(prop->data);
} else {
len = prop->length;
}
SDL_RWread(src, &prop->data, len, 1);
281
break;
282
283
284
case PROP_VISIBLE:
prop->data.visible = SDL_ReadBE32 (src);
break;
285
286
default:
// SDL_RWread (src, &prop->data, prop->length, 1);
287
SDL_RWseek (src, prop->length, RW_SEEK_CUR);
288
289
290
}
}
291
static void free_xcf_header (xcf_header * h) {
292
if (h->cm_num)
293
SDL_free (h->cm_map);
294
if (h->layer_file_offsets)
295
SDL_free (h->layer_file_offsets);
296
SDL_free (h);
297
298
}
299
static xcf_header * read_xcf_header (SDL_RWops * src) {
300
301
302
xcf_header * h;
xcf_prop prop;
303
h = (xcf_header *) SDL_malloc (sizeof (xcf_header));
304
305
306
if (!h) {
return NULL;
}
307
308
309
310
311
312
SDL_RWread (src, h->sign, 14, 1);
h->width = SDL_ReadBE32 (src);
h->height = SDL_ReadBE32 (src);
h->image_type = SDL_ReadBE32 (src);
h->properties = NULL;
313
h->layer_file_offsets = NULL;
314
315
316
317
318
319
320
321
h->compr = COMPR_NONE;
h->cm_num = 0;
h->cm_map = NULL;
// Just read, don't save
do {
xcf_read_property (src, &prop);
if (prop.id == PROP_COMPRESSION)
322
h->compr = (xcf_compr_type)prop.data.compression;
323
else if (prop.id == PROP_COLORMAP) {
324
// unused var: int i;
325
326
327
328
329
330
331
332
333
334
Uint32 cm_num;
unsigned char *cm_map;
cm_num = prop.data.colormap.num;
cm_map = (unsigned char *) SDL_realloc(h->cm_map, sizeof (unsigned char) * 3 * cm_num);
if (cm_map) {
h->cm_num = cm_num;
h->cm_map = cm_map;
SDL_memcpy (h->cm_map, prop.data.colormap.cmap, 3*sizeof (char)*h->cm_num);
}
335
SDL_free (prop.data.colormap.cmap);
336
337
338
339
340
if (!cm_map) {
free_xcf_header(h);
return NULL;
}
341
342
343
344
345
346
}
} while (prop.id != PROP_END);
return h;
}
347
static void free_xcf_layer (xcf_layer * l) {
348
349
SDL_free (l->name);
SDL_free (l);
350
351
}
352
static xcf_layer * read_xcf_layer (SDL_RWops * src) {
353
354
355
xcf_layer * l;
xcf_prop prop;
356
l = (xcf_layer *) SDL_malloc (sizeof (xcf_layer));
357
358
359
360
361
362
363
364
365
366
367
l->width = SDL_ReadBE32 (src);
l->height = SDL_ReadBE32 (src);
l->layer_type = SDL_ReadBE32 (src);
l->name = read_string (src);
do {
xcf_read_property (src, &prop);
if (prop.id == PROP_OFFSETS) {
l->offset_x = prop.data.offset.x;
l->offset_y = prop.data.offset.y;
368
369
} else if (prop.id == PROP_VISIBLE) {
l->visible = prop.data.visible ? 1 : 0;
370
371
372
373
374
375
376
377
378
}
} while (prop.id != PROP_END);
l->hierarchy_file_offset = SDL_ReadBE32 (src);
l->layer_mask_offset = SDL_ReadBE32 (src);
return l;
}
379
static void free_xcf_channel (xcf_channel * c) {
380
381
SDL_free (c->name);
SDL_free (c);
382
383
}
384
static xcf_channel * read_xcf_channel (SDL_RWops * src) {
385
386
387
xcf_channel * l;
xcf_prop prop;
388
l = (xcf_channel *) SDL_malloc (sizeof (xcf_channel));
389
390
391
392
393
394
395
396
397
398
399
400
401
402
l->width = SDL_ReadBE32 (src);
l->height = SDL_ReadBE32 (src);
l->name = read_string (src);
l->selection = 0;
do {
xcf_read_property (src, &prop);
switch (prop.id) {
case PROP_OPACITY:
l->opacity = prop.data.opacity << 24;
break;
case PROP_COLOR:
l->color = ((Uint32) prop.data.color[0] << 16)
403
404
| ((Uint32) prop.data.color[1] << 8)
| ((Uint32) prop.data.color[2]);
405
406
407
408
break;
case PROP_SELECTION:
l->selection = 1;
break;
409
410
411
case PROP_VISIBLE:
l->visible = prop.data.visible ? 1 : 0;
break;
412
default:
413
;
414
415
416
417
418
419
420
421
}
} while (prop.id != PROP_END);
l->hierarchy_file_offset = SDL_ReadBE32 (src);
return l;
}
422
static void free_xcf_hierarchy (xcf_hierarchy * h) {
423
424
SDL_free (h->level_file_offsets);
SDL_free (h);
425
426
}
427
static xcf_hierarchy * read_xcf_hierarchy (SDL_RWops * src) {
428
429
430
xcf_hierarchy * h;
int i;
431
h = (xcf_hierarchy *) SDL_malloc (sizeof (xcf_hierarchy));
432
433
434
435
436
437
438
h->width = SDL_ReadBE32 (src);
h->height = SDL_ReadBE32 (src);
h->bpp = SDL_ReadBE32 (src);
h->level_file_offsets = NULL;
i = 0;
do {
439
h->level_file_offsets = (Uint32 *) SDL_realloc (h->level_file_offsets, sizeof (Uint32) * (i+1));
440
441
442
443
444
445
h->level_file_offsets [i] = SDL_ReadBE32 (src);
} while (h->level_file_offsets [i++]);
return h;
}
446
static void free_xcf_level (xcf_level * l) {
447
448
SDL_free (l->tile_file_offsets);
SDL_free (l);
449
450
}
451
static xcf_level * read_xcf_level (SDL_RWops * src) {
452
453
454
xcf_level * l;
int i;
455
l = (xcf_level *) SDL_malloc (sizeof (xcf_level));
456
457
458
459
460
461
l->width = SDL_ReadBE32 (src);
l->height = SDL_ReadBE32 (src);
l->tile_file_offsets = NULL;
i = 0;
do {
462
l->tile_file_offsets = (Uint32 *) SDL_realloc (l->tile_file_offsets, sizeof (Uint32) * (i+1));
463
464
465
466
467
468
l->tile_file_offsets [i] = SDL_ReadBE32 (src);
} while (l->tile_file_offsets [i++]);
return l;
}
469
static void free_xcf_tile (unsigned char * t) {
470
SDL_free (t);
471
472
}
473
static unsigned char * load_xcf_tile_none (SDL_RWops * src, Uint32 len, int bpp, int x, int y) {
474
475
unsigned char * load;
476
load = (unsigned char *) SDL_malloc (len); // expect this is okay
477
478
479
480
481
SDL_RWread (src, load, len, 1);
return load;
}
482
static unsigned char * load_xcf_tile_rle (SDL_RWops * src, Uint32 len, int bpp, int x, int y) {
483
484
485
486
487
unsigned char * load, * t, * data, * d;
Uint32 reallen;
int i, size, count, j, length;
unsigned char val;
488
489
490
491
if (len == 0) { /* probably bogus data. */
return NULL;
}
492
t = load = (unsigned char *) SDL_malloc (len);
493
494
reallen = SDL_RWread (src, t, 1, len);
495
data = (unsigned char *) SDL_calloc (1, x*y*bpp);
496
497
498
499
for (i = 0; i < bpp; i++) {
d = data + i;
size = x*y;
count = 0;
500
501
502
503
504
505
while (size > 0) {
val = *t++;
length = val;
if (length >= 128) {
506
507
508
509
510
length = 255 - (length - 1);
if (length == 128) {
length = (*t << 8) + t[1];
t += 2;
}
511
512
513
514
515
516
517
if (((size_t) (t - load) + length) >= len) {
break; /* bogus data */
} else if (length > size) {
break; /* bogus data */
}
518
519
count += length;
size -= length;
520
521
522
523
524
525
526
527
528
529
530
while (length-- > 0) {
*d = *t++;
d += bpp;
}
} else {
length += 1;
if (length == 128) {
length = (*t << 8) + t[1];
t += 2;
}
531
532
533
534
535
536
537
if (((size_t) (t - load)) >= len) {
break; /* bogus data */
} else if (length > size) {
break; /* bogus data */
}
538
539
count += length;
size -= length;
540
541
val = *t++;
542
543
544
545
546
for (j = 0; j < length; j++) {
*d = val;
d += bpp;
}
547
548
}
}
549
550
551
552
553
if (size > 0) {
break; /* just drop out, untouched data initialized to zero. */
}
554
555
}
556
SDL_free (load);
557
558
559
560
561
return (data);
}
static Uint32 rgb2grey (Uint32 a) {
Uint8 l;
562
563
564
l = (Uint8)(0.2990 * ((a & 0x00FF0000) >> 16)
+ 0.5870 * ((a & 0x0000FF00) >> 8)
+ 0.1140 * ((a & 0x000000FF)));
565
566
567
568
return (l << 16) | (l << 8) | l;
}
569
static void create_channel_surface (SDL_Surface * surf, xcf_image_type itype, Uint32 color, Uint32 opacity) {
570
Uint32 c = 0;
571
572
573
574
575
576
577
578
579
580
581
582
583
switch (itype) {
case IMAGE_RGB:
case IMAGE_INDEXED:
c = opacity | color;
break;
case IMAGE_GREYSCALE:
c = opacity | rgb2grey (color);
break;
}
SDL_FillRect (surf, NULL, c);
}
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
static int
do_layer_surface(SDL_Surface * surface, SDL_RWops * src, xcf_header * head, xcf_layer * layer, load_tile_type load_tile)
{
xcf_hierarchy *hierarchy;
xcf_level *level;
unsigned char *tile;
Uint8 *p8;
Uint16 *p16;
Uint32 *p;
int i, j;
Uint32 x, y, tx, ty, ox, oy;
Uint32 *row;
SDL_RWseek(src, layer->hierarchy_file_offset, RW_SEEK_SET);
hierarchy = read_xcf_hierarchy(src);
600
601
602
603
604
605
606
607
608
609
610
611
if (hierarchy->bpp > 4) { /* unsupported. */
SDL_Log("Unknown Gimp image bpp (%u)\n", (unsigned int) hierarchy->bpp);
free_xcf_hierarchy(hierarchy);
return 1;
}
if ((hierarchy->width > 20000) || (hierarchy->height > 20000)) { /* arbitrary limit to avoid integer overflow. */
SDL_Log("Gimp image too large (%ux%u)\n", (unsigned int) hierarchy->width, (unsigned int) hierarchy->height);
free_xcf_hierarchy(hierarchy);
return 1;
}
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
level = NULL;
for (i = 0; hierarchy->level_file_offsets[i]; i++) {
SDL_RWseek(src, hierarchy->level_file_offsets[i], RW_SEEK_SET);
level = read_xcf_level(src);
ty = tx = 0;
for (j = 0; level->tile_file_offsets[j]; j++) {
SDL_RWseek(src, level->tile_file_offsets[j], RW_SEEK_SET);
ox = tx + 64 > level->width ? level->width % 64 : 64;
oy = ty + 64 > level->height ? level->height % 64 : 64;
if (level->tile_file_offsets[j + 1]) {
tile = load_tile(src, level->tile_file_offsets[j + 1] - level->tile_file_offsets[j], hierarchy->bpp, ox, oy);
} else {
tile = load_tile(src, ox * oy * 6, hierarchy->bpp, ox, oy);
}
629
630
631
632
633
634
635
636
637
638
if (!tile) {
if (hierarchy) {
free_xcf_hierarchy(hierarchy);
}
if (level) {
free_xcf_level(level);
}
return 1;
}
639
640
641
642
p8 = tile;
p16 = (Uint16 *) p8;
p = (Uint32 *) p8;
for (y = ty; y < ty + oy; y++) {
643
644
645
if ((ty >= surface->h) || ((tx+ox) > surface->w)) {
break;
}
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
row = (Uint32 *) ((Uint8 *) surface->pixels + y * surface->pitch + tx * 4);
switch (hierarchy->bpp) {
case 4:
for (x = tx; x < tx + ox; x++)
*row++ = Swap32(*p++);
break;
case 3:
for (x = tx; x < tx + ox; x++) {
*row = 0xFF000000;
*row |= ((Uint32)*p8++ << 16);
*row |= ((Uint32)*p8++ << 8);
*row |= ((Uint32)*p8++ << 0);
row++;
}
break;
case 2:
/* Indexed / Greyscale + Alpha */
switch (head->image_type) {
case IMAGE_INDEXED:
for (x = tx; x < tx + ox; x++) {
*row = ((Uint32)(head->cm_map[*p8 * 3]) << 16);
*row |= ((Uint32)(head->cm_map[*p8 * 3 + 1]) << 8);
*row |= ((Uint32)(head->cm_map[*p8++ * 3 + 2]) << 0);
*row |= ((Uint32)*p8++ << 24);
row++;
}
break;
case IMAGE_GREYSCALE:
for (x = tx; x < tx + ox; x++) {
*row = ((Uint32)*p8 << 16);
*row |= ((Uint32)*p8 << 8);
*row |= ((Uint32)*p8++ << 0);
*row |= ((Uint32)*p8++ << 24);
row++;
}
break;
default:
683
SDL_Log("Unknown Gimp image type (%d)\n", head->image_type);
684
685
686
687
688
689
690
691
692
693
if (hierarchy) {
free_xcf_hierarchy(hierarchy);
}
if (level)
free_xcf_level(level);
return 1;
}
break;
case 1:
/* Indexed / Greyscale */
694
switch (head->image_type) {
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
case IMAGE_INDEXED:
for (x = tx; x < tx + ox; x++) {
*row++ = 0xFF000000
| ((Uint32)(head->cm_map[*p8 * 3]) << 16)
| ((Uint32)(head->cm_map[*p8 * 3 + 1]) << 8)
| ((Uint32)(head->cm_map[*p8 * 3 + 2]) << 0);
p8++;
}
break;
case IMAGE_GREYSCALE:
for (x = tx; x < tx + ox; x++) {
*row++ = 0xFF000000
| (((Uint32)(*p8)) << 16)
| (((Uint32)(*p8)) << 8)
| (((Uint32)(*p8)) << 0);
++p8;
}
break;
default:
714
SDL_Log("Unknown Gimp image type (%d)\n", head->image_type);
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
if (tile)
free_xcf_tile(tile);
if (level)
free_xcf_level(level);
if (hierarchy)
free_xcf_hierarchy(hierarchy);
return 1;
}
break;
}
}
free_xcf_tile(tile);
tx += 64;
if (tx >= level->width) {
tx = 0;
ty += 64;
}
if (ty >= level->height) {
break;
}
736
}
737
free_xcf_level(level);
738
}
739
740
free_xcf_hierarchy(hierarchy);
741
742
return 0;
743
744
}
745
746
SDL_Surface *IMG_LoadXCF_RW(SDL_RWops *src)
{
747
Sint64 start;
748
const char *error = NULL;
749
750
751
752
SDL_Surface *surface, *lays;
xcf_header * head;
xcf_layer * layer;
xcf_channel ** channel;
753
int chnls, i, offsets;
754
Sint64 offset, fp;
755
756
757
unsigned char * (* load_tile) (SDL_RWops *, Uint32, int, int, int);
758
if (!src) {
759
760
761
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
762
start = SDL_RWtell(src);
763
764
765
766
/* Initialize the data we will clean up when we're done */
surface = NULL;
767
768
769
770
head = read_xcf_header(src);
if (!head) {
return NULL;
}
771
772
773
774
775
776
777
778
779
switch (head->compr) {
case COMPR_NONE:
load_tile = load_xcf_tile_none;
break;
case COMPR_RLE:
load_tile = load_xcf_tile_rle;
break;
default:
780
SDL_Log("Unsupported Compression.\n");
781
782
783
784
785
free_xcf_header (head);
return NULL;
}
/* Create the surface of the appropriate type */
786
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, head->width, head->height, 32,
787
0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
788
789
if ( surface == NULL ) {
790
error = "Out of memory";
791
792
793
794
795
goto done;
}
offsets = 0;
796
while ((offset = SDL_ReadBE32 (src))) {
797
head->layer_file_offsets = (Uint32 *) SDL_realloc (head->layer_file_offsets, sizeof (Uint32) * (offsets+1));
798
head->layer_file_offsets [offsets] = (Uint32)offset;
799
800
801
offsets++;
}
fp = SDL_RWtell (src);
802
803
lays = SDL_CreateRGBSurface(SDL_SWSURFACE, head->width, head->height, 32,
804
0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
805
806
if ( lays == NULL ) {
807
error = "Out of memory";
808
809
810
811
812
813
goto done;
}
// Blit layers backwards, because Gimp saves them highest first
for (i = offsets; i > 0; i--) {
SDL_Rect rs, rd;
814
SDL_RWseek (src, head->layer_file_offsets [i-1], RW_SEEK_SET);
815
816
817
818
819
820
821
822
823
824
825
826
layer = read_xcf_layer (src);
do_layer_surface (lays, src, head, layer, load_tile);
rs.x = 0;
rs.y = 0;
rs.w = layer->width;
rs.h = layer->height;
rd.x = layer->offset_x;
rd.y = layer->offset_y;
rd.w = layer->width;
rd.h = layer->height;
827
828
829
if (layer->visible)
SDL_BlitSurface (lays, &rs, surface, &rd);
free_xcf_layer (layer);
830
831
832
833
}
SDL_FreeSurface (lays);
834
SDL_RWseek (src, fp, RW_SEEK_SET);
835
836
837
838
// read channels
channel = NULL;
chnls = 0;
839
while ((offset = SDL_ReadBE32 (src))) {
840
channel = (xcf_channel **) SDL_realloc (channel, sizeof (xcf_channel *) * (chnls+1));
841
fp = SDL_RWtell (src);
842
SDL_RWseek (src, offset, RW_SEEK_SET);
843
channel [chnls++] = (read_xcf_channel (src));
844
SDL_RWseek (src, fp, RW_SEEK_SET);
845
846
847
848
849
}
if (chnls) {
SDL_Surface * chs;
850
chs = SDL_CreateRGBSurface(SDL_SWSURFACE, head->width, head->height, 32,
851
0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
852
853
if (chs == NULL) {
854
error = "Out of memory";
855
856
857
858
goto done;
}
for (i = 0; i < chnls; i++) {
// printf ("CNLBLT %i\n", i);
859
if (!channel [i]->selection && channel [i]->visible) {
860
861
create_channel_surface (chs, (xcf_image_type)head->image_type, channel [i]->color, channel [i]->opacity);
SDL_BlitSurface (chs, NULL, surface, NULL);
862
863
864
}
free_xcf_channel (channel [i]);
}
865
SDL_free(channel);
866
867
868
869
SDL_FreeSurface (chs);
}
870
done:
871
free_xcf_header (head);
872
if ( error ) {
873
SDL_RWseek(src, start, RW_SEEK_SET);
874
875
876
877
if ( surface ) {
SDL_FreeSurface(surface);
surface = NULL;
}
878
IMG_SetError("%s", error);
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
}
return(surface);
}
#else
/* See if an image is contained in a data source */
int IMG_isXCF(SDL_RWops *src)
{
return(0);
}
/* Load a XCF type image from an SDL datasource */
SDL_Surface *IMG_LoadXCF_RW(SDL_RWops *src)
{
return(NULL);
}
#endif /* LOAD_XCF */