]> git.mxchange.org Git - flightgear.git/blob - src/Objects/texload.c
Set the initial log-level back to info
[flightgear.git] / src / Objects / texload.c
1
2 /* texture.c - by David Blythe, SGI */
3
4 /* texload is a simplistic routine for reading an SGI .rgb image file. */
5
6 #ifdef HAVE_CONFIG_H
7 #  include <config.h>
8 #endif
9
10 #ifdef HAVE_WINDOWS_H
11 #  include <windows.h>
12 #endif
13
14 #include <stdio.h>
15 #include <stdlib.h> 
16 #include <string.h>
17
18 #include <simgear/sg_zlib.h>
19
20 #include "texload.h"
21 #include "colours.h"
22
23 typedef struct _ImageRec {
24     unsigned short imagic;
25     unsigned short type;
26     unsigned short dim;
27     unsigned short xsize, ysize, zsize;
28     unsigned int min, max;
29     unsigned int wasteBytes;
30     char name[80];
31     unsigned long colorMap;
32     sgFile file;
33     unsigned char *tmp;
34     unsigned long rleEnd;
35     unsigned int *rowStart;
36     int *rowSize;
37 } ImageRec;
38
39 void
40 rgbtorgb(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *l,int n) {
41     while(n--) {
42         l[0] = r[0];
43         l[1] = g[0];
44         l[2] = b[0];
45         l += 3; r++; g++; b++;
46     }
47 }
48
49 static void
50 ConvertShort(unsigned short *array, unsigned int length) {
51     unsigned short b1, b2;
52     unsigned char *ptr;
53
54     ptr = (unsigned char *)array;
55     while (length--) {
56         b1 = *ptr++;
57         b2 = *ptr++;
58         *array++ = (b1 << 8) | (b2);
59     }
60 }
61
62 static void
63 ConvertUint(unsigned *array, unsigned int length) {
64     unsigned int b1, b2, b3, b4;
65     unsigned char *ptr;
66
67     ptr = (unsigned char *)array;
68     while (length--) {
69         b1 = *ptr++;
70         b2 = *ptr++;
71         b3 = *ptr++;
72         b4 = *ptr++;
73         *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
74     }
75 }
76
77 static ImageRec *ImageOpen(const char *fileName)
78 {
79      union {
80        int testWord;
81        char testByte[4];
82      } endianTest;
83
84     ImageRec *image;
85     int swapFlag;
86     int x;
87
88     endianTest.testWord = 1;
89     if (endianTest.testByte[0] == 1) {
90         swapFlag = 1;
91     } else {
92         swapFlag = 0;
93     }
94
95     image = (ImageRec *)malloc(sizeof(ImageRec));
96     if (image == NULL) {
97         fprintf(stderr, "Out of memory!\n");
98         exit(1);
99     }
100     if ((image->file = sgopen(fileName, "rb")) == NULL) {
101       return NULL;
102     }
103
104     // fread(image, 1, 12, image->file);
105     sgread(image->file, image, 12);
106
107     if (swapFlag) {
108         ConvertShort(&image->imagic, 6);
109     }
110
111     image->tmp = (unsigned char *)malloc(image->xsize*256);
112     if (image->tmp == NULL) {
113         fprintf(stderr, "\nOut of memory!\n");
114         exit(1);
115     }
116
117     if ((image->type & 0xFF00) == 0x0100) {
118         x = image->ysize * image->zsize * (int) sizeof(unsigned);
119         image->rowStart = (unsigned *)malloc(x);
120         image->rowSize = (int *)malloc(x);
121         if (image->rowStart == NULL || image->rowSize == NULL) {
122             fprintf(stderr, "\nOut of memory!\n");
123             exit(1);
124         }
125         image->rleEnd = 512 + (2 * x);
126         sgseek(image->file, 512, SEEK_SET);
127         // fread(image->rowStart, 1, x, image->file);
128         sgread(image->file, image->rowStart, x);
129         // fread(image->rowSize, 1, x, image->file);
130         sgread(image->file, image->rowSize, x);
131         if (swapFlag) {
132             ConvertUint(image->rowStart, x/(int) sizeof(unsigned));
133             ConvertUint((unsigned *)image->rowSize, x/(int) sizeof(int));
134         }
135     }
136     return image;
137 }
138
139 static void
140 ImageClose(ImageRec *image) {
141     sgclose(image->file);
142     free(image->tmp);
143     free(image);
144 }
145
146 static void
147 ImageGetRow(ImageRec *image, unsigned char *buf, int y, int z) {
148     unsigned char *iPtr, *oPtr, pixel;
149     int count;
150
151     if ((image->type & 0xFF00) == 0x0100) {
152         sgseek(image->file, (long) image->rowStart[y+z*image->ysize], SEEK_SET);
153         // fread(image->tmp, 1, (unsigned int)image->rowSize[y+z*image->ysize],
154         //      image->file);
155         sgread(image->file, image->tmp, 
156                (unsigned int)image->rowSize[y+z*image->ysize]);
157
158         iPtr = image->tmp;
159         oPtr = buf;
160         for (;;) {
161             pixel = *iPtr++;
162             count = (int)(pixel & 0x7F);
163             if (!count) {
164                 return;
165             }
166             if (pixel & 0x80) {
167                 while (count--) {
168                     *oPtr++ = *iPtr++;
169                 }
170             } else {
171                 pixel = *iPtr++;
172                 while (count--) {
173                     *oPtr++ = pixel;
174                 }
175             }
176         }
177     } else {
178         sgseek(image->file, 512+(y*image->xsize)+(z*image->xsize*image->ysize),
179               SEEK_SET);
180         // fread(buf, 1, image->xsize, image->file);
181         sgread(image->file, buf, image->xsize);
182     }
183 }
184
185 GLubyte *
186 read_alpha_texture(const char *name, int *width, int *height)
187 {
188     unsigned char *base, *lptr;
189     ImageRec *image;
190     int y;
191
192     image = ImageOpen(name);
193     if(!image) {
194         return NULL;
195     }
196
197     (*width)=image->xsize;
198     (*height)=image->ysize;
199
200     printf("image->zsize = %d\n", image->zsize);
201
202     if (image->zsize != 1) {
203       ImageClose(image);
204       return NULL;
205     }
206
207     base = (unsigned char *)malloc(image->xsize*image->ysize*sizeof(unsigned char));
208     lptr = base;
209     for(y=0; y<image->ysize; y++) {
210         ImageGetRow(image,lptr,y,0);
211         lptr += image->xsize;
212     }
213     ImageClose(image);
214
215     return (unsigned char *) base;
216 }
217
218 GLubyte *
219 read_rgb_texture(const char *name, int *width, int *height)
220 {
221     unsigned char *base, *ptr;
222     unsigned char *rbuf, *gbuf, *bbuf, *abuf;
223     ImageRec *image;
224     int y;
225
226     image = ImageOpen(name);
227     
228     if(!image)
229         return NULL;
230     (*width)=image->xsize;
231     (*height)=image->ysize;
232     if (image->zsize != 3 && image->zsize != 4) {
233       ImageClose(image);
234       return NULL;
235     }
236
237     base = (unsigned char*)malloc(image->xsize*image->ysize*sizeof(unsigned int)*3);
238     rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
239     gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
240     bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
241     abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
242     if(!base || !rbuf || !gbuf || !bbuf || !abuf) {
243       if (base) free(base);
244       if (rbuf) free(rbuf);
245       if (gbuf) free(gbuf);
246       if (bbuf) free(bbuf);
247       if (abuf) free(abuf);
248       return NULL;
249     }
250     ptr = base;
251     for(y=0; y<image->ysize; y++) {
252         if(image->zsize == 4) {
253             ImageGetRow(image,rbuf,y,0);
254             ImageGetRow(image,gbuf,y,1);
255             ImageGetRow(image,bbuf,y,2);
256             ImageGetRow(image,abuf,y,3);  /* Discard. */
257             rgbtorgb(rbuf,gbuf,bbuf,ptr,image->xsize);
258             ptr += (image->xsize * 3);
259         } else {
260             ImageGetRow(image,rbuf,y,0);
261             ImageGetRow(image,gbuf,y,1);
262             ImageGetRow(image,bbuf,y,2);
263             rgbtorgb(rbuf,gbuf,bbuf,ptr,image->xsize);
264             ptr += (image->xsize * 3);
265         }
266     }
267     ImageClose(image);
268     free(rbuf);
269     free(gbuf);
270     free(bbuf);
271     free(abuf);
272
273     return (GLubyte *) base;
274 }
275
276
277 static ImageRec *RawImageOpen(const char *fileName)
278 {
279      union {
280        int testWord;
281        char testByte[4];
282      } endianTest;
283
284     ImageRec *image;
285     int swapFlag;
286
287     endianTest.testWord = 1;
288     if (endianTest.testByte[0] == 1) {
289         swapFlag = 1;
290     } else {
291         swapFlag = 0;
292     }
293
294     image = (ImageRec *)malloc(sizeof(ImageRec));
295     if (image == NULL) {
296         fprintf(stderr, "Out of memory!\n");
297         exit(1);
298     }
299     if ((image->file = sgopen(fileName, "rb")) == NULL) {
300       return NULL;
301     }
302
303     sgread(image->file, image, 12);
304
305     if (swapFlag) {
306         ConvertShort(&image->imagic, 6);
307     }
308
309     
310         image->tmp = (unsigned char *)malloc(1);        //just allocate a pseudo value as I'm too lazy to change ImageClose()...
311     if (image->tmp == NULL) {
312         fprintf(stderr, "\nOut of memory!\n");
313         exit(1);
314     }
315
316     return image;
317 }
318
319
320 GLubyte *
321 read_raw_texture(const char *name, int *width, int *height)
322 {
323     unsigned char *base, *ptr;
324     ImageRec *image;
325     int y;
326
327     image = RawImageOpen(name);
328     
329     if(!image)
330         return NULL;
331     (*width)=256; 
332     (*height)=256; 
333
334     base = (unsigned char*)malloc(256*256*sizeof(unsigned char)*3);
335     if(!base) {
336       if (base) free(base);
337       return NULL;
338     }
339     ptr = base;
340     for(y=0; y<256; y++) {
341                 sgread(image->file, ptr, 256*3);
342                 ptr+=256*3;
343     }
344     ImageClose(image);
345
346     return (GLubyte *) base;
347 }
348
349
350 GLubyte *
351 read_r8_texture(const char *name, int *width, int *height)
352 {
353     unsigned char *base, *ptr;
354     ImageRec *image;
355     int xy;
356         unsigned char c[1];
357
358     image = RawImageOpen(name); //it wouldn't make sense to write a new function...
359     
360     if(!image)
361         return NULL;
362     (*width)=256; 
363     (*height)=256; 
364
365     base = (unsigned char*)malloc(256*256*sizeof(unsigned char)*3);
366     if(!base) {
367       if (base) free(base);
368       return NULL;
369     }
370     ptr = base;
371     for(xy=0; xy<(256*256); xy++) {
372                 sgread(image->file,c,1);
373                 ptr[0]=msfs_colour[c[0]][0];    //look in the table for the right colours
374                 ptr[1]=msfs_colour[c[0]][1];
375                 ptr[2]=msfs_colour[c[0]][2];
376                 
377                 ptr+=3;
378     }
379     ImageClose(image);
380
381     return (GLubyte *) base;
382 }