/
IMG_gif.c
646 lines (553 loc) · 16.1 KB
1
/*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
SDL_image: An example image loading library for use with SDL
Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>
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.
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:
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
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
24
25
26
27
28
29
30
31
32
33
34
35
/* This is a GIF image file loading framework */
#include <stdio.h>
#include <string.h>
#include "SDL_image.h"
#ifdef LOAD_GIF
/* See if an image is contained in a data source */
int IMG_isGIF(SDL_RWops *src)
{
36
int start;
37
38
39
int is_GIF;
char magic[6];
40
41
if ( !src )
return 0;
42
start = SDL_RWtell(src);
43
is_GIF = 0;
44
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
45
46
47
48
49
50
if ( (strncmp(magic, "GIF", 3) == 0) &&
((memcmp(magic + 3, "87a", 3) == 0) ||
(memcmp(magic + 3, "89a", 3) == 0)) ) {
is_GIF = 1;
}
}
51
SDL_RWseek(src, start, RW_SEEK_SET);
52
53
54
55
56
57
58
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
return(is_GIF);
}
/* Code from here to end of file has been adapted from XPaint: */
/* +-------------------------------------------------------------------+ */
/* | Copyright 1990, 1991, 1993 David Koblas. | */
/* | Copyright 1996 Torsten Martinsen. | */
/* | Permission to use, copy, modify, and distribute this software | */
/* | and its documentation for any purpose and without fee is hereby | */
/* | granted, provided that the above copyright notice appear in all | */
/* | copies and that both that copyright notice and this permission | */
/* | notice appear in supporting documentation. This software is | */
/* | provided "as is" without express or implied warranty. | */
/* +-------------------------------------------------------------------+ */
/* Adapted for use in SDL by Sam Lantinga -- 7/20/98 */
#define USED_BY_SDL
#include <stdio.h>
#include <string.h>
#ifdef USED_BY_SDL
/* Changes to work with SDL:
Include SDL header file
Use SDL_Surface rather than xpaint Image structure
Define SDL versions of RWSetMsg(), ImageNewCmap() and ImageSetCmap()
*/
#include "SDL.h"
#define Image SDL_Surface
#define RWSetMsg IMG_SetError
#define ImageNewCmap(w, h, s) SDL_AllocSurface(SDL_SWSURFACE,w,h,8,0,0,0,0)
#define ImageSetCmap(s, i, R, G, B) do { \
s->format->palette->colors[i].r = R; \
s->format->palette->colors[i].g = G; \
s->format->palette->colors[i].b = B; \
} while (0)
/* * * * * */
#else
/* Original XPaint sources */
#include "image.h"
#include "rwTable.h"
#define SDL_RWops FILE
#define SDL_RWclose fclose
#endif /* USED_BY_SDL */
#define MAXCOLORMAPSIZE 256
#define TRUE 1
#define FALSE 0
#define CM_RED 0
#define CM_GREEN 1
#define CM_BLUE 2
#define MAX_LWZ_BITS 12
#define INTERLACE 0x40
#define LOCALCOLORMAP 0x80
#define BitSet(byte, bit) (((byte) & (bit)) == (bit))
#define ReadOK(file,buffer,len) SDL_RWread(file, buffer, len, 1)
#define LM_to_uint(a,b) (((b)<<8)|(a))
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
typedef struct {
struct {
unsigned int Width;
unsigned int Height;
unsigned char ColorMap[3][MAXCOLORMAPSIZE];
unsigned int BitPixel;
unsigned int ColorResolution;
unsigned int Background;
unsigned int AspectRatio;
int GrayScale;
} GifScreen;
struct {
int transparent;
int delayTime;
int inputFlag;
int disposal;
} Gif89;
unsigned char buf[280];
int curbit, lastbit, done, last_byte;
int fresh;
int code_size, set_code_size;
int max_code, max_code_size;
int firstcode, oldcode;
int clear_code, end_code;
int table[2][(1 << MAX_LWZ_BITS)];
int stack[(1 << (MAX_LWZ_BITS)) * 2], *sp;
int ZeroDataBlock;
} State_t;
156
157
158
static int ReadColorMap(SDL_RWops * src, int number,
unsigned char buffer[3][MAXCOLORMAPSIZE], int *flag);
159
160
161
162
static int DoExtension(SDL_RWops * src, int label, State_t * state);
static int GetDataBlock(SDL_RWops * src, unsigned char *buf, State_t * state);
static int GetCode(SDL_RWops * src, int code_size, int flag, State_t * state);
static int LWZReadByte(SDL_RWops * src, int flag, int input_code_size, State_t * state);
163
164
static Image *ReadImage(SDL_RWops * src, int len, int height, int,
unsigned char cmap[3][MAXCOLORMAPSIZE],
165
int gray, int interlace, int ignore, State_t * state);
166
167
168
169
Image *
IMG_LoadGIF_RW(SDL_RWops *src)
{
170
int start;
171
172
173
174
175
176
177
178
179
180
unsigned char buf[16];
unsigned char c;
unsigned char localColorMap[3][MAXCOLORMAPSIZE];
int grayScale;
int useGlobalColormap;
int bitPixel;
int imageCount = 0;
char version[4];
int imageNumber = 1;
Image *image = NULL;
181
182
183
184
State_t state;
state.ZeroDataBlock = FALSE;
state.fresh = FALSE;
state.last_byte = 0;
185
186
if ( src == NULL ) {
187
return NULL;
188
}
189
190
start = SDL_RWtell(src);
191
192
193
194
195
196
197
198
if (!ReadOK(src, buf, 6)) {
RWSetMsg("error reading magic number");
goto done;
}
if (strncmp((char *) buf, "GIF", 3) != 0) {
RWSetMsg("not a GIF file");
goto done;
}
199
memcpy(version, (char *) buf + 3, 3);
200
201
202
203
204
205
version[3] = '\0';
if ((strcmp(version, "87a") != 0) && (strcmp(version, "89a") != 0)) {
RWSetMsg("bad version number, not '87a' or '89a'");
goto done;
}
206
207
208
209
state.Gif89.transparent = -1;
state.Gif89.delayTime = -1;
state.Gif89.inputFlag = -1;
state.Gif89.disposal = 0;
210
211
212
213
214
if (!ReadOK(src, buf, 7)) {
RWSetMsg("failed to read screen descriptor");
goto done;
}
215
216
217
218
219
220
state.GifScreen.Width = LM_to_uint(buf[0], buf[1]);
state.GifScreen.Height = LM_to_uint(buf[2], buf[3]);
state.GifScreen.BitPixel = 2 << (buf[4] & 0x07);
state.GifScreen.ColorResolution = (((buf[4] & 0x70) >> 3) + 1);
state.GifScreen.Background = buf[5];
state.GifScreen.AspectRatio = buf[6];
221
222
if (BitSet(buf[4], LOCALCOLORMAP)) { /* Global Colormap */
223
224
if (ReadColorMap(src, state.GifScreen.BitPixel,
state.GifScreen.ColorMap, &state.GifScreen.GrayScale)) {
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
RWSetMsg("error reading global colormap");
goto done;
}
}
do {
if (!ReadOK(src, &c, 1)) {
RWSetMsg("EOF / read error on image data");
goto done;
}
if (c == ';') { /* GIF terminator */
if (imageCount < imageNumber) {
RWSetMsg("only %d image%s found in file",
imageCount, imageCount > 1 ? "s" : "");
goto done;
}
}
if (c == '!') { /* Extension */
if (!ReadOK(src, &c, 1)) {
RWSetMsg("EOF / read error on extention function code");
goto done;
}
246
DoExtension(src, c, &state);
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
continue;
}
if (c != ',') { /* Not a valid start character */
continue;
}
++imageCount;
if (!ReadOK(src, buf, 9)) {
RWSetMsg("couldn't read left/top/width/height");
goto done;
}
useGlobalColormap = !BitSet(buf[8], LOCALCOLORMAP);
bitPixel = 1 << ((buf[8] & 0x07) + 1);
if (!useGlobalColormap) {
if (ReadColorMap(src, bitPixel, localColorMap, &grayScale)) {
RWSetMsg("error reading local colormap");
goto done;
}
image = ReadImage(src, LM_to_uint(buf[4], buf[5]),
LM_to_uint(buf[6], buf[7]),
bitPixel, localColorMap, grayScale,
BitSet(buf[8], INTERLACE),
271
imageCount != imageNumber, &state);
272
273
274
} else {
image = ReadImage(src, LM_to_uint(buf[4], buf[5]),
LM_to_uint(buf[6], buf[7]),
275
276
277
state.GifScreen.BitPixel, state.GifScreen.ColorMap,
state.GifScreen.GrayScale, BitSet(buf[8], INTERLACE),
imageCount != imageNumber, &state);
278
279
280
281
}
} while (image == NULL);
#ifdef USED_BY_SDL
282
283
if ( state.Gif89.transparent >= 0 ) {
SDL_SetColorKey(image, SDL_SRCCOLORKEY, state.Gif89.transparent);
284
285
286
287
}
#endif
done:
288
if ( image == NULL ) {
289
SDL_RWseek(src, start, RW_SEEK_SET);
290
}
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
return image;
}
static int
ReadColorMap(SDL_RWops *src, int number,
unsigned char buffer[3][MAXCOLORMAPSIZE], int *gray)
{
int i;
unsigned char rgb[3];
int flag;
flag = TRUE;
for (i = 0; i < number; ++i) {
if (!ReadOK(src, rgb, sizeof(rgb))) {
RWSetMsg("bad colormap");
return 1;
}
buffer[CM_RED][i] = rgb[0];
buffer[CM_GREEN][i] = rgb[1];
buffer[CM_BLUE][i] = rgb[2];
flag &= (rgb[0] == rgb[1] && rgb[1] == rgb[2]);
}
#if 0
if (flag)
*gray = (number == 2) ? PBM_TYPE : PGM_TYPE;
else
*gray = PPM_TYPE;
#else
*gray = 0;
#endif
return FALSE;
}
static int
328
DoExtension(SDL_RWops *src, int label, State_t * state)
329
{
330
unsigned char buf[256];
331
332
333
334
335
336
337
338
339
340
341
char *str;
switch (label) {
case 0x01: /* Plain Text Extension */
str = "Plain Text Extension";
break;
case 0xff: /* Application Extension */
str = "Application Extension";
break;
case 0xfe: /* Comment Extension */
str = "Comment Extension";
342
while (GetDataBlock(src, (unsigned char *) buf, state) > 0)
343
;
344
345
346
return FALSE;
case 0xf9: /* Graphic Control Extension */
str = "Graphic Control Extension";
347
348
349
350
(void) GetDataBlock(src, (unsigned char *) buf, state);
state->Gif89.disposal = (buf[0] >> 2) & 0x7;
state->Gif89.inputFlag = (buf[0] >> 1) & 0x1;
state->Gif89.delayTime = LM_to_uint(buf[1], buf[2]);
351
if ((buf[0] & 0x1) != 0)
352
state->Gif89.transparent = buf[3];
353
354
while (GetDataBlock(src, (unsigned char *) buf, state) > 0)
355
;
356
357
358
359
360
361
362
return FALSE;
default:
str = (char *)buf;
sprintf(str, "UNKNOWN (0x%02x)", label);
break;
}
363
while (GetDataBlock(src, (unsigned char *) buf, state) > 0)
364
;
365
366
367
368
369
return FALSE;
}
static int
370
GetDataBlock(SDL_RWops *src, unsigned char *buf, State_t * state)
371
372
373
374
375
376
377
{
unsigned char count;
if (!ReadOK(src, &count, 1)) {
/* pm_message("error in getting DataBlock size" ); */
return -1;
}
378
state->ZeroDataBlock = count == 0;
379
380
381
382
383
384
385
386
387
if ((count != 0) && (!ReadOK(src, buf, count))) {
/* pm_message("error in reading DataBlock" ); */
return -1;
}
return count;
}
static int
388
GetCode(SDL_RWops *src, int code_size, int flag, State_t * state)
389
390
391
392
393
{
int i, j, ret;
unsigned char count;
if (flag) {
394
395
396
state->curbit = 0;
state->lastbit = 0;
state->done = FALSE;
397
398
return 0;
}
399
400
401
if ((state->curbit + code_size) >= state->lastbit) {
if (state->done) {
if (state->curbit >= state->lastbit)
402
403
404
RWSetMsg("ran off the end of my bits");
return -1;
}
405
406
state->buf[0] = state->buf[state->last_byte - 2];
state->buf[1] = state->buf[state->last_byte - 1];
407
408
409
if ((count = GetDataBlock(src, &state->buf[2], state)) <= 0)
state->done = TRUE;
410
411
412
413
state->last_byte = 2 + count;
state->curbit = (state->curbit - state->lastbit) + 16;
state->lastbit = (2 + count) * 8;
414
415
}
ret = 0;
416
417
for (i = state->curbit, j = 0; j < code_size; ++i, ++j)
ret |= ((state->buf[i / 8] & (1 << (i % 8))) != 0) << j;
418
419
state->curbit += code_size;
420
421
422
423
424
return ret;
}
static int
425
LWZReadByte(SDL_RWops *src, int flag, int input_code_size, State_t * state)
426
427
428
429
{
int code, incode;
register int i;
430
431
432
433
/* Fixed buffer overflow found by Michael Skladnikiewicz */
if (input_code_size > MAX_LWZ_BITS)
return -1;
434
if (flag) {
435
436
437
438
439
440
state->set_code_size = input_code_size;
state->code_size = state->set_code_size + 1;
state->clear_code = 1 << state->set_code_size;
state->end_code = state->clear_code + 1;
state->max_code_size = 2 * state->clear_code;
state->max_code = state->clear_code + 2;
441
442
GetCode(src, 0, TRUE, state);
443
444
state->fresh = TRUE;
445
446
447
448
for (i = 0; i < state->clear_code; ++i) {
state->table[0][i] = 0;
state->table[1][i] = i;
449
}
450
state->table[1][0] = 0;
451
for (; i < (1 << MAX_LWZ_BITS); ++i)
452
state->table[0][i] = 0;
453
454
state->sp = state->stack;
455
456
return 0;
457
458
} else if (state->fresh) {
state->fresh = FALSE;
459
do {
460
461
462
state->firstcode = state->oldcode = GetCode(src, state->code_size, FALSE, state);
} while (state->firstcode == state->clear_code);
return state->firstcode;
463
}
464
465
466
467
468
469
470
471
if (state->sp > state->stack)
return *--state->sp;
while ((code = GetCode(src, state->code_size, FALSE, state)) >= 0) {
if (code == state->clear_code) {
for (i = 0; i < state->clear_code; ++i) {
state->table[0][i] = 0;
state->table[1][i] = i;
472
473
}
for (; i < (1 << MAX_LWZ_BITS); ++i)
474
475
476
477
478
479
480
481
state->table[0][i] = state->table[1][i] = 0;
state->code_size = state->set_code_size + 1;
state->max_code_size = 2 * state->clear_code;
state->max_code = state->clear_code + 2;
state->sp = state->stack;
state->firstcode = state->oldcode = GetCode(src, state->code_size, FALSE, state);
return state->firstcode;
} else if (code == state->end_code) {
482
483
484
int count;
unsigned char buf[260];
485
if (state->ZeroDataBlock)
486
487
return -2;
488
while ((count = GetDataBlock(src, buf, state)) > 0)
489
;
490
491
492
493
494
495
496
497
498
499
if (count != 0) {
/*
* pm_message("missing EOD in data stream (common occurence)");
*/
}
return -2;
}
incode = code;
500
501
502
if (code >= state->max_code) {
*state->sp++ = state->firstcode;
code = state->oldcode;
503
}
504
while (code >= state->clear_code) {
505
506
507
508
509
/* Guard against buffer overruns */
if (code < 0 || code >= (1 << MAX_LWZ_BITS)) {
RWSetMsg("invalid LWZ data");
return -3;
}
510
511
*state->sp++ = state->table[1][code];
if (code == state->table[0][code]) {
512
RWSetMsg("circular table entry BIG ERROR");
513
514
return -3;
}
515
code = state->table[0][code];
516
517
}
518
519
520
521
522
/* Guard against buffer overruns */
if (code < 0 || code >= (1 << MAX_LWZ_BITS)) {
RWSetMsg("invalid LWZ data");
return -4;
}
523
524
525
526
527
528
529
530
531
532
*state->sp++ = state->firstcode = state->table[1][code];
if ((code = state->max_code) < (1 << MAX_LWZ_BITS)) {
state->table[0][code] = state->oldcode;
state->table[1][code] = state->firstcode;
++state->max_code;
if ((state->max_code >= state->max_code_size) &&
(state->max_code_size < (1 << MAX_LWZ_BITS))) {
state->max_code_size *= 2;
++state->code_size;
533
534
}
}
535
state->oldcode = incode;
536
537
538
if (state->sp > state->stack)
return *--state->sp;
539
540
541
542
543
544
545
}
return code;
}
static Image *
ReadImage(SDL_RWops * src, int len, int height, int cmapSize,
unsigned char cmap[3][MAXCOLORMAPSIZE],
546
int gray, int interlace, int ignore, State_t * state)
547
548
549
550
551
552
553
554
555
556
557
558
559
{
Image *image;
unsigned char c;
int i, v;
int xpos = 0, ypos = 0, pass = 0;
/*
** Initialize the compression routines
*/
if (!ReadOK(src, &c, 1)) {
RWSetMsg("EOF / read error on image data");
return NULL;
}
560
if (LWZReadByte(src, TRUE, c, state) < 0) {
561
562
563
564
565
566
567
RWSetMsg("error reading image");
return NULL;
}
/*
** If this is an "uninteresting picture" ignore it.
*/
if (ignore) {
568
while (LWZReadByte(src, FALSE, c, state) >= 0)
569
;
570
571
572
573
574
575
576
577
return NULL;
}
image = ImageNewCmap(len, height, cmapSize);
for (i = 0; i < cmapSize; i++)
ImageSetCmap(image, i, cmap[CM_RED][i],
cmap[CM_GREEN][i], cmap[CM_BLUE][i]);
578
while ((v = LWZReadByte(src, FALSE, c, state)) >= 0) {
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
#ifdef USED_BY_SDL
((Uint8 *)image->pixels)[xpos + ypos * image->pitch] = v;
#else
image->data[xpos + ypos * len] = v;
#endif
++xpos;
if (xpos == len) {
xpos = 0;
if (interlace) {
switch (pass) {
case 0:
case 1:
ypos += 8;
break;
case 2:
ypos += 4;
break;
case 3:
ypos += 2;
break;
}
if (ypos >= height) {
++pass;
switch (pass) {
case 1:
ypos = 4;
break;
case 2:
ypos = 2;
break;
case 3:
ypos = 1;
break;
default:
goto fini;
}
}
} else {
++ypos;
}
}
if (ypos >= height)
break;
}
fini:
return image;
}
#else
/* See if an image is contained in a data source */
int IMG_isGIF(SDL_RWops *src)
{
return(0);
}
/* Load a GIF type image from an SDL datasource */
SDL_Surface *IMG_LoadGIF_RW(SDL_RWops *src)
{
return(NULL);
}
#endif /* LOAD_GIF */
645
646
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */