aboutsummaryrefslogtreecommitdiffstats
path: root/q3radiant/LBMLIB.CPP
diff options
context:
space:
mode:
Diffstat (limited to 'q3radiant/LBMLIB.CPP')
-rwxr-xr-xq3radiant/LBMLIB.CPP1329
1 files changed, 0 insertions, 1329 deletions
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 );
- }
-}
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-15 20:50:57 +0000