Quake-III-Arena

LBMLIB.CPP (27293B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code is free software; you can redistribute it
 and/or modify it under the terms of the GNU General Public License as
 published by the Free Software Foundation; either version 2 of the License,
 or (at your option) any later version.
 
 Quake III Arena source code is distributed in the hope that it will be
 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 // lbmlib.c
 
 #include "stdafx.h"
 #include "cmdlib.h"
 #include "lbmlib.h"
 #include "bmp.h"
 #include "pakstuff.h"
 #include "jpeglib.h"
 
 
 /*
 ============================================================================
 
 						LBM STUFF
 
 ============================================================================
 */
 
 
 typedef unsigned char	UBYTE;
 //conflicts with windows typedef short			WORD;
 typedef unsigned short	UWORD;
 typedef long			LONG;
 
 typedef enum
 {
 	ms_none,
 	ms_mask,
 	ms_transcolor,
 	ms_lasso
 } mask_t;
 
 typedef enum
 {
 	cm_none,
 	cm_rle1
 } compress_t;
 
 typedef struct
 {
 	UWORD		w,h;
 	short		x,y;
 	UBYTE		nPlanes;
 	UBYTE		masking;
 	UBYTE		compression;
 	UBYTE		pad1;
 	UWORD		transparentColor;
 	UBYTE		xAspect,yAspect;
 	short		pageWidth,pageHeight;
 } bmhd_t;
 
 extern	bmhd_t	bmhd;						// will be in native byte order
 
 
 
 #define FORMID ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))
 #define ILBMID ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))
 #define PBMID  ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))
 #define BMHDID ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))
 #define BODYID ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))
 #define CMAPID ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))
 
 
 bmhd_t  bmhd;
 
 int    Align (int l)
 {
 	if (l&1)
 		return l+1;
 	return l;
 }
 
 
 
 /*
 ================
 LBMRLEdecompress
 
 Source must be evenly aligned!
 ================
 */
 byte  *LBMRLEDecompress (byte *source,byte *unpacked, int bpwidth)
 {
 	int     count;
 	byte    b,rept;
 
 	count = 0;
 
 	do
 	{
 		rept = *source++;
 
 		if (rept > 0x80)
 		{
 			rept = (rept^0xff)+2;
 			b = *source++;
 			memset(unpacked,b,rept);
 			unpacked += rept;
 		}
 		else if (rept < 0x80)
 		{
 			rept++;
 			memcpy(unpacked,source,rept);
 			unpacked += rept;
 			source += rept;
 		}
 		else
 			rept = 0;               // rept of 0x80 is NOP
 
 		count += rept;
 
 	} while (count<bpwidth);
 
 	if (count>bpwidth)
 		Error ("Decompression exceeded width!\n");
 
 
 	return source;
 }
 
 
 /*
 =================
 LoadLBM
 =================
 */
 void LoadLBM (char *filename, byte **picture, byte **palette)
 {
 	byte    *LBMbuffer, *picbuffer, *cmapbuffer;
 	int             y;
 	byte    *LBM_P, *LBMEND_P;
 	byte    *pic_p;
 	byte    *body_p;
 
 	int    formtype,formlength;
 	int    chunktype,chunklength;
 
 // qiet compiler warnings
 	picbuffer = NULL;
 	cmapbuffer = NULL;
 
 //
 // load the LBM
 //
 	LoadFile (filename, (void **)&LBMbuffer);
 
   if (LBMbuffer == NULL)
   {
     return;
   }
 //
 // parse the LBM header
 //
 	LBM_P = LBMbuffer;
 	if ( *(int *)LBMbuffer != LittleLong(FORMID) )
 	   Error ("No FORM ID at start of file!\n");
 
 	LBM_P += 4;
 	formlength = BigLong( *(int *)LBM_P );
 	LBM_P += 4;
 	LBMEND_P = LBM_P + Align(formlength);
 
 	formtype = LittleLong(*(int *)LBM_P);
 
 	if (formtype != ILBMID && formtype != PBMID)
 		Error ("Unrecognized form type: %c%c%c%c\n", formtype&0xff
 		,(formtype>>8)&0xff,(formtype>>16)&0xff,(formtype>>24)&0xff);
 
 	LBM_P += 4;
 
 //
 // parse chunks
 //
 
 	while (LBM_P < LBMEND_P)
 	{
 		chunktype = LBM_P[0] + (LBM_P[1]<<8) + (LBM_P[2]<<16) + (LBM_P[3]<<24);
 		LBM_P += 4;
 		chunklength = LBM_P[3] + (LBM_P[2]<<8) + (LBM_P[1]<<16) + (LBM_P[0]<<24);
 		LBM_P += 4;
 
 		switch ( chunktype )
 		{
 		case BMHDID:
 			memcpy (&bmhd,LBM_P,sizeof(bmhd));
 			bmhd.w = BigShort(bmhd.w);
 			bmhd.h = BigShort(bmhd.h);
 			bmhd.x = BigShort(bmhd.x);
 			bmhd.y = BigShort(bmhd.y);
 			bmhd.pageWidth = BigShort(bmhd.pageWidth);
 			bmhd.pageHeight = BigShort(bmhd.pageHeight);
 			break;
 
 		case CMAPID:
 			cmapbuffer = (unsigned char*)malloc (768);
 			memset (cmapbuffer, 0, 768);
 			memcpy (cmapbuffer, LBM_P, chunklength);
 			break;
 
 		case BODYID:
 			body_p = LBM_P;
 
 			pic_p = picbuffer = (unsigned char*)malloc (bmhd.w*bmhd.h);
 			if (formtype == PBMID)
 			{
 			//
 			// unpack PBM
 			//
 				for (y=0 ; y<bmhd.h ; y++, pic_p += bmhd.w)
 				{
 					if (bmhd.compression == cm_rle1)
 						body_p = LBMRLEDecompress ((byte *)body_p
 						, pic_p , bmhd.w);
 					else if (bmhd.compression == cm_none)
 					{
 						memcpy (pic_p,body_p,bmhd.w);
 						body_p += Align(bmhd.w);
 					}
 				}
 
 			}
 			else
 			{
 			//
 			// unpack ILBM
 			//
 				Error ("%s is an interlaced LBM, not packed", filename);
 			}
 			break;
 		}
 
 		LBM_P += Align(chunklength);
 	}
 
 	free (LBMbuffer);
 
 	*picture = picbuffer;
 
 	if (palette)
 		*palette = cmapbuffer;
 }
 
 
 /*
 ============================================================================
 
 							WRITE LBM
 
 ============================================================================
 */
 
 /*
 ==============
 WriteLBMfile
 ==============
 */
 void WriteLBMfile (char *filename, byte *data,
 				   int width, int height, byte *palette)
 {
 	byte    *lbm, *lbmptr;
 	int    *formlength, *bmhdlength, *cmaplength, *bodylength;
 	int    length;
 	bmhd_t  basebmhd;
 
 	lbm = lbmptr = (unsigned char*)malloc (width*height+1000);
 
 //
 // start FORM
 //
 	*lbmptr++ = 'F';
 	*lbmptr++ = 'O';
 	*lbmptr++ = 'R';
 	*lbmptr++ = 'M';
 
 	formlength = (int*)lbmptr;
 	lbmptr+=4;                      // leave space for length
 
 	*lbmptr++ = 'P';
 	*lbmptr++ = 'B';
 	*lbmptr++ = 'M';
 	*lbmptr++ = ' ';
 
 //
 // write BMHD
 //
 	*lbmptr++ = 'B';
 	*lbmptr++ = 'M';
 	*lbmptr++ = 'H';
 	*lbmptr++ = 'D';
 
 	bmhdlength = (int *)lbmptr;
 	lbmptr+=4;                      // leave space for length
 
 	memset (&basebmhd,0,sizeof(basebmhd));
 	basebmhd.w = BigShort((short)width);
 	basebmhd.h = BigShort((short)height);
 	basebmhd.nPlanes = 8;
 	basebmhd.xAspect = 5;
 	basebmhd.yAspect = 6;
 	basebmhd.pageWidth = BigShort((short)width);
 	basebmhd.pageHeight = BigShort((short)height);
 
 	memcpy (lbmptr,&basebmhd,sizeof(basebmhd));
 	lbmptr += sizeof(basebmhd);
 
 	length = lbmptr-(byte *)bmhdlength-4;
 	*bmhdlength = BigLong(length);
 	if (length&1)
 		*lbmptr++ = 0;          // pad chunk to even offset
 
 //
 // write CMAP
 //
 	*lbmptr++ = 'C';
 	*lbmptr++ = 'M';
 	*lbmptr++ = 'A';
 	*lbmptr++ = 'P';
 
 	cmaplength = (int *)lbmptr;
 	lbmptr+=4;                      // leave space for length
 
 	memcpy (lbmptr,palette,768);
 	lbmptr += 768;
 
 	length = lbmptr-(byte *)cmaplength-4;
 	*cmaplength = BigLong(length);
 	if (length&1)
 		*lbmptr++ = 0;          // pad chunk to even offset
 
 //
 // write BODY
 //
 	*lbmptr++ = 'B';
 	*lbmptr++ = 'O';
 	*lbmptr++ = 'D';
 	*lbmptr++ = 'Y';
 
 	bodylength = (int *)lbmptr;
 	lbmptr+=4;                      // leave space for length
 
 	memcpy (lbmptr,data,width*height);
 	lbmptr += width*height;
 
 	length = lbmptr-(byte *)bodylength-4;
 	*bodylength = BigLong(length);
 	if (length&1)
 		*lbmptr++ = 0;          // pad chunk to even offset
 
 //
 // done
 //
 	length = lbmptr-(byte *)formlength-4;
 	*formlength = BigLong(length);
 	if (length&1)
 		*lbmptr++ = 0;          // pad chunk to even offset
 
 //
 // write output file
 //
 	SaveFile (filename, lbm, lbmptr-lbm);
 	free (lbm);
 }
 
 /*
 ============================================================================
 
 LOAD PCX
 
 ============================================================================
 */
 typedef struct
 {
     char	manufacturer;
     char	version;
     char	encoding;
     char	bits_per_pixel;
     unsigned short	xmin,ymin,xmax,ymax;
     unsigned short	hres,vres;
     unsigned char	palette[48];
     char	reserved;
     char	color_planes;
     unsigned short	bytes_per_line;
     unsigned short	palette_type;
     char	filler[58];
     unsigned char	data;			// unbounded
 } pcx_t;
 
 /*
 ==============
 LoadPCX
 ==============
 */
 void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
 {
 	byte	*raw = 0;
 	pcx_t	*pcx;
 	int		x, y;
 	int		len;
 	int		dataByte, runLength;
 	byte	*out, *pix;
 
 	if (pic)
 		*pic = NULL;
 	if (palette)
 		*palette = NULL;
 	if (width)
 		*width = 0;
 	if (height)
 		*height = 0;
 
 	//
 	// load the file
 	//
 	len = LoadFile (filename, (void **)&raw);
 	if (len == -1)
 		return;
 
 	//
 	// parse the PCX file
 	//
 	pcx = (pcx_t *)raw;
 	raw = &pcx->data;
 
 	pcx->xmin = LittleShort(pcx->xmin);
 	pcx->ymin = LittleShort(pcx->ymin);
 	pcx->xmax = LittleShort(pcx->xmax);
 	pcx->ymax = LittleShort(pcx->ymax);
 	pcx->hres = LittleShort(pcx->hres);
 	pcx->vres = LittleShort(pcx->vres);
 	pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
 	pcx->palette_type = LittleShort(pcx->palette_type);
 
 	if (pcx->manufacturer != 0x0a
 		|| pcx->version != 5
 		|| pcx->encoding != 1
 		|| pcx->bits_per_pixel != 8
 		|| pcx->xmax >= 640
 		|| pcx->ymax >= 480)
 		Error ("Bad pcx file %s", filename);
 	
 	if (palette)
 	{
 		*palette = (unsigned char*)malloc(768);
 		memcpy (*palette, (byte *)pcx + len - 768, 768);
 	}
 
 	if (width)
 		*width = pcx->xmax+1;
 	if (height)
 		*height = pcx->ymax+1;
 
 	if (!pic)
   {
     free(pcx);
 		return;
   }
 
 	out = (unsigned char*)malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
 	if (!out)
 		Error ("Skin_Cache: couldn't allocate");
 
 	*pic = out;
 
 	pix = out;
 
 	for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
 	{
 		for (x=0 ; x<=pcx->xmax ; )
 		{
 			dataByte = *raw++;
 
 			if((dataByte & 0xC0) == 0xC0)
 			{
 				runLength = dataByte & 0x3F;
 				dataByte = *raw++;
 			}
 			else
 				runLength = 1;
 
 			while(runLength-- > 0)
 				pix[x++] = dataByte;
 		}
 
 	}
 
 	if ( raw - (byte *)pcx > len)
 		Error ("PCX file %s was malformed", filename);
 
 	free (pcx);
 }
 /* 
 ============== 
 WritePCXfile 
 ============== 
 */ 
 void WritePCXfile (char *filename, byte *data, 
 				   int width, int height, byte *palette) 
 {
 	int		i, j, length;
 	pcx_t	*pcx;
 	byte		*pack;
 	  
 	pcx = (pcx_t*)malloc (width*height*2+1000);
 	memset (pcx, 0, sizeof(*pcx));
 
 	pcx->manufacturer = 0x0a;	// PCX id
 	pcx->version = 5;			// 256 color
  	pcx->encoding = 1;		// uncompressed
 	pcx->bits_per_pixel = 8;		// 256 color
 	pcx->xmin = 0;
 	pcx->ymin = 0;
 	pcx->xmax = LittleShort((short)(width-1));
 	pcx->ymax = LittleShort((short)(height-1));
 	pcx->hres = LittleShort((short)width);
 	pcx->vres = LittleShort((short)height);
 	pcx->color_planes = 1;		// chunky image
 	pcx->bytes_per_line = LittleShort((short)width);
 	pcx->palette_type = LittleShort(2);		// not a grey scale
 
 	// pack the image
 	pack = &pcx->data;
 	
 	for (i=0 ; i<height ; i++)
 	{
 		for (j=0 ; j<width ; j++)
 		{
 			if ( (*data & 0xc0) != 0xc0)
 				*pack++ = *data++;
 			else
 			{
 				*pack++ = 0xc1;
 				*pack++ = *data++;
 			}
 		}
 	}
 			
 	// write the palette
 	*pack++ = 0x0c;	// palette ID byte
 	for (i=0 ; i<768 ; i++)
 		*pack++ = *palette++;
 		
 // write output file 
 	length = pack - (byte *)pcx;
 	SaveFile (filename, pcx, length);
 
 	free (pcx);
 } 
 
 /*
 ============================================================================
 
 LOAD IMAGE
 
 ============================================================================
 */
 
 /*
 ==============
 Load256Image
 
 Will load either an lbm or pcx, depending on extension.
 Any of the return pointers can be NULL if you don't want them.
 ==============
 */
 void Load256Image (char *name, byte **pixels, byte **palette,
 				   int *width, int *height)
 {
 	char	ext[128];
 	bitmap_t	bmp;
 
 	ExtractFileExtension (name, ext);
 	if (stricmp(ext, "lbm"))
 	{
 		LoadLBM (name, pixels, palette);
 		if (width)
 			*width = bmhd.w;
 		if (height)
 			*height = bmhd.h;
 	}
 	else if (stricmp (ext, "pcx"))
 	{
 		LoadPCX (name, pixels, palette, width, height);
 	}
 	else if (stricmp (ext, "bmp"))
 	{
 		LoadBMP (name, &bmp);
 		if (bmp.palette)
 		{
 			*palette = (unsigned char*)malloc (768);
 			memcpy (*palette, bmp.palette, 768);
 		}
 		FreeBMP (&bmp);		
 	}
 	else
 		Error ("%s doesn't have a known image extension", name);
 }
 
 
 /*
 ==============
 Save256Image
 
 Will save either an lbm or pcx, depending on extension.
 ==============
 */
 void Save256Image (char *name, byte *pixels, byte *palette,
 				   int width, int height)
 {
 	char	ext[128];
 
 	ExtractFileExtension (name, ext);
 	if (!strcmp (ext, "lbm"))
 	{
 		WriteLBMfile (name, pixels, width, height, palette);
 	}
 	else if (!stricmp (ext, "pcx"))
 	{
 		WritePCXfile (name, pixels, width, height, palette);
 	}
 	else
 		Error ("%s doesn't have a known image extension", name);
 }
 
 
 
 /*
 ============================================================================
 
 TARGA IMAGE
 
 ============================================================================
 */
 typedef struct _TargaHeader {
 	unsigned char 	id_length, colormap_type, image_type;
 	unsigned short	colormap_index, colormap_length;
 	unsigned char	colormap_size;
 	unsigned short	x_origin, y_origin, width, height;
 	unsigned char	pixel_size, attributes;
 } TargaHeader;
 
 int fgetLittleShort (FILE *f)
 {
 	byte	b1, b2;
 
 	b1 = fgetc(f);
 	b2 = fgetc(f);
 
 	return (short)(b1 + b2*256);
 }
 
 int getLittleShort (byte*& p)
 {
 	byte	b1, b2;
 	b1 = *p++;
 	b2 = *p++;
 	return (short)(b1 + b2*256);
 }
 
 int getLittleLong (byte*& p)
 {
 	byte	b1, b2, b3, b4;
 
 	b1 = *p++;
 	b2 = *p++;
 	b3 = *p++;
 	b4 = *p++;
 	return b1 + (b2<<8) + (b3<<16) + (b4<<24);
 }
 
 char getc(byte*& p)
 {
   return *p++;
 }
 
 /*
 =========================================================
 
 BMP LOADING
 
 =========================================================
 */
 typedef struct
 {
 	char id[2];
 	unsigned long fileSize;
 	unsigned long reserved0;
 	unsigned long bitmapDataOffset;
 	unsigned long bitmapHeaderSize;
 	unsigned long width;
 	unsigned long height;
 	unsigned short planes;
 	unsigned short bitsPerPixel;
 	unsigned long compression;
 	unsigned long bitmapDataSize;
 	unsigned long hRes;
 	unsigned long vRes;
 	unsigned long colors;
 	unsigned long importantColors;
 	unsigned char palette[256][4];
 } BMPHeader_t;
 
 static void LoadBMP( const char *name, byte **pic, int *width, int *height )
 {
 	int		columns, rows, numPixels;
 	byte	*pixbuf;
 	int		row, column;
 	byte	*buf_p;
 	byte	*buffer;
 	unsigned int		length;
 	BMPHeader_t bmpHeader;
 	byte		*bmpRGBA;
 
 	*pic = NULL;
 
 	//
 	// load the file
 	//
 	length = LoadFile( ( char * ) name, (void **)&buffer);
 	if (length == -1)
   {
     length = PakLoadAnyFile( (char*)name, (void**)&buffer);
     if (length == -1)
     {
 		  return;
     }
   }
 
 	buf_p = buffer;
 
 	bmpHeader.id[0] = *buf_p++;
 	bmpHeader.id[1] = *buf_p++;
 	bmpHeader.fileSize = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.reserved0 = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.bitmapDataOffset = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.bitmapHeaderSize = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.width = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.height = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.planes = LittleShort( * ( short * ) buf_p );
 	buf_p += 2;
 	bmpHeader.bitsPerPixel = LittleShort( * ( short * ) buf_p );
 	buf_p += 2;
 	bmpHeader.compression = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.bitmapDataSize = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.hRes = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.vRes = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.colors = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 	bmpHeader.importantColors = LittleLong( * ( long * ) buf_p );
 	buf_p += 4;
 
 	memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) );
 
 	if ( bmpHeader.bitsPerPixel == 8 )
 		buf_p += 1024;
 
 	if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' ) 
 	{
 		Sys_Printf("LoadBMP: only Windows-style BMP files supported (%s)\n", name );
 	}
 	if ( bmpHeader.fileSize != length )
 	{
 		Sys_Printf("LoadBMP: header size does not match file size (%d vs. %d) (%s)\n", bmpHeader.fileSize, length, name );
 	}
 	if ( bmpHeader.compression != 0 )
 	{
 		Sys_Printf("LoadBMP: only uncompressed BMP files supported (%s)\n", name );
 	}
 	if ( bmpHeader.bitsPerPixel < 8 )
 	{
 		Sys_Printf("LoadBMP: monochrome and 4-bit BMP files not supported (%s)\n", name );
 	}
 
 	columns = bmpHeader.width;
 	rows = bmpHeader.height;
 	if ( rows < 0 )
 		rows = -rows;
 	numPixels = columns * rows;
 
 	if ( width ) 
 		*width = columns;
 	if ( height )
 		*height = rows;
 
 	bmpRGBA = reinterpret_cast<unsigned char*>(malloc( numPixels * 4 ));
 	*pic = bmpRGBA;
 
 
 	for ( row = rows-1; row >= 0; row-- )
 	{
 		pixbuf = bmpRGBA + row*columns*4;
 
 		for ( column = 0; column < columns; column++ )
 		{
 			unsigned char red, green, blue, alpha;
 			int palIndex;
 			unsigned short shortPixel;
 
 			switch ( bmpHeader.bitsPerPixel )
 			{
 			case 8:
 				palIndex = *buf_p++;
 				*pixbuf++ = bmpHeader.palette[palIndex][2];
 				*pixbuf++ = bmpHeader.palette[palIndex][1];
 				*pixbuf++ = bmpHeader.palette[palIndex][0];
 				*pixbuf++ = 0xff;
 				break;
 			case 16:
 				shortPixel = * ( unsigned short * ) pixbuf;
 				pixbuf += 2;
 				*pixbuf++ = ( shortPixel & ( 31 << 10 ) ) >> 7;
 				*pixbuf++ = ( shortPixel & ( 31 << 5 ) ) >> 2;
 				*pixbuf++ = ( shortPixel & ( 31 ) ) << 3;
 				*pixbuf++ = 0xff;
 				break;
 
 			case 24:
 				blue = *buf_p++;
 				green = *buf_p++;
 				red = *buf_p++;
 				*pixbuf++ = red;
 				*pixbuf++ = green;
 				*pixbuf++ = blue;
 				*pixbuf++ = 255;
 				break;
 			case 32:
 				blue = *buf_p++;
 				green = *buf_p++;
 				red = *buf_p++;
 				alpha = *buf_p++;
 				*pixbuf++ = red;
 				*pixbuf++ = green;
 				*pixbuf++ = blue;
 				*pixbuf++ = alpha;
 				break;
 			default:
 				Sys_Printf("LoadBMP: illegal pixel_size '%d' in file '%s'\n", bmpHeader.bitsPerPixel, name );
 				break;
 			}
 		}
 	}
 
 	free( buffer );
 
 }
 
 
 /*
 =================================================================
 
 PCX LOADING
 
 =================================================================
 */
 
 
 /*
 ==============
 LoadPCX
 ==============
 */
 static void LoadPCX ( const char *filename, byte **pic, byte **palette, int *width, int *height)
 {
 	byte	*raw;
 	pcx_t	*pcx;
 	int		x, y;
 	int		len;
 	int		dataByte, runLength;
 	byte	*out, *pix;
 	int		xmax, ymax;
 
 	*pic = NULL;
 	*palette = NULL;
 
 	//
 	// load the file
 	//
 	len = LoadFile( ( char * ) filename, (void **)&raw);
 	if (len == -1) 
   {
     len = PakLoadAnyFile( (char*)filename, (void**)&raw);
     if (len == -1)
     {
 		  return;
     }
 	}
 
 	//
 	// parse the PCX file
 	//
 	pcx = (pcx_t *)raw;
 	raw = &pcx->data;
 
   	xmax = LittleShort(pcx->xmax);
     ymax = LittleShort(pcx->ymax);
 
 	if (pcx->manufacturer != 0x0a
 		|| pcx->version != 5
 		|| pcx->encoding != 1
 		|| pcx->bits_per_pixel != 8
 		|| xmax >= 1024
 		|| ymax >= 1024)
 	{
 		Sys_Printf ("Bad pcx file %s (%i x %i) (%i x %i)\n", filename, xmax+1, ymax+1, pcx->xmax, pcx->ymax);
 		return;
 	}
 
 	out = reinterpret_cast<unsigned char*>(malloc ( (ymax+1) * (xmax+1) ));
 
 	*pic = out;
 
 	pix = out;
 
 	if (palette)
 	{
 		*palette = reinterpret_cast<unsigned char*>(malloc(768));
 		memcpy (*palette, (byte *)pcx + len - 768, 768);
 	}
 
 	if (width)
 		*width = xmax+1;
 	if (height)
 		*height = ymax+1;
 // FIXME: use bytes_per_line here?
 
 	for (y=0 ; y<=ymax ; y++, pix += xmax+1)
 	{
 		for (x=0 ; x<=xmax ; )
 		{
 			dataByte = *raw++;
 
 			if((dataByte & 0xC0) == 0xC0)
 			{
 				runLength = dataByte & 0x3F;
 				dataByte = *raw++;
 			}
 			else
 				runLength = 1;
 
 			while(runLength-- > 0)
 				pix[x++] = dataByte;
 		}
 
 	}
 
 	if ( raw - (byte *)pcx > len)
 	{
 		Sys_Printf ("PCX file %s was malformed", filename);
 		free (*pic);
 		*pic = NULL;
 	}
 
 	free(pcx);
 }
 
 
 /*
 ==============
 LoadPCX32
 ==============
 */
 static void LoadPCX32 ( const char *filename, byte **pic, int *width, int *height) {
 	byte	*palette;
 	byte	*pic8;
 	int		i, c, p;
 	byte	*pic32;
 
 	LoadPCX (filename, &pic8, &palette, width, height);
 	if (!pic8) {
 		*pic = NULL;
 		return;
 	}
 
 	c = (*width) * (*height);
 	pic32 = *pic = reinterpret_cast<unsigned char*>(malloc(4 * c ));
 	for (i = 0 ; i < c ; i++) {
 		p = pic8[i];
 		pic32[0] = palette[p*3];
 		pic32[1] = palette[p*3 + 1];
 		pic32[2] = palette[p*3 + 2];
 		pic32[3] = 255;
 		pic32 += 4;
 	}
 
 	free (pic8);
 	free (palette);
 }
 
 /*
 =========================================================
 
 TARGA LOADING
 
 =========================================================
 */
 
 /*
 =============
 LoadTGA
 =============
 */
 void LoadTGA ( const char *name, byte **pic, int *width, int *height)
 {
 	int		columns, rows, numPixels;
 	byte	*pixbuf;
 	int		row, column;
 	byte	*buf_p;
 	byte	*buffer;
 	TargaHeader	targa_header;
 	byte		*targa_rgba;
 
 	*pic = NULL;
 
 	//
 	// load the file
 	//
 	int nLen = LoadFile ( ( char * ) name, (void **)&buffer);
 	if (nLen == -1) 
   {
     nLen = PakLoadAnyFile((char*)name, (void**)&buffer);
     if (nLen == -1)
     {
 		  return;
     }
 	}
 
 	buf_p = buffer;
 
 	targa_header.id_length = *buf_p++;
 	targa_header.colormap_type = *buf_p++;
 	targa_header.image_type = *buf_p++;
 	
 	targa_header.colormap_index = LittleShort ( *(short *)buf_p );
 	buf_p += 2;
 	targa_header.colormap_length = LittleShort ( *(short *)buf_p );
 	buf_p += 2;
 	targa_header.colormap_size = *buf_p++;
 	targa_header.x_origin = LittleShort ( *(short *)buf_p );
 	buf_p += 2;
 	targa_header.y_origin = LittleShort ( *(short *)buf_p );
 	buf_p += 2;
 	targa_header.width = LittleShort ( *(short *)buf_p );
 	buf_p += 2;
 	targa_header.height = LittleShort ( *(short *)buf_p );
 	buf_p += 2;
 	targa_header.pixel_size = *buf_p++;
 	targa_header.attributes = *buf_p++;
 
 	//++timo debug
 	if (targa_header.pixel_size == 32)
 		Sys_Printf("%s is 32bit\n", name);
 	bool bAlphaOK = false;
 
 	if (targa_header.image_type!=2 
 		&& targa_header.image_type!=10
 		&& targa_header.image_type != 3 ) 
 	{
 		Sys_Printf("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
 	}
 
 	if ( targa_header.colormap_type != 0 )
 	{
 		Sys_Printf("LoadTGA: colormaps not supported\n" );
 	}
 
 	if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 )
 	{
 		Sys_Printf("LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
 	}
 
 	columns = targa_header.width;
 	rows = targa_header.height;
 	numPixels = columns * rows;
 
 	if (width)
 		*width = columns;
 	if (height)
 		*height = rows;
 
 	targa_rgba = reinterpret_cast<unsigned char*>(malloc (numPixels*4));
 	*pic = targa_rgba;
 
 	if (targa_header.id_length != 0)
 		buf_p += targa_header.id_length;  // skip TARGA image comment
 	
 	if ( targa_header.image_type==2 || targa_header.image_type == 3 )
 	{ 
 		// Uncompressed RGB or gray scale image
 		for(row=rows-1; row>=0; row--) 
 		{
 			pixbuf = targa_rgba + row*columns*4;
 			for(column=0; column<columns; column++) 
 			{
 				unsigned char red,green,blue,alphabyte;
 				switch (targa_header.pixel_size) 
 				{
 					
 				case 8:
 					blue = *buf_p++;
 					green = blue;
 					red = blue;
 					*pixbuf++ = red;
 					*pixbuf++ = green;
 					*pixbuf++ = blue;
 					*pixbuf++ = 255;
 					break;
 
 				case 24:
 					blue = *buf_p++;
 					green = *buf_p++;
 					red = *buf_p++;
 					*pixbuf++ = red;
 					*pixbuf++ = green;
 					*pixbuf++ = blue;
 					*pixbuf++ = 255;
 					break;
 				case 32:
 					blue = *buf_p++;
 					green = *buf_p++;
 					red = *buf_p++;
 					alphabyte = *buf_p++;
 					//++timo debug: detect if the whole alpha channel is 0
 					if (alphabyte != 0)
 						bAlphaOK = true;
 					*pixbuf++ = red;
 					*pixbuf++ = green;
 					*pixbuf++ = blue;
 					*pixbuf++ = alphabyte;
 					break;
 				default:
 					Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
 					break;
 				}
 			}
 		}
 
 		//++timo debug
 		if (bAlphaOK)
 			Sys_Printf("alpha channel OK");
 		else
 			Sys_Printf("empty alpha channel!");
 	}
 	else if (targa_header.image_type==10) {   // Runlength encoded RGB images
 
 		//++timo debug
 		Sys_Printf("runlength encode RGB image");
 
 		unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
 
 		red = 0;
 		green = 0;
 		blue = 0;
 		alphabyte = 0xff;
 
 		for(row=rows-1; row>=0; row--) {
 			pixbuf = targa_rgba + row*columns*4;
 			for(column=0; column<columns; ) {
 				packetHeader= *buf_p++;
 				packetSize = 1 + (packetHeader & 0x7f);
 				if (packetHeader & 0x80) {        // run-length packet
 					switch (targa_header.pixel_size) {
 						case 24:
 								blue = *buf_p++;
 								green = *buf_p++;
 								red = *buf_p++;
 								alphabyte = 255;
 								break;
 						case 32:
 								blue = *buf_p++;
 								green = *buf_p++;
 								red = *buf_p++;
 								alphabyte = *buf_p++;
 								break;
 						default:
 							Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
 							break;
 					}
 	
 					for(j=0;j<packetSize;j++) {
 						*pixbuf++=red;
 						*pixbuf++=green;
 						*pixbuf++=blue;
 						*pixbuf++=alphabyte;
 						column++;
 						if (column==columns) { // run spans across rows
 							column=0;
 							if (row>0)
 								row--;
 							else
 								goto breakOut;
 							pixbuf = targa_rgba + row*columns*4;
 						}
 					}
 				}
 				else {                            // non run-length packet
 					for(j=0;j<packetSize;j++) {
 						switch (targa_header.pixel_size) {
 							case 24:
 									blue = *buf_p++;
 									green = *buf_p++;
 									red = *buf_p++;
 									*pixbuf++ = red;
 									*pixbuf++ = green;
 									*pixbuf++ = blue;
 									*pixbuf++ = 255;
 									break;
 							case 32:
 									blue = *buf_p++;
 									green = *buf_p++;
 									red = *buf_p++;
 									alphabyte = *buf_p++;
 									*pixbuf++ = red;
 									*pixbuf++ = green;
 									*pixbuf++ = blue;
 									*pixbuf++ = alphabyte;
 									break;
 							default:
 								Sys_Printf("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name );
 								break;
 						}
 						column++;
 						if (column==columns) { // pixel packet run spans across rows
 							column=0;
 							if (row>0)
 								row--;
 							else
 								goto breakOut;
 							pixbuf = targa_rgba + row*columns*4;
 						}						
 					}
 				}
 			}
 			breakOut:;
 		}
 	}
 
 	free(buffer);
 }
 
 
 
 
 void LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) 
 {
   byte	*fbuffer = NULL;
   int nLen = LoadFile( ( char * ) filename, (void **)&fbuffer);
   if (nLen == -1) 
   {
     nLen = PakLoadAnyFile((char*)filename, (void**)&fbuffer);
     if (nLen == -1)
     {
 		  return;
     }
   }
   LoadJPGBuff(fbuffer, pic, width, height);
   free(fbuffer);
 }
 
 //===================================================================
 
 /*
 =================
 LoadImage
 
 Loads any of the supported image types into a cannonical
 32 bit format.
 =================
 */
 void LoadImage( const char *name, byte **pic, int *width, int *height ) 
 {
 	int		len;
 	*pic = NULL;
 	*width = 0;
 	*height = 0;
 
 	len = strlen(name);
 	if (len<5) 
   {
 		return;
 	}
 
 	if ( !stricmp( name+len-4, ".tga" ) ) 
   {
 	  LoadTGA( name, pic, width, height );
 	}
   else if ( !stricmp(name+len-4, ".pcx") ) 
   {
     LoadPCX32( name, pic, width, height );
 	} 
   else if ( !stricmp( name+len-4, ".bmp" ) ) 
   {
 		LoadBMP( name, pic, width, height );
 	} 
   else if ( !stricmp( name+len-4, ".jpg" ) ) 
   {
 		LoadJPG( name, pic, width, height ); 
 	}
 }