/
IMG_gif.c
650 lines (557 loc) · 16.2 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
410
411
if ((ret = GetDataBlock(src, &state->buf[2], state)) > 0)
count = (unsigned char) ret;
else {
count = 0;
412
state->done = TRUE;
413
}
414
415
416
417
state->last_byte = 2 + count;
state->curbit = (state->curbit - state->lastbit) + 16;
state->lastbit = (2 + count) * 8;
418
419
}
ret = 0;
420
421
for (i = state->curbit, j = 0; j < code_size; ++i, ++j)
ret |= ((state->buf[i / 8] & (1 << (i % 8))) != 0) << j;
422
423
state->curbit += code_size;
424
425
426
427
428
return ret;
}
static int
429
LWZReadByte(SDL_RWops *src, int flag, int input_code_size, State_t * state)
430
431
432
433
{
int code, incode;
register int i;
434
435
436
437
/* Fixed buffer overflow found by Michael Skladnikiewicz */
if (input_code_size > MAX_LWZ_BITS)
return -1;
438
if (flag) {
439
440
441
442
443
444
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;
445
446
GetCode(src, 0, TRUE, state);
447
448
state->fresh = TRUE;
449
450
451
452
for (i = 0; i < state->clear_code; ++i) {
state->table[0][i] = 0;
state->table[1][i] = i;
453
}
454
state->table[1][0] = 0;
455
for (; i < (1 << MAX_LWZ_BITS); ++i)
456
state->table[0][i] = 0;
457
458
state->sp = state->stack;
459
460
return 0;
461
462
} else if (state->fresh) {
state->fresh = FALSE;
463
do {
464
465
466
state->firstcode = state->oldcode = GetCode(src, state->code_size, FALSE, state);
} while (state->firstcode == state->clear_code);
return state->firstcode;
467
}
468
469
470
471
472
473
474
475
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;
476
477
}
for (; i < (1 << MAX_LWZ_BITS); ++i)
478
479
480
481
482
483
484
485
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) {
486
487
488
int count;
unsigned char buf[260];
489
if (state->ZeroDataBlock)
490
491
return -2;
492
while ((count = GetDataBlock(src, buf, state)) > 0)
493
;
494
495
496
497
498
499
500
501
502
503
if (count != 0) {
/*
* pm_message("missing EOD in data stream (common occurence)");
*/
}
return -2;
}
incode = code;
504
505
506
if (code >= state->max_code) {
*state->sp++ = state->firstcode;
code = state->oldcode;
507
}
508
while (code >= state->clear_code) {
509
510
511
512
513
/* Guard against buffer overruns */
if (code < 0 || code >= (1 << MAX_LWZ_BITS)) {
RWSetMsg("invalid LWZ data");
return -3;
}
514
515
*state->sp++ = state->table[1][code];
if (code == state->table[0][code]) {
516
RWSetMsg("circular table entry BIG ERROR");
517
518
return -3;
}
519
code = state->table[0][code];
520
521
}
522
523
524
525
526
/* Guard against buffer overruns */
if (code < 0 || code >= (1 << MAX_LWZ_BITS)) {
RWSetMsg("invalid LWZ data");
return -4;
}
527
528
529
530
531
532
533
534
535
536
*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;
537
538
}
}
539
state->oldcode = incode;
540
541
542
if (state->sp > state->stack)
return *--state->sp;
543
544
545
546
547
548
549
}
return code;
}
static Image *
ReadImage(SDL_RWops * src, int len, int height, int cmapSize,
unsigned char cmap[3][MAXCOLORMAPSIZE],
550
int gray, int interlace, int ignore, State_t * state)
551
552
553
554
555
556
557
558
559
560
561
562
563
{
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;
}
564
if (LWZReadByte(src, TRUE, c, state) < 0) {
565
566
567
568
569
570
571
RWSetMsg("error reading image");
return NULL;
}
/*
** If this is an "uninteresting picture" ignore it.
*/
if (ignore) {
572
while (LWZReadByte(src, FALSE, c, state) >= 0)
573
;
574
575
576
577
578
579
580
581
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]);
582
while ((v = LWZReadByte(src, FALSE, c, state)) >= 0) {
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
645
646
647
648
#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 */
649
650
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */