tr_image.c File Reference

#include "tr_local.h"
#include "../jpeg-6/jpeglib.h"

Include dependency graph for tr_image.c:

Go to the source code of this file.

Data Structures
struct	BMPHeader_t
struct	my_destination_mgr
struct	textureMode_t
Defines
#define	DEFAULT_SIZE   16
#define	DLIGHT_SIZE   16
#define	FILE_HASH_SIZE   1024
#define	FOG_S   256
#define	FOG_T   32
#define	JPEG_INTERNALS
Typedefs
typedef my_destination_mgr *	my_dest_ptr
Functions
char *	CommaParse (char **data_p)
boolean	empty_output_buffer (j_compress_ptr cinfo)
long	generateHashValue (const char *fname)
void	GL_TextureMode (const char *string)
void	init_destination (j_compress_ptr cinfo)
GLOBAL void	jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
GLOBAL JDIMENSION	jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines)
void	jpegDest (j_compress_ptr cinfo, byte *outfile, int size)
void	LoadBMP (const char *name, byte **pic, int *width, int *height)
void	LoadJPG (const char *filename, unsigned char **pic, int *width, int *height)
void	LoadJPG (const char *name, byte **pic, int *width, int *height)
void	LoadPCX (const 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	R_BlendOverTexture (byte *data, int pixelCount, byte blend[4])
void	R_CreateBuiltinImages (void)
void	R_CreateDefaultImage (void)
void	R_CreateDlightImage (void)
void	R_CreateFogImage (void)
image_t *	R_CreateImage (const char *name, const byte *pic, int width, int height, qboolean mipmap, qboolean allowPicmip, int glWrapClampMode)
void	R_DeleteTextures (void)
image_t *	R_FindImageFile (const char *name, qboolean mipmap, qboolean allowPicmip, int glWrapClampMode)
float	R_FogFactor (float s, float t)
void	R_GammaCorrect (byte *buffer, int bufSize)
skin_t *	R_GetSkinByHandle (qhandle_t hSkin)
void	R_ImageList_f (void)
void	R_InitFogTable (void)
void	R_InitImages (void)
void	R_InitSkins (void)
void	R_LightScaleTexture (unsigned *in, int inwidth, int inheight, qboolean only_gamma)
void	R_LoadImage (const char *name, byte **pic, int *width, int *height)
void	R_MipMap (byte *in, int width, int height)
void	R_MipMap2 (unsigned *in, int inWidth, int inHeight)
void	R_SetColorMappings (void)
void	R_SkinList_f (void)
int	R_SumOfUsedImages (void)
qhandle_t	RE_RegisterSkin (const char *name)
void	ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight)
void	SaveJPG (char *filename, int quality, int image_width, int image_height, unsigned char *image_buffer)
void	term_destination (j_compress_ptr cinfo)
void	Upload32 (unsigned *data, int width, int height, qboolean mipmap, qboolean picmip, qboolean lightMap, int *format, int *pUploadWidth, int *pUploadHeight)
Variables
qboolean	charSet
int	gl_filter_max = GL_LINEAR
int	gl_filter_min = GL_LINEAR_MIPMAP_NEAREST
int	hackSize
image_t *	hashTable [FILE_HASH_SIZE]
byte	mipBlendColors [16][4]
textureMode_t	modes []
unsigned char	s_gammatable [256]
byte	s_intensitytable [256]

---

Define Documentation

#define DEFAULT_SIZE   16

Definition at line 2050 of file tr_image.c. Referenced by R_CreateBuiltinImages(), and R_CreateDefaultImage().

#define DLIGHT_SIZE   16

Definition at line 1919 of file tr_image.c. Referenced by R_CreateDlightImage().

#define FILE_HASH_SIZE   1024

Definition at line 47 of file tr_image.c.

#define FOG_S   256

Definition at line 2007 of file tr_image.c. Referenced by R_CreateFogImage().

#define FOG_T   32

Definition at line 2008 of file tr_image.c. Referenced by R_CreateFogImage().

#define JPEG_INTERNALS

Definition at line 33 of file tr_image.c.

---

Typedef Documentation

typedef my_destination_mgr* my_dest_ptr

Definition at line 1514 of file tr_image.c.

---

Function Documentation

char* CommaParse (  char **  data_p  )  [static]

Definition at line 2263 of file tr_image.c. References c, com_token, and data. Referenced by RE_RegisterSkin(). { int c = 0, len; char *data; static char com_token[MAX_TOKEN_CHARS]; data = *data_p; len = 0; com_token[0] = 0; // make sure incoming data is valid if ( !data ) { *data_p = NULL; return com_token; } while ( 1 ) { // skip whitespace while( (c = *data) <= ' ') { if( !c ) { break; } data++; } c = *data; // skip double slash comments if ( c == '/' && data[1] == '/' ) { while (*data && *data != '\n') data++; } // skip /* */ comments else if ( c=='/' && data[1] == '*' ) { while ( *data && ( *data != '*' || data[1] != '/' ) ) { data++; } if ( *data ) { data += 2; } } else { break; } } if ( c == 0 ) { return ""; } // handle quoted strings if (c == '\"') { data++; while (1) { c = *data++; if (c=='\"' || !c) { com_token[len] = 0; *data_p = ( char * ) data; return com_token; } if (len < MAX_TOKEN_CHARS) { com_token[len] = c; len++; } } } // parse a regular word do { if (len < MAX_TOKEN_CHARS) { com_token[len] = c; len++; } data++; c = *data; } while (c>32 && c != ',' ); if (len == MAX_TOKEN_CHARS) { // Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS); len = 0; } com_token[len] = 0; *data_p = ( char * ) data; return com_token; }

boolean empty_output_buffer (  j_compress_ptr  cinfo  )

Definition at line 1554 of file tr_image.c. References j_compress_ptr. { return TRUE; }

long generateHashValue (  const char *  fname  )  [static]

Definition at line 80 of file tr_image.c. References FILE_HASH_SIZE, i, and tolower(). { int i; long hash; char letter; hash = 0; i = 0; while (fname[i] != '\0') { letter = tolower(fname[i]); if (letter =='.') break; // don't include extension if (letter =='\\') letter = '/'; // damn path names hash+=(long)(letter)*(i+119); i++; } hash &= (FILE_HASH_SIZE-1); return hash; }

Here is the call graph for this function:

void GL_TextureMode (  const char *  string  )

Definition at line 103 of file tr_image.c. References GL_Bind(), gl_filter_max, gl_filter_min, glConfig, glconfig_t::hardwareType, i, image_t, trGlobals_t::images, textureMode_t::maximize, textureMode_t::minimize, image_s::mipmap, modes, name, trGlobals_t::numImages, PRINT_ALL, Q_stricmp(), qglTexParameterf, ri, string(), and tr. Referenced by GL_SetDefaultState(), and RE_BeginFrame(). { int i; image_t *glt; for ( i=0 ; i< 6 ; i++ ) { if ( !Q_stricmp( modes[i].name, string ) ) { break; } } // hack to prevent trilinear from being set on voodoo, // because their driver freaks... if ( i == 5 && glConfig.hardwareType == GLHW_3DFX_2D3D ) { ri.Printf( PRINT_ALL, "Refusing to set trilinear on a voodoo.\n" ); i = 3; } if ( i == 6 ) { ri.Printf (PRINT_ALL, "bad filter name\n"); return; } gl_filter_min = modes[i].minimize; gl_filter_max = modes[i].maximize; // change all the existing mipmap texture objects for ( i = 0 ; i < tr.numImages ; i++ ) { glt = tr.images[ i ]; if ( glt->mipmap ) { GL_Bind (glt); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); } } }

Here is the call graph for this function:

void init_destination (  j_compress_ptr  cinfo  )

Definition at line 1522 of file tr_image.c. References jpeg_compress_struct::dest, jpeg_destination_mgr::free_in_buffer, j_compress_ptr, my_dest_ptr, jpeg_destination_mgr::next_output_byte, my_destination_mgr::outfile, my_destination_mgr::pub, and my_destination_mgr::size. { my_dest_ptr dest = (my_dest_ptr) cinfo->dest; dest->pub.next_output_byte = dest->outfile; dest->pub.free_in_buffer = dest->size; }

GLOBAL void jpeg_start_compress (  j_compress_ptr  cinfo, boolean  write_all_tables )

Definition at line 1576 of file tr_image.c. References CSTATE_RAW_OK, jpeg_compress_struct::dest, ERREXIT1, FALSE, j_common_ptr, j_compress_ptr, jinit_compress_master(), jpeg_suppress_tables(), jpeg_compress_struct::master, jpeg_compress_struct::next_scanline, and jpeg_compress_struct::raw_data_in. Referenced by SaveJPG(). { if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (write_all_tables) jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */ /* (Re)initialize error mgr and destination modules */ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); (*cinfo->dest->init_destination) (cinfo); /* Perform master selection of active modules */ jinit_compress_master(cinfo); /* Set up for the first pass */ (*cinfo->master->prepare_for_pass) (cinfo); /* Ready for application to drive first pass through jpeg_write_scanlines * or jpeg_write_raw_data. */ cinfo->next_scanline = 0; cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING); }

Here is the call graph for this function:

GLOBAL JDIMENSION jpeg_write_scanlines (  j_compress_ptr  cinfo, JSAMPARRAY  scanlines, JDIMENSION  num_lines )

Definition at line 1615 of file tr_image.c. References jpeg_comp_master::call_pass_startup, ERREXIT1, jpeg_compress_struct::image_height, j_common_ptr, j_compress_ptr, JDIMENSION, JWRN_TOO_MUCH_DATA, jpeg_compress_struct::main, jpeg_compress_struct::master, jpeg_compress_struct::next_scanline, and WARNMS. Referenced by SaveJPG(). { JDIMENSION row_ctr, rows_left; if (cinfo->global_state != CSTATE_SCANNING) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->next_scanline >= cinfo->image_height) WARNMS(cinfo, JWRN_TOO_MUCH_DATA); /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->next_scanline; cinfo->progress->pass_limit = (long) cinfo->image_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Give master control module another chance if this is first call to * jpeg_write_scanlines. This lets output of the frame/scan headers be * delayed so that application can write COM, etc, markers between * jpeg_start_compress and jpeg_write_scanlines. */ if (cinfo->master->call_pass_startup) (*cinfo->master->pass_startup) (cinfo); /* Ignore any extra scanlines at bottom of image. */ rows_left = cinfo->image_height - cinfo->next_scanline; if (num_lines > rows_left) num_lines = rows_left; row_ctr = 0; (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines); cinfo->next_scanline += row_ctr; return row_ctr; }

void jpegDest (  j_compress_ptr  cinfo, byte *  outfile, int  size )

Definition at line 1676 of file tr_image.c. References byte, jpeg_compress_struct::dest, j_common_ptr, j_compress_ptr, my_dest_ptr, my_destination_mgr::outfile, my_destination_mgr::pub, and my_destination_mgr::size. Referenced by SaveJPG(). { my_dest_ptr dest; /* The destination object is made permanent so that multiple JPEG images * can be written to the same file without re-executing jpeg_stdio_dest. * This makes it dangerous to use this manager and a different destination * manager serially with the same JPEG object, because their private object * sizes may be different. Caveat programmer. */ if (cinfo->dest == NULL) { /* first time for this JPEG object? */ cinfo->dest = (struct jpeg_destination_mgr *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_destination_mgr)); } dest = (my_dest_ptr) cinfo->dest; dest->pub.init_destination = init_destination; dest->pub.empty_output_buffer = empty_output_buffer; dest->pub.term_destination = term_destination; dest->outfile = outfile; dest->size = size; }

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

Definition at line 822 of file tr_image.c. References alpha, BMPHeader_t::bitmapDataOffset, BMPHeader_t::bitmapDataSize, BMPHeader_t::bitmapHeaderSize, BMPHeader_t::bitsPerPixel, blue, buffer, byte, BMPHeader_t::colors, Com_Memcpy(), BMPHeader_t::compression, ERR_DROP, BMPHeader_t::fileSize, refimport_t::FS_FreeFile, refimport_t::FS_ReadFile, green, height, BMPHeader_t::height, BMPHeader_t::hRes, BMPHeader_t::id, BMPHeader_t::importantColors, length(), LittleLong(), LittleShort(), refimport_t::Malloc, name, BMPHeader_t::palette, BMPHeader_t::planes, BMPHeader_t::reserved0, ri, rows, BMPHeader_t::vRes, width, and BMPHeader_t::width. { int columns, rows, numPixels; byte *pixbuf; int row, column; byte *buf_p; byte *buffer; int length; BMPHeader_t bmpHeader; byte *bmpRGBA; *pic = NULL; // // load the file // length = ri.FS_ReadFile( ( char * ) name, (void **)&buffer); if (!buffer) { 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; Com_Memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) ); if ( bmpHeader.bitsPerPixel == 8 ) buf_p += 1024; if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' ) { ri.Error( ERR_DROP, "LoadBMP: only Windows-style BMP files supported (%s)\n", name ); } if ( bmpHeader.fileSize != length ) { ri.Error( ERR_DROP, "LoadBMP: header size does not match file size (%d vs. %d) (%s)\n", bmpHeader.fileSize, length, name ); } if ( bmpHeader.compression != 0 ) { ri.Error( ERR_DROP, "LoadBMP: only uncompressed BMP files supported (%s)\n", name ); } if ( bmpHeader.bitsPerPixel < 8 ) { ri.Error( ERR_DROP, "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 = ri.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: ri.Error( ERR_DROP, "LoadBMP: illegal pixel_size '%d' in file '%s'\n", bmpHeader.bitsPerPixel, name ); break; } } } ri.FS_FreeFile( buffer ); }

Here is the call graph for this function:

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

Definition at line 1360 of file tr_image.c. References buffer, byte, refimport_t::FS_FreeFile, refimport_t::FS_ReadFile, height, i, j, jpeg_create_decompress(), jpeg_destroy_decompress(), jpeg_finish_decompress(), jpeg_read_header(), jpeg_read_scanlines(), jpeg_start_decompress(), jpeg_std_error(), jpeg_stdio_src(), JSAMPARRAY, refimport_t::Malloc, jpeg_decompress_struct::output_components, jpeg_decompress_struct::output_height, jpeg_decompress_struct::output_scanline, jpeg_decompress_struct::output_width, ri, TRUE, and width. { /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ /* This struct represents a JPEG error handler. It is declared separately * because applications often want to supply a specialized error handler * (see the second half of this file for an example). But here we just * take the easy way out and use the standard error handler, which will * print a message on stderr and call exit() if compression fails. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct jpeg_error_mgr jerr; /* More stuff */ JSAMPARRAY buffer; /* Output row buffer */ int row_stride; /* physical row width in output buffer */ unsigned char *out; byte *fbuffer; byte *bbuf; /* In this example we want to open the input file before doing anything else, * so that the setjmp() error recovery below can assume the file is open. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to read binary files. */ ri.FS_ReadFile ( ( char * ) filename, (void **)&fbuffer); if (!fbuffer) { return; } /* Step 1: allocate and initialize JPEG decompression object */ /* We have to set up the error handler first, in case the initialization * step fails. (Unlikely, but it could happen if you are out of memory.) * This routine fills in the contents of struct jerr, and returns jerr's * address which we place into the link field in cinfo. */ cinfo.err = jpeg_std_error(&jerr); /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* Step 2: specify data source (eg, a file) */ jpeg_stdio_src(&cinfo, fbuffer); /* Step 3: read file parameters with jpeg_read_header() */ (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ /* Step 4: set parameters for decompression */ /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ /* Step 5: Start decompressor */ (void) jpeg_start_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* JSAMPLEs per row in output buffer */ row_stride = cinfo.output_width * cinfo.output_components; out = ri.Malloc(cinfo.output_width*cinfo.output_height*cinfo.output_components); *pic = out; *width = cinfo.output_width; *height = cinfo.output_height; /* Step 6: while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ bbuf = ((out+(row_stride*cinfo.output_scanline))); buffer = &bbuf; (void) jpeg_read_scanlines(&cinfo, buffer, 1); } // clear all the alphas to 255 { int i, j; byte *buf; buf = *pic; j = cinfo.output_width * cinfo.output_height * 4; for ( i = 3 ; i < j ; i+=4 ) { buf[i] = 255; } } /* Step 7: Finish decompression */ (void) jpeg_finish_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&cinfo); /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ ri.FS_FreeFile (fbuffer); /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */ /* And we're done! */ }

Here is the call graph for this function:

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

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

Definition at line 986 of file tr_image.c. References pcx_t::bits_per_pixel, byte, Com_Memcpy(), pcx_t::data, pcx_t::encoding, refimport_t::Free, refimport_t::FS_FreeFile, refimport_t::FS_ReadFile, height, LittleShort(), refimport_t::Malloc, pcx_t::manufacturer, PRINT_ALL, PRINT_DEVELOPER, ri, 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 = ri.FS_ReadFile( ( char * ) filename, (void **)&raw); if (!raw) { 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) { ri.Printf (PRINT_ALL, "Bad pcx file %s (%i x %i) (%i x %i)\n", filename, xmax+1, ymax+1, pcx->xmax, pcx->ymax); return; } out = ri.Malloc ( (ymax+1) * (xmax+1) ); *pic = out; pix = out; if (palette) { *palette = ri.Malloc(768); Com_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) { ri.Printf (PRINT_DEVELOPER, "PCX file %s was malformed", filename); ri.Free (*pic); *pic = NULL; } ri.FS_FreeFile (pcx); }

Here is the call graph for this function:

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

Definition at line 1081 of file tr_image.c. References byte, c, refimport_t::Free, height, i, LoadPCX(), refimport_t::Malloc, p, ri, and width. { 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 = ri.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; } ri.Free (pic8); ri.Free (palette); }

Here is the call graph for this function:

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

Definition at line 1121 of file tr_image.c. References _TargaHeader::attributes, blue, buffer, byte, _TargaHeader::colormap_index, _TargaHeader::colormap_length, _TargaHeader::colormap_size, _TargaHeader::colormap_type, ERR_DROP, free(), refimport_t::FS_FreeFile, refimport_t::FS_ReadFile, green, height, _TargaHeader::height, _TargaHeader::id_length, _TargaHeader::image_type, j, LittleShort(), malloc(), refimport_t::Malloc, memcpy(), name, _TargaHeader::pixel_size, PRINT_WARNING, ri, rows, src, 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 // ri.FS_ReadFile ( ( char * ) name, (void **)&buffer); if (!buffer) { 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++; if (targa_header.image_type!=2 && targa_header.image_type!=10 && targa_header.image_type != 3 ) { ri.Error (ERR_DROP, "LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n"); } if ( targa_header.colormap_type != 0 ) { ri.Error( ERR_DROP, "LoadTGA: colormaps not supported\n" ); } if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 ) { ri.Error (ERR_DROP, "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 = ri.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: ri.Error( ERR_DROP, "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: ri.Error( ERR_DROP, "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++;