]> git.xonotic.org Git - xonotic/netradiant.git/blob - tools/quake3/common/imagelib.c
Merge commit 'c5a6237a2b002c9811719172931b0c9cc5a725f4' into master-merge
[xonotic/netradiant.git] / tools / quake3 / common / imagelib.c
1 /*
2    Copyright (C) 1999-2007 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 "etclib.h"
27 #include "imagelib.h"
28 #include "vfs.h"
29
30 int fgetLittleShort( FILE *f ){
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         byte b1, b2, b3, b4;
41
42         b1 = fgetc( f );
43         b2 = fgetc( f );
44         b3 = fgetc( f );
45         b4 = fgetc( f );
46
47         return b1 + ( b2 << 8 ) + ( b3 << 16 ) + ( b4 << 24 );
48 }
49
50 int bufLittleShort( byte *buf, int len, int *pos ){
51         byte b1, b2;
52
53         if ( ( len - *pos ) < 2 ) {
54                 Error( "Unexpected buffer end" );
55         }
56
57         b1 = buf[*pos]; *pos += 1;
58         b2 = buf[*pos]; *pos += 1;
59
60         return (short)( b1 + b2 * 256 );
61 }
62
63 int bufLittleLong( byte *buf, int len, int *pos ){
64         byte b1, b2, b3, b4;
65
66         if ( ( len - *pos ) < 4 ) {
67                 Error( "Unexpected buffer end" );
68         }
69
70         b1 = buf[*pos]; *pos += 1;
71         b2 = buf[*pos]; *pos += 1;
72         b3 = buf[*pos]; *pos += 1;
73         b4 = buf[*pos]; *pos += 1;
74
75         return b1 + ( b2 << 8 ) + ( b3 << 16 ) + ( b4 << 24 );
76 }
77
78
79 /*
80    ============================================================================
81
82                         LBM STUFF
83
84    ============================================================================
85  */
86
87
88 typedef unsigned char UBYTE;
89 //conflicts with windows typedef short                  WORD;
90 typedef unsigned short UWORD;
91 typedef long LONG;
92
93 typedef enum
94 {
95         ms_none,
96         ms_mask,
97         ms_transcolor,
98         ms_lasso
99 } mask_t;
100
101 typedef enum
102 {
103         cm_none,
104         cm_rle1
105 } compress_t;
106
107 typedef struct
108 {
109         UWORD w,h;
110         short x,y;
111         UBYTE nPlanes;
112         UBYTE masking;
113         UBYTE compression;
114         UBYTE pad1;
115         UWORD transparentColor;
116         UBYTE xAspect,yAspect;
117         short pageWidth,pageHeight;
118 } bmhd_t;
119
120 extern bmhd_t bmhd;                         // will be in native byte order
121
122
123
124 #define FORMID ( 'F' + ( 'O' << 8 ) + ( (int)'R' << 16 ) + ( (int)'M' << 24 ) )
125 #define ILBMID ( 'I' + ( 'L' << 8 ) + ( (int)'B' << 16 ) + ( (int)'M' << 24 ) )
126 #define PBMID  ( 'P' + ( 'B' << 8 ) + ( (int)'M' << 16 ) + ( (int)' ' << 24 ) )
127 #define BMHDID ( 'B' + ( 'M' << 8 ) + ( (int)'H' << 16 ) + ( (int)'D' << 24 ) )
128 #define BODYID ( 'B' + ( 'O' << 8 ) + ( (int)'D' << 16 ) + ( (int)'Y' << 24 ) )
129 #define CMAPID ( 'C' + ( 'M' << 8 ) + ( (int)'A' << 16 ) + ( (int)'P' << 24 ) )
130
131
132 bmhd_t bmhd;
133
134 int    Align( int l ){
135         if ( l & 1 ) {
136                 return l + 1;
137         }
138         return l;
139 }
140
141
142
143 /*
144    ================
145    LBMRLEdecompress
146
147    Source must be evenly aligned!
148    ================
149  */
150 byte  *LBMRLEDecompress( byte *source,byte *unpacked, int bpwidth ){
151         int count;
152         byte b,rept;
153
154         count = 0;
155
156         do
157         {
158                 rept = *source++;
159
160                 if ( rept > 0x80 ) {
161                         rept = ( rept ^ 0xff ) + 2;
162                         b = *source++;
163                         memset( unpacked,b,rept );
164                         unpacked += rept;
165                 }
166                 else if ( rept < 0x80 ) {
167                         rept++;
168                         memcpy( unpacked,source,rept );
169                         unpacked += rept;
170                         source += rept;
171                 }
172                 else{
173                         rept = 0;               // rept of 0x80 is NOP
174
175                 }
176                 count += rept;
177
178         } while ( count < bpwidth );
179
180         if ( count > bpwidth ) {
181                 Error( "Decompression exceeded width!\n" );
182         }
183
184
185         return source;
186 }
187
188
189 /*
190    =================
191    LoadLBM
192    =================
193  */
194 void LoadLBM( const char *filename, byte **picture, byte **palette ){
195         byte    *LBMbuffer, *picbuffer, *cmapbuffer;
196         int y;
197         byte    *LBM_P, *LBMEND_P;
198         byte    *pic_p;
199         byte    *body_p;
200
201         int formtype,formlength;
202         int chunktype,chunklength;
203
204 // qiet compiler warnings
205         picbuffer = NULL;
206         cmapbuffer = NULL;
207
208 //
209 // load the LBM
210 //
211         LoadFile( filename, (void **)&LBMbuffer );
212
213 //
214 // parse the LBM header
215 //
216         LBM_P = LBMbuffer;
217         if ( *(int *)LBMbuffer != LittleLong( FORMID ) ) {
218                 Error( "No FORM ID at start of file!\n" );
219         }
220
221         LBM_P += 4;
222         formlength = BigLong( *(int *)LBM_P );
223         LBM_P += 4;
224         LBMEND_P = LBM_P + Align( formlength );
225
226         formtype = LittleLong( *(int *)LBM_P );
227
228         if ( formtype != ILBMID && formtype != PBMID ) {
229                 Error( "Unrecognized form type: %c%c%c%c\n", formtype & 0xff
230                            ,( formtype >> 8 ) & 0xff,( formtype >> 16 ) & 0xff,( formtype >> 24 ) & 0xff );
231         }
232
233         LBM_P += 4;
234
235 //
236 // parse chunks
237 //
238
239         while ( LBM_P < LBMEND_P )
240         {
241                 chunktype = LBM_P[0] + ( LBM_P[1] << 8 ) + ( LBM_P[2] << 16 ) + ( LBM_P[3] << 24 );
242                 LBM_P += 4;
243                 chunklength = LBM_P[3] + ( LBM_P[2] << 8 ) + ( LBM_P[1] << 16 ) + ( LBM_P[0] << 24 );
244                 LBM_P += 4;
245
246                 switch ( chunktype )
247                 {
248                 case BMHDID:
249                         memcpy( &bmhd,LBM_P,sizeof( bmhd ) );
250                         bmhd.w = BigShort( bmhd.w );
251                         bmhd.h = BigShort( bmhd.h );
252                         bmhd.x = BigShort( bmhd.x );
253                         bmhd.y = BigShort( bmhd.y );
254                         bmhd.pageWidth = BigShort( bmhd.pageWidth );
255                         bmhd.pageHeight = BigShort( bmhd.pageHeight );
256                         break;
257
258                 case CMAPID:
259                         cmapbuffer = safe_malloc0( 768 );
260                         memcpy( cmapbuffer, LBM_P, chunklength );
261                         break;
262
263                 case BODYID:
264                         body_p = LBM_P;
265
266                         pic_p = picbuffer = safe_malloc( bmhd.w * bmhd.h );
267                         if ( formtype == PBMID ) {
268                                 //
269                                 // unpack PBM
270                                 //
271                                 for ( y = 0 ; y < bmhd.h ; y++, pic_p += bmhd.w )
272                                 {
273                                         if ( bmhd.compression == cm_rle1 ) {
274                                                 body_p = LBMRLEDecompress( (byte *)body_p
275                                                                                                    , pic_p, bmhd.w );
276                                         }
277                                         else if ( bmhd.compression == cm_none ) {
278                                                 memcpy( pic_p,body_p,bmhd.w );
279                                                 body_p += Align( bmhd.w );
280                                         }
281                                 }
282
283                         }
284                         else
285                         {
286                                 //
287                                 // unpack ILBM
288                                 //
289                                 Error( "%s is an interlaced LBM, not packed", filename );
290                         }
291                         break;
292                 }
293
294                 LBM_P += Align( chunklength );
295         }
296
297         free( LBMbuffer );
298
299         *picture = picbuffer;
300
301         if ( palette ) {
302                 *palette = cmapbuffer;
303         }
304 }
305
306
307 /*
308    ============================================================================
309
310                             WRITE LBM
311
312    ============================================================================
313  */
314
315 /*
316    ==============
317    WriteLBMfile
318    ==============
319  */
320 void WriteLBMfile( const char *filename, byte *data,
321                                    int width, int height, byte *palette ){
322         byte    *lbm, *lbmptr;
323         int    *formlength, *bmhdlength, *cmaplength, *bodylength;
324         int length;
325         bmhd_t basebmhd;
326
327         lbm = lbmptr = safe_malloc( width * height + 1000 );
328
329 //
330 // start FORM
331 //
332         *lbmptr++ = 'F';
333         *lbmptr++ = 'O';
334         *lbmptr++ = 'R';
335         *lbmptr++ = 'M';
336
337         formlength = (int*)lbmptr;
338         lbmptr += 4;                      // leave space for length
339
340         *lbmptr++ = 'P';
341         *lbmptr++ = 'B';
342         *lbmptr++ = 'M';
343         *lbmptr++ = ' ';
344
345 //
346 // write BMHD
347 //
348         *lbmptr++ = 'B';
349         *lbmptr++ = 'M';
350         *lbmptr++ = 'H';
351         *lbmptr++ = 'D';
352
353         bmhdlength = (int *)lbmptr;
354         lbmptr += 4;                      // leave space for length
355
356         memset( &basebmhd,0,sizeof( basebmhd ) );
357         basebmhd.w = BigShort( (short)width );
358         basebmhd.h = BigShort( (short)height );
359         basebmhd.nPlanes = BigShort( 8 );
360         basebmhd.xAspect = BigShort( 5 );
361         basebmhd.yAspect = BigShort( 6 );
362         basebmhd.pageWidth = BigShort( (short)width );
363         basebmhd.pageHeight = BigShort( (short)height );
364
365         memcpy( lbmptr,&basebmhd,sizeof( basebmhd ) );
366         lbmptr += sizeof( basebmhd );
367
368         length = lbmptr - (byte *)bmhdlength - 4;
369         *bmhdlength = BigLong( length );
370         if ( length & 1 ) {
371                 *lbmptr++ = 0;          // pad chunk to even offset
372
373         }
374 //
375 // write CMAP
376 //
377         *lbmptr++ = 'C';
378         *lbmptr++ = 'M';
379         *lbmptr++ = 'A';
380         *lbmptr++ = 'P';
381
382         cmaplength = (int *)lbmptr;
383         lbmptr += 4;                      // leave space for length
384
385         memcpy( lbmptr,palette,768 );
386         lbmptr += 768;
387
388         length = lbmptr - (byte *)cmaplength - 4;
389         *cmaplength = BigLong( length );
390         if ( length & 1 ) {
391                 *lbmptr++ = 0;          // pad chunk to even offset
392
393         }
394 //
395 // write BODY
396 //
397         *lbmptr++ = 'B';
398         *lbmptr++ = 'O';
399         *lbmptr++ = 'D';
400         *lbmptr++ = 'Y';
401
402         bodylength = (int *)lbmptr;
403         lbmptr += 4;                      // leave space for length
404
405         memcpy( lbmptr,data,width * height );
406         lbmptr += width * height;
407
408         length = lbmptr - (byte *)bodylength - 4;
409         *bodylength = BigLong( length );
410         if ( length & 1 ) {
411                 *lbmptr++ = 0;          // pad chunk to even offset
412
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 //
424 // write output file
425 //
426         SaveFile( filename, lbm, lbmptr - lbm );
427         free( lbm );
428 }
429
430
431 /*
432    ============================================================================
433
434    LOAD PCX
435
436    ============================================================================
437  */
438
439 typedef struct
440 {
441         char manufacturer;
442         char version;
443         char encoding;
444         char bits_per_pixel;
445         unsigned short xmin,ymin,xmax,ymax;
446         unsigned short hres,vres;
447         unsigned char palette[48];
448         char reserved;
449         char color_planes;
450         unsigned short bytes_per_line;
451         unsigned short palette_type;
452         char filler[58];
453         unsigned char data;             // unbounded
454 } pcx_t;
455
456
457 /*
458    ==============
459    LoadPCX
460    ==============
461  */
462
463 /* RR2DO2 */
464 #define DECODEPCX( b, d, r ) d = *b++; if ( ( d & 0xC0 ) == 0xC0 ) {r = d & 0x3F; d = *b++; }else{r = 1; }
465
466 void LoadPCX( const char *filename, byte **pic, byte **palette, int *width, int *height ){
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
482         /* parse the PCX file */
483         pcx = (pcx_t *)raw;
484         raw = &pcx->data;
485
486         pcx->xmin = LittleShort( pcx->xmin );
487         pcx->ymin = LittleShort( pcx->ymin );
488         pcx->xmax = LittleShort( pcx->xmax );
489         pcx->ymax = LittleShort( pcx->ymax );
490         pcx->hres = LittleShort( pcx->hres );
491         pcx->vres = LittleShort( pcx->vres );
492         pcx->bytes_per_line = LittleShort( pcx->bytes_per_line );
493         pcx->palette_type = LittleShort( pcx->palette_type );
494
495         if ( pcx->manufacturer != 0x0a
496                  || pcx->version != 5
497                  || pcx->encoding != 1
498                  || pcx->bits_per_pixel != 8
499                  || pcx->xmax >= 640
500                  || pcx->ymax >= 480 ) {
501                 Error( "Bad pcx file %s", filename );
502         }
503
504         if ( palette ) {
505                 *palette = safe_malloc( 768 );
506                 memcpy( *palette, (byte *)pcx + len - 768, 768 );
507         }
508
509         if ( width ) {
510                 *width = pcx->xmax + 1;
511         }
512         if ( height ) {
513                 *height = pcx->ymax + 1;
514         }
515
516         if ( !pic ) {
517                 return;
518         }
519
520         out = safe_malloc( ( pcx->ymax + 1 ) * ( pcx->xmax + 1 ) );
521         if ( !out ) {
522                 Error( "LoadPCX: couldn't allocate" );
523         }
524
525         *pic = out;
526         pix = out;
527
528         /* RR2DO2: pcx fix  */
529         lsize = pcx->color_planes * pcx->bytes_per_line;
530
531         /* go scanline by scanline */
532         for ( y = 0; y <= pcx->ymax; y++, pix += pcx->xmax + 1 )
533         {
534                 /* do a scanline */
535                 runLength = 0;
536                 for ( x = 0; x <= pcx->xmax; )
537                 {
538                         /* RR2DO2 */
539                         DECODEPCX( raw, dataByte, runLength );
540                         while ( runLength-- > 0 )
541                                 pix[ x++ ] = dataByte;
542                 }
543
544                 /* RR2DO2: discard any other data */
545                 while ( x < lsize )
546                 {
547                         DECODEPCX( raw, dataByte, runLength );
548                         x++;
549                 }
550                 while ( runLength-- > 0 )
551                         x++;
552         }
553
554         /* validity check */
555         if ( raw - (byte *) pcx > len ) {
556                 Error( "PCX file %s was malformed", filename );
557         }
558         free( pcx );
559 }
560
561
562
563 /*
564    ==============
565    WritePCXfile
566    ==============
567  */
568 void WritePCXfile( const char *filename, byte *data,
569                                    int width, int height, byte *palette ){
570         int i, j, length;
571         pcx_t   *pcx;
572         byte        *pack;
573
574         pcx = safe_malloc0( width * height * 2 + 1000 );
575
576         pcx->manufacturer = 0x0a;   // PCX id
577         pcx->version = 5;           // 256 color
578         pcx->encoding = 1;      // uncompressed
579         pcx->bits_per_pixel = 8;        // 256 color
580         pcx->xmin = 0;
581         pcx->ymin = 0;
582         pcx->xmax = LittleShort( (short)( width - 1 ) );
583         pcx->ymax = LittleShort( (short)( height - 1 ) );
584         pcx->hres = LittleShort( (short)width );
585         pcx->vres = LittleShort( (short)height );
586         pcx->color_planes = 1;      // chunky image
587         pcx->bytes_per_line = LittleShort( (short)width );
588         pcx->palette_type = LittleShort( 1 );     // not a grey scale
589
590         // pack the image
591         pack = &pcx->data;
592
593         for ( i = 0 ; i < height ; i++ )
594         {
595                 for ( j = 0 ; j < width ; j++ )
596                 {
597                         if ( ( *data & 0xc0 ) != 0xc0 ) {
598                                 *pack++ = *data++;
599                         }
600                         else
601                         {
602                                 *pack++ = 0xc1;
603                                 *pack++ = *data++;
604                         }
605                 }
606         }
607
608         // write the palette
609         *pack++ = 0x0c; // palette ID byte
610         for ( i = 0 ; i < 768 ; i++ )
611                 *pack++ = *palette++;
612
613 // write output file
614         length = pack - (byte *)pcx;
615         SaveFile( filename, pcx, length );
616
617         free( pcx );
618 }
619
620 /*
621    ============================================================================
622
623    LOAD BMP
624
625    ============================================================================
626  */
627
628
629 /*
630
631    // we can't just use these structures, because
632    // compiler structure alignment will not be portable
633    // on this unaligned stuff
634
635    typedef struct tagBITMAPFILEHEADER { // bmfh
636         WORD    bfType;                         // BM
637         DWORD   bfSize;
638         WORD    bfReserved1;
639         WORD    bfReserved2;
640         DWORD   bfOffBits;
641    } BITMAPFILEHEADER;
642
643    typedef struct tagBITMAPINFOHEADER{ // bmih
644    DWORD  biSize;
645    LONG   biWidth;
646    LONG   biHeight;
647    WORD   biPlanes;
648    WORD   biBitCount
649    DWORD  biCompression;
650    DWORD  biSizeImage;
651    LONG   biXPelsPerMeter;
652    LONG   biYPelsPerMeter;
653    DWORD  biClrUsed;
654    DWORD  biClrImportant;
655    } BITMAPINFOHEADER;
656
657    typedef struct tagBITMAPINFO { // bmi
658    BITMAPINFOHEADER bmiHeader;
659    RGBQUAD          bmiColors[1];
660    } BITMAPINFO;
661
662    typedef struct tagBITMAPCOREHEADER { // bmch
663         DWORD   bcSize;
664         WORD    bcWidth;
665         WORD    bcHeight;
666         WORD    bcPlanes;
667         WORD    bcBitCount;
668    } BITMAPCOREHEADER;
669
670    typedef struct _BITMAPCOREINFO {    // bmci
671         BITMAPCOREHEADER  bmciHeader;
672         RGBTRIPLE         bmciColors[1];
673    } BITMAPCOREINFO;
674
675  */
676
677 /*
678    ==============
679    LoadBMP
680    ==============
681  */
682 void LoadBMP( const char *filename, byte **pic, byte **palette, int *width, int *height ){
683         byte  *out;
684         int i;
685         int bfOffBits;
686         int structSize;
687         int bcWidth;
688         int bcHeight;
689         int bcPlanes;
690         int bcBitCount;
691         byte bcPalette[1024];
692         qboolean flipped;
693         byte *in;
694         int len, pos = 0;
695
696         len = vfsLoadFile( filename, (void **)&in, 0 );
697         if ( len == -1 ) {
698                 Error( "Couldn't read %s", filename );
699         }
700
701         i = bufLittleShort( in, len, &pos );
702         if ( i != 'B' + ( 'M' << 8 ) ) {
703                 Error( "%s is not a bmp file", filename );
704         }
705
706         /* bfSize = */ bufLittleLong( in, len, &pos );
707         bufLittleShort( in, len, &pos );
708         bufLittleShort( in, len, &pos );
709         bfOffBits = bufLittleLong( in, len, &pos );
710
711         // the size will tell us if it is a
712         // bitmapinfo or a bitmapcore
713         structSize = bufLittleLong( in, len, &pos );
714         if ( structSize == 40 ) {
715                 // bitmapinfo
716                 bcWidth = bufLittleLong( in, len, &pos );
717                 bcHeight = bufLittleLong( in, len, &pos );
718                 bcPlanes = bufLittleShort( in, len, &pos );
719                 bcBitCount = bufLittleShort( in, len, &pos );
720
721                 pos += 24;
722
723                 if ( palette ) {
724                         memcpy( bcPalette, in + pos, 1024 );
725                         pos += 1024;
726                         *palette = safe_malloc( 768 );
727
728                         for ( i = 0 ; i < 256 ; i++ )
729                         {
730                                 ( *palette )[i * 3 + 0] = bcPalette[i * 4 + 2];
731                                 ( *palette )[i * 3 + 1] = bcPalette[i * 4 + 1];
732                                 ( *palette )[i * 3 + 2] = bcPalette[i * 4 + 0];
733                         }
734                 }
735         }
736         else if ( structSize == 12 ) {
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                         memcpy( bcPalette, in + pos, 768 );
745                         pos += 768;
746                         *palette = safe_malloc( 768 );
747
748                         for ( i = 0 ; i < 256 ; i++ ) {
749                                 ( *palette )[i * 3 + 0] = bcPalette[i * 3 + 2];
750                                 ( *palette )[i * 3 + 1] = bcPalette[i * 3 + 1];
751                                 ( *palette )[i * 3 + 2] = bcPalette[i * 3 + 0];
752                         }
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         }
771         else {
772                 flipped = qfalse;
773         }
774
775         if ( width ) {
776                 *width = bcWidth;
777         }
778         if ( height ) {
779                 *height = bcHeight;
780         }
781
782         if ( !pic ) {
783                 free( in );
784                 return;
785         }
786
787         out = safe_malloc( bcWidth * bcHeight );
788         *pic = out;
789         pos = bfOffBits;
790
791         if ( flipped ) {
792                 for ( i = 0 ; i < bcHeight ; i++ ) {
793                         memcpy( out + bcWidth * ( bcHeight - 1 - i ), in + pos, bcWidth );
794                         pos += bcWidth;
795                 }
796         }
797         else {
798                 memcpy( out, in + pos, bcWidth * bcHeight );
799                 pos += bcWidth * bcHeight;
800         }
801
802         free( in );
803 }
804
805
806 /*
807    ============================================================================
808
809    LOAD IMAGE
810
811    ============================================================================
812  */
813
814 /*
815    ==============
816    Load256Image
817
818    Will load either an lbm or pcx, depending on extension.
819    Any of the return pointers can be NULL if you don't want them.
820    ==============
821  */
822 void Load256Image( const char *name, byte **pixels, byte **palette, int *width, int *height ){
823         char ext[128];
824
825         ExtractFileExtension( name, ext );
826         if ( !Q_stricmp( ext, "lbm" ) ) {
827                 LoadLBM( name, pixels, palette );
828                 if ( width ) {
829                         *width = bmhd.w;
830                 }
831                 if ( height ) {
832                         *height = bmhd.h;
833                 }
834         }
835         else if ( !Q_stricmp( ext, "pcx" ) ) {
836                 LoadPCX( name, pixels, palette, width, height );
837         }
838         else if ( !Q_stricmp( ext, "bmp" ) ) {
839                 LoadBMP( name, pixels, palette, width, height );
840         }
841         else{
842                 Error( "%s doesn't have a known image extension", name );
843         }
844 }
845
846
847 /*
848    ==============
849    Save256Image
850
851    Will save either an lbm or pcx, depending on extension.
852    ==============
853  */
854 void Save256Image( const char *name, byte *pixels, byte *palette,
855                                    int width, int height ){
856         char ext[128];
857
858         ExtractFileExtension( name, ext );
859         if ( !Q_stricmp( ext, "lbm" ) ) {
860                 WriteLBMfile( name, pixels, width, height, palette );
861         }
862         else if ( !Q_stricmp( ext, "pcx" ) ) {
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
876    TARGA IMAGE
877
878    ============================================================================
879  */
880
881 typedef struct _TargaHeader {
882         unsigned char id_length, colormap_type, image_type;
883         unsigned short colormap_index, colormap_length;
884         unsigned char colormap_size;
885         unsigned short x_origin, y_origin, width, height;
886         unsigned char pixel_size, attributes;
887 } TargaHeader;
888
889 void TargaError( TargaHeader *t, const char *message ){
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         int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex, alphabits, image_width, image_height;
900         byte *pixbuf, *image_rgba;
901         const byte *fin;
902         unsigned char *p;
903         TargaHeader targa_header;
904         unsigned char palette[256 * 4];
905
906         *pic = NULL;
907
908         // abort if it is too small to parse
909         if ( enddata - f < 19 ) {
910                 return;
911         }
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                 if ( targa_header.colormap_length > 256 ) {
939                         TargaError( &targa_header, "LoadTGA: only up to 256 colormap_length supported\n" );
940                         return;
941                 }
942                 if ( targa_header.colormap_index ) {
943                         TargaError( &targa_header, "LoadTGA: colormap_index not supported\n" );
944                         return;
945                 }
946                 if ( targa_header.colormap_size == 24 ) {
947                         for ( x = 0; x < targa_header.colormap_length; x++ )
948                         {
949                                 palette[x * 4 + 2] = *fin++;
950                                 palette[x * 4 + 1] = *fin++;
951                                 palette[x * 4 + 0] = *fin++;
952                                 palette[x * 4 + 3] = 255;
953                         }
954                 }
955                 else if ( targa_header.colormap_size == 32 ) {
956                         for ( x = 0; x < targa_header.colormap_length; x++ )
957                         {
958                                 palette[x * 4 + 2] = *fin++;
959                                 palette[x * 4 + 1] = *fin++;
960                                 palette[x * 4 + 0] = *fin++;
961                                 palette[x * 4 + 3] = *fin++;
962                         }
963                 }
964                 else
965                 {
966                         TargaError( &targa_header, "LoadTGA: Only 32 and 24 bit colormap_size supported\n" );
967                         return;
968                 }
969         }
970
971         // check our pixel_size restrictions according to image_type
972         if ( targa_header.image_type == 2 || targa_header.image_type == 10 ) {
973                 if ( targa_header.pixel_size != 24 && targa_header.pixel_size != 32 ) {
974                         TargaError( &targa_header, "LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n" );
975                         return;
976                 }
977         }
978         else if ( targa_header.image_type == 1 || targa_header.image_type == 9 ) {
979                 if ( targa_header.pixel_size != 8 ) {
980                         TargaError( &targa_header, "LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n" );
981                         return;
982                 }
983         }
984         else if ( targa_header.image_type == 3 || targa_header.image_type == 11 ) {
985                 if ( targa_header.pixel_size != 8 ) {
986                         TargaError( &targa_header, "LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n" );
987                         return;
988                 }
989         }
990         else
991         {
992                 TargaError( &targa_header, "LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported" );
993                 return;
994         }
995
996         if ( targa_header.attributes & 0x10 ) {
997                 TargaError( &targa_header, "LoadTGA: origin must be in top left or bottom left, top right and bottom right are not supported\n" );
998                 return;
999         }
1000
1001         // number of attribute bits per pixel, we only support 0 or 8
1002         alphabits = targa_header.attributes & 0x0F;
1003         if ( alphabits != 8 && alphabits != 0 ) {
1004                 TargaError( &targa_header, "LoadTGA: only 0 or 8 attribute (alpha) bits supported\n" );
1005                 return;
1006         }
1007
1008         image_rgba = safe_malloc( image_width * image_height * 4 );
1009         if ( !image_rgba ) {
1010                 Sys_Printf( "LoadTGA: not enough memory for %i by %i image\n", image_width, image_height );
1011                 return;
1012         }
1013
1014         // If bit 5 of attributes isn't set, the image has been stored from bottom to top
1015         if ( ( targa_header.attributes & 0x20 ) == 0 ) {
1016                 pixbuf = image_rgba + ( image_height - 1 ) * image_width * 4;
1017                 row_inc = -image_width * 4 * 2;
1018         }
1019         else
1020         {
1021                 pixbuf = image_rgba;
1022                 row_inc = 0;
1023         }
1024
1025         compressed = targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11;
1026         x = 0;
1027         y = 0;
1028         red = green = blue = alpha = 255;
1029         while ( y < image_height )
1030         {
1031                 // decoder is mostly the same whether it's compressed or not
1032                 readpixelcount = 1000000;
1033                 runlen = 1000000;
1034                 if ( compressed && fin < enddata ) {
1035                         runlen = *fin++;
1036                         // high bit indicates this is an RLE compressed run
1037                         if ( runlen & 0x80 ) {
1038                                 readpixelcount = 1;
1039                         }
1040                         runlen = 1 + ( runlen & 0x7f );
1041                 }
1042
1043                 while ( ( runlen-- ) && y < image_height )
1044                 {
1045                         if ( readpixelcount > 0 ) {
1046                                 readpixelcount--;
1047                                 red = green = blue = alpha = 255;
1048                                 if ( fin < enddata ) {
1049                                         switch ( targa_header.image_type )
1050                                         {
1051                                         case 1:
1052                                         case 9:
1053                                                 // colormapped
1054                                                 pindex = *fin++;
1055                                                 if ( pindex >= targa_header.colormap_length ) {
1056                                                         pindex = 0; // error
1057                                                 }
1058                                                 p = palette + pindex * 4;
1059                                                 red = p[0];
1060                                                 green = p[1];
1061                                                 blue = p[2];
1062                                                 alpha = p[3];
1063                                                 break;
1064                                         case 2:
1065                                         case 10:
1066                                                 // BGR or BGRA
1067                                                 blue = *fin++;
1068                                                 if ( fin < enddata ) {
1069                                                         green = *fin++;
1070                                                 }
1071                                                 if ( fin < enddata ) {
1072                                                         red = *fin++;
1073                                                 }
1074                                                 if ( targa_header.pixel_size == 32 && fin < enddata ) {
1075                                                         alpha = *fin++;
1076                                                 }
1077                                                 break;
1078                                         case 3:
1079                                         case 11:
1080                                                 // greyscale
1081                                                 red = green = blue = *fin++;
1082                                                 break;
1083                                         }
1084                                         if ( !alphabits ) {
1085                                                 alpha = 255;
1086                                         }
1087                                 }
1088                         }
1089                         *pixbuf++ = red;
1090                         *pixbuf++ = green;
1091                         *pixbuf++ = blue;
1092                         *pixbuf++ = alpha;
1093                         x++;
1094                         if ( x == image_width ) {
1095                                 // end of line, advance to next
1096                                 x = 0;
1097                                 y++;
1098                                 pixbuf += row_inc;
1099                         }
1100                 }
1101         }
1102
1103         *pic = image_rgba;
1104         if ( width ) {
1105                 *width = image_width;
1106         }
1107         if ( height ) {
1108                 *height = image_height;
1109         }
1110 }
1111
1112
1113 /*
1114    =============
1115    LoadTGA
1116    =============
1117  */
1118 void LoadTGA( const char *name, byte **pixels, int *width, int *height ){
1119         byte            *buffer;
1120         int nLen;
1121         //
1122         // load the file
1123         //
1124         nLen = vfsLoadFile( name, (void **)&buffer, 0 );
1125         if ( nLen == -1 ) {
1126                 Error( "Couldn't read %s", name );
1127         }
1128
1129         LoadTGABuffer( buffer, buffer + nLen, pixels, width, height );
1130
1131 }
1132
1133
1134 /*
1135    ================
1136    WriteTGA
1137    ================
1138  */
1139 void WriteTGA( const char *filename, byte *data, int width, int height ) {
1140         byte    *buffer;
1141         int i;
1142         int c;
1143         FILE    *f;
1144
1145         buffer = safe_malloc( width * height * 4 + 18 );
1146         /* we may also use safe_malloc0 on the whole instead,
1147          * this would just be a bit slower */
1148         memset( buffer, 0, 18 );
1149         buffer[2] = 2;      // uncompressed type
1150         buffer[12] = width & 255;
1151         buffer[13] = width >> 8;
1152         buffer[14] = height & 255;
1153         buffer[15] = height >> 8;
1154         buffer[16] = 32;    // pixel size
1155
1156         // swap rgb to bgr
1157         c = 18 + width * height * 4;
1158         for ( i = 18 ; i < c ; i += 4 )
1159         {
1160                 buffer[i] = data[i - 18 + 2];       // blue
1161                 buffer[i + 1] = data[i - 18 + 1];     // green
1162                 buffer[i + 2] = data[i - 18 + 0];     // red
1163                 buffer[i + 3] = data[i - 18 + 3];     // alpha
1164         }
1165
1166         f = fopen( filename, "wb" );
1167         fwrite( buffer, 1, c, f );
1168         fclose( f );
1169
1170         free( buffer );
1171 }
1172
1173 void WriteTGAGray( const char *filename, byte *data, int width, int height ) {
1174         byte buffer[18];
1175         FILE *f;
1176
1177         memset( buffer, 0, 18 );
1178         buffer[2] = 3;      // uncompressed type
1179         buffer[12] = width & 255;
1180         buffer[13] = width >> 8;
1181         buffer[14] = height & 255;
1182         buffer[15] = height >> 8;
1183         buffer[16] = 8; // pixel size
1184
1185         f = fopen( filename, "wb" );
1186         fwrite( buffer, 1, 18, f );
1187         fwrite( data, 1, width * height, f );
1188         fclose( f );
1189 }
1190
1191 /*
1192    ============================================================================
1193
1194    LOAD32BITIMAGE
1195
1196    ============================================================================
1197  */
1198
1199 /*
1200    ==============
1201    Load32BitImage
1202
1203    Any of the return pointers can be NULL if you don't want them.
1204    ==============
1205  */
1206 void Load32BitImage( const char *name, unsigned **pixels,  int *width, int *height ){
1207         char ext[128];
1208         byte    *palette;
1209         byte    *pixels8;
1210         byte    *pixels32;
1211         int size;
1212         int i;
1213         int v;
1214
1215         ExtractFileExtension( name, ext );
1216         if ( !Q_stricmp( ext, "tga" ) ) {
1217                 LoadTGA( name, (byte **)pixels, width, height );
1218         }
1219         else {
1220                 Load256Image( name, &pixels8, &palette, width, height );
1221                 if ( !pixels ) {
1222                         return;
1223                 }
1224                 size = *width * *height;
1225                 pixels32 = safe_malloc( size * 4 );
1226                 *pixels = (unsigned *)pixels32;
1227                 for ( i = 0 ; i < size ; i++ ) {
1228                         v = pixels8[i];
1229                         pixels32[i * 4 + 0] = palette[ v * 3 + 0 ];
1230                         pixels32[i * 4 + 1] = palette[ v * 3 + 1 ];
1231                         pixels32[i * 4 + 2] = palette[ v * 3 + 2 ];
1232                         pixels32[i * 4 + 3] = 0xff;
1233                 }
1234         }
1235 }
1236
1237
1238 /*
1239    ============================================================================
1240
1241    KHRONOS TEXTURE
1242
1243    ============================================================================
1244  */
1245
1246
1247 #define KTX_UINT32_LE( buf ) ( ( unsigned int )( (buf)[0] | ( (buf)[1] << 8 ) | ( (buf)[2] << 16 ) | ( (buf)[3] << 24 ) ) )
1248 #define KTX_UINT32_BE( buf ) ( ( unsigned int )( (buf)[3] | ( (buf)[2] << 8 ) | ( (buf)[1] << 16 ) | ( (buf)[0] << 24 ) ) )
1249
1250 #define KTX_TYPE_UNSIGNED_BYTE                          0x1401
1251 #define KTX_TYPE_UNSIGNED_SHORT_4_4_4_4         0x8033
1252 #define KTX_TYPE_UNSIGNED_SHORT_5_5_5_1         0x8034
1253 #define KTX_TYPE_UNSIGNED_SHORT_5_6_5           0x8363
1254
1255 #define KTX_FORMAT_ALPHA                                        0x1906
1256 #define KTX_FORMAT_RGB                                          0x1907
1257 #define KTX_FORMAT_RGBA                                         0x1908
1258 #define KTX_FORMAT_LUMINANCE                            0x1909
1259 #define KTX_FORMAT_LUMINANCE_ALPHA                      0x190A
1260 #define KTX_FORMAT_BGR                                          0x80E0
1261 #define KTX_FORMAT_BGRA                                         0x80E1
1262
1263 #define KTX_FORMAT_ETC1_RGB8                            0x8D64
1264
1265 static void KTX_DecodeA8( const byte *in, qboolean bigEndian, byte *out ){
1266         out[0] = out[1] = out[2] = 0;
1267         out[3] = in[0];
1268 }
1269
1270 static void KTX_DecodeRGB8( const byte *in, qboolean bigEndian, byte *out ){
1271         out[0] = in[0];
1272         out[1] = in[1];
1273         out[2] = in[2];
1274         out[3] = 255;
1275 }
1276
1277 static void KTX_DecodeRGBA8( const byte *in, qboolean bigEndian, byte *out ){
1278         out[0] = in[0];
1279         out[1] = in[1];
1280         out[2] = in[2];
1281         out[3] = in[3];
1282 }
1283
1284 static void KTX_DecodeL8( const byte *in, qboolean bigEndian, byte *out ){
1285         out[0] = out[1] = out[2] = in[0];
1286         out[3] = 255;
1287 }
1288
1289 static void KTX_DecodeLA8( const byte *in, qboolean bigEndian, byte *out ){
1290         out[0] = out[1] = out[2] = in[0];
1291         out[3] = in[1];
1292 }
1293
1294 static void KTX_DecodeBGR8( const byte *in, qboolean bigEndian, byte *out ){
1295         out[0] = in[2];
1296         out[1] = in[1];
1297         out[2] = in[0];
1298         out[3] = 255;
1299 }
1300
1301 static void KTX_DecodeBGRA8( const byte *in, qboolean bigEndian, byte *out ){
1302         out[0] = in[2];
1303         out[1] = in[1];
1304         out[2] = in[0];
1305         out[3] = in[3];
1306 }
1307
1308 static void KTX_DecodeRGBA4( const byte *in, qboolean bigEndian, byte *out ){
1309         unsigned short rgba;
1310         int r, g, b, a;
1311
1312         if ( bigEndian ) {
1313                 rgba = ( in[0] << 8 ) | in[1];
1314         }
1315         else {
1316                 rgba = ( in[1] << 8 ) | in[0];
1317         }
1318
1319         r = ( rgba >> 12 ) & 0xf;
1320         g = ( rgba >> 8 ) & 0xf;
1321         b = ( rgba >> 4 ) & 0xf;
1322         a = rgba & 0xf;
1323         out[0] = ( r << 4 ) | r;
1324         out[1] = ( g << 4 ) | g;
1325         out[2] = ( b << 4 ) | b;
1326         out[3] = ( a << 4 ) | a;
1327 }
1328
1329 static void KTX_DecodeRGBA5( const byte *in, qboolean bigEndian, byte *out ){
1330         unsigned short rgba;
1331         int r, g, b;
1332
1333         if ( bigEndian ) {
1334                 rgba = ( in[0] << 8 ) | in[1];
1335         }
1336         else {
1337                 rgba = ( in[1] << 8 ) | in[0];
1338         }
1339
1340         r = ( rgba >> 11 ) & 0x1f;
1341         g = ( rgba >> 6 ) & 0x1f;
1342         b = ( rgba >> 1 ) & 0x1f;
1343         out[0] = ( r << 3 ) | ( r >> 2 );
1344         out[1] = ( g << 3 ) | ( g >> 2 );
1345         out[2] = ( b << 3 ) | ( b >> 2 );
1346         out[3] = ( rgba & 1 ) * 255;
1347 }
1348
1349 static void KTX_DecodeRGB5( const byte *in, qboolean bigEndian, byte *out ){
1350         unsigned short rgba;
1351         int r, g, b;
1352
1353         if ( bigEndian ) {
1354                 rgba = ( in[0] << 8 ) | in[1];
1355         }
1356         else {
1357                 rgba = ( in[1] << 8 ) | in[0];
1358         }
1359
1360         r = ( rgba >> 11 ) & 0x1f;
1361         g = ( rgba >> 5 ) & 0x3f;
1362         b = rgba & 0x1f;
1363         out[0] = ( r << 3 ) | ( r >> 2 );
1364         out[1] = ( g << 2 ) | ( g >> 4 );
1365         out[2] = ( b << 3 ) | ( b >> 2 );
1366         out[3] = 255;
1367 }
1368
1369 typedef struct
1370 {
1371         unsigned int type;
1372         unsigned int format;
1373         unsigned int pixelSize;
1374         void ( *decode )( const byte *in, qboolean bigEndian, byte *out );
1375 } KTX_UncompressedFormat_t;
1376
1377 static const KTX_UncompressedFormat_t KTX_UncompressedFormats[] =
1378 {
1379         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_ALPHA, 1, KTX_DecodeA8 },
1380         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_RGB, 3, KTX_DecodeRGB8 },
1381         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_RGBA, 4, KTX_DecodeRGBA8 },
1382         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_LUMINANCE, 1, KTX_DecodeL8 },
1383         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_LUMINANCE_ALPHA, 2, KTX_DecodeLA8 },
1384         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_BGR, 3, KTX_DecodeBGR8 },
1385         { KTX_TYPE_UNSIGNED_BYTE, KTX_FORMAT_BGRA, 4, KTX_DecodeBGRA8 },
1386         { KTX_TYPE_UNSIGNED_SHORT_4_4_4_4, KTX_FORMAT_RGBA, 2, KTX_DecodeRGBA4 },
1387         { KTX_TYPE_UNSIGNED_SHORT_5_5_5_1, KTX_FORMAT_RGBA, 2, KTX_DecodeRGBA5 },
1388         { KTX_TYPE_UNSIGNED_SHORT_5_6_5, KTX_FORMAT_RGB, 2, KTX_DecodeRGB5 },
1389         { 0, 0, 0, NULL }
1390 };
1391
1392 static qboolean KTX_DecodeETC1( const byte* in, size_t inSize, unsigned int width, unsigned int height, byte* out ){
1393         unsigned int y, stride = width * 4;
1394         byte rgba[64];
1395
1396         if ( inSize < ( ( ( ( width + 3 ) & ~3 ) * ( ( height + 3 ) & ~3 ) ) >> 1 ) ) {
1397                 return qfalse;
1398         }
1399
1400         for ( y = 0; y < height; y += 4, out += stride * 4 )
1401         {
1402                 byte *p;
1403                 unsigned int x, blockrows;
1404
1405                 blockrows = height - y;
1406                 if ( blockrows > 4 ) {
1407                         blockrows = 4;
1408                 }
1409
1410                 p = out;
1411                 for ( x = 0; x < width; x += 4, p += 16 )
1412                 {
1413                         unsigned int blockrowsize, blockrow;
1414
1415                         ETC_DecodeETC1Block( in, rgba, qtrue );
1416                         in += 8;
1417
1418                         blockrowsize = width - x;
1419                         if ( blockrowsize > 4 ) {
1420                                 blockrowsize = 4;
1421                         }
1422                         blockrowsize *= 4;
1423                         for ( blockrow = 0; blockrow < blockrows; blockrow++ )
1424                         {
1425                                 memcpy( p + blockrow * stride, rgba + blockrow * 16, blockrowsize );
1426                         }
1427                 }
1428         }
1429
1430         return qtrue;
1431 }
1432
1433 #define KTX_HEADER_UINT32( buf ) ( bigEndian ? KTX_UINT32_BE( buf ) : KTX_UINT32_LE( buf ) )
1434
1435 void LoadKTXBufferFirstImage( const byte *buffer, size_t bufSize, byte **pic, int *picWidth, int *picHeight ){
1436         unsigned int type, format, width, height, imageOffset;
1437         byte *pixels;
1438
1439         if ( bufSize < 64 ) {
1440                 Error( "LoadKTX: Image doesn't have a header" );
1441         }
1442
1443         if ( memcmp( buffer, "\xABKTX 11\xBB\r\n\x1A\n", 12 ) ) {
1444                 Error( "LoadKTX: Image has the wrong identifier" );
1445         }
1446
1447         qboolean bigEndian = ( buffer[4] == 4 );
1448
1449         type = KTX_HEADER_UINT32( buffer + 16 );
1450         if ( type ) {
1451                 format = KTX_HEADER_UINT32( buffer + 32 );
1452         }
1453         else {
1454                 format = KTX_HEADER_UINT32( buffer + 28 );
1455         }
1456
1457         width = KTX_HEADER_UINT32( buffer + 36 );
1458         height = KTX_HEADER_UINT32( buffer + 40 );
1459         if ( !width ) {
1460                 Error( "LoadKTX: Image has zero width" );
1461         }
1462         if ( !height ) {
1463                 height = 1;
1464         }
1465         if ( picWidth ) {
1466                 *picWidth = width;
1467         }
1468         if ( picHeight ) {
1469                 *picHeight = height;
1470         }
1471
1472         imageOffset = 64 + KTX_HEADER_UINT32( buffer + 60 ) + 4;
1473         if ( bufSize < imageOffset ) {
1474                 Error( "LoadKTX: No image in the file" );
1475         }
1476         buffer += imageOffset;
1477         bufSize -= imageOffset;
1478
1479         pixels = safe_malloc( width * height * 4 );
1480         *pic = pixels;
1481
1482         if ( type ) {
1483                 const KTX_UncompressedFormat_t *ktxFormat = KTX_UncompressedFormats;
1484                 unsigned int pixelSize;
1485                 unsigned int inRowLength, inPadding;
1486                 unsigned int y;
1487
1488                 while ( ktxFormat->type )
1489                 {
1490                         if ( ktxFormat->type == type && ktxFormat->format == format ) {
1491                                 break;
1492                         }
1493                         ktxFormat++;
1494                 }
1495                 if ( !ktxFormat->type ) {
1496                         Error( "LoadKTX: Image has an unsupported pixel type 0x%X or format 0x%X", type, format );
1497                 }
1498
1499                 pixelSize = ktxFormat->pixelSize;
1500                 inRowLength = width * pixelSize;
1501                 inPadding = ( ( inRowLength + 3 ) & ~3 ) - inRowLength;
1502
1503                 if ( bufSize < height * ( inRowLength + inPadding ) ) {
1504                         Error( "LoadKTX: Image is truncated" );
1505                 }
1506
1507                 for ( y = 0; y < height; y++ )
1508                 {
1509                         unsigned int x;
1510                         for ( x = 0; x < width; x++, buffer += pixelSize, pixels += 4 )
1511                         {
1512                                 ktxFormat->decode( buffer, bigEndian, pixels );
1513                         }
1514                         buffer += inPadding;
1515                 }
1516         }
1517         else {
1518                 qboolean decoded = qfalse;
1519
1520                 switch ( format )
1521                 {
1522                 case KTX_FORMAT_ETC1_RGB8:
1523                         decoded = KTX_DecodeETC1( buffer, bufSize, width, height, pixels );
1524                         break;
1525                 default:
1526                         Error( "LoadKTX: Image has an unsupported compressed format format 0x%X", format );
1527                         break;
1528                 }
1529
1530                 if ( !decoded ) {
1531                         Error( "LoadKTX: Image is truncated" );
1532                 }
1533         }
1534 }