LBMLIB.CPP File Reference

#include "stdafx.h"
#include "cmdlib.h"
#include "lbmlib.h"
#include "bmp.h"
#include "pakstuff.h"
#include "jpeglib.h"

Include dependency graph for LBMLIB.CPP:

Go to the source code of this file.

Data Structures
struct	_TargaHeader
struct	bmhd_t
struct	BMPHeader_t
struct	pcx_t
Defines
#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))
#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))
Typedefs
typedef long	LONG
typedef _TargaHeader	TargaHeader
typedef unsigned char	UBYTE
typedef unsigned short	UWORD
Enumerations
enum	compress_t { cm_none, cm_rle1 }
enum	mask_t { ms_none, ms_mask, ms_transcolor, ms_lasso }
Functions
int	Align (int l)
int	fgetLittleShort (FILE *f)
char	getc (byte *&p)
int	getLittleLong (byte *&p)
int	getLittleShort (byte *&p)
byte *	LBMRLEDecompress (byte *source, byte *unpacked, int bpwidth)
void	Load256Image (char *name, byte **pixels, byte **palette, int *width, int *height)
void	LoadBMP (const char *name, byte **pic, int *width, int *height)
void	LoadImage (const char *name, byte **pic, int *width, int *height)
void	LoadJPG (const char *filename, unsigned char **pic, int *width, int *height)
void	LoadLBM (char *filename, byte **picture, byte **palette)
void	LoadPCX (const char *filename, byte **pic, byte **palette, int *width, int *height)
void	LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
void	LoadPCX32 (const char *filename, byte **pic, int *width, int *height)
void	LoadTGA (const char *name, byte **pic, int *width, int *height)
void	Save256Image (char *name, byte *pixels, byte *palette, int width, int height)
void	WriteLBMfile (char *filename, byte *data, int width, int height, byte *palette)
void	WritePCXfile (char *filename, byte *data, int width, int height, byte *palette)
Variables
bmhd_t	bmhd

---

Define Documentation

#define BMHDID   ('B'+('M'<<8)+((int)'H'<<16)+((int)'D'<<24))

Definition at line 80 of file LBMLIB.CPP.

#define BODYID   ('B'+('O'<<8)+((int)'D'<<16)+((int)'Y'<<24))

Definition at line 81 of file LBMLIB.CPP.

#define CMAPID   ('C'+('M'<<8)+((int)'A'<<16)+((int)'P'<<24))

Definition at line 82 of file LBMLIB.CPP.

#define FORMID   ('F'+('O'<<8)+((int)'R'<<16)+((int)'M'<<24))

Definition at line 77 of file LBMLIB.CPP.

#define ILBMID   ('I'+('L'<<8)+((int)'B'<<16)+((int)'M'<<24))

Definition at line 78 of file LBMLIB.CPP.

#define PBMID   ('P'+('B'<<8)+((int)'M'<<16)+((int)' '<<24))

Definition at line 79 of file LBMLIB.CPP.

---

Typedef Documentation

typedef long LONG

Definition at line 44 of file LBMLIB.CPP.

typedef struct _TargaHeader TargaHeader

typedef unsigned char UBYTE

Definition at line 41 of file LBMLIB.CPP.

typedef unsigned short UWORD

Definition at line 43 of file LBMLIB.CPP.

---

Enumeration Type Documentation

enum compress_t

Enumeration values: cm_none  cm_rle1  Definition at line 54 of file LBMLIB.CPP. { cm_none, cm_rle1 } compress_t;

enum mask_t

Enumeration values: ms_none  ms_mask  ms_transcolor  ms_lasso  Definition at line 46 of file LBMLIB.CPP. { ms_none, ms_mask, ms_transcolor, ms_lasso } mask_t;

---

Function Documentation

int Align (  int  l  )

Definition at line 87 of file LBMLIB.CPP. References l. Referenced by LoadLBM(). { if (l&1) return l+1; return l; }

int fgetLittleShort (  FILE *  f  )

Definition at line 662 of file LBMLIB.CPP. References byte, f, and fgetc(). Referenced by LoadBMP(). { byte b1, b2; b1 = fgetc(f); b2 = fgetc(f); return (short)(b1 + b2*256); }

Here is the call graph for this function:

char getc (  byte *&  p  )

Definition at line 691 of file LBMLIB.CPP. References byte, and p. { return *p++; }

int getLittleLong (  byte *&  p  )

Definition at line 680 of file LBMLIB.CPP. References byte, and p. { byte b1, b2, b3, b4; b1 = *p++; b2 = *p++; b3 = *p++; b4 = *p++; return b1 + (b2<<8) + (b3<<16) + (b4<<24); }

int getLittleShort (  byte *&  p  )

Definition at line 672 of file LBMLIB.CPP. References byte, and p. { byte b1, b2; b1 = *p++; b2 = *p++; return (short)(b1 + b2*256); }

byte* LBMRLEDecompress (  byte *  source, byte *  unpacked, int  bpwidth )

Definition at line 103 of file LBMLIB.CPP. References b, byte, count, Error(), memcpy(), memset(), and source. Referenced by LoadLBM(). { 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; }

Here is the call graph for this function:

void Load256Image (  char *  name, byte **  pixels, byte **  palette, int *  width, int *  height )

Definition at line 586 of file LBMLIB.CPP. References bmhd, byte, Error(), ExtractFileExtension(), FreeBMP(), bmhd_t::h, height, LoadBMP(), LoadLBM(), LoadPCX(), malloc(), memcpy(), name, bitmap_t::palette, pixels, bmhd_t::w, and width. Referenced by Load32BitImage(), LoadAlphaMap(), and Texture_Init(). { 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); }

Here is the call graph for this function:

void LoadBMP (  const char *  name, byte **  pic, int *  width, int *  height )  [static]

Definition at line 723 of file LBMLIB.CPP. References alpha, BMPHeader_t::bitmapDataOffset, BMPHeader_t::bitmapDataSize, BMPHeader_t::bitmapHeaderSize, BMPHeader_t::bitsPerPixel, blue, buffer, byte, BMPHeader_t::colors, BMPHeader_t::compression, BMPHeader_t::fileSize, free(), green, height, BMPHeader_t::height, BMPHeader_t::hRes, BMPHeader_t::id, BMPHeader_t::importantColors, length(), LittleLong(), LittleShort(), LoadFile(), malloc(), memcpy(), name, PakLoadAnyFile(), BMPHeader_t::palette, BMPHeader_t::planes, BMPHeader_t::reserved0, rows, Sys_Printf(), BMPHeader_t::vRes, width, and BMPHeader_t::width. Referenced by Load256Image(), LoadImage(), and R_LoadImage(). { 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 ); }

Here is the call graph for this function:

void LoadImage (  const char *  name, byte **  pic, int *  width, int *  height )

Definition at line 1299 of file LBMLIB.CPP. References byte, height, LoadBMP(), LoadJPG(), LoadPCX32(), LoadTGA(), name, strlen(), and width. Referenced by QERApp_TryTextureForName(), Texture_ForName(), Texture_ForNamePath(), and Texture_LoadSkin(). { 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 ); } }

Here is the call graph for this function:

void LoadJPG (  const char *  filename, unsigned char **  pic, int *  width, int *  height )

Definition at line 1273 of file LBMLIB.CPP. References byte, free(), height, LoadFile(), LoadJPGBuff(), PakLoadAnyFile(), and width. Referenced by LoadImage(), and R_LoadImage(). { 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); }

Here is the call graph for this function:

void LoadLBM (  char *  filename, byte **  picture, byte **  palette )

Definition at line 148 of file LBMLIB.CPP. References Align(), BigLong(), BigShort(), bmhd, BMHDID, BODYID, byte, CMAPID, bmhd_t::compression, Error(), FORMID, free(), bmhd_t::h, ILBMID, LBMRLEDecompress(), LittleLong(), LoadFile(), malloc(), memcpy(), memset(), bmhd_t::pageHeight, bmhd_t::pageWidth, bmhd_t::w, bmhd_t::x, bmhd_t::y, and y. Referenced by Load256Image(). { 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; }

Here is the call graph for this function:

void LoadPCX (  const char *  filename, byte **  pic, byte **  palette, int *  width, int *  height )  [static]

Definition at line 892 of file LBMLIB.CPP. References pcx_t::bits_per_pixel, byte, pcx_t::data, pcx_t::encoding, free(), height, LittleShort(), LoadFile(), malloc(), pcx_t::manufacturer, memcpy(), PakLoadAnyFile(), Sys_Printf(), pcx_t::version, width, x, pcx_t::xmax, y, and pcx_t::ymax. { 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); }

Here is the call graph for this function:

void LoadPCX (  char *  filename, byte **  pic, byte **  palette, int *  width, int *  height )

Definition at line 414 of file LBMLIB.CPP. References pcx_t::bits_per_pixel, byte, pcx_t::bytes_per_line, pcx_t::data, pcx_t::encoding, Error(), free(), height, pcx_t::hres, LittleShort(), LoadFile(), malloc(), pcx_t::manufacturer, memcpy(), pcx_t::palette_type, pcx_t::version, pcx_t::vres, width, x, pcx_t::xmax, pcx_t::xmin, y, pcx_t::ymax, and pcx_t::ymin. Referenced by Load256Image(), and LoadPCX32(). { 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); }

Here is the call graph for this function:

void LoadPCX32 (  const char *  filename, byte **  pic, int *  width, int *  height )  [static]

Definition at line 992 of file LBMLIB.CPP. References byte, c, free(), height, i, LoadPCX(), malloc(), p, and width. Referenced by LoadImage(), and R_LoadImage(). { 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); }

Here is the call graph for this function:

void LoadTGA (  const char *  name, byte **  pic, int *  width, int *  height )

Definition at line 1032 of file LBMLIB.CPP. References _TargaHeader::attributes, blue, buffer, byte, _TargaHeader::colormap_index, _TargaHeader::colormap_length, _TargaHeader::colormap_size, _TargaHeader::colormap_type, free(), green, height, _TargaHeader::height, _TargaHeader::id_length, _TargaHeader::image_type, j, LittleShort(), LoadFile(), malloc(), name, PakLoadAnyFile(), _TargaHeader::pixel_size, rows, Sys_Printf(), TargaHeader, width, _TargaHeader::width, _TargaHeader::x_origin, and _TargaHeader::y_origin. { 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); }

Here is the call graph for this function:

void Save256Image (  char *  name, byte *  pixels, byte *  palette, int  width, int  height )

Definition at line 627 of file LBMLIB.CPP. References byte, Error(), ExtractFileExtension(), height, name, pixels, strcmp(), width, WriteLBMfile(), and WritePCXfile(). { 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); }

Here is the call graph for this function:

void WriteLBMfile (  char *  filename, byte *  data, int  width, int  height, byte *  palette )

Definition at line 278 of file LBMLIB.CPP. References BigLong(), BigShort(), byte, data, free(), bmhd_t::h, height, length(), malloc(), memcpy(), memset(), bmhd_t::nPlanes, bmhd_t::pageHeight, bmhd_t::pageWidth, SaveFile(), bmhd_t::w, width, bmhd_t::xAspect, and bmhd_t::yAspect. Referenced by Save256Image(). { 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); }

Here is the call graph for this function:

void WritePCXfile (  char *  filename, byte *  data, int  width, int  height, byte *  palette )

Definition at line 517 of file LBMLIB.CPP. References pcx_t::bits_per_pixel, byte, pcx_t::bytes_per_line, pcx_t::color_planes, pcx_t::data, data, pcx_t::encoding, free(), height, pcx_t::hres, i, j, length(), LittleShort(), malloc(), pcx_t::manufacturer, memset(), pcx_t::palette_type, SaveFile(), pcx_t::version, pcx_t::vres, width, pcx_t::xmax, pcx_t::xmin, pcx_t::ymax, and pcx_t::ymin. Referenced by Save256Image(). { 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); }

Here is the call graph for this function:

---

Variable Documentation

bmhd_t bmhd

Definition at line 85 of file LBMLIB.CPP.

---