allow 64 directories, no longer 8
[divverent/netradiant.git] / tools / quake3 / common / imagelib.c
1 /*
2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 // imagelib.c
23
24 #include "inout.h"
25 #include "cmdlib.h"
26 #include "imagelib.h"
27 #include "vfs.h"
28
29 int fgetLittleShort (FILE *f)
30 {
31         byte    b1, b2;
32
33         b1 = fgetc(f);
34         b2 = fgetc(f);
35
36         return (short)(b1 + b2*256);
37 }
38
39 int fgetLittleLong (FILE *f)
40 {
41         byte    b1, b2, b3, b4;
42
43         b1 = fgetc(f);
44         b2 = fgetc(f);
45         b3 = fgetc(f);
46         b4 = fgetc(f);
47
48         return b1 + (b2<<8) + (b3<<16) + (b4<<24);
49 }
50
51 int bufLittleShort (byte *buf, int len, int *pos)
52 {
53   byte  b1, b2;
54
55   if ((len - *pos) < 2)
56     Error ("Unexpected buffer end");
57
58   b1 = buf[*pos]; *pos += 1;
59   b2 = buf[*pos]; *pos += 1;
60
61   return (short)(b1 + b2*256);
62 }
63
64 int bufLittleLong (byte *buf, int len, int *pos)
65 {
66   byte b1, b2, b3, b4;
67
68   if ((len - *pos) < 4)
69     Error ("Unexpected buffer end");
70
71   b1 = buf[*pos]; *pos += 1;
72   b2 = buf[*pos]; *pos += 1;
73   b3 = buf[*pos]; *pos += 1;
74   b4 = buf[*pos]; *pos += 1;
75
76   return b1 + (b2<<8) + (b3<<16) + (b4<<24);
77 }
78
79
80 /*
81 ============================================================================
82
83                                                 LBM STUFF
84
85 ============================================================================
86 */
87
88
89 typedef unsigned char   UBYTE;
90 //conflicts with windows typedef short                  WORD;
91 typedef unsigned short  UWORD;
92 typedef long                    LONG;
93
94 typedef enum
95 {
96         ms_none,
97         ms_mask,
98         ms_transcolor,
99         ms_lasso
100 } mask_t;
101
102 typedef enum
103 {
104         cm_none,
105         cm_rle1
106 } compress_t;
107
108 typedef struct
109 {
110         UWORD           w,h;
111         short           x,y;
112         UBYTE           nPlanes;
113         UBYTE           masking;
114         UBYTE           compression;
115         UBYTE           pad1;
116         UWORD           transparentColor;
117         UBYTE           xAspect,yAspect;
118         short           pageWidth,pageHeight;
119 } bmhd_t;
120
121 extern  bmhd_t  bmhd;                                           // will be in native byte order
122
123
124
125 #define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
126 #define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
127 #define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
128 #define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
129 #define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
130 #define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
131
132
133 bmhd_t  bmhd;
134
135 int    Align (int l)
136 {
137         if (l&1)
138                 return l+1;
139         return l;
140 }
141
142
143
144 /*
145 ================
146 LBMRLEdecompress
147
148 Source must be evenly aligned!
149 ================
150 */
151 byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
152 {
153         int     count;
154         byte    b,rept;
155
156         count = 0;
157
158         do
159         {
160                 rept = *source++;
161
162                 if (rept > 0x80)
163                 {
164                         rept = (rept^0xff)+2;
165                         b = *source++;
166                         memset(unpacked,b,rept);
167                         unpacked += rept;
168                 }
169                 else if (rept < 0x80)
170                 {
171                         rept++;
172                         memcpy(unpacked,source,rept);
173                         unpacked += rept;
174                         source += rept;
175                 }
176                 else
177                         rept = 0;               // rept of 0x80 is NOP
178
179                 count += rept;
180
181         } while (count<bpwidth);
182
183         if (count>bpwidth)
184                 Error ("Decompression exceeded width!\n");
185
186
187         return source;
188 }
189
190
191 /*
192 =================
193 LoadLBM
194 =================
195 */
196 void LoadLBM (const char *filename, byte **picture, byte **palette)
197 {
198         byte    *LBMbuffer, *picbuffer, *cmapbuffer;
199         int             y;
200         byte    *LBM_P, *LBMEND_P;
201         byte    *pic_p;
202         byte    *body_p;
203
204         int    formtype,formlength;
205         int    chunktype,chunklength;
206
207 // qiet compiler warnings
208         picbuffer = NULL;
209         cmapbuffer = NULL;
210
211 //
212 // load the LBM
213 //
214         LoadFile (filename, (void **)&LBMbuffer);
215
216 //
217 // parse the LBM header
218 //
219         LBM_P = LBMbuffer;
220         if ( *(int *)LBMbuffer != LittleLong(FORMID) )
221            Error ("No FORM ID at start of file!\n");
222
223         LBM_P += 4;
224         formlength = BigLong( *(int *)LBM_P );
225         LBM_P += 4;
226         LBMEND_P = LBM_P + Align(formlength);
227
228         formtype = LittleLong(*(int *)LBM_P);
229
230         if (formtype != ILBMID && formtype != PBMID)
231                 Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
232                 ,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
233
234         LBM_P += 4;
235
236 //
237 // parse chunks
238 //
239
240         while (LBM_P < LBMEND_P)
241         {
242                 chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
243                 LBM_P += 4;
244                 chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
245                 LBM_P += 4;
246
247                 switch ( chunktype )
248                 {
249                 case BMHDID:
250                         memcpy (&bmhd,LBM_P,sizeof(bmhd));
251                         bmhd.w = BigShort(bmhd.w);
252                         bmhd.h = BigShort(bmhd.h);
253                         bmhd.x = BigShort(bmhd.x);
254                         bmhd.y = BigShort(bmhd.y);
255                         bmhd.pageWidth = BigShort(bmhd.pageWidth);
256                         bmhd.pageHeight = BigShort(bmhd.pageHeight);
257                         break;
258
259                 case CMAPID:
260                         cmapbuffer = safe_malloc (768);
261                         memset (cmapbuffer, 0, 768);
262                         memcpy (cmapbuffer, LBM_P, chunklength);
263                         break;
264
265                 case BODYID:
266                         body_p = LBM_P;
267
268                         pic_p = picbuffer = safe_malloc (bmhd.w*bmhd.h);
269                         if (formtype == PBMID)
270                         {
271                         //
272                         // unpack PBM
273                         //
274                                 for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
275                                 {
276                                         if (bmhd.compression == cm_rle1)
277                                                 body_p = LBMRLEDecompress ((byte *)body_p
278                                                 , pic_p , bmhd.w);
279                                         else if (bmhd.compression == cm_none)
280                                         {
281                                                 memcpy (pic_p,body_p,bmhd.w);
282                                                 body_p += Align(bmhd.w);
283                                         }
284                                 }
285
286                         }
287                         else
288                         {
289                         //
290                         // unpack ILBM
291                         //
292                                 Error ("%s is an interlaced LBM, not packed", filename);
293                         }
294                         break;
295                 }
296
297                 LBM_P += Align(chunklength);
298         }
299
300         free (LBMbuffer);
301
302         *picture = picbuffer;
303
304         if (palette)
305                 *palette = cmapbuffer;
306 }
307
308
309 /*
310 ============================================================================
311
312                                                         WRITE LBM
313
314 ============================================================================
315 */
316
317 /*
318 ==============
319 WriteLBMfile
320 ==============
321 */
322 void WriteLBMfile (const char *filename, byte *data,
323                                    int width, int height, byte *palette)
324 {
325         byte    *lbm, *lbmptr;
326         int    *formlength, *bmhdlength, *cmaplength, *bodylength;
327         int    length;
328         bmhd_t  basebmhd;
329
330         lbm = lbmptr = safe_malloc (width*height+1000);
331
332 //
333 // start FORM
334 //
335         *lbmptr++ = 'F';
336         *lbmptr++ = 'O';
337         *lbmptr++ = 'R';
338         *lbmptr++ = 'M';
339
340         formlength = (int*)lbmptr;
341         lbmptr+=4;                      // leave space for length
342
343         *lbmptr++ = 'P';
344         *lbmptr++ = 'B';
345         *lbmptr++ = 'M';
346         *lbmptr++ = ' ';
347
348 //
349 // write BMHD
350 //
351         *lbmptr++ = 'B';
352         *lbmptr++ = 'M';
353         *lbmptr++ = 'H';
354         *lbmptr++ = 'D';
355
356         bmhdlength = (int *)lbmptr;
357         lbmptr+=4;                      // leave space for length
358
359         memset (&basebmhd,0,sizeof(basebmhd));
360         basebmhd.w = BigShort((short)width);
361         basebmhd.h = BigShort((short)height);
362         basebmhd.nPlanes = BigShort(8);
363         basebmhd.xAspect = BigShort(5);
364         basebmhd.yAspect = BigShort(6);
365         basebmhd.pageWidth = BigShort((short)width);
366         basebmhd.pageHeight = BigShort((short)height);
367
368         memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
369         lbmptr += sizeof(basebmhd);
370
371         length = lbmptr-(byte *)bmhdlength-4;
372         *bmhdlength = BigLong(length);
373         if (length&1)
374                 *lbmptr++ = 0;          // pad chunk to even offset
375
376 //
377 // write CMAP
378 //
379         *lbmptr++ = 'C';
380         *lbmptr++ = 'M';
381         *lbmptr++ = 'A';
382         *lbmptr++ = 'P';
383
384         cmaplength = (int *)lbmptr;
385         lbmptr+=4;                      // leave space for length
386
387         memcpy (lbmptr,palette,768);
388         lbmptr += 768;
389
390         length = lbmptr-(byte *)cmaplength-4;
391         *cmaplength = BigLong(length);
392         if (length&1)
393                 *lbmptr++ = 0;          // pad chunk to even offset
394
395 //
396 // write BODY
397 //
398         *lbmptr++ = 'B';
399         *lbmptr++ = 'O';
400         *lbmptr++ = 'D';
401         *lbmptr++ = 'Y';
402
403         bodylength = (int *)lbmptr;
404         lbmptr+=4;                      // leave space for length
405
406         memcpy (lbmptr,data,width*height);
407         lbmptr += width*height;
408
409         length = lbmptr-(byte *)bodylength-4;
410         *bodylength = BigLong(length);
411         if (length&1)
412                 *lbmptr++ = 0;          // pad chunk to even offset
413
414 //
415 // done
416 //
417         length = lbmptr-(byte *)formlength-4;
418         *formlength = BigLong(length);
419         if (length&1)
420                 *lbmptr++ = 0;          // pad chunk to even offset
421
422 //
423 // write output file
424 //
425         SaveFile (filename, lbm, lbmptr-lbm);
426         free (lbm);
427 }
428
429
430 /*
431 ============================================================================
432
433 LOAD PCX
434
435 ============================================================================
436 */
437
438 typedef struct
439 {
440     char        manufacturer;
441     char        version;
442     char        encoding;
443     char        bits_per_pixel;
444     unsigned short      xmin,ymin,xmax,ymax;
445     unsigned short      hres,vres;
446     unsigned char       palette[48];
447     char        reserved;
448     char        color_planes;
449     unsigned short      bytes_per_line;
450     unsigned short      palette_type;
451     char        filler[58];
452     unsigned char       data;                   // unbounded
453 } pcx_t;
454
455
456 /*
457 ==============
458 LoadPCX
459 ==============
460 */
461
462 /* RR2DO2 */
463 #define DECODEPCX( b, d, r ) d=*b++;if((d&0xC0)==0xC0){r=d&0x3F;d=*b++;}else{r=1;}
464
465 void LoadPCX( const char *filename, byte **pic, byte **palette, int *width, int *height )
466 {
467         byte    *raw;
468         pcx_t   *pcx;
469         int             x, y, lsize;
470         int             len;
471         int             dataByte, runLength;
472         byte    *out, *pix;
473         
474
475         /* load the file */
476         len = vfsLoadFile (filename, (void **)&raw, 0);
477     if( len == -1 ) 
478                 Error( "LoadPCX: Couldn't read %s", filename );
479
480         
481         /* parse the PCX file */
482         pcx = (pcx_t *)raw;
483         raw = &pcx->data;
484
485         pcx->xmin = LittleShort(pcx->xmin);
486         pcx->ymin = LittleShort(pcx->ymin);
487         pcx->xmax = LittleShort(pcx->xmax);
488         pcx->ymax = LittleShort(pcx->ymax);
489         pcx->hres = LittleShort(pcx->hres);
490         pcx->vres = LittleShort(pcx->vres);
491         pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
492         pcx->palette_type = LittleShort(pcx->palette_type);
493
494         if (pcx->manufacturer != 0x0a
495                 || pcx->version != 5
496                 || pcx->encoding != 1
497                 || pcx->bits_per_pixel != 8
498                 || pcx->xmax >= 640
499                 || pcx->ymax >= 480)
500                 Error ("Bad pcx file %s", filename);
501         
502         if (palette)
503         {
504                 *palette = safe_malloc(768);
505                 memcpy (*palette, (byte *)pcx + len - 768, 768);
506         }
507
508         if (width)
509                 *width = pcx->xmax+1;
510         if (height)
511                 *height = pcx->ymax+1;
512
513         if (!pic)
514                 return;
515
516         out = safe_malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
517         if (!out)
518                 Error( "LoadPCX: couldn't allocate");
519
520         *pic = out;
521         pix = out;
522         
523         /* RR2DO2: pcx fix  */
524         lsize = pcx->color_planes * pcx->bytes_per_line;
525         
526         /* go scanline by scanline */
527         for( y = 0; y <= pcx->ymax; y++, pix += pcx->xmax + 1 )
528         {
529                 /* do a scanline */
530                 for( x=0; x <= pcx->xmax; )
531                 {
532                         /* RR2DO2 */
533                         DECODEPCX( raw, dataByte, runLength );
534                         while( runLength-- > 0 )
535                                 pix[ x++ ] = dataByte;
536                 }
537
538                 /* RR2DO2: discard any other data */
539                 while( x < lsize )
540                 {
541                         DECODEPCX( raw, dataByte, runLength );
542                         x++;
543                 }
544                 while( runLength-- > 0 )
545                         x++;
546         }
547         
548         /* validity check */
549         if( raw - (byte *) pcx > len)
550                 Error( "PCX file %s was malformed", filename );
551         free( pcx );
552 }
553
554
555
556 /* 
557 ============== 
558 WritePCXfile 
559 ============== 
560 */ 
561 void WritePCXfile (const char *filename, byte *data, 
562                                    int width, int height, byte *palette) 
563 {
564         int             i, j, length;
565         pcx_t   *pcx;
566         byte            *pack;
567           
568         pcx = safe_malloc (width*height*2+1000);
569         memset (pcx, 0, sizeof(*pcx));
570
571         pcx->manufacturer = 0x0a;       // PCX id
572         pcx->version = 5;                       // 256 color
573         pcx->encoding = 1;              // uncompressed
574         pcx->bits_per_pixel = 8;                // 256 color
575         pcx->xmin = 0;
576         pcx->ymin = 0;
577         pcx->xmax = LittleShort((short)(width-1));
578         pcx->ymax = LittleShort((short)(height-1));
579         pcx->hres = LittleShort((short)width);
580         pcx->vres = LittleShort((short)height);
581         pcx->color_planes = 1;          // chunky image
582         pcx->bytes_per_line = LittleShort((short)width);
583         pcx->palette_type = LittleShort(1);             // not a grey scale
584
585         // pack the image
586         pack = &pcx->data;
587         
588         for (i=0 ; i<height ; i++)
589         {
590                 for (j=0 ; j<width ; j++)
591                 {
592                         if ( (*data & 0xc0) != 0xc0)
593                                 *pack++ = *data++;
594                         else
595                         {
596                                 *pack++ = 0xc1;
597                                 *pack++ = *data++;
598                         }
599                 }
600         }
601                         
602         // write the palette
603         *pack++ = 0x0c; // palette ID byte
604         for (i=0 ; i<768 ; i++)
605                 *pack++ = *palette++;
606                 
607 // write output file 
608         length = pack - (byte *)pcx;
609         SaveFile (filename, pcx, length);
610
611         free (pcx);
612
613  
614 /*
615 ============================================================================
616
617 LOAD BMP
618
619 ============================================================================
620 */
621
622
623 /*
624
625 // we can't just use these structures, because
626 // compiler structure alignment will not be portable
627 // on this unaligned stuff
628
629 typedef struct tagBITMAPFILEHEADER { // bmfh 
630         WORD    bfType;                         // BM
631         DWORD   bfSize; 
632         WORD    bfReserved1; 
633         WORD    bfReserved2; 
634         DWORD   bfOffBits; 
635 } BITMAPFILEHEADER; 
636  
637 typedef struct tagBITMAPINFOHEADER{ // bmih 
638    DWORD  biSize; 
639    LONG   biWidth; 
640    LONG   biHeight; 
641    WORD   biPlanes; 
642    WORD   biBitCount 
643    DWORD  biCompression; 
644    DWORD  biSizeImage; 
645    LONG   biXPelsPerMeter; 
646    LONG   biYPelsPerMeter; 
647    DWORD  biClrUsed; 
648    DWORD  biClrImportant; 
649 } BITMAPINFOHEADER; 
650  
651 typedef struct tagBITMAPINFO { // bmi 
652    BITMAPINFOHEADER bmiHeader; 
653    RGBQUAD          bmiColors[1]; 
654 } BITMAPINFO; 
655
656 typedef struct tagBITMAPCOREHEADER { // bmch 
657         DWORD   bcSize; 
658         WORD    bcWidth; 
659         WORD    bcHeight; 
660         WORD    bcPlanes; 
661         WORD    bcBitCount; 
662 } BITMAPCOREHEADER; 
663  
664 typedef struct _BITMAPCOREINFO {    // bmci 
665         BITMAPCOREHEADER  bmciHeader; 
666         RGBTRIPLE         bmciColors[1]; 
667 } BITMAPCOREINFO; 
668  
669 */
670
671 /*
672 ==============
673 LoadBMP
674 ==============
675 */
676 void LoadBMP (const char *filename, byte **pic, byte **palette, int *width, int *height)
677 {
678   byte  *out;
679   int           i;
680   int           bfSize; 
681   int           bfOffBits; 
682   int           structSize;
683   int           bcWidth; 
684   int     bcHeight; 
685   int       bcPlanes; 
686   int           bcBitCount; 
687   byte  bcPalette[1024];
688   qboolean      flipped;
689   byte *in;
690   int len, pos = 0;
691
692   len = vfsLoadFile (filename, (void **)&in, 0);
693   if (len == -1) 
694   {
695     Error ("Couldn't read %s", filename);
696   }
697
698   i = bufLittleShort (in, len, &pos);
699   if (i != 'B' + ('M'<<8) ) {
700     Error ("%s is not a bmp file", filename);
701   }
702
703   bfSize = bufLittleLong (in, len, &pos);
704   bufLittleShort(in, len, &pos);
705   bufLittleShort(in, len, &pos);
706   bfOffBits = bufLittleLong (in, len, &pos);
707
708   // the size will tell us if it is a
709   // bitmapinfo or a bitmapcore
710   structSize = bufLittleLong (in, len, &pos);
711   if (structSize == 40)
712   {
713     // bitmapinfo
714     bcWidth = bufLittleLong(in, len, &pos); 
715     bcHeight= bufLittleLong(in, len, &pos); 
716     bcPlanes = bufLittleShort(in, len, &pos); 
717     bcBitCount = bufLittleShort(in, len, &pos); 
718
719     pos += 24;
720
721     if (palette)
722     {
723       memcpy (bcPalette, in+pos, 1024);
724       pos += 1024;
725       *palette = safe_malloc(768);
726
727       for (i = 0 ; i < 256 ; i++)
728       {
729         (*palette)[i * 3 + 0] = bcPalette[i * 4 + 2];
730         (*palette)[i * 3 + 1] = bcPalette[i * 4 + 1];
731         (*palette)[i * 3 + 2] = bcPalette[i * 4 + 0];
732       }
733     }
734   }
735   else if (structSize == 12)
736   {
737     // bitmapcore
738     bcWidth = bufLittleShort(in, len, &pos); 
739     bcHeight= bufLittleShort(in, len, &pos); 
740     bcPlanes = bufLittleShort(in, len, &pos); 
741     bcBitCount = bufLittleShort(in, len, &pos); 
742
743     if (palette)
744     {
745       memcpy (bcPalette, in+pos, 768);
746       pos += 768;
747       *palette = safe_malloc(768);
748
749       for (i = 0 ; i < 256 ; i++) {
750         (*palette)[i * 3 + 0] = bcPalette[i * 3 + 2];
751         (*palette)[i * 3 + 1] = bcPalette[i * 3 + 1];
752         (*palette)[i * 3 + 2] = bcPalette[i * 3 + 0];
753       }
754     }
755   } else {
756     Error ("%s had strange struct size", filename);
757   }
758
759   if (bcPlanes != 1) {
760     Error ("%s was not a single plane image", filename);
761   }
762
763   if (bcBitCount != 8) {
764     Error ("%s was not an 8 bit image", filename);
765   }
766
767   if (bcHeight < 0) {
768     bcHeight = -bcHeight;
769     flipped = qtrue;
770   } else {
771     flipped = qfalse;
772   }
773
774   if (width)
775     *width = bcWidth;
776   if (height)
777     *height = bcHeight;
778
779   if (!pic) {
780     free (in);
781     return;
782   }
783
784   out = safe_malloc ( bcWidth * bcHeight );
785   *pic = out;
786   pos = bfOffBits;
787
788   if (flipped) {
789     for (i = 0 ; i < bcHeight ; i++) {
790       memcpy (out + bcWidth * (bcHeight - 1 - i), in+pos, bcWidth);
791       pos += bcWidth;
792     }
793   } else {
794     memcpy (out, in+pos, bcWidth*bcHeight);
795     pos += bcWidth*bcHeight;
796   }
797
798   free (in);
799 }
800
801
802 /*
803 ============================================================================
804
805 LOAD IMAGE
806
807 ============================================================================
808 */
809
810 /*
811 ==============
812 Load256Image
813
814 Will load either an lbm or pcx, depending on extension.
815 Any of the return pointers can be NULL if you don't want them.
816 ==============
817 */
818 void Load256Image (const char *name, byte **pixels, byte **palette, int *width, int *height)
819 {
820   char ext[128];
821
822   ExtractFileExtension (name, ext);
823   if (!Q_stricmp (ext, "lbm"))
824   {
825     LoadLBM (name, pixels, palette);
826     if (width)
827       *width = bmhd.w;
828     if (height)
829       *height = bmhd.h;
830   }
831   else if (!Q_stricmp (ext, "pcx"))
832   {
833     LoadPCX (name, pixels, palette, width, height);
834   }
835   else if (!Q_stricmp (ext, "bmp"))
836   {
837     LoadBMP (name, pixels, palette, width, height);
838   }
839   else
840     Error ("%s doesn't have a known image extension", name);
841 }
842
843
844 /*
845 ==============
846 Save256Image
847
848 Will save either an lbm or pcx, depending on extension.
849 ==============
850 */
851 void Save256Image (const char *name, byte *pixels, byte *palette,
852                                    int width, int height)
853 {
854         char    ext[128];
855
856         ExtractFileExtension (name, ext);
857         if (!Q_stricmp (ext, "lbm"))
858         {
859                 WriteLBMfile (name, pixels, width, height, palette);
860         }
861         else if (!Q_stricmp (ext, "pcx"))
862         {
863                 WritePCXfile (name, pixels, width, height, palette);
864         }
865         else
866                 Error ("%s doesn't have a known image extension", name);
867 }
868
869
870
871
872 /*
873 ============================================================================
874
875 TARGA IMAGE
876
877 ============================================================================
878 */
879
880 typedef struct _TargaHeader {
881         unsigned char   id_length, colormap_type, image_type;
882         unsigned short  colormap_index, colormap_length;
883         unsigned char   colormap_size;
884         unsigned short  x_origin, y_origin, width, height;
885         unsigned char   pixel_size, attributes;
886 } TargaHeader;
887
888 void TargaError(TargaHeader *t, const char *message)
889 {
890         Sys_Printf("%s\n:TargaHeader:\nuint8 id_length = %i;\nuint8 colormap_type = %i;\nuint8 image_type = %i;\nuint16 colormap_index = %i;\nuint16 colormap_length = %i;\nuint8 colormap_size = %i;\nuint16 x_origin = %i;\nuint16 y_origin = %i;\nuint16 width = %i;\nuint16 height = %i;\nuint8 pixel_size = %i;\nuint8 attributes = %i;\n", message, t->id_length, t->colormap_type, t->image_type, t->colormap_index, t->colormap_length, t->colormap_size, t->x_origin, t->y_origin, t->width, t->height, t->pixel_size, t->attributes);
891 }
892
893 /*
894 =============
895 LoadTGABuffer
896 =============
897 */
898 void LoadTGABuffer (const byte *f, const byte *enddata, byte **pic, int *width, int *height)
899 {
900         int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex, alphabits, image_width, image_height;
901         byte *pixbuf, *image_rgba;
902         const byte *fin;
903         unsigned char *p;
904         TargaHeader targa_header;
905         unsigned char palette[256*4];
906
907         *pic = NULL;
908
909         // abort if it is too small to parse
910         if (enddata - f < 19)
911                 return;
912
913         targa_header.id_length = f[0];
914         targa_header.colormap_type = f[1];
915         targa_header.image_type = f[2];
916
917         targa_header.colormap_index = f[3] + f[4] * 256;
918         targa_header.colormap_length = f[5] + f[6] * 256;
919         targa_header.colormap_size = f[7];
920         targa_header.x_origin = f[8] + f[9] * 256;
921         targa_header.y_origin = f[10] + f[11] * 256;
922         targa_header.width = image_width = f[12] + f[13] * 256;
923         targa_header.height = image_height = f[14] + f[15] * 256;
924
925         targa_header.pixel_size = f[16];
926         targa_header.attributes = f[17];
927
928         // advance to end of header
929         fin = f + 18;
930
931         // skip TARGA image comment (usually 0 bytes)
932         fin += targa_header.id_length;
933
934         // read/skip the colormap if present (note: according to the TARGA spec it
935         // can be present even on truecolor or greyscale images, just not used by
936         // the image data)
937         if (targa_header.colormap_type)
938         {
939                 if (targa_header.colormap_length > 256)
940                 {
941                         TargaError(&targa_header, "LoadTGA: only up to 256 colormap_length supported\n");
942                         return;
943                 }
944                 if (targa_header.colormap_index)
945                 {
946                         TargaError(&targa_header, "LoadTGA: colormap_index not supported\n");
947                         return;
948                 }
949                 if (targa_header.colormap_size == 24)
950                 {
951                         for (x = 0;x < targa_header.colormap_length;x++)
952                         {
953                                 palette[x*4+2] = *fin++;
954                                 palette[x*4+1] = *fin++;
955                                 palette[x*4+0] = *fin++;
956                                 palette[x*4+3] = 255;
957                         }
958                 }
959                 else if (targa_header.colormap_size == 32)
960                 {
961                         for (x = 0;x < targa_header.colormap_length;x++)
962                         {
963                                 palette[x*4+2] = *fin++;
964                                 palette[x*4+1] = *fin++;
965                                 palette[x*4+0] = *fin++;
966                                 palette[x*4+3] = *fin++;
967                         }
968                 }
969                 else
970                 {
971                         TargaError(&targa_header, "LoadTGA: Only 32 and 24 bit colormap_size supported\n");
972                         return;
973                 }
974         }
975
976         // check our pixel_size restrictions according to image_type
977         if (targa_header.image_type == 2 || targa_header.image_type == 10)
978         {
979                 if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
980                 {
981                         TargaError(&targa_header, "LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
982                         return;
983                 }
984         }
985         else if (targa_header.image_type == 1 || targa_header.image_type == 9)
986         {
987                 if (targa_header.pixel_size != 8)
988                 {
989                         TargaError(&targa_header, "LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
990                         return;
991                 }
992         }
993         else if (targa_header.image_type == 3 || targa_header.image_type == 11)
994         {
995                 if (targa_header.pixel_size != 8)
996                 {
997                         TargaError(&targa_header, "LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
998                         return;
999                 }
1000         }
1001         else
1002         {
1003                 TargaError(&targa_header, "LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported");
1004                 return;
1005         }
1006
1007         if (targa_header.attributes & 0x10)
1008         {
1009                 TargaError(&targa_header, "LoadTGA: origin must be in top left or bottom left, top right and bottom right are not supported\n");
1010                 return;
1011         }
1012
1013         // number of attribute bits per pixel, we only support 0 or 8
1014         alphabits = targa_header.attributes & 0x0F;
1015         if (alphabits != 8 && alphabits != 0)
1016         {
1017                 TargaError(&targa_header, "LoadTGA: only 0 or 8 attribute (alpha) bits supported\n");
1018                 return;
1019         }
1020
1021         image_rgba = safe_malloc(image_width * image_height * 4);
1022         if (!image_rgba)
1023         {
1024                 Sys_Printf("LoadTGA: not enough memory for %i by %i image\n", image_width, image_height);
1025                 return;
1026         }
1027
1028         // If bit 5 of attributes isn't set, the image has been stored from bottom to top
1029         if ((targa_header.attributes & 0x20) == 0)
1030         {
1031                 pixbuf = image_rgba + (image_height - 1)*image_width*4;
1032                 row_inc = -image_width*4*2;
1033         }
1034         else
1035         {
1036                 pixbuf = image_rgba;
1037                 row_inc = 0;
1038         }
1039
1040         compressed = targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11;
1041         x = 0;
1042         y = 0;
1043         red = green = blue = alpha = 255;
1044         while (y < image_height)
1045         {
1046                 // decoder is mostly the same whether it's compressed or not
1047                 readpixelcount = 1000000;
1048                 runlen = 1000000;
1049                 if (compressed && fin < enddata)
1050                 {
1051                         runlen = *fin++;
1052                         // high bit indicates this is an RLE compressed run
1053                         if (runlen & 0x80)
1054                                 readpixelcount = 1;
1055                         runlen = 1 + (runlen & 0x7f);
1056                 }
1057
1058                 while((runlen--) && y < image_height)
1059                 {
1060                         if (readpixelcount > 0)
1061                         {
1062                                 readpixelcount--;
1063                                 red = green = blue = alpha = 255;
1064                                 if (fin < enddata)
1065                                 {
1066                                         switch(targa_header.image_type)
1067                                         {
1068                                         case 1:
1069                                         case 9:
1070                                                 // colormapped
1071                                                 pindex = *fin++;
1072                                                 if (pindex >= targa_header.colormap_length)
1073                                                         pindex = 0; // error
1074                                                 p = palette + pindex * 4;
1075                                                 red = p[0];
1076                                                 green = p[1];
1077                                                 blue = p[2];
1078                                                 alpha = p[3];
1079                                                 break;
1080                                         case 2:
1081                                         case 10:
1082                                                 // BGR or BGRA
1083                                                 blue = *fin++;
1084                                                 if (fin < enddata)
1085                                                         green = *fin++;
1086                                                 if (fin < enddata)
1087                                                         red = *fin++;
1088                                                 if (targa_header.pixel_size == 32 && fin < enddata)
1089                                                         alpha = *fin++;
1090                                                 break;
1091                                         case 3:
1092                                         case 11:
1093                                                 // greyscale
1094                                                 red = green = blue = *fin++;
1095                                                 break;
1096                                         }
1097                                         if (!alphabits)
1098                                                 alpha = 255;
1099                                 }
1100                         }
1101                         *pixbuf++ = red;
1102                         *pixbuf++ = green;
1103                         *pixbuf++ = blue;
1104                         *pixbuf++ = alpha;
1105                         x++;
1106                         if (x == image_width)
1107                         {
1108                                 // end of line, advance to next
1109                                 x = 0;
1110                                 y++;
1111                                 pixbuf += row_inc;
1112                         }
1113                 }
1114         }
1115
1116         *pic = image_rgba;
1117         if (width)
1118                 *width = image_width;
1119         if (height)
1120                 *height = image_height;
1121 }
1122
1123
1124 /*
1125 =============
1126 LoadTGA
1127 =============
1128 */
1129 void LoadTGA (const char *name, byte **pixels, int *width, int *height)
1130 {
1131         byte                    *buffer;
1132         int nLen;
1133         //
1134         // load the file
1135         //
1136         nLen = vfsLoadFile ( ( char * ) name, (void **)&buffer, 0);
1137         if (nLen == -1)
1138         {
1139                 Error ("Couldn't read %s", name);
1140         }
1141
1142         LoadTGABuffer(buffer, buffer + nLen, pixels, width, height);
1143
1144 }
1145
1146
1147 /*
1148 ================
1149 WriteTGA
1150 ================
1151 */
1152 void WriteTGA (const char *filename, byte *data, int width, int height) {
1153         byte    *buffer;
1154         int             i;
1155         int             c;
1156         FILE    *f;
1157
1158         buffer = safe_malloc(width*height*4 + 18);
1159         memset (buffer, 0, 18);
1160         buffer[2] = 2;          // uncompressed type
1161         buffer[12] = width&255;
1162         buffer[13] = width>>8;
1163         buffer[14] = height&255;
1164         buffer[15] = height>>8;
1165         buffer[16] = 32;        // pixel size
1166
1167         // swap rgb to bgr
1168         c = 18 + width * height * 4;
1169         for (i=18 ; i<c ; i+=4)
1170         {
1171                 buffer[i] = data[i-18+2];               // blue
1172                 buffer[i+1] = data[i-18+1];             // green
1173                 buffer[i+2] = data[i-18+0];             // red
1174                 buffer[i+3] = data[i-18+3];             // alpha
1175         }
1176
1177         f = fopen (filename, "wb");
1178         fwrite (buffer, 1, c, f);
1179         fclose (f);
1180
1181         free (buffer);
1182 }
1183
1184 void WriteTGAGray (const char *filename, byte *data, int width, int height) {
1185         byte    buffer[18];
1186         int             i;
1187         int             c;
1188         FILE    *f;
1189
1190         memset (buffer, 0, 18);
1191         buffer[2] = 3;          // uncompressed type
1192         buffer[12] = width&255;
1193         buffer[13] = width>>8;
1194         buffer[14] = height&255;
1195         buffer[15] = height>>8;
1196         buffer[16] = 8; // pixel size
1197
1198         f = fopen (filename, "wb");
1199         fwrite (buffer, 1, 18, f);
1200         fwrite (data, 1, width * height, f);
1201         fclose (f);
1202 }
1203
1204 /*
1205 ============================================================================
1206
1207 LOAD32BITIMAGE
1208
1209 ============================================================================
1210 */
1211
1212 /*
1213 ==============
1214 Load32BitImage
1215
1216 Any of the return pointers can be NULL if you don't want them.
1217 ==============
1218 */
1219 void Load32BitImage (const char *name, unsigned **pixels,  int *width, int *height)
1220 {
1221         char    ext[128];
1222         byte    *palette;
1223         byte    *pixels8;
1224         byte    *pixels32;
1225         int             size;
1226         int             i;
1227         int             v;
1228
1229         ExtractFileExtension (name, ext);
1230         if (!Q_stricmp (ext, "tga")) {
1231                 LoadTGA (name, (byte **)pixels, width, height);
1232         } else {
1233                 Load256Image (name, &pixels8, &palette, width, height);
1234                 if (!pixels) {
1235                         return;
1236                 }
1237                 size = *width * *height;
1238                 pixels32 = safe_malloc(size * 4);
1239                 *pixels = (unsigned *)pixels32;
1240                 for (i = 0 ; i < size ; i++) {
1241                         v = pixels8[i];
1242                         pixels32[i*4 + 0] = palette[ v * 3 + 0 ];
1243                         pixels32[i*4 + 1] = palette[ v * 3 + 1 ];
1244                         pixels32[i*4 + 2] = palette[ v * 3 + 2 ];
1245                         pixels32[i*4 + 3] = 0xff;
1246                 }
1247         }
1248 }
1249
1250