imagelib.c File Reference

#include "cmdlib.h"
#include "imagelib.h"

Include dependency graph for imagelib.c:

Go to the source code of this file.

Data Structures
struct	_TargaHeader
struct	bmhd_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	fgetLittleLong (FILE *f)
int	fgetLittleShort (FILE *f)
byte *	LBMRLEDecompress (byte *source, byte *unpacked, int bpwidth)
void	Load256Image (const char *name, byte **pixels, byte **palette, int *width, int *height)
void	Load32BitImage (const char *name, unsigned **pixels, int *width, int *height)
void	LoadBMP (const char *filename, byte **pic, byte **palette, int *width, int *height)
void	LoadLBM (const char *filename, byte **picture, byte **palette)
void	LoadPCX (const char *filename, byte **pic, byte **palette, int *width, int *height)
void	LoadTGA (const char *name, byte **pixels, int *width, int *height)
void	LoadTGABuffer (byte *buffer, byte **pic, int *width, int *height)
void	Save256Image (const char *name, byte *pixels, byte *palette, int width, int height)
void	WriteLBMfile (const char *filename, byte *data, int width, int height, byte *palette)
void	WritePCXfile (const char *filename, byte *data, int width, int height, byte *palette)
void	WriteTGA (const char *filename, byte *data, int width, int height)
Variables
bmhd_t	bmhd

---

Define Documentation

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

Definition at line 100 of file imagelib.c. Referenced by LoadLBM().

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

Definition at line 101 of file imagelib.c. Referenced by LoadLBM().

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

Definition at line 102 of file imagelib.c. Referenced by LoadLBM().

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

Definition at line 97 of file imagelib.c. Referenced by LoadLBM().

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

Definition at line 98 of file imagelib.c. Referenced by LoadLBM().

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

Definition at line 99 of file imagelib.c.

---

Typedef Documentation

typedef long LONG

Definition at line 64 of file imagelib.c. Referenced by ConWndProc(), DoPatchInspector(), DoSurface(), gettok(), InputLineWndProc(), LoadWindowPlacement(), MainWndProc(), CRadiantApp::OnIdle(), CFindTextureDlg::show(), showCameraInspector(), specifier(), WCam_WndProc(), WZ_WndProc(), and XYWndProc().

typedef struct _TargaHeader TargaHeader

typedef unsigned char UBYTE

Definition at line 61 of file imagelib.c.

typedef unsigned short UWORD

Definition at line 63 of file imagelib.c.

---

Enumeration Type Documentation

enum compress_t

Enumeration values: cm_none  cm_rle1  Definition at line 74 of file imagelib.c. { cm_none, cm_rle1 } compress_t;

enum mask_t

Enumeration values: ms_none  ms_mask  ms_transcolor  ms_lasso  Definition at line 66 of file imagelib.c. { ms_none, ms_mask, ms_transcolor, ms_lasso } mask_t;

---

Function Documentation

int Align (  int  l  )

Definition at line 107 of file imagelib.c. References l. { if (l&1) return l+1; return l; }

int fgetLittleLong (  FILE *  f  )

Definition at line 38 of file imagelib.c. References byte, f, and fgetc(). Referenced by LoadBMP(). { byte b1, b2, b3, b4; b1 = fgetc(f); b2 = fgetc(f); b3 = fgetc(f); b4 = fgetc(f); return b1 + (b2<<8) + (b3<<16) + (b4<<24); }

Here is the call graph for this function:

int fgetLittleShort (  FILE *  f  )

Definition at line 28 of file imagelib.c. References byte, f, and fgetc(). { byte b1, b2; b1 = fgetc(f); b2 = fgetc(f); return (short)(b1 + b2*256); }

Here is the call graph for this function:

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

Definition at line 123 of file imagelib.c. References b, byte, count, Error(), memcpy(), memset(), and source. { 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 (  const char *  name, byte **  pixels, byte **  palette, int *  width, int *  height )

Definition at line 774 of file imagelib.c. { char ext[128]; ExtractFileExtension (name, ext); if (!Q_stricmp (ext, "lbm")) { LoadLBM (name, pixels, palette); if (width) *width = bmhd.w; if (height) *height = bmhd.h; } else if (!Q_stricmp (ext, "pcx")) { LoadPCX (name, pixels, palette, width, height); } else if (!Q_stricmp (ext, "bmp")) { LoadBMP (name, pixels, palette, width, height); } else Error ("%s doesn't have a known image extension", name); }

void Load32BitImage (  const char *  name, unsigned **  pixels, int *  width, int *  height )

Definition at line 1133 of file imagelib.c. References byte, ExtractFileExtension(), height, i, Load256Image(), LoadTGA(), malloc(), name, pixels, Q_stricmp(), v, and width. Referenced by LoadAlphaMap(). { char ext[128]; byte *palette; byte *pixels8; byte *pixels32; int size; int i; int v; ExtractFileExtension (name, ext); if (!Q_stricmp (ext, "tga")) { LoadTGA (name, (byte **)pixels, width, height); } else { Load256Image (name, &pixels8, &palette, width, height); if (!pixels) { return; } size = *width * *height; pixels32 = malloc(size * 4); *pixels = (unsigned *)pixels32; for (i = 0 ; i < size ; i++) { v = pixels8[i]; pixels32[i*4 + 0] = palette[ v * 3 + 0 ]; pixels32[i*4 + 1] = palette[ v * 3 + 1 ]; pixels32[i*4 + 2] = palette[ v * 3 + 2 ]; pixels32[i*4 + 3] = 0xff; } } }

Here is the call graph for this function:

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

Definition at line 644 of file imagelib.c. References byte, Error(), fclose(), fgetLittleLong(), fgetLittleShort(), fopen(), fread(), fseek(), height, i, malloc(), qboolean, SEEK_CUR, SEEK_SET, and width. { byte *out; FILE *fin; int i; int bfSize; int bfOffBits; int structSize; int bcWidth; int bcHeight; int bcPlanes; int bcBitCount; byte bcPalette[1024]; qboolean flipped; fin = fopen (filename, "rb"); if (!fin) { Error ("Couldn't read %s", filename); } i = fgetLittleShort (fin); if (i != 'B' + ('M'<<8) ) { Error ("%s is not a bmp file", filename); } bfSize = fgetLittleLong (fin); fgetLittleShort(fin); fgetLittleShort(fin); bfOffBits = fgetLittleLong (fin); // the size will tell us if it is a // bitmapinfo or a bitmapcore structSize = fgetLittleLong (fin); if (structSize == 40) { // bitmapinfo bcWidth = fgetLittleLong(fin); bcHeight= fgetLittleLong(fin); bcPlanes = fgetLittleShort(fin); bcBitCount = fgetLittleShort(fin); fseek (fin, 24, SEEK_CUR); if (palette) { fread (bcPalette, 1, 1024, fin); *palette = malloc(768); for (i = 0 ; i < 256 ; i++) { (*palette)[i * 3 + 0] = bcPalette[i * 4 + 2]; (*palette)[i * 3 + 1] = bcPalette[i * 4 + 1]; (*palette)[i * 3 + 2] = bcPalette[i * 4 + 0]; } } } else if (structSize == 12) { // bitmapcore bcWidth = fgetLittleShort(fin); bcHeight= fgetLittleShort(fin); bcPlanes = fgetLittleShort(fin); bcBitCount = fgetLittleShort(fin); if (palette) { fread (bcPalette, 1, 768, fin); *palette = malloc(768); for (i = 0 ; i < 256 ; i++) { (*palette)[i * 3 + 0] = bcPalette[i * 3 + 2]; (*palette)[i * 3 + 1] = bcPalette[i * 3 + 1]; (*palette)[i * 3 + 2] = bcPalette[i * 3 + 0]; } } } else { Error ("%s had strange struct size", filename); } if (bcPlanes != 1) { Error ("%s was not a single plane image", filename); } if (bcBitCount != 8) { Error ("%s was not an 8 bit image", filename); } if (bcHeight < 0) { bcHeight = -bcHeight; flipped = qtrue; } else { flipped = qfalse; } if (width) *width = bcWidth; if (height) *height = bcHeight; if (!pic) { fclose (fin); return; } out = malloc ( bcWidth * bcHeight ); *pic = out; fseek (fin, bfOffBits, SEEK_SET); if (flipped) { for (i = 0 ; i < bcHeight ; i++) { fread (out + bcWidth * (bcHeight - 1 - i), 1, bcWidth, fin); } } else { fread (out, 1, bcWidth*bcHeight, fin); } fclose (fin); }

Here is the call graph for this function:

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

Definition at line 168 of file imagelib.c. { 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); // // 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 = malloc (768); memset (cmapbuffer, 0, 768); memcpy (cmapbuffer, LBM_P, chunklength); break; case BODYID: body_p = LBM_P; pic_p = picbuffer = 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; }

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

Definition at line 433 of file imagelib.c. { byte *raw; pcx_t *pcx; int x, y; int len; int dataByte, runLength; byte *out, *pix; // // load the file // len = LoadFile (filename, (void **)&raw); // // 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 = malloc(768); memcpy (*palette, (byte *)pcx + len - 768, 768); } if (width) *width = pcx->xmax+1; if (height) *height = pcx->ymax+1; if (!pic) return; out = 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; // FIXME: this shouldn't happen, but it does. Are we decoding the file wrong? // Truncate runLength so we don't overrun the end of the buffer if ( ( y == pcx->ymax ) && ( x + runLength > pcx->xmax + 1 ) ) { runLength = pcx->xmax - x + 1; } while(runLength-- > 0) pix[x++] = dataByte; } } if ( raw - (byte *)pcx > len) Error ("PCX file %s was malformed", filename); free (pcx); }

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

Definition at line 1063 of file imagelib.c. { byte *buffer; int nLen; // // load the file // nLen = LoadFile ( ( char * ) name, (void **)&buffer); if (nLen == -1) { Error ("Couldn't read %s", name); } LoadTGABuffer(buffer, pixels, width, height); }

void LoadTGABuffer (  byte *  buffer, byte **  pic, int *  width, int *  height )

Definition at line 850 of file imagelib.c. References _TargaHeader::attributes, blue, byte, _TargaHeader::colormap_index, _TargaHeader::colormap_length, _TargaHeader::colormap_size, _TargaHeader::colormap_type, Error(), green, _TargaHeader::height, height, _TargaHeader::id_length, _TargaHeader::image_type, j, LittleShort(), malloc(), _TargaHeader::pixel_size, rows, TargaHeader, _TargaHeader::width, width, _TargaHeader::x_origin, and _TargaHeader::y_origin. Referenced by LoadShaderImage(), and LoadTGA(). { int columns, rows, numPixels; byte *pixbuf; int row, column; byte *buf_p; TargaHeader targa_header; byte *targa_rgba; *pic = NULL; 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++; if (targa_header.image_type!=2 && targa_header.image_type!=10 && targa_header.image_type != 3 ) { Error("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n"); } if ( targa_header.colormap_type != 0 ) { Error("LoadTGA: colormaps not supported\n" ); } if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 ) { Error("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 = 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++; *pixbuf++ = red; *pixbuf++ = green; *pixbuf++ = blue; *pixbuf++ = alphabyte; break; default: //Error("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size, name ); break; } } } } else if (targa_header.image_type==10) { // Runlength encoded RGB images 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: //Error("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 (  const char *  name, byte *  pixels, byte *  palette, int  width, int  height )

Definition at line 808 of file imagelib.c. { char ext[128]; ExtractFileExtension (name, ext); if (!Q_stricmp (ext, "lbm")) { WriteLBMfile (name, pixels, width, height, palette); } else if (!Q_stricmp (ext, "pcx")) { WritePCXfile (name, pixels, width, height, palette); } else Error ("%s doesn't have a known image extension", name); }

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

Definition at line 294 of file imagelib.c. { byte *lbm, *lbmptr; int *formlength, *bmhdlength, *cmaplength, *bodylength; int length; bmhd_t basebmhd; lbm = lbmptr = 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 = BigShort(8); basebmhd.xAspect = BigShort(5); basebmhd.yAspect = BigShort(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); }

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

Definition at line 529 of file imagelib.c. { int i, j, length; pcx_t *pcx; byte *pack; pcx = 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(1); // 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); }

void WriteTGA (  const char *  filename, byte *  data, int  width, int  height )

Definition at line 1086 of file imagelib.c. References buffer, byte, c, data, f, fclose(), fopen(), free(), fwrite(), height, i, malloc(), memset(), and width. Referenced by RE_RegisterFont(). { byte *buffer; int i; int c; FILE *f; buffer = malloc(width*height*4 + 18); memset (buffer, 0, 18); buffer[2] = 2; // uncompressed type buffer[12] = width&255; buffer[13] = width>>8; buffer[14] = height&255; buffer[15] = height>>8; buffer[16] = 32; // pixel size // swap rgb to bgr c = 18 + width * height * 4; for (i=18 ; i<c ; i+=4) { buffer[i] = data[i-18+2]; // blue buffer[i+1] = data[i-18+1]; // green buffer[i+2] = data[i-18+0]; // red buffer[i+3] = data[i-18+3]; // alpha } f = fopen (filename, "wb"); fwrite (buffer, 1, c, f); fclose (f); free (buffer); }

Here is the call graph for this function:

---

Variable Documentation

bmhd_t bmhd

Definition at line 85 of file LBMLIB.CPP. Referenced by Load256Image(), and LoadLBM().

---