/
IMG_tga.c
340 lines (297 loc) · 7.79 KB
1
/*
2
SDL_image: An example image loading library for use with SDL
3
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
/* This is a Targa image file loading framework */
26
#include <stdlib.h>
27
28
#include <stdio.h>
#include <string.h>
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include "SDL_endian.h"
#include "SDL_image.h"
#ifdef LOAD_TGA
/*
* A TGA loader for the SDL library
* Supports: Reading 8, 15, 16, 24 and 32bpp images, with alpha or colourkey,
* uncompressed or RLE encoded.
*
* 2000-06-10 Mattias Engdegård <f91-men@nada.kth.se>: initial version
* 2000-06-26 Mattias Engdegård <f91-men@nada.kth.se>: read greyscale TGAs
43
* 2000-08-09 Mattias Engdegård <f91-men@nada.kth.se>: alpha inversion removed
44
45
46
47
48
49
50
51
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
*/
struct TGAheader {
Uint8 infolen; /* length of info field */
Uint8 has_cmap; /* 1 if image has colormap, 0 otherwise */
Uint8 type;
Uint8 cmap_start[2]; /* index of first colormap entry */
Uint8 cmap_len[2]; /* number of entries in colormap */
Uint8 cmap_bits; /* bits per colormap entry */
Uint8 yorigin[2]; /* image origin (ignored here) */
Uint8 xorigin[2];
Uint8 width[2]; /* image size */
Uint8 height[2];
Uint8 pixel_bits; /* bits/pixel */
Uint8 flags;
};
enum tga_type {
TGA_TYPE_INDEXED = 1,
TGA_TYPE_RGB = 2,
TGA_TYPE_BW = 3,
TGA_TYPE_RLE_INDEXED = 9,
TGA_TYPE_RLE_RGB = 10,
TGA_TYPE_RLE_BW = 11
};
#define TGA_INTERLEAVE_MASK 0xc0
#define TGA_INTERLEAVE_NONE 0x00
#define TGA_INTERLEAVE_2WAY 0x40
#define TGA_INTERLEAVE_4WAY 0x80
#define TGA_ORIGIN_MASK 0x30
#define TGA_ORIGIN_LEFT 0x00
#define TGA_ORIGIN_RIGHT 0x10
#define TGA_ORIGIN_LOWER 0x00
#define TGA_ORIGIN_UPPER 0x20
/* read/write unaligned little-endian 16-bit ints */
#define LE16(p) ((p)[0] + ((p)[1] << 8))
#define SETLE16(p, v) ((p)[0] = (v), (p)[1] = (v) >> 8)
/* Load a TGA type image from an SDL datasource */
SDL_Surface *IMG_LoadTGA_RW(SDL_RWops *src)
{
90
Sint64 start;
91
const char *error = NULL;
92
93
94
95
96
97
98
struct TGAheader hdr;
int rle = 0;
int alpha = 0;
int indexed = 0;
int grey = 0;
int ckey = -1;
int ncols, w, h;
99
SDL_Surface *img = NULL;
100
101
102
103
104
105
106
107
Uint32 rmask, gmask, bmask, amask;
Uint8 *dst;
int i;
int bpp;
int lstep;
Uint32 pixel;
int count, rep;
108
109
110
111
if ( !src ) {
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
112
start = SDL_RWtell(src);
113
114
115
if(!SDL_RWread(src, &hdr, sizeof(hdr), 1)) {
error = "Error reading TGA data";
116
goto error;
117
}
118
119
120
121
122
123
124
ncols = LE16(hdr.cmap_len);
switch(hdr.type) {
case TGA_TYPE_RLE_INDEXED:
rle = 1;
/* fallthrough */
case TGA_TYPE_INDEXED:
if(!hdr.has_cmap || hdr.pixel_bits != 8 || ncols > 256)
125
goto unsupported;
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
indexed = 1;
break;
case TGA_TYPE_RLE_RGB:
rle = 1;
/* fallthrough */
case TGA_TYPE_RGB:
indexed = 0;
break;
case TGA_TYPE_RLE_BW:
rle = 1;
/* fallthrough */
case TGA_TYPE_BW:
if(hdr.pixel_bits != 8)
141
goto unsupported;
142
143
144
145
146
/* Treat greyscale as 8bpp indexed images */
indexed = grey = 1;
break;
default:
147
goto unsupported;
148
149
150
}
bpp = (hdr.pixel_bits + 7) >> 3;
151
rmask = gmask = bmask = amask = 0;
152
153
154
switch(hdr.pixel_bits) {
case 8:
if(!indexed) {
155
goto unsupported;
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
}
break;
case 15:
case 16:
/* 15 and 16bpp both seem to use 5 bits/plane. The extra alpha bit
is ignored for now. */
rmask = 0x7c00;
gmask = 0x03e0;
bmask = 0x001f;
break;
case 32:
alpha = 1;
/* fallthrough */
case 24:
172
173
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
{
174
175
176
177
178
int s = alpha ? 0 : 8;
amask = 0x000000ff >> s;
rmask = 0x0000ff00 >> s;
gmask = 0x00ff0000 >> s;
bmask = 0xff000000 >> s;
179
180
}
#else
181
182
183
184
amask = alpha ? 0xff000000 : 0;
rmask = 0x00ff0000;
gmask = 0x0000ff00;
bmask = 0x000000ff;
185
#endif
186
187
188
break;
default:
189
goto unsupported;
190
191
192
193
}
if((hdr.flags & TGA_INTERLEAVE_MASK) != TGA_INTERLEAVE_NONE
|| hdr.flags & TGA_ORIGIN_RIGHT) {
194
goto unsupported;
195
196
}
197
SDL_RWseek(src, hdr.infolen, RW_SEEK_CUR); /* skip info field */
198
199
200
201
202
203
w = LE16(hdr.width);
h = LE16(hdr.height);
img = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
bpp * 8,
rmask, gmask, bmask, amask);
204
205
206
207
if(img == NULL) {
error = "Out of memory";
goto error;
}
208
209
210
211
if(hdr.has_cmap) {
int palsiz = ncols * ((hdr.cmap_bits + 7) >> 3);
if(indexed && !grey) {
212
Uint8 *pal = (Uint8 *)SDL_malloc(palsiz), *p = pal;
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
SDL_Color *colors = img->format->palette->colors;
img->format->palette->ncolors = ncols;
SDL_RWread(src, pal, palsiz, 1);
for(i = 0; i < ncols; i++) {
switch(hdr.cmap_bits) {
case 15:
case 16:
{
Uint16 c = p[0] + (p[1] << 8);
p += 2;
colors[i].r = (c >> 7) & 0xf8;
colors[i].g = (c >> 2) & 0xf8;
colors[i].b = c << 3;
}
break;
case 24:
case 32:
colors[i].b = *p++;
colors[i].g = *p++;
colors[i].r = *p++;
if(hdr.cmap_bits == 32 && *p++ < 128)
ckey = i;
break;
}
}
238
SDL_free(pal);
239
if(ckey >= 0)
240
SDL_SetColorKey(img, SDL_TRUE, ckey);
241
242
} else {
/* skip unneeded colormap */
243
SDL_RWseek(src, palsiz, RW_SEEK_CUR);
244
245
246
247
248
249
250
251
252
253
254
}
}
if(grey) {
SDL_Color *colors = img->format->palette->colors;
for(i = 0; i < 256; i++)
colors[i].r = colors[i].g = colors[i].b = i;
img->format->palette->ncolors = 256;
}
if(hdr.flags & TGA_ORIGIN_UPPER) {
255
256
lstep = img->pitch;
dst = (Uint8 *)img->pixels;
257
} else {
258
259
lstep = -img->pitch;
dst = (Uint8 *)img->pixels + (h - 1) * img->pitch;
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
}
/* The RLE decoding code is slightly convoluted since we can't rely on
spans not to wrap across scan lines */
count = rep = 0;
for(i = 0; i < h; i++) {
if(rle) {
int x = 0;
for(;;) {
Uint8 c;
if(count) {
int n = count;
if(n > w - x)
n = w - x;
SDL_RWread(src, dst + x * bpp, n * bpp, 1);
count -= n;
x += n;
if(x == w)
break;
} else if(rep) {
int n = rep;
if(n > w - x)
n = w - x;
rep -= n;
while(n--) {
286
SDL_memcpy(dst + x * bpp, &pixel, bpp);
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
x++;
}
if(x == w)
break;
}
SDL_RWread(src, &c, 1, 1);
if(c & 0x80) {
SDL_RWread(src, &pixel, bpp, 1);
rep = (c & 0x7f) + 1;
} else {
count = c + 1;
}
}
} else {
SDL_RWread(src, dst, w * bpp, 1);
}
305
306
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
if (bpp == 2) {
307
308
309
310
311
312
/* swap byte order */
int x;
Uint16 *p = (Uint16 *)dst;
for(x = 0; x < w; x++)
p[x] = SDL_Swap16(p[x]);
}
313
#endif
314
315
316
317
dst += lstep;
}
return img;
318
unsupported:
319
320
321
error = "Unsupported TGA format";
error:
322
SDL_RWseek(src, start, RW_SEEK_SET);
323
324
325
326
if ( img ) {
SDL_FreeSurface(img);
}
IMG_SetError(error);
327
return NULL;
328
329
330
331
332
333
334
335
336
337
338
}
#else
/* dummy TGA load routine */
SDL_Surface *IMG_LoadTGA_RW(SDL_RWops *src)
{
return(NULL);
}
#endif /* LOAD_TGA */
339
340
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */