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_malloc( 768 );
 260                         memset( cmapbuffer, 0, 768 );
 261                         memcpy( cmapbuffer, LBM_P, chunklength );
 262                         break;
 263
 264                 case BODYID:
 265                         body_p = LBM_P;
 266
 267                         pic_p = picbuffer = safe_malloc( bmhd.w * bmhd.h );
 268                         if ( formtype == PBMID ) {
 269                                 //
 270                                 // unpack PBM
 271                                 //
 272                                 for ( y = 0 ; y < bmhd.h ; y++, pic_p += bmhd.w )
 273                                 {
 274                                         if ( bmhd.compression == cm_rle1 ) {
 275                                                 body_p = LBMRLEDecompress( (byte *)body_p
 276                                                                                                    , pic_p, bmhd.w );
 277                                         }
 278                                         else if ( bmhd.compression == cm_none ) {
 279                                                 memcpy( pic_p,body_p,bmhd.w );
 280                                                 body_p += Align( bmhd.w );
 281                                         }
 282                                 }
 283
 284                         }
 285                         else
 286                         {
 287                                 //
 288                                 // unpack ILBM
 289                                 //
 290                                 Error( "%s is an interlaced LBM, not packed", filename );
 291                         }
 292                         break;
 293                 }
 294
 295                 LBM_P += Align( chunklength );
 296         }
 297
 298         free( LBMbuffer );
 299
 300         *picture = picbuffer;
 301
 302         if ( palette ) {
 303                 *palette = cmapbuffer;
 304         }
 305 }
 306
 307
 308 /*
 309    ============================================================================
 310
 311                             WRITE LBM
 312
 313    ============================================================================
 314  */
 315
 316 /*
 317    ==============
 318    WriteLBMfile
 319    ==============
 320  */
 321 void WriteLBMfile( const char *filename, byte *data,
 322                                    int width, int height, byte *palette ){
 323         byte    *lbm, *lbmptr;
 324         int    *formlength, *bmhdlength, *cmaplength, *bodylength;
 325         int length;
 326         bmhd_t basebmhd;
 327
 328         lbm = lbmptr = safe_malloc( width * height + 1000 );
 329
 330 //
 331 // start FORM
 332 //
 333         *lbmptr++ = 'F';
 334         *lbmptr++ = 'O';
 335         *lbmptr++ = 'R';
 336         *lbmptr++ = 'M';
 337
 338         formlength = (int*)lbmptr;
 339         lbmptr += 4;                      // leave space for length
 340
 341         *lbmptr++ = 'P';
 342         *lbmptr++ = 'B';
 343         *lbmptr++ = 'M';
 344         *lbmptr++ = ' ';
 345
 346 //
 347 // write BMHD
 348 //
 349         *lbmptr++ = 'B';
 350         *lbmptr++ = 'M';
 351         *lbmptr++ = 'H';
 352         *lbmptr++ = 'D';
 353
 354         bmhdlength = (int *)lbmptr;
 355         lbmptr += 4;                      // leave space for length
 356
 357         memset( &basebmhd,0,sizeof( basebmhd ) );
 358         basebmhd.w = BigShort( (short)width );
 359         basebmhd.h = BigShort( (short)height );
 360         basebmhd.nPlanes = BigShort( 8 );
 361         basebmhd.xAspect = BigShort( 5 );
 362         basebmhd.yAspect = BigShort( 6 );
 363         basebmhd.pageWidth = BigShort( (short)width );
 364         basebmhd.pageHeight = BigShort( (short)height );
 365
 366         memcpy( lbmptr,&basebmhd,sizeof( basebmhd ) );
 367         lbmptr += sizeof( basebmhd );
 368
 369         length = lbmptr - (byte *)bmhdlength - 4;
 370         *bmhdlength = BigLong( length );
 371         if ( length & 1 ) {
 372                 *lbmptr++ = 0;          // pad chunk to even offset
 373
 374         }
 375 //
 376 // write CMAP
 377 //
 378         *lbmptr++ = 'C';
 379         *lbmptr++ = 'M';
 380         *lbmptr++ = 'A';
 381         *lbmptr++ = 'P';
 382
 383         cmaplength = (int *)lbmptr;
 384         lbmptr += 4;                      // leave space for length
 385
 386         memcpy( lbmptr,palette,768 );
 387         lbmptr += 768;
 388
 389         length = lbmptr - (byte *)cmaplength - 4;
 390         *cmaplength = BigLong( length );
 391         if ( length & 1 ) {
 392                 *lbmptr++ = 0;          // pad chunk to even offset
 393
 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 //
 416 // done
 417 //
 418         length = lbmptr - (byte *)formlength - 4;
 419         *formlength = BigLong( length );
 420         if ( length & 1 ) {
 421                 *lbmptr++ = 0;          // pad chunk to even offset
 422
 423         }
 424 //
 425 // write output file
 426 //
 427         SaveFile( filename, lbm, lbmptr - lbm );
 428         free( lbm );
 429 }
 430
 431
 432 /*
 433    ============================================================================
 434
 435    LOAD PCX
 436
 437    ============================================================================
 438  */
 439
 440 typedef struct
 441 {
 442         char manufacturer;
 443         char version;
 444         char encoding;
 445         char bits_per_pixel;
 446         unsigned short xmin,ymin,xmax,ymax;
 447         unsigned short hres,vres;
 448         unsigned char palette[48];
 449         char reserved;
 450         char color_planes;
 451         unsigned short bytes_per_line;
 452         unsigned short palette_type;
 453         char filler[58];
 454         unsigned char data;             // unbounded
 455 } pcx_t;
 456
 457
 458 /*
 459    ==============
 460    LoadPCX
 461    ==============
 462  */
 463
 464 /* RR2DO2 */
 465 #define DECODEPCX( b, d, r ) d = *b++; if ( ( d & 0xC0 ) == 0xC0 ) {r = d & 0x3F; d = *b++; }else{r = 1; }
 466
 467 void LoadPCX( const char *filename, byte **pic, byte **palette, int *width, int *height ){
 468         byte    *raw;
 469         pcx_t   *pcx;
 470         int x, y, lsize;
 471         int len;
 472         int dataByte, runLength;
 473         byte    *out, *pix;
 474
 475
 476         /* load the file */
 477         len = vfsLoadFile( filename, (void **)&raw, 0 );
 478         if ( len == -1 ) {
 479                 Error( "LoadPCX: Couldn't read %s", filename );
 480         }
 481
 482
 483         /* parse the PCX file */
 484         pcx = (pcx_t *)raw;
 485         raw = &pcx->data;
 486
 487         pcx->xmin = LittleShort( pcx->xmin );
 488         pcx->ymin = LittleShort( pcx->ymin );
 489         pcx->xmax = LittleShort( pcx->xmax );
 490         pcx->ymax = LittleShort( pcx->ymax );
 491         pcx->hres = LittleShort( pcx->hres );
 492         pcx->vres = LittleShort( pcx->vres );
 493         pcx->bytes_per_line = LittleShort( pcx->bytes_per_line );
 494         pcx->palette_type = LittleShort( pcx->palette_type );
 495
 496         if ( pcx->manufacturer != 0x0a
 497                  || pcx->version != 5
 498                  || pcx->encoding != 1
 499                  || pcx->bits_per_pixel != 8
 500                  || pcx->xmax >= 640
 501                  || pcx->ymax >= 480 ) {
 502                 Error( "Bad pcx file %s", filename );
 503         }
 504
 505         if ( palette ) {
 506                 *palette = safe_malloc( 768 );
 507                 memcpy( *palette, (byte *)pcx + len - 768, 768 );
 508         }
 509
 510         if ( width ) {
 511                 *width = pcx->xmax + 1;
 512         }
 513         if ( height ) {
 514                 *height = pcx->ymax + 1;
 515         }
 516
 517         if ( !pic ) {
 518                 return;
 519         }
 520
 521         out = safe_malloc( ( pcx->ymax + 1 ) * ( pcx->xmax + 1 ) );
 522         if ( !out ) {
 523                 Error( "LoadPCX: couldn't allocate" );
 524         }
 525
 526         *pic = out;
 527         pix = out;
 528
 529         /* RR2DO2: pcx fix  */
 530         lsize = pcx->color_planes * pcx->bytes_per_line;
 531
 532         /* go scanline by scanline */
 533         for ( y = 0; y <= pcx->ymax; y++, pix += pcx->xmax + 1 )
 534         {
 535                 /* do a scanline */
 536                 runLength = 0;
 537                 for ( x = 0; x <= pcx->xmax; )
 538                 {
 539                         /* RR2DO2 */
 540                         DECODEPCX( raw, dataByte, runLength );
 541                         while ( runLength-- > 0 )
 542                                 pix[ x++ ] = dataByte;
 543                 }
 544
 545                 /* RR2DO2: discard any other data */
 546                 while ( x < lsize )
 547                 {
 548                         DECODEPCX( raw, dataByte, runLength );
 549                         x++;
 550                 }
 551                 while ( runLength-- > 0 )
 552                         x++;
 553         }
 554
 555         /* validity check */
 556         if ( raw - (byte *) pcx > len ) {
 557                 Error( "PCX file %s was malformed", filename );
 558         }
 559         free( pcx );
 560 }
 561
 562
 563
 564 /*
 565    ==============
 566    WritePCXfile
 567    ==============
 568  */
 569 void WritePCXfile( const char *filename, byte *data,
 570                                    int width, int height, byte *palette ){
 571         int i, j, length;
 572         pcx_t   *pcx;
 573         byte        *pack;
 574
 575         pcx = safe_malloc( width * height * 2 + 1000 );
 576         memset( pcx, 0, sizeof( *pcx ) );
 577
 578         pcx->manufacturer = 0x0a;   // PCX id
 579         pcx->version = 5;           // 256 color
 580         pcx->encoding = 1;      // uncompressed
 581         pcx->bits_per_pixel = 8;        // 256 color
 582         pcx->xmin = 0;
 583         pcx->ymin = 0;
 584         pcx->xmax = LittleShort( (short)( width - 1 ) );
 585         pcx->ymax = LittleShort( (short)( height - 1 ) );
 586         pcx->hres = LittleShort( (short)width );
 587         pcx->vres = LittleShort( (short)height );
 588         pcx->color_planes = 1;      // chunky image
 589         pcx->bytes_per_line = LittleShort( (short)width );
 590         pcx->palette_type = LittleShort( 1 );     // not a grey scale
 591
 592         // pack the image
 593         pack = &pcx->data;
 594
 595         for ( i = 0 ; i < height ; i++ )
 596         {
 597                 for ( j = 0 ; j < width ; j++ )
 598                 {
 599                         if ( ( *data & 0xc0 ) != 0xc0 ) {
 600                                 *pack++ = *data++;
 601                         }
 602                         else
 603                         {
 604                                 *pack++ = 0xc1;
 605                                 *pack++ = *data++;
 606                         }
 607                 }
 608         }
 609
 610         // write the palette
 611         *pack++ = 0x0c; // palette ID byte
 612         for ( i = 0 ; i < 768 ; i++ )
 613                 *pack++ = *palette++;
 614
 615 // write output file
 616         length = pack - (byte *)pcx;
 617         SaveFile( filename, pcx, length );
 618
 619         free( pcx );
 620 }
 621
 622 /*
 623    ============================================================================
 624
 625    LOAD BMP
 626
 627    ============================================================================
 628  */
 629
 630
 631 /*
 632
 633    // we can't just use these structures, because
 634    // compiler structure alignment will not be portable
 635    // on this unaligned stuff
 636
 637    typedef struct tagBITMAPFILEHEADER { // bmfh
 638         WORD    bfType;                         // BM
 639         DWORD   bfSize;
 640         WORD    bfReserved1;
 641         WORD    bfReserved2;
 642         DWORD   bfOffBits;
 643    } BITMAPFILEHEADER;
 644
 645    typedef struct tagBITMAPINFOHEADER{ // bmih
 646    DWORD  biSize;
 647    LONG   biWidth;
 648    LONG   biHeight;
 649    WORD   biPlanes;
 650    WORD   biBitCount
 651    DWORD  biCompression;
 652    DWORD  biSizeImage;
 653    LONG   biXPelsPerMeter;
 654    LONG   biYPelsPerMeter;
 655    DWORD  biClrUsed;
 656    DWORD  biClrImportant;
 657    } BITMAPINFOHEADER;
 658
 659    typedef struct tagBITMAPINFO { // bmi
 660    BITMAPINFOHEADER bmiHeader;
 661    RGBQUAD          bmiColors[1];
 662    } BITMAPINFO;
 663
 664    typedef struct tagBITMAPCOREHEADER { // bmch
 665         DWORD   bcSize;
 666         WORD    bcWidth;
 667         WORD    bcHeight;
 668         WORD    bcPlanes;
 669         WORD    bcBitCount;
 670    } BITMAPCOREHEADER;
 671
 672    typedef struct _BITMAPCOREINFO {    // bmci
 673         BITMAPCOREHEADER  bmciHeader;
 674         RGBTRIPLE         bmciColors[1];
 675    } BITMAPCOREINFO;
 676
 677  */
 678
 679 /*
 680    ==============
 681    LoadBMP
 682    ==============
 683  */
 684 void LoadBMP( const char *filename, byte **pic, byte **palette, int *width, int *height ){
 685         byte  *out;
 686         int i;
 687         int bfOffBits;
 688         int structSize;
 689         int bcWidth;
 690         int bcHeight;
 691         int bcPlanes;
 692         int bcBitCount;
 693         byte bcPalette[1024];
 694         qboolean flipped;
 695         byte *in;
 696         int len, pos = 0;
 697
 698         len = vfsLoadFile( filename, (void **)&in, 0 );
 699         if ( len == -1 ) {
 700                 Error( "Couldn't read %s", filename );
 701         }
 702
 703         i = bufLittleShort( in, len, &pos );
 704         if ( i != 'B' + ( 'M' << 8 ) ) {
 705                 Error( "%s is not a bmp file", filename );
 706         }
 707
 708         /* bfSize = */ bufLittleLong( in, len, &pos );
 709         bufLittleShort( in, len, &pos );
 710         bufLittleShort( in, len, &pos );
 711         bfOffBits = bufLittleLong( in, len, &pos );
 712
 713         // the size will tell us if it is a
 714         // bitmapinfo or a bitmapcore
 715         structSize = bufLittleLong( in, len, &pos );
 716         if ( structSize == 40 ) {
 717                 // bitmapinfo
 718                 bcWidth = bufLittleLong( in, len, &pos );
 719                 bcHeight = bufLittleLong( in, len, &pos );
 720                 bcPlanes = bufLittleShort( in, len, &pos );
 721                 bcBitCount = bufLittleShort( in, len, &pos );
 722
 723                 pos += 24;
 724
 725                 if ( palette ) {
 726                         memcpy( bcPalette, in + pos, 1024 );
 727                         pos += 1024;
 728                         *palette = safe_malloc( 768 );
 729
 730                         for ( i = 0 ; i < 256 ; i++ )
 731                         {
 732                                 ( *palette )[i * 3 + 0] = bcPalette[i * 4 + 2];
 733                                 ( *palette )[i * 3 + 1] = bcPalette[i * 4 + 1];
 734                                 ( *palette )[i * 3 + 2] = bcPalette[i * 4 + 0];
 735                         }
 736                 }
 737         }
 738         else if ( structSize == 12 ) {
 739                 // bitmapcore
 740                 bcWidth = bufLittleShort( in, len, &pos );
 741                 bcHeight = bufLittleShort( in, len, &pos );
 742                 bcPlanes = bufLittleShort( in, len, &pos );
 743                 bcBitCount = bufLittleShort( in, len, &pos );
 744
 745                 if ( palette ) {
 746                         memcpy( bcPalette, in + pos, 768 );
 747                         pos += 768;
 748                         *palette = safe_malloc( 768 );
 749
 750                         for ( i = 0 ; i < 256 ; i++ ) {
 751                                 ( *palette )[i * 3 + 0] = bcPalette[i * 3 + 2];
 752                                 ( *palette )[i * 3 + 1] = bcPalette[i * 3 + 1];
 753                                 ( *palette )[i * 3 + 2] = bcPalette[i * 3 + 0];
 754                         }
 755                 }
 756         }
 757         else {
 758                 Error( "%s had strange struct size", filename );
 759         }
 760
 761         if ( bcPlanes != 1 ) {
 762                 Error( "%s was not a single plane image", filename );
 763         }
 764
 765         if ( bcBitCount != 8 ) {
 766                 Error( "%s was not an 8 bit image", filename );
 767         }
 768
 769         if ( bcHeight < 0 ) {
 770                 bcHeight = -bcHeight;
 771                 flipped = qtrue;
 772         }
 773         else {
 774                 flipped = qfalse;
 775         }
 776
 777         if ( width ) {
 778                 *width = bcWidth;
 779         }
 780         if ( height ) {
 781                 *height = bcHeight;
 782         }
 783
 784         if ( !pic ) {
 785                 free( in );
 786                 return;
 787         }
 788
 789         out = safe_malloc( bcWidth * bcHeight );
 790         *pic = out;
 791         pos = bfOffBits;
 792
 793         if ( flipped ) {
 794                 for ( i = 0 ; i < bcHeight ; i++ ) {
 795                         memcpy( out + bcWidth * ( bcHeight - 1 - i ), in + pos, bcWidth );
 796                         pos += bcWidth;
 797                 }
 798         }
 799         else {
 800                 memcpy( out, in + pos, bcWidth * bcHeight );
 801                 pos += bcWidth * bcHeight;
 802         }
 803
 804         free( in );
 805 }
 806
 807
 808 /*
 809    ============================================================================
 810
 811    LOAD IMAGE
 812
 813    ============================================================================
 814  */
 815
 816 /*
 817    ==============
 818    Load256Image
 819
 820    Will load either an lbm or pcx, depending on extension.
 821    Any of the return pointers can be NULL if you don't want them.
 822    ==============
 823  */
 824 void Load256Image( const char *name, byte **pixels, byte **palette, int *width, int *height ){
 825         char ext[128];
 826
 827         ExtractFileExtension( name, ext );
 828         if ( !Q_stricmp( ext, "lbm" ) ) {
 829                 LoadLBM( name, pixels, palette );
 830                 if ( width ) {
 831                         *width = bmhd.w;
 832                 }
 833                 if ( height ) {
 834                         *height = bmhd.h;
 835                 }
 836         }
 837         else if ( !Q_stricmp( ext, "pcx" ) ) {
 838                 LoadPCX( name, pixels, palette, width, height );
 839         }
 840         else if ( !Q_stricmp( ext, "bmp" ) ) {
 841                 LoadBMP( name, pixels, palette, width, height );
 842         }
 843         else{
 844                 Error( "%s doesn't have a known image extension", name );
 845         }
 846 }
 847
 848
 849 /*
 850    ==============
 851    Save256Image
 852
 853    Will save either an lbm or pcx, depending on extension.
 854    ==============
 855  */
 856 void Save256Image( const char *name, byte *pixels, byte *palette,
 857                                    int width, int height ){
 858         char ext[128];
 859
 860         ExtractFileExtension( name, ext );
 861         if ( !Q_stricmp( ext, "lbm" ) ) {
 862                 WriteLBMfile( name, pixels, width, height, palette );
 863         }
 864         else if ( !Q_stricmp( ext, "pcx" ) ) {
 865                 WritePCXfile( name, pixels, width, height, palette );
 866         }
 867         else{
 868                 Error( "%s doesn't have a known image extension", name );
 869         }
 870 }
 871
 872
 873
 874
 875 /*
 876    ============================================================================
 877
 878    TARGA IMAGE
 879
 880    ============================================================================
 881  */
 882
 883 typedef struct _TargaHeader {
 884         unsigned char id_length, colormap_type, image_type;
 885         unsigned short colormap_index, colormap_length;
 886         unsigned char colormap_size;
 887         unsigned short x_origin, y_origin, width, height;
 888         unsigned char pixel_size, attributes;
 889 } TargaHeader;
 890
 891 void TargaError( TargaHeader *t, const char *message ){
 892         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 );
 893 }
 894
 895 /*
 896    =============
 897    LoadTGABuffer
 898    =============
 899  */
 900 void LoadTGABuffer( const byte *f, const byte *enddata, byte **pic, int *width, int *height ){
 901         int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex, alphabits, image_width, image_height;
 902         byte *pixbuf, *image_rgba;
 903         const byte *fin;
 904         unsigned char *p;
 905         TargaHeader targa_header;
 906         unsigned char palette[256 * 4];
 907
 908         *pic = NULL;
 909
 910         // abort if it is too small to parse
 911         if ( enddata - f < 19 ) {
 912                 return;
 913         }
 914
 915         targa_header.id_length = f[0];
 916         targa_header.colormap_type = f[1];
 917         targa_header.image_type = f[2];
 918
 919         targa_header.colormap_index = f[3] + f[4] * 256;
 920         targa_header.colormap_length = f[5] + f[6] * 256;
 921         targa_header.colormap_size = f[7];
 922         targa_header.x_origin = f[8] + f[9] * 256;
 923         targa_header.y_origin = f[10] + f[11] * 256;
 924         targa_header.width = image_width = f[12] + f[13] * 256;
 925         targa_header.height = image_height = f[14] + f[15] * 256;
 926
 927         targa_header.pixel_size = f[16];
 928         targa_header.attributes = f[17];
 929
 930         // advance to end of header
 931         fin = f + 18;
 932
 933         // skip TARGA image comment (usually 0 bytes)
 934         fin += targa_header.id_length;
 935
 936         // read/skip the colormap if present (note: according to the TARGA spec it
 937         // can be present even on truecolor or greyscale images, just not used by
 938         // the image data)
 939         if ( targa_header.colormap_type ) {
 940                 if ( targa_header.colormap_length > 256 ) {
 941                         TargaError( &targa_header, "LoadTGA: only up to 256 colormap_length supported\n" );
 942                         return;
 943                 }
 944                 if ( targa_header.colormap_index ) {
 945                         TargaError( &targa_header, "LoadTGA: colormap_index not supported\n" );
 946                         return;
 947                 }
 948                 if ( targa_header.colormap_size == 24 ) {
 949                         for ( x = 0; x < targa_header.colormap_length; x++ )
 950                         {
 951                                 palette[x * 4 + 2] = *fin++;
 952                                 palette[x * 4 + 1] = *fin++;
 953                                 palette[x * 4 + 0] = *fin++;
 954                                 palette[x * 4 + 3] = 255;
 955                         }
 956                 }
 957                 else if ( targa_header.colormap_size == 32 ) {
 958                         for ( x = 0; x < targa_header.colormap_length; x++ )
 959                         {
 960                                 palette[x * 4 + 2] = *fin++;
 961                                 palette[x * 4 + 1] = *fin++;
 962                                 palette[x * 4 + 0] = *fin++;
 963                                 palette[x * 4 + 3] = *fin++;
 964                         }
 965                 }
 966                 else
 967                 {
 968                         TargaError( &targa_header, "LoadTGA: Only 32 and 24 bit colormap_size supported\n" );
 969                         return;
 970                 }
 971         }
 972
 973         // check our pixel_size restrictions according to image_type
 974         if ( targa_header.image_type == 2 || targa_header.image_type == 10 ) {
 975                 if ( targa_header.pixel_size != 24 && targa_header.pixel_size != 32 ) {
 976                         TargaError( &targa_header, "LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n" );
 977                         return;
 978                 }
 979         }
 980         else if ( targa_header.image_type == 1 || targa_header.image_type == 9 ) {
 981                 if ( targa_header.pixel_size != 8 ) {
 982                         TargaError( &targa_header, "LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n" );
 983                         return;
 984                 }
 985         }
 986         else if ( targa_header.image_type == 3 || targa_header.image_type == 11 ) {
 987                 if ( targa_header.pixel_size != 8 ) {
 988                         TargaError( &targa_header, "LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n" );
 989                         return;
 990                 }
 991         }
 992         else
 993         {
 994                 TargaError( &targa_header, "LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported" );
 995                 return;
 996         }
 997
 998         if ( targa_header.attributes & 0x10 ) {
 999                 TargaError( &targa_header, "LoadTGA: origin must be in top left or bottom left, top right and bottom right are not supported\n" );
1000                 return;
1001         }
1002
1003         // number of attribute bits per pixel, we only support 0 or 8
1004         alphabits = targa_header.attributes & 0x0F;
1005         if ( alphabits != 8 && alphabits != 0 ) {
1006                 TargaError( &targa_header, "LoadTGA: only 0 or 8 attribute (alpha) bits supported\n" );
1007                 return;
1008         }
1009
1010         image_rgba = safe_malloc( image_width * image_height * 4 );
1011         if ( !image_rgba ) {
1012                 Sys_Printf( "LoadTGA: not enough memory for %i by %i image\n", image_width, image_height );
1013                 return;
1014         }
1015
1016         // If bit 5 of attributes isn't set, the image has been stored from bottom to top
1017         if ( ( targa_header.attributes & 0x20 ) == 0 ) {
1018                 pixbuf = image_rgba + ( image_height - 1 ) * image_width * 4;
1019                 row_inc = -image_width * 4 * 2;
1020         }
1021         else
1022         {
1023                 pixbuf = image_rgba;
1024                 row_inc = 0;
1025         }
1026
1027         compressed = targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11;
1028         x = 0;
1029         y = 0;
1030         red = green = blue = alpha = 255;
1031         while ( y < image_height )
1032         {
1033                 // decoder is mostly the same whether it's compressed or not
1034                 readpixelcount = 1000000;
1035                 runlen = 1000000;
1036                 if ( compressed && fin < enddata ) {
1037                         runlen = *fin++;
1038                         // high bit indicates this is an RLE compressed run
1039                         if ( runlen & 0x80 ) {
1040                                 readpixelcount = 1;
1041                         }
1042                         runlen = 1 + ( runlen & 0x7f );
1043                 }
1044
1045                 while ( ( runlen-- ) && y < image_height )
1046                 {
1047                         if ( readpixelcount > 0 ) {
1048                                 readpixelcount--;
1049                                 red = green = blue = alpha = 255;
1050                                 if ( fin < enddata ) {
1051                                         switch ( targa_header.image_type )
1052                                         {
1053                                         case 1:
1054                                         case 9:
1055                                                 // colormapped
1056                                                 pindex = *fin++;
1057                                                 if ( pindex >= targa_header.colormap_length ) {
1058                                                         pindex = 0; // error
1059                                                 }
1060                                                 p = palette + pindex * 4;
1061                                                 red = p[0];
1062                                                 green = p[1];
1063                                                 blue = p[2];
1064                                                 alpha = p[3];
1065                                                 break;
1066                                         case 2:
1067                                         case 10:
1068                                                 // BGR or BGRA
1069                                                 blue = *fin++;
1070                                                 if ( fin < enddata ) {
1071                                                         green = *fin++;
1072                                                 }
1073                                                 if ( fin < enddata ) {
1074                                                         red = *fin++;
1075                                                 }
1076                                                 if ( targa_header.pixel_size == 32 && fin < enddata ) {
1077                                                         alpha = *fin++;
1078                                                 }
1079                                                 break;
1080                                         case 3:
1081                                         case 11:
1082                                                 // greyscale
1083                                                 red = green = blue = *fin++;
1084                                                 break;
1085                                         }
1086                                         if ( !alphabits ) {
1087                                                 alpha = 255;
1088                                         }
1089                                 }
1090                         }
1091                         *pixbuf++ = red;
1092                         *pixbuf++ = green;
1093                         *pixbuf++ = blue;
1094                         *pixbuf++ = alpha;
1095                         x++;
1096                         if ( x == image_width ) {
1097                                 // end of line, advance to next
1098                                 x = 0;
1099                                 y++;
1100                                 pixbuf += row_inc;
1101                         }
1102                 }
1103         }
1104
1105         *pic = image_rgba;
1106         if ( width ) {
1107                 *width = image_width;
1108         }
1109         if ( height ) {
1110                 *height = image_height;
1111         }
1112 }
1113
1114
1115 /*
1116    =============
1117    LoadTGA
1118    =============
1119  */
1120 void LoadTGA( const char *name, byte **pixels, int *width, int *height ){
1121         byte            *buffer;
1122         int nLen;
1123         //
1124         // load the file
1125         //
1126         nLen = vfsLoadFile( name, (void **)&buffer, 0 );
1127         if ( nLen == -1 ) {
1128                 Error( "Couldn't read %s", name );
1129         }
1130
1131         LoadTGABuffer( buffer, buffer + nLen, pixels, width, height );
1132
1133 }
1134
1135
1136 /*
1137    ================
1138    WriteTGA
1139    ================
1140  */
1141 void WriteTGA( const char *filename, byte *data, int width, int height ) {
1142         byte    *buffer;
1143         int i;
1144         int c;
1145         FILE    *f;
1146
1147         buffer = safe_malloc( width * height * 4 + 18 );
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 }