/
IMG_tga.c
340 lines (297 loc) · 8.43 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
*/
struct TGAheader {
47
48
Uint8 infolen; /* length of info field */
Uint8 has_cmap; /* 1 if image has colormap, 0 otherwise */
49
50
Uint8 type;
51
52
53
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 */
54
55
Uint8 yorigin[2]; /* image origin (ignored here) */
56
Uint8 xorigin[2];
57
Uint8 width[2]; /* image size */
58
Uint8 height[2];
59
Uint8 pixel_bits; /* bits/pixel */
60
61
62
63
64
65
66
67
68
69
70
71
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
};
72
73
74
75
#define TGA_INTERLEAVE_MASK 0xc0
#define TGA_INTERLEAVE_NONE 0x00
#define TGA_INTERLEAVE_2WAY 0x40
#define TGA_INTERLEAVE_4WAY 0x80
76
77
78
79
80
81
#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
82
83
84
85
86
87
88
89
/* 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
ncols = LE16(hdr.cmap_len);
switch(hdr.type) {
case TGA_TYPE_RLE_INDEXED:
121
122
rle = 1;
/* fallthrough */
123
case TGA_TYPE_INDEXED:
124
125
126
127
if(!hdr.has_cmap || hdr.pixel_bits != 8 || ncols > 256)
goto unsupported;
indexed = 1;
break;
128
129
case TGA_TYPE_RLE_RGB:
130
131
rle = 1;
/* fallthrough */
132
case TGA_TYPE_RGB:
133
134
indexed = 0;
break;
135
136
case TGA_TYPE_RLE_BW:
137
138
rle = 1;
/* fallthrough */
139
case TGA_TYPE_BW:
140
141
142
143
144
if(hdr.pixel_bits != 8)
goto unsupported;
/* Treat greyscale as 8bpp indexed images */
indexed = grey = 1;
break;
145
146
default:
147
goto unsupported;
148
149
150
}
bpp = (hdr.pixel_bits + 7) >> 3;
151
rmask = gmask = bmask = amask = 0;
152
153
switch(hdr.pixel_bits) {
case 8:
154
if(!indexed) {
155
goto unsupported;
156
157
}
break;
158
159
160
case 15:
case 16:
161
162
163
164
165
166
/* 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;
167
168
case 32:
169
170
alpha = 1;
/* fallthrough */
171
case 24:
172
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
173
174
175
176
177
178
179
{
int s = alpha ? 0 : 8;
amask = 0x000000ff >> s;
rmask = 0x0000ff00 >> s;
gmask = 0x00ff0000 >> s;
bmask = 0xff000000 >> s;
}
180
#else
181
182
183
184
amask = alpha ? 0xff000000 : 0;
rmask = 0x00ff0000;
gmask = 0x0000ff00;
bmask = 0x000000ff;
185
#endif
186
break;
187
188
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
w = LE16(hdr.width);
h = LE16(hdr.height);
img = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
202
203
bpp * 8,
rmask, gmask, bmask, amask);
204
205
206
207
if(img == NULL) {
error = "Out of memory";
goto error;
}
208
209
if(hdr.has_cmap) {
210
211
212
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
238
239
240
241
242
243
244
int palsiz = ncols * ((hdr.cmap_bits + 7) >> 3);
if(indexed && !grey) {
Uint8 *pal = (Uint8 *)SDL_malloc(palsiz), *p = pal;
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;
}
}
SDL_free(pal);
if(ckey >= 0)
SDL_SetColorKey(img, SDL_TRUE, ckey);
} else {
/* skip unneeded colormap */
SDL_RWseek(src, palsiz, RW_SEEK_CUR);
}
245
246
247
}
if(grey) {
248
249
250
251
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;
252
253
254
}
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
}
/* 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++) {
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
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--) {
SDL_memcpy(dst + x * bpp, &pixel, bpp);
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
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
306
307
308
309
310
311
312
if (bpp == 2) {
/* swap byte order */
int x;
Uint16 *p = (Uint16 *)dst;
for(x = 0; x < w; x++)
p[x] = SDL_Swap16(p[x]);
}
313
#endif
314
dst += lstep;
315
316
317
}
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
}
#else
/* dummy TGA load routine */
SDL_Surface *IMG_LoadTGA_RW(SDL_RWops *src)
{
335
return(NULL);
336
337
338
}
#endif /* LOAD_TGA */
339
340
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */