From 2177daffd38e1b372613a716d6d18d274d4b6b48 Mon Sep 17 00:00:00 2001
From: zakk <zakk@edf5b092-35ff-0310-97b2-ce42778d08ea>
Date: Fri, 26 Aug 2005 05:42:38 +0000
Subject: See the readme.

git-svn-id: svn://svn.icculus.org/quake3/trunk@4 edf5b092-35ff-0310-97b2-ce42778d08ea
---
 q3radiant/LBMLIB.CPP | 1329 --------------------------------------------------
 1 file changed, 1329 deletions(-)
 delete mode 100755 q3radiant/LBMLIB.CPP

(limited to 'q3radiant/LBMLIB.CPP')

diff --git a/q3radiant/LBMLIB.CPP b/q3radiant/LBMLIB.CPP
deleted file mode 100755
index 5d52307..0000000
--- a/q3radiant/LBMLIB.CPP
+++ /dev/null
@@ -1,1329 +0,0 @@
-/*
-===========================================================================
-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 ); 
-	}
-}
-
-- 
cgit v1.2.3