You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2301 lines
62 KiB
2301 lines
62 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// NOTE: To make use of this file, g_pFullFileSystem must be defined, or you can modify |
|
// this source to take an IFileSystem * as input. |
|
// |
|
//=======================================================================================// |
|
|
|
// @note Tom Bui: we need to use fopen below in the jpeg code, so we can't have this on... |
|
#ifdef PROTECTED_THINGS_ENABLE |
|
#if !defined( POSIX ) |
|
#undef fopen |
|
#endif // POSIX |
|
#endif |
|
|
|
#if defined( WIN32 ) && !defined( _X360 ) |
|
#include <windows.h> // SRC only!! |
|
#elif defined( POSIX ) |
|
#include <stdio.h> |
|
#include <sys/stat.h> |
|
#ifdef OSX |
|
#include <copyfile.h> |
|
#endif |
|
#endif |
|
|
|
#include "imageutils.h" |
|
#include "filesystem.h" |
|
#include "utlbuffer.h" |
|
#include "bitmap/bitmap.h" |
|
#include "vtf/vtf.h" |
|
|
|
// clang3 on OSX folks the attribute into the prototype, causing a compile failure |
|
// filed radar bug 10397783 |
|
#if ( __clang_major__ == 3 ) |
|
#include <setjmp.h> |
|
extern void longjmp( jmp_buf, int ) __attribute__((noreturn)); |
|
#endif |
|
|
|
|
|
#ifdef ENGINE_DLL |
|
#include "common.h" |
|
#elif CLIENT_DLL |
|
// @note Tom Bui: instead of forcing the project to include EngineInterface.h... |
|
#include "cdll_int.h" |
|
// engine interface singleton accessors |
|
extern IVEngineClient *engine; |
|
extern class IGameUIFuncs *gameuifuncs; |
|
extern class IEngineSound *enginesound; |
|
extern class IMatchmaking *matchmaking; |
|
extern class IXboxSystem *xboxsystem; |
|
extern class IAchievementMgr *achievementmgr; |
|
extern class CSteamAPIContext *steamapicontext; |
|
#elif REPLAY_DLL |
|
#include "replay/ienginereplay.h" |
|
extern IEngineReplay *g_pEngine; |
|
#elif ENGINE_DLL |
|
#include "EngineInterface.h" |
|
#else |
|
#include "cdll_int.h" |
|
extern IVEngineClient *engine; |
|
#endif |
|
|
|
// use the JPEGLIB_USE_STDIO define so that we can read in jpeg's from outside the game directory tree. |
|
#define JPEGLIB_USE_STDIO |
|
#include "jpeglib/jpeglib.h" |
|
#undef JPEGLIB_USE_STDIO |
|
|
|
#include "libpng/png.h" |
|
|
|
#include <setjmp.h> |
|
|
|
#include "bitmap/tgawriter.h" |
|
#include "ivtex.h" |
|
#ifdef WIN32 |
|
#include <io.h> |
|
#endif |
|
#ifdef OSX |
|
#include <copyfile.h> |
|
#endif |
|
|
|
#ifndef WIN32 |
|
#define DeleteFile(s) remove(s) |
|
#endif |
|
|
|
#if defined( _X360 ) |
|
#include "xbox/xbox_win32stubs.h" |
|
#endif |
|
|
|
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include <tier0/memdbgon.h> |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
struct ValveJpegErrorHandler_t |
|
{ |
|
// The default manager |
|
struct jpeg_error_mgr m_Base; |
|
// For handling any errors |
|
jmp_buf m_ErrorContext; |
|
}; |
|
|
|
#define JPEG_OUTPUT_BUF_SIZE 4096 |
|
|
|
struct JPEGDestinationManager_t |
|
{ |
|
struct jpeg_destination_mgr pub; // public fields |
|
|
|
CUtlBuffer *pBuffer; // target/final buffer |
|
byte *buffer; // start of temp buffer |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: We'll override the default error handler so we can deal with errors without having to exit the engine |
|
//----------------------------------------------------------------------------- |
|
static void ValveJpegErrorHandler( j_common_ptr cinfo ) |
|
{ |
|
ValveJpegErrorHandler_t *pError = reinterpret_cast< ValveJpegErrorHandler_t * >( cinfo->err ); |
|
|
|
char buffer[ JMSG_LENGTH_MAX ]; |
|
|
|
/* Create the message */ |
|
( *cinfo->err->format_message )( cinfo, buffer ); |
|
|
|
Warning( "%s\n", buffer ); |
|
|
|
// Bail |
|
longjmp( pError->m_ErrorContext, 1 ); |
|
} |
|
|
|
|
|
// convert the JPEG file given to a TGA file at the given output path. |
|
ConversionErrorType ImgUtl_ConvertJPEGToTGA( const char *jpegpath, const char *tgaPath, bool bRequirePowerOfTwo ) |
|
{ |
|
#if !defined( _X360 ) |
|
|
|
// |
|
// !FIXME! This really probably should use ImgUtl_ReadJPEGAsRGBA, to avoid duplicated code. |
|
// |
|
|
|
struct jpeg_decompress_struct jpegInfo; |
|
struct ValveJpegErrorHandler_t jerr; |
|
JSAMPROW row_pointer[1]; |
|
int row_stride; |
|
int cur_row = 0; |
|
|
|
// image attributes |
|
int image_height; |
|
int image_width; |
|
|
|
// open the jpeg image file. |
|
FILE *infile = fopen(jpegpath, "rb"); |
|
if (infile == NULL) |
|
{ |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
// setup error to print to stderr. |
|
jpegInfo.err = jpeg_std_error(&jerr.m_Base); |
|
|
|
jpegInfo.err->error_exit = &ValveJpegErrorHandler; |
|
|
|
// create the decompress struct. |
|
jpeg_create_decompress(&jpegInfo); |
|
|
|
if ( setjmp( jerr.m_ErrorContext ) ) |
|
{ |
|
// Get here if there is any error |
|
jpeg_destroy_decompress( &jpegInfo ); |
|
|
|
fclose(infile); |
|
|
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
jpeg_stdio_src(&jpegInfo, infile); |
|
|
|
// read in the jpeg header and make sure that's all good. |
|
if (jpeg_read_header(&jpegInfo, TRUE) != JPEG_HEADER_OK) |
|
{ |
|
fclose(infile); |
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
// start the decompress with the jpeg engine. |
|
if ( !jpeg_start_decompress(&jpegInfo) ) |
|
{ |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose(infile); |
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
// Check for valid width and height (ie. power of 2 and print out an error and exit if not). |
|
if ( ( bRequirePowerOfTwo && ( !IsPowerOfTwo(jpegInfo.image_height) || !IsPowerOfTwo(jpegInfo.image_width) ) ) |
|
|| jpegInfo.output_components != 3 ) |
|
{ |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose( infile ); |
|
return CE_SOURCE_FILE_SIZE_NOT_SUPPORTED; |
|
} |
|
|
|
// now that we've started the decompress with the jpeg lib, we have the attributes of the |
|
// image ready to be read out of the decompress struct. |
|
row_stride = jpegInfo.output_width * jpegInfo.output_components; |
|
image_height = jpegInfo.image_height; |
|
image_width = jpegInfo.image_width; |
|
int mem_required = jpegInfo.image_height * jpegInfo.image_width * jpegInfo.output_components; |
|
|
|
// allocate the memory to read the image data into. |
|
unsigned char *buf = (unsigned char *)malloc(mem_required); |
|
if (buf == NULL) |
|
{ |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose(infile); |
|
return CE_MEMORY_ERROR; |
|
} |
|
|
|
// read in all the scan lines of the image into our image data buffer. |
|
bool working = true; |
|
while (working && (jpegInfo.output_scanline < jpegInfo.output_height)) |
|
{ |
|
row_pointer[0] = &(buf[cur_row * row_stride]); |
|
if ( !jpeg_read_scanlines(&jpegInfo, row_pointer, 1) ) |
|
{ |
|
working = false; |
|
} |
|
++cur_row; |
|
} |
|
|
|
if (!working) |
|
{ |
|
free(buf); |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose(infile); |
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
jpeg_finish_decompress(&jpegInfo); |
|
|
|
fclose(infile); |
|
|
|
// ok, at this point we have read in the JPEG image to our buffer, now we need to write it out as a TGA file. |
|
CUtlBuffer outBuf; |
|
bool bRetVal = TGAWriter::WriteToBuffer( buf, outBuf, image_width, image_height, IMAGE_FORMAT_RGB888, IMAGE_FORMAT_RGB888 ); |
|
if ( bRetVal ) |
|
{ |
|
if ( !g_pFullFileSystem->WriteFile( tgaPath, NULL, outBuf ) ) |
|
{ |
|
bRetVal = false; |
|
} |
|
} |
|
|
|
free(buf); |
|
return bRetVal ? CE_SUCCESS : CE_ERROR_WRITING_OUTPUT_FILE; |
|
|
|
#else |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
#endif |
|
} |
|
|
|
// convert the bmp file given to a TGA file at the given destination path. |
|
ConversionErrorType ImgUtl_ConvertBMPToTGA(const char *bmpPath, const char *tgaPath) |
|
{ |
|
if ( !IsPC() ) |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
|
|
#ifdef WIN32 |
|
|
|
int nWidth, nHeight; |
|
ConversionErrorType result; |
|
unsigned char *pBufRGBA = ImgUtl_ReadBMPAsRGBA( bmpPath, nWidth, nHeight, result ); |
|
if ( result != CE_SUCCESS) |
|
{ |
|
Assert( !pBufRGBA ); |
|
free( pBufRGBA ); |
|
return result; |
|
} |
|
Assert( pBufRGBA ); |
|
|
|
// write out the TGA file using the RGB data buffer. |
|
CUtlBuffer outBuf; |
|
bool retval = TGAWriter::WriteToBuffer(pBufRGBA, outBuf, nWidth, nHeight, IMAGE_FORMAT_RGBA8888, IMAGE_FORMAT_RGB888); |
|
free( pBufRGBA ); |
|
|
|
if ( retval ) |
|
{ |
|
if ( !g_pFullFileSystem->WriteFile( tgaPath, NULL, outBuf ) ) |
|
{ |
|
retval = false; |
|
} |
|
} |
|
|
|
return retval ? CE_SUCCESS : CE_ERROR_WRITING_OUTPUT_FILE; |
|
|
|
#else // WIN32 |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
#endif |
|
} |
|
|
|
unsigned char *ImgUtl_ReadVTFAsRGBA( const char *vtfPath, int &width, int &height, ConversionErrorType &errcode ) |
|
{ |
|
// Just load the whole file into a memory buffer |
|
CUtlBuffer bufFileContents; |
|
if ( !g_pFullFileSystem->ReadFile( vtfPath, NULL, bufFileContents ) ) |
|
{ |
|
errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
return NULL; |
|
} |
|
|
|
IVTFTexture *pVTFTexture = CreateVTFTexture(); |
|
if ( !pVTFTexture->Unserialize( bufFileContents ) ) |
|
{ |
|
DestroyVTFTexture( pVTFTexture ); |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
return NULL; |
|
} |
|
|
|
width = pVTFTexture->Width(); |
|
height = pVTFTexture->Height(); |
|
pVTFTexture->ConvertImageFormat( IMAGE_FORMAT_RGBA8888, false ); |
|
|
|
int nMemSize = ImageLoader::GetMemRequired( width, height, 1, IMAGE_FORMAT_RGBA8888, false ); |
|
unsigned char *pMemImage = (unsigned char *)malloc(nMemSize); |
|
if ( pMemImage == NULL ) |
|
{ |
|
DestroyVTFTexture( pVTFTexture ); |
|
errcode = CE_MEMORY_ERROR; |
|
return NULL; |
|
} |
|
Q_memcpy( pMemImage, pVTFTexture->ImageData(), nMemSize ); |
|
|
|
DestroyVTFTexture( pVTFTexture ); |
|
|
|
errcode = CE_SUCCESS; |
|
return pMemImage; |
|
} |
|
|
|
// read a TGA header from the current point in the file stream. |
|
static void ImgUtl_ReadTGAHeader(FILE *infile, TGAHeader &header) |
|
{ |
|
if (infile == NULL) |
|
{ |
|
return; |
|
} |
|
|
|
fread(&header.identsize, sizeof(header.identsize), 1, infile); |
|
fread(&header.colourmaptype, sizeof(header.colourmaptype), 1, infile); |
|
fread(&header.imagetype, sizeof(header.imagetype), 1, infile); |
|
fread(&header.colourmapstart, sizeof(header.colourmapstart), 1, infile); |
|
fread(&header.colourmaplength, sizeof(header.colourmaplength), 1, infile); |
|
fread(&header.colourmapbits, sizeof(header.colourmapbits), 1, infile); |
|
fread(&header.xstart, sizeof(header.xstart), 1, infile); |
|
fread(&header.ystart, sizeof(header.ystart), 1, infile); |
|
fread(&header.width, sizeof(header.width), 1, infile); |
|
fread(&header.height, sizeof(header.height), 1, infile); |
|
fread(&header.bits, sizeof(header.bits), 1, infile); |
|
fread(&header.descriptor, sizeof(header.descriptor), 1, infile); |
|
} |
|
|
|
// write a TGA header to the current point in the file stream. |
|
static void WriteTGAHeader(FILE *outfile, TGAHeader &header) |
|
{ |
|
if (outfile == NULL) |
|
{ |
|
return; |
|
} |
|
|
|
fwrite(&header.identsize, sizeof(header.identsize), 1, outfile); |
|
fwrite(&header.colourmaptype, sizeof(header.colourmaptype), 1, outfile); |
|
fwrite(&header.imagetype, sizeof(header.imagetype), 1, outfile); |
|
fwrite(&header.colourmapstart, sizeof(header.colourmapstart), 1, outfile); |
|
fwrite(&header.colourmaplength, sizeof(header.colourmaplength), 1, outfile); |
|
fwrite(&header.colourmapbits, sizeof(header.colourmapbits), 1, outfile); |
|
fwrite(&header.xstart, sizeof(header.xstart), 1, outfile); |
|
fwrite(&header.ystart, sizeof(header.ystart), 1, outfile); |
|
fwrite(&header.width, sizeof(header.width), 1, outfile); |
|
fwrite(&header.height, sizeof(header.height), 1, outfile); |
|
fwrite(&header.bits, sizeof(header.bits), 1, outfile); |
|
fwrite(&header.descriptor, sizeof(header.descriptor), 1, outfile); |
|
} |
|
|
|
// reads in a TGA file and converts it to 32 bit RGBA color values in a memory buffer. |
|
unsigned char * ImgUtl_ReadTGAAsRGBA(const char *tgaPath, int &width, int &height, ConversionErrorType &errcode, TGAHeader &tgaHeader ) |
|
{ |
|
FILE *tgaFile = fopen(tgaPath, "rb"); |
|
if (tgaFile == NULL) |
|
{ |
|
errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
return NULL; |
|
} |
|
|
|
// read header for TGA file. |
|
ImgUtl_ReadTGAHeader(tgaFile, tgaHeader); |
|
|
|
if ( |
|
( tgaHeader.imagetype != 2 ) // image type 2 is uncompressed RGB, other types not supported. |
|
|| ( tgaHeader.descriptor & 0x10 ) // Origin on righthand side (flipped horizontally from common sense) --- nobody ever uses this |
|
|| ( tgaHeader.bits != 24 && tgaHeader.bits != 32 ) // Must be 24- ot 32-bit |
|
) |
|
{ |
|
fclose(tgaFile); |
|
|
|
errcode = CE_SOURCE_FILE_TGA_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
} |
|
|
|
int tgaDataSize = tgaHeader.width * tgaHeader.height * tgaHeader.bits / 8; |
|
unsigned char *tgaData = (unsigned char *)malloc(tgaDataSize); |
|
if (tgaData == NULL) |
|
{ |
|
fclose(tgaFile); |
|
|
|
errcode = CE_MEMORY_ERROR; |
|
return NULL; |
|
} |
|
|
|
fread(tgaData, 1, tgaDataSize, tgaFile); |
|
|
|
fclose(tgaFile); |
|
|
|
width = tgaHeader.width; |
|
height = tgaHeader.height; |
|
int numPixels = tgaHeader.width * tgaHeader.height; |
|
|
|
if (tgaHeader.bits == 24) |
|
{ |
|
// image needs to be converted to a 32-bit image. |
|
|
|
unsigned char *retBuf = (unsigned char *)malloc(numPixels * 4); |
|
if (retBuf == NULL) |
|
{ |
|
free(tgaData); |
|
|
|
errcode = CE_MEMORY_ERROR; |
|
return NULL; |
|
} |
|
|
|
// convert from BGR to RGBA color format. |
|
for (int index = 0; index < numPixels; ++index) |
|
{ |
|
retBuf[index * 4] = tgaData[index * 3 + 2]; |
|
retBuf[index * 4 + 1] = tgaData[index * 3 + 1]; |
|
retBuf[index * 4 + 2] = tgaData[index * 3]; |
|
retBuf[index * 4 + 3] = 0xff; |
|
} |
|
|
|
free(tgaData); |
|
tgaData = retBuf; |
|
tgaHeader.bits = 32; |
|
} |
|
else if (tgaHeader.bits == 32) |
|
{ |
|
// Swap blue and red to convert BGR -> RGB |
|
for (int index = 0; index < numPixels; ++index) |
|
{ |
|
V_swap( tgaData[index*4], tgaData[index*4 + 2] ); |
|
} |
|
} |
|
|
|
// Flip image vertically if necessary |
|
if ( !( tgaHeader.descriptor & 0x20 ) ) |
|
{ |
|
int y0 = 0; |
|
int y1 = height-1; |
|
int iStride = width*4; |
|
while ( y0 < y1 ) |
|
{ |
|
unsigned char *ptr0 = tgaData + y0*iStride; |
|
unsigned char *ptr1 = tgaData + y1*iStride; |
|
for ( int i = 0 ; i < iStride ; ++i ) |
|
{ |
|
V_swap( ptr0[i], ptr1[i] ); |
|
} |
|
++y0; |
|
--y1; |
|
} |
|
tgaHeader.descriptor |= 0x20; |
|
} |
|
|
|
errcode = CE_SUCCESS; |
|
return tgaData; |
|
} |
|
|
|
unsigned char *ImgUtl_ReadJPEGAsRGBA( const char *jpegPath, int &width, int &height, ConversionErrorType &errcode ) |
|
{ |
|
#if !defined( _X360 ) |
|
struct jpeg_decompress_struct jpegInfo; |
|
struct ValveJpegErrorHandler_t jerr; |
|
JSAMPROW row_pointer[1]; |
|
int row_stride; |
|
int cur_row = 0; |
|
|
|
// image attributes |
|
int image_height; |
|
int image_width; |
|
|
|
// open the jpeg image file. |
|
FILE *infile = fopen(jpegPath, "rb"); |
|
if (infile == NULL) |
|
{ |
|
errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
return NULL; |
|
} |
|
|
|
//CJpegSourceMgr src; |
|
//FileHandle_t fileHandle = g_pFullFileSystem->Open( jpegPath, "rb" ); |
|
//if ( fileHandle == FILESYSTEM_INVALID_HANDLE ) |
|
//{ |
|
// errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
// return NULL; |
|
//} |
|
//if ( !src.Init( g_pFullFileSystem, fileHandle ) ) { |
|
// errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
// g_pFullFileSystem->Close( fileHandle ); |
|
// return NULL; |
|
//} |
|
|
|
// setup error to print to stderr. |
|
memset( &jpegInfo, 0, sizeof( jpegInfo ) ); |
|
jpegInfo.err = jpeg_std_error(&jerr.m_Base); |
|
|
|
jpegInfo.err->error_exit = &ValveJpegErrorHandler; |
|
|
|
// create the decompress struct. |
|
jpeg_create_decompress(&jpegInfo); |
|
|
|
if ( setjmp( jerr.m_ErrorContext ) ) |
|
{ |
|
// Get here if there is any error |
|
jpeg_destroy_decompress( &jpegInfo ); |
|
|
|
fclose( infile ); |
|
//g_pFullFileSystem->Close( fileHandle ); |
|
|
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
return NULL; |
|
} |
|
|
|
jpeg_stdio_src(&jpegInfo, infile); |
|
//jpegInfo.src = &src; |
|
|
|
// read in the jpeg header and make sure that's all good. |
|
if (jpeg_read_header(&jpegInfo, TRUE) != JPEG_HEADER_OK) |
|
{ |
|
fclose( infile ); |
|
//g_pFullFileSystem->Close( fileHandle ); |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
return NULL; |
|
} |
|
|
|
// start the decompress with the jpeg engine. |
|
if ( !jpeg_start_decompress(&jpegInfo) ) |
|
{ |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose( infile ); |
|
//g_pFullFileSystem->Close( fileHandle ); |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
return NULL; |
|
} |
|
|
|
// We only support 24-bit JPEG's |
|
if ( jpegInfo.out_color_space != JCS_RGB || jpegInfo.output_components != 3 ) |
|
{ |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose( infile ); |
|
//g_pFullFileSystem->Close( fileHandle ); |
|
errcode = CE_SOURCE_FILE_SIZE_NOT_SUPPORTED; |
|
return NULL; |
|
} |
|
|
|
// now that we've started the decompress with the jpeg lib, we have the attributes of the |
|
// image ready to be read out of the decompress struct. |
|
row_stride = jpegInfo.output_width * 4; |
|
image_height = jpegInfo.image_height; |
|
image_width = jpegInfo.image_width; |
|
int mem_required = jpegInfo.image_height * row_stride; |
|
|
|
// allocate the memory to read the image data into. |
|
unsigned char *buf = (unsigned char *)malloc(mem_required); |
|
if (buf == NULL) |
|
{ |
|
jpeg_destroy_decompress(&jpegInfo); |
|
fclose( infile ); |
|
//g_pFullFileSystem->Close( fileHandle ); |
|
errcode = CE_MEMORY_ERROR; |
|
return NULL; |
|
} |
|
|
|
// read in all the scan lines of the image into our image data buffer. |
|
bool working = true; |
|
while (working && (jpegInfo.output_scanline < jpegInfo.output_height)) |
|
{ |
|
unsigned char *pRow = &(buf[cur_row * row_stride]); |
|
row_pointer[0] = pRow; |
|
if ( !jpeg_read_scanlines(&jpegInfo, row_pointer, 1) ) |
|
{ |
|
working = false; |
|
} |
|
|
|
// Expand the row RGB -> RGBA |
|
for ( int x = image_width-1 ; x >= 0 ; --x ) |
|
{ |
|
pRow[x*4+3] = 0xff; |
|
pRow[x*4+2] = pRow[x*3+2]; |
|
pRow[x*4+1] = pRow[x*3+1]; |
|
pRow[x*4] = pRow[x*3]; |
|
} |
|
|
|
++cur_row; |
|
} |
|
|
|
// Clean up |
|
fclose( infile ); |
|
//g_pFullFileSystem->Close( fileHandle ); |
|
jpeg_destroy_decompress(&jpegInfo); |
|
|
|
// Check success status |
|
if (!working) |
|
{ |
|
free(buf); |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
return NULL; |
|
} |
|
|
|
// OK! |
|
width = image_width; |
|
height = image_height; |
|
errcode = CE_SUCCESS; |
|
return buf; |
|
|
|
#else |
|
errcode = CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
#endif |
|
} |
|
|
|
static void ReadPNGData( png_structp png_ptr, png_bytep outBytes, png_size_t byteCountToRead ) |
|
{ |
|
|
|
// Cast pointer |
|
CUtlBuffer *pBuf = (CUtlBuffer *)png_get_io_ptr( png_ptr ); |
|
Assert( pBuf ); |
|
|
|
// Check for IO error |
|
if ( pBuf->TellGet() + (int)byteCountToRead > pBuf->TellPut() ) |
|
{ |
|
// Attempt to read past the end of the buffer. |
|
// Use longjmp to report the error |
|
png_longjmp( png_ptr, 1 ); |
|
} |
|
|
|
// Read the bytes |
|
pBuf->Get( outBytes, byteCountToRead ); |
|
} |
|
|
|
|
|
unsigned char *ImgUtl_ReadPNGAsRGBA( const char *pngPath, int &width, int &height, ConversionErrorType &errcode ) |
|
{ |
|
#if !defined( _X360 ) |
|
|
|
// Just load the whole file into a memory buffer |
|
CUtlBuffer bufFileContents; |
|
if ( !g_pFullFileSystem->ReadFile( pngPath, NULL, bufFileContents ) ) |
|
{ |
|
errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
return NULL; |
|
} |
|
|
|
// Load it |
|
return ImgUtl_ReadPNGAsRGBAFromBuffer( bufFileContents, width, height, errcode ); |
|
|
|
#else |
|
errcode = CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
#endif |
|
} |
|
|
|
unsigned char *ImgUtl_ReadPNGAsRGBAFromBuffer( CUtlBuffer &buffer, int &width, int &height, ConversionErrorType &errcode ) |
|
{ |
|
#if !defined( _X360 ) |
|
|
|
png_const_bytep pngData = (png_const_bytep)buffer.Base(); |
|
if (png_sig_cmp( pngData, 0, 8)) |
|
{ |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
return NULL; |
|
} |
|
|
|
png_structp png_ptr = NULL; |
|
png_infop info_ptr = NULL; |
|
|
|
/* could pass pointers to user-defined error handlers instead of NULLs: */ |
|
|
|
png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL ); |
|
if (!png_ptr) |
|
{ |
|
errcode = CE_MEMORY_ERROR; |
|
return NULL; |
|
} |
|
|
|
unsigned char *pResultData = NULL; |
|
png_bytepp row_pointers = NULL; |
|
|
|
info_ptr = png_create_info_struct( png_ptr ); |
|
if ( !info_ptr ) |
|
{ |
|
errcode = CE_MEMORY_ERROR; |
|
fail: |
|
png_destroy_read_struct( &png_ptr, &info_ptr, NULL ); |
|
if ( row_pointers ) |
|
{ |
|
free( row_pointers ); |
|
} |
|
if ( pResultData ) |
|
{ |
|
free( pResultData ); |
|
} |
|
return NULL; |
|
} |
|
|
|
/* setjmp() must be called in every function that calls a PNG-reading |
|
* libpng function */ |
|
|
|
if ( setjmp( png_jmpbuf(png_ptr) ) ) |
|
{ |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
goto fail; |
|
} |
|
|
|
png_set_read_fn( png_ptr, &buffer, ReadPNGData ); |
|
png_read_info( png_ptr, info_ptr ); /* read all PNG info up to image data */ |
|
|
|
|
|
/* alternatively, could make separate calls to png_get_image_width(), |
|
* etc., but want bit_depth and color_type for later [don't care about |
|
* compression_type and filter_type => NULLs] */ |
|
|
|
int bit_depth; |
|
int color_type; |
|
uint32 png_width; |
|
uint32 png_height; |
|
|
|
png_get_IHDR( png_ptr, info_ptr, &png_width, &png_height, &bit_depth, &color_type, NULL, NULL, NULL ); |
|
|
|
width = png_width; |
|
height = png_height; |
|
|
|
png_uint_32 rowbytes; |
|
|
|
/* expand palette images to RGB, low-bit-depth grayscale images to 8 bits, |
|
* transparency chunks to full alpha channel; strip 16-bit-per-sample |
|
* images to 8 bits per sample; and convert grayscale to RGB[A] */ |
|
|
|
if (color_type == PNG_COLOR_TYPE_PALETTE) |
|
png_set_expand( png_ptr ); |
|
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) |
|
png_set_expand( png_ptr ); |
|
if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS ) ) |
|
png_set_expand( png_ptr ); |
|
if (bit_depth == 16) |
|
png_set_strip_16( png_ptr ); |
|
if (color_type == PNG_COLOR_TYPE_GRAY || |
|
color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
|
png_set_gray_to_rgb( png_ptr ); |
|
|
|
// Force in an alpha channel |
|
if ( !( color_type & PNG_COLOR_MASK_ALPHA ) ) |
|
{ |
|
png_set_add_alpha(png_ptr, 255, PNG_FILLER_AFTER); |
|
} |
|
|
|
/* |
|
double gamma; |
|
if (png_get_gAMA(png_ptr, info_ptr, &gamma)) |
|
png_set_gamma(png_ptr, display_exponent, gamma); |
|
|
|
*/ |
|
/* all transformations have been registered; now update info_ptr data, |
|
* get rowbytes and channels, and allocate image memory */ |
|
|
|
png_read_update_info( png_ptr, info_ptr ); |
|
|
|
rowbytes = png_get_rowbytes( png_ptr, info_ptr ); |
|
png_byte channels = (int)png_get_channels( png_ptr, info_ptr ); |
|
if ( channels != 4 ) |
|
{ |
|
Assert( channels == 4 ); |
|
errcode = CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
goto fail; |
|
} |
|
|
|
row_pointers = (png_bytepp)malloc( height*sizeof(png_bytep) ); |
|
pResultData = (unsigned char *)malloc( rowbytes*height ); |
|
|
|
if ( row_pointers == NULL || pResultData == NULL ) |
|
{ |
|
errcode = CE_MEMORY_ERROR; |
|
goto fail; |
|
} |
|
|
|
/* set the individual row_pointers to point at the correct offsets */ |
|
|
|
for ( int i = 0; i < height; ++i) |
|
row_pointers[i] = pResultData + i*rowbytes; |
|
|
|
/* now we can go ahead and just read the whole image */ |
|
|
|
png_read_image( png_ptr, row_pointers ); |
|
|
|
png_read_end(png_ptr, NULL); |
|
|
|
free( row_pointers ); |
|
row_pointers = NULL; |
|
|
|
// Clean up |
|
png_destroy_read_struct( &png_ptr, &info_ptr, NULL ); |
|
|
|
// OK! |
|
width = png_width; |
|
height = png_height; |
|
errcode = CE_SUCCESS; |
|
return pResultData; |
|
|
|
#else |
|
errcode = CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
#endif |
|
} |
|
|
|
unsigned char *ImgUtl_ReadBMPAsRGBA( const char *bmpPath, int &width, int &height, ConversionErrorType &errcode ) |
|
{ |
|
#ifdef WIN32 |
|
// Load up bitmap |
|
HBITMAP hBitmap = (HBITMAP)LoadImage(NULL, bmpPath, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE | LR_DEFAULTSIZE); |
|
|
|
// Handle failure |
|
if ( hBitmap == NULL) |
|
{ |
|
|
|
// !KLUDGE! Try to detect what went wrong |
|
FILE *fp = fopen( bmpPath, "rb" ); |
|
if (fp == NULL) |
|
{ |
|
errcode = CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
else |
|
{ |
|
errcode = CE_ERROR_PARSING_SOURCE; |
|
} |
|
return NULL; |
|
} |
|
|
|
BITMAP bitmap; |
|
|
|
GetObject(hBitmap, sizeof(bitmap), &bitmap); |
|
|
|
BITMAPINFO *bitmapInfo; |
|
|
|
bool bUseColorTable = false; |
|
if (bitmap.bmBitsPixel == 24 || bitmap.bmBitsPixel == 32) |
|
{ |
|
bitmapInfo = (BITMAPINFO *)malloc(sizeof(BITMAPINFO)); |
|
} |
|
else if (bitmap.bmBitsPixel == 8 || bitmap.bmBitsPixel == 4 || bitmap.bmBitsPixel == 1) |
|
{ |
|
int colorsUsed = 1 << bitmap.bmBitsPixel; |
|
bitmapInfo = (BITMAPINFO *)malloc(colorsUsed * sizeof(RGBQUAD) + sizeof(BITMAPINFO)); |
|
bUseColorTable = true; |
|
} |
|
else |
|
{ |
|
DeleteObject(hBitmap); |
|
errcode = CE_SOURCE_FILE_BMP_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
} |
|
|
|
memset(bitmapInfo, 0, sizeof(BITMAPINFO)); |
|
bitmapInfo->bmiHeader.biSize = sizeof(bitmapInfo->bmiHeader); |
|
if (bUseColorTable) |
|
{ |
|
bitmapInfo->bmiHeader.biBitCount = bitmap.bmBitsPixel; // need to specify the bits per pixel so GDI will generate a color table for us. |
|
} |
|
|
|
HDC dc = CreateCompatibleDC(NULL); |
|
|
|
int retcode = GetDIBits(dc, hBitmap, 0, bitmap.bmHeight, NULL, bitmapInfo, DIB_RGB_COLORS); |
|
|
|
DeleteDC(dc); |
|
|
|
if (retcode == 0) |
|
{ |
|
// error getting the bitmap info for some reason. |
|
free(bitmapInfo); |
|
errcode = CE_SOURCE_FILE_BMP_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
} |
|
|
|
int nDestStride = 4 * bitmap.bmWidth; |
|
int mem_required = nDestStride * bitmap.bmHeight; // mem required for copying the data out into RGBA format. |
|
|
|
unsigned char *buf = (unsigned char *)malloc(mem_required); |
|
if (buf == NULL) |
|
{ |
|
free(bitmapInfo); |
|
errcode = CE_MEMORY_ERROR; |
|
return NULL; |
|
} |
|
|
|
if (bitmapInfo->bmiHeader.biBitCount == 32) |
|
{ |
|
for (int y = 0; y < bitmap.bmHeight; ++y) |
|
{ |
|
unsigned char *pDest = buf + nDestStride * ( ( bitmap.bmHeight - 1 ) - y ); // BMPs are stored upside down |
|
const unsigned char *pSrc = (unsigned char *)(bitmap.bmBits) + (y * bitmap.bmWidthBytes); |
|
|
|
for (int x = 0; x < bitmap.bmWidth; ++x) |
|
{ |
|
|
|
// Swap BGR -> RGB while copying data |
|
pDest[0] = pSrc[2]; // R |
|
pDest[1] = pSrc[1]; // G |
|
pDest[2] = pSrc[0]; // B |
|
pDest[3] = pSrc[3]; // A |
|
|
|
pSrc += 4; |
|
pDest += 4; |
|
} |
|
} |
|
} |
|
else if (bitmapInfo->bmiHeader.biBitCount == 24) |
|
{ |
|
for (int y = 0; y < bitmap.bmHeight; ++y) |
|
{ |
|
unsigned char *pDest = buf + nDestStride * ( ( bitmap.bmHeight - 1 ) - y ); // BMPs are stored upside down |
|
const unsigned char *pSrc = (unsigned char *)(bitmap.bmBits) + (y * bitmap.bmWidthBytes); |
|
|
|
for (int x = 0; x < bitmap.bmWidth; ++x) |
|
{ |
|
|
|
// Swap BGR -> RGB while copying data |
|
pDest[0] = pSrc[2]; // R |
|
pDest[1] = pSrc[1]; // G |
|
pDest[2] = pSrc[0]; // B |
|
pDest[3] = 0xff; // A |
|
|
|
pSrc += 3; |
|
pDest += 4; |
|
} |
|
} |
|
} |
|
else if (bitmapInfo->bmiHeader.biBitCount == 8) |
|
{ |
|
// 8-bit 256 color bitmap. |
|
for (int y = 0; y < bitmap.bmHeight; ++y) |
|
{ |
|
unsigned char *pDest = buf + nDestStride * ( ( bitmap.bmHeight - 1 ) - y ); // BMPs are stored upside down |
|
const unsigned char *pSrc = (unsigned char *)(bitmap.bmBits) + (y * bitmap.bmWidthBytes); |
|
|
|
for (int x = 0; x < bitmap.bmWidth; ++x) |
|
{ |
|
|
|
// compute the color map entry for this pixel |
|
int colorTableEntry = *pSrc; |
|
|
|
// get the color for this color map entry. |
|
RGBQUAD *rgbQuad = &(bitmapInfo->bmiColors[colorTableEntry]); |
|
|
|
// copy the color values for this pixel to the destination buffer. |
|
pDest[0] = rgbQuad->rgbRed; |
|
pDest[1] = rgbQuad->rgbGreen; |
|
pDest[2] = rgbQuad->rgbBlue; |
|
pDest[3] = 0xff; |
|
|
|
++pSrc; |
|
pDest += 4; |
|
} |
|
} |
|
} |
|
else if (bitmapInfo->bmiHeader.biBitCount == 4) |
|
{ |
|
// 4-bit 16 color bitmap. |
|
for (int y = 0; y < bitmap.bmHeight; ++y) |
|
{ |
|
unsigned char *pDest = buf + nDestStride * ( ( bitmap.bmHeight - 1 ) - y ); // BMPs are stored upside down |
|
const unsigned char *pSrc = (unsigned char *)(bitmap.bmBits) + (y * bitmap.bmWidthBytes); |
|
|
|
// Two pixels at a time |
|
for (int x = 0; x < bitmap.bmWidth; x += 2) |
|
{ |
|
|
|
// get the color table entry for this pixel |
|
int colorTableEntry = (0xf0 & *pSrc) >> 4; |
|
|
|
// get the color values for this pixel's color table entry. |
|
RGBQUAD *rgbQuad = &(bitmapInfo->bmiColors[colorTableEntry]); |
|
|
|
// copy the pixel's color values to the destination buffer. |
|
pDest[0] = pSrc[2]; // R |
|
pDest[1] = pSrc[1]; // G |
|
pDest[2] = pSrc[0]; // B |
|
pDest[3] = 0xff; // A |
|
|
|
// make sure we haven't reached the end of the row. |
|
if ((x + 1) > bitmap.bmWidth) |
|
{ |
|
break; |
|
} |
|
|
|
pDest += 4; |
|
|
|
// get the color table entry for this pixel. |
|
colorTableEntry = 0x0f & *pSrc; |
|
|
|
// get the color values for this pixel's color table entry. |
|
rgbQuad = &(bitmapInfo->bmiColors[colorTableEntry]); |
|
|
|
// copy the pixel's color values to the destination buffer. |
|
pDest[0] = pSrc[2]; // R |
|
pDest[1] = pSrc[1]; // G |
|
pDest[2] = pSrc[0]; // B |
|
pDest[3] = 0xff; // A |
|
|
|
++pSrc; |
|
pDest += 4; |
|
} |
|
} |
|
} |
|
else if (bitmapInfo->bmiHeader.biBitCount == 1) |
|
{ |
|
// 1-bit monochrome bitmap. |
|
for (int y = 0; y < bitmap.bmHeight; ++y) |
|
{ |
|
unsigned char *pDest = buf + nDestStride * ( ( bitmap.bmHeight - 1 ) - y ); // BMPs are stored upside down |
|
const unsigned char *pSrc = (unsigned char *)(bitmap.bmBits) + (y * bitmap.bmWidthBytes); |
|
|
|
// Eight pixels at a time |
|
int x = 0; |
|
while (x < bitmap.bmWidth) |
|
{ |
|
|
|
RGBQUAD *rgbQuad = NULL; |
|
int bitMask = 0x80; |
|
|
|
// go through all 8 bits in this byte to get all 8 pixel colors. |
|
do |
|
{ |
|
// get the value of the bit for this pixel. |
|
int bit = *pSrc & bitMask; |
|
|
|
// bit will either be 0 or non-zero since there are only two colors. |
|
if (bit == 0) |
|
{ |
|
rgbQuad = &(bitmapInfo->bmiColors[0]); |
|
} |
|
else |
|
{ |
|
rgbQuad = &(bitmapInfo->bmiColors[1]); |
|
} |
|
|
|
// copy this pixel's color values into the destination buffer. |
|
pDest[0] = pSrc[2]; // R |
|
pDest[1] = pSrc[1]; // G |
|
pDest[2] = pSrc[0]; // B |
|
pDest[3] = 0xff; // A |
|
pDest += 4; |
|
|
|
// go to the next pixel. |
|
++x; |
|
bitMask = bitMask >> 1; |
|
} while ((x < bitmap.bmWidth) && (bitMask > 0)); |
|
|
|
++pSrc; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
free(bitmapInfo); |
|
free(buf); |
|
DeleteObject(hBitmap); |
|
errcode = CE_SOURCE_FILE_BMP_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
} |
|
|
|
free(bitmapInfo); |
|
DeleteObject(hBitmap); |
|
|
|
// OK! |
|
width = bitmap.bmWidth; |
|
height = bitmap.bmHeight; |
|
errcode = CE_SUCCESS; |
|
return buf; |
|
#else |
|
errcode = CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
#endif |
|
} |
|
|
|
unsigned char *ImgUtl_ReadImageAsRGBA( const char *path, int &width, int &height, ConversionErrorType &errcode ) |
|
{ |
|
|
|
// Split out the file extension |
|
const char *pExt = V_GetFileExtension( path ); |
|
if ( pExt ) |
|
{ |
|
if ( !Q_stricmp(pExt, "vtf") ) |
|
{ |
|
return ImgUtl_ReadVTFAsRGBA( path, width, height, errcode ); |
|
} |
|
if ( !Q_stricmp(pExt, "bmp") ) |
|
{ |
|
return ImgUtl_ReadBMPAsRGBA( path, width, height, errcode ); |
|
} |
|
if ( !Q_stricmp(pExt, "jpg") || !Q_stricmp(pExt, "jpeg") ) |
|
{ |
|
return ImgUtl_ReadJPEGAsRGBA( path, width, height, errcode ); |
|
} |
|
if ( !Q_stricmp(pExt, "png") ) |
|
{ |
|
return ImgUtl_ReadPNGAsRGBA( path, width, height, errcode ); |
|
} |
|
if ( !Q_stricmp(pExt, "tga") ) |
|
{ |
|
TGAHeader header; |
|
return ImgUtl_ReadTGAAsRGBA( path, width, height, errcode, header ); |
|
} |
|
} |
|
|
|
errcode = CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
return NULL; |
|
} |
|
|
|
// resizes the file specified by tgaPath so that it has dimensions that are |
|
// powers-of-two and is equal to or smaller than (nMaxWidth)x(nMaxHeight). |
|
// also converts from 24-bit RGB to 32-bit RGB (with 8-bit alpha) |
|
ConversionErrorType ImgUtl_ConvertTGA(const char *tgaPath, int nMaxWidth/*=-1*/, int nMaxHeight/*=-1*/) |
|
{ |
|
int tgaWidth = 0, tgaHeight = 0; |
|
ConversionErrorType errcode; |
|
TGAHeader tgaHeader; |
|
unsigned char *srcBuffer = ImgUtl_ReadTGAAsRGBA(tgaPath, tgaWidth, tgaHeight, errcode, tgaHeader); |
|
|
|
if (srcBuffer == NULL) |
|
{ |
|
return errcode; |
|
} |
|
|
|
int paddedImageWidth, paddedImageHeight; |
|
|
|
if ((tgaWidth <= 0) || (tgaHeight <= 0)) |
|
{ |
|
free(srcBuffer); |
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
// get the nearest power of two that is greater than the width of the image. |
|
paddedImageWidth = tgaWidth; |
|
if (!IsPowerOfTwo(paddedImageWidth)) |
|
{ |
|
// width is not a power of two, calculate the next highest power of two value. |
|
int i = 1; |
|
while (paddedImageWidth > 1) |
|
{ |
|
paddedImageWidth = paddedImageWidth >> 1; |
|
++i; |
|
} |
|
|
|
paddedImageWidth = paddedImageWidth << i; |
|
} |
|
|
|
// make sure the width is less than or equal to nMaxWidth |
|
if (nMaxWidth != -1 && paddedImageWidth > nMaxWidth) |
|
{ |
|
paddedImageWidth = nMaxWidth; |
|
} |
|
|
|
// get the nearest power of two that is greater than the height of the image |
|
paddedImageHeight = tgaHeight; |
|
if (!IsPowerOfTwo(paddedImageHeight)) |
|
{ |
|
// height is not a power of two, calculate the next highest power of two value. |
|
int i = 1; |
|
while (paddedImageHeight > 1) |
|
{ |
|
paddedImageHeight = paddedImageHeight >> 1; |
|
++i; |
|
} |
|
|
|
paddedImageHeight = paddedImageHeight << i; |
|
} |
|
|
|
// make sure the height is less than or equal to nMaxHeight |
|
if (nMaxHeight != -1 && paddedImageHeight > nMaxHeight) |
|
{ |
|
paddedImageHeight = nMaxHeight; |
|
} |
|
|
|
// compute the amount of stretching that needs to be done to both width and height to get the image to fit. |
|
float widthRatio = (float)paddedImageWidth / tgaWidth; |
|
float heightRatio = (float)paddedImageHeight / tgaHeight; |
|
|
|
int finalWidth; |
|
int finalHeight; |
|
|
|
// compute the final dimensions of the stretched image. |
|
if (widthRatio < heightRatio) |
|
{ |
|
finalWidth = paddedImageWidth; |
|
finalHeight = (int)(tgaHeight * widthRatio + 0.5f); |
|
// i.e. for 1x1 size pixels in the resized image we will take color from sourceRatio x sourceRatio sized pixels in the source image. |
|
} |
|
else if (heightRatio < widthRatio) |
|
{ |
|
finalHeight = paddedImageHeight; |
|
finalWidth = (int)(tgaWidth * heightRatio + 0.5f); |
|
} |
|
else |
|
{ |
|
finalHeight = paddedImageHeight; |
|
finalWidth = paddedImageWidth; |
|
} |
|
|
|
unsigned char *resizeBuffer = (unsigned char *)malloc(finalWidth * finalHeight * 4); |
|
|
|
// do the actual stretching |
|
ImgUtl_StretchRGBAImage(srcBuffer, tgaWidth, tgaHeight, resizeBuffer, finalWidth, finalHeight); |
|
|
|
free(srcBuffer); // don't need this anymore. |
|
|
|
/////////////////////////////////////////////////////////////////////// |
|
///// need to pad the image so both dimensions are power of two's ///// |
|
/////////////////////////////////////////////////////////////////////// |
|
unsigned char *finalBuffer = (unsigned char *)malloc(paddedImageWidth * paddedImageHeight * 4); |
|
ImgUtl_PadRGBAImage(resizeBuffer, finalWidth, finalHeight, finalBuffer, paddedImageWidth, paddedImageHeight); |
|
|
|
FILE *outfile = fopen(tgaPath, "wb"); |
|
if (outfile == NULL) |
|
{ |
|
free(resizeBuffer); |
|
free(finalBuffer); |
|
|
|
return CE_ERROR_WRITING_OUTPUT_FILE; |
|
} |
|
|
|
tgaHeader.width = paddedImageWidth; |
|
tgaHeader.height = paddedImageHeight; |
|
|
|
WriteTGAHeader(outfile, tgaHeader); |
|
|
|
// Write the image data --- remember that TGA uses BGRA data |
|
int numPixels = paddedImageWidth * paddedImageHeight; |
|
for (int i = 0 ; i < numPixels ; ++i ) |
|
{ |
|
fputc( finalBuffer[i*4 + 2], outfile ); // B |
|
fputc( finalBuffer[i*4 + 1], outfile ); // G |
|
fputc( finalBuffer[i*4 ], outfile ); // R |
|
fputc( finalBuffer[i*4 + 3], outfile ); // A |
|
} |
|
|
|
fclose(outfile); |
|
|
|
free(resizeBuffer); |
|
free(finalBuffer); |
|
|
|
return CE_SUCCESS; |
|
} |
|
|
|
// resize by stretching (or compressing) an RGBA image pointed to by srcBuf into the buffer pointed to by destBuf. |
|
// the buffers are assumed to be sized appropriately to accomidate RGBA images of the given widths and heights. |
|
ConversionErrorType ImgUtl_StretchRGBAImage(const unsigned char *srcBuf, const int srcWidth, const int srcHeight, |
|
unsigned char *destBuf, const int destWidth, const int destHeight) |
|
{ |
|
if ((srcBuf == NULL) || (destBuf == NULL)) |
|
{ |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
int destRow,destColumn; |
|
|
|
float ratioX = (float)srcWidth / (float)destWidth; |
|
float ratioY = (float)srcHeight / (float)destHeight; |
|
|
|
// loop through all the pixels in the destination image. |
|
for (destRow = 0; destRow < destHeight; ++destRow) |
|
{ |
|
for (destColumn = 0; destColumn < destWidth; ++destColumn) |
|
{ |
|
// calculate the center of the pixel in the source image. |
|
float srcCenterX = ratioX * (destColumn + 0.5f); |
|
float srcCenterY = ratioY * (destRow + 0.5f); |
|
|
|
// calculate the starting and ending coords for this destination pixel in the source image. |
|
float srcStartX = srcCenterX - (ratioX / 2.0f); |
|
if (srcStartX < 0.0f) |
|
{ |
|
srcStartX = 0.0f; // this should never happen, but just in case. |
|
} |
|
|
|
float srcStartY = srcCenterY - (ratioY / 2.0f); |
|
if (srcStartY < 0.0f) |
|
{ |
|
srcStartY = 0.0f; // this should never happen, but just in case. |
|
} |
|
|
|
float srcEndX = srcCenterX + (ratioX / 2.0f); |
|
if (srcEndX > srcWidth) |
|
{ |
|
srcEndX = srcWidth; // this should never happen, but just in case. |
|
} |
|
|
|
float srcEndY = srcCenterY + (ratioY / 2.0f); |
|
if (srcEndY > srcHeight) |
|
{ |
|
srcEndY = srcHeight; // this should never happen, but just in case. |
|
} |
|
|
|
// Calculate the percentage of each source pixels' contribution to the destination pixel color. |
|
|
|
float srcCurrentX; // initialized at the start of the y loop. |
|
float srcCurrentY = srcStartY; |
|
|
|
float destRed = 0.0f; |
|
float destGreen = 0.0f; |
|
float destBlue = 0.0f; |
|
float destAlpha = 0.0f; |
|
|
|
//// loop for the parts of the source image that will contribute color to the destination pixel. |
|
while (srcCurrentY < srcEndY) |
|
{ |
|
float srcCurrentEndY = (float)((int)srcCurrentY + 1); |
|
if (srcCurrentEndY > srcEndY) |
|
{ |
|
srcCurrentEndY = srcEndY; |
|
} |
|
|
|
float srcCurrentHeight = srcCurrentEndY - srcCurrentY; |
|
|
|
srcCurrentX = srcStartX; |
|
|
|
while (srcCurrentX < srcEndX) |
|
{ |
|
float srcCurrentEndX = (float)((int)srcCurrentX + 1); |
|
if (srcCurrentEndX > srcEndX) |
|
{ |
|
srcCurrentEndX = srcEndX; |
|
} |
|
float srcCurrentWidth = srcCurrentEndX - srcCurrentX; |
|
|
|
// compute the percentage of the destination pixel's color this source pixel will contribute. |
|
float srcColorPercentage = (srcCurrentWidth / ratioX) * (srcCurrentHeight / ratioY); |
|
|
|
int srcCurrentPixelX = (int)srcCurrentX; |
|
int srcCurrentPixelY = (int)srcCurrentY; |
|
|
|
// get the color values for this source pixel. |
|
unsigned char srcCurrentRed = srcBuf[(srcCurrentPixelY * srcWidth * 4) + (srcCurrentPixelX * 4)]; |
|
unsigned char srcCurrentGreen = srcBuf[(srcCurrentPixelY * srcWidth * 4) + (srcCurrentPixelX * 4) + 1]; |
|
unsigned char srcCurrentBlue = srcBuf[(srcCurrentPixelY * srcWidth * 4) + (srcCurrentPixelX * 4) + 2]; |
|
unsigned char srcCurrentAlpha = srcBuf[(srcCurrentPixelY * srcWidth * 4) + (srcCurrentPixelX * 4) + 3]; |
|
|
|
// add the color contribution from this source pixel to the destination pixel. |
|
destRed += srcCurrentRed * srcColorPercentage; |
|
destGreen += srcCurrentGreen * srcColorPercentage; |
|
destBlue += srcCurrentBlue * srcColorPercentage; |
|
destAlpha += srcCurrentAlpha * srcColorPercentage; |
|
|
|
srcCurrentX = srcCurrentEndX; |
|
} |
|
|
|
srcCurrentY = srcCurrentEndY; |
|
} |
|
|
|
// assign the computed color to the destination pixel, round to the nearest value. Make sure the value doesn't exceed 255. |
|
destBuf[(destRow * destWidth * 4) + (destColumn * 4)] = min((int)(destRed + 0.5f), 255); |
|
destBuf[(destRow * destWidth * 4) + (destColumn * 4) + 1] = min((int)(destGreen + 0.5f), 255); |
|
destBuf[(destRow * destWidth * 4) + (destColumn * 4) + 2] = min((int)(destBlue + 0.5f), 255); |
|
destBuf[(destRow * destWidth * 4) + (destColumn * 4) + 3] = min((int)(destAlpha + 0.5f), 255); |
|
} // column loop |
|
} // row loop |
|
|
|
return CE_SUCCESS; |
|
} |
|
|
|
ConversionErrorType ImgUtl_PadRGBAImage(const unsigned char *srcBuf, const int srcWidth, const int srcHeight, |
|
unsigned char *destBuf, const int destWidth, const int destHeight) |
|
{ |
|
if ((srcBuf == NULL) || (destBuf == NULL)) |
|
{ |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
memset(destBuf, 0, destWidth * destHeight * 4); |
|
|
|
if ((destWidth < srcWidth) || (destHeight < srcHeight)) |
|
{ |
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
if ((srcWidth == destWidth) && (srcHeight == destHeight)) |
|
{ |
|
// no padding is needed, just copy the buffer straight over and call it done. |
|
memcpy(destBuf, srcBuf, destWidth * destHeight * 4); |
|
return CE_SUCCESS; |
|
} |
|
|
|
if (destWidth == srcWidth) |
|
{ |
|
// only the top and bottom of the image need padding. |
|
// do this separately since we can do this more efficiently than the other cases. |
|
int numRowsToPad = (destHeight - srcHeight) / 2; |
|
memcpy(destBuf + (numRowsToPad * destWidth * 4), srcBuf, srcWidth * srcHeight * 4); |
|
} |
|
else |
|
{ |
|
int numColumnsToPad = (destWidth - srcWidth) / 2; |
|
int numRowsToPad = (destHeight - srcHeight) / 2; |
|
int lastRow = numRowsToPad + srcHeight; |
|
int row; |
|
for (row = numRowsToPad; row < lastRow; ++row) |
|
{ |
|
unsigned char * destOffset = destBuf + (row * destWidth * 4) + (numColumnsToPad * 4); |
|
const unsigned char * srcOffset = srcBuf + ((row - numRowsToPad) * srcWidth * 4); |
|
memcpy(destOffset, srcOffset, srcWidth * 4); |
|
} |
|
} |
|
|
|
return CE_SUCCESS; |
|
} |
|
|
|
// convert TGA file at the given location to a VTF file of the same root name at the same location. |
|
ConversionErrorType ImgUtl_ConvertTGAToVTF(const char *tgaPath, int nMaxWidth/*=-1*/, int nMaxHeight/*=-1*/ ) |
|
{ |
|
FILE *infile = fopen(tgaPath, "rb"); |
|
if (infile == NULL) |
|
{ |
|
Msg( "Failed to open TGA: %s\n", tgaPath); |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
// read out the header of the image. |
|
TGAHeader header; |
|
ImgUtl_ReadTGAHeader(infile, header); |
|
|
|
// check to make sure that the TGA has the proper dimensions and size. |
|
if (!IsPowerOfTwo(header.width) || !IsPowerOfTwo(header.height)) |
|
{ |
|
fclose(infile); |
|
Msg( "Failed to open TGA - size dimensions (%d, %d) not power of 2: %s\n", header.width, header.height, tgaPath); |
|
return CE_SOURCE_FILE_SIZE_NOT_SUPPORTED; |
|
} |
|
|
|
// check to make sure that the TGA isn't too big, if we care. |
|
if ( ( nMaxWidth != -1 && header.width > nMaxWidth ) || ( nMaxHeight != -1 && header.height > nMaxHeight ) ) |
|
{ |
|
fclose(infile); |
|
Msg( "Failed to open TGA - dimensions too large (%d, %d) (max: %d, %d): %s\n", header.width, header.height, nMaxWidth, nMaxHeight, tgaPath); |
|
return CE_SOURCE_FILE_SIZE_NOT_SUPPORTED; |
|
} |
|
|
|
int imageMemoryFootprint = header.width * header.height * header.bits / 8; |
|
|
|
CUtlBuffer inbuf(0, imageMemoryFootprint); |
|
|
|
// read in the image |
|
int nBytesRead = fread(inbuf.Base(), imageMemoryFootprint, 1, infile); |
|
|
|
fclose(infile); |
|
inbuf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead ); |
|
|
|
// load vtex_dll.dll and get the interface to it. |
|
CSysModule *vtexmod = Sys_LoadModule("vtex_dll"); |
|
if (vtexmod == NULL) |
|
{ |
|
Msg( "Failed to open TGA conversion module vtex_dll: %s\n", tgaPath); |
|
return CE_ERROR_LOADING_DLL; |
|
} |
|
|
|
CreateInterfaceFn factory = Sys_GetFactory(vtexmod); |
|
if (factory == NULL) |
|
{ |
|
Sys_UnloadModule(vtexmod); |
|
Msg( "Failed to open TGA conversion module vtex_dll Factory: %s\n", tgaPath); |
|
return CE_ERROR_LOADING_DLL; |
|
} |
|
|
|
IVTex *vtex = (IVTex *)factory(IVTEX_VERSION_STRING, NULL); |
|
if (vtex == NULL) |
|
{ |
|
Sys_UnloadModule(vtexmod); |
|
Msg( "Failed to open TGA conversion module vtex_dll Factory (is null): %s\n", tgaPath); |
|
return CE_ERROR_LOADING_DLL; |
|
} |
|
|
|
char *vtfParams[4]; |
|
|
|
// the 0th entry is skipped cause normally thats the program name. |
|
vtfParams[0] = ""; |
|
vtfParams[1] = "-quiet"; |
|
vtfParams[2] = "-dontusegamedir"; |
|
vtfParams[3] = (char *)tgaPath; |
|
|
|
// call vtex to do the conversion. |
|
vtex->VTex(4, vtfParams); // how do we know this works? |
|
|
|
Sys_UnloadModule(vtexmod); |
|
|
|
return CE_SUCCESS; |
|
} |
|
|
|
static void DoCopyFile( const char *source, const char *destination ) |
|
{ |
|
#if defined( WIN32 ) |
|
CopyFile( source, destination, true ); |
|
#elif defined( OSX ) |
|
copyfile( source, destination, NULL, COPYFILE_ALL ); |
|
#elif defined( ENGINE_DLL ) |
|
::COM_CopyFile( source, destination ); |
|
#elif REPLAY_DLL |
|
g_pEngine->CopyFile( source, destination ); |
|
#else |
|
engine->CopyLocalFile( source, destination ); |
|
#endif |
|
} |
|
|
|
static void DoDeleteFile( const char *filename ) |
|
{ |
|
#ifdef WIN32 |
|
DeleteFile( filename ); |
|
#else |
|
unlink( filename ); |
|
#endif |
|
} |
|
|
|
ConversionErrorType ImgUtl_ConvertToVTFAndDumpVMT( const char *pInPath, const char *pMaterialsSubDir, int nMaxWidth/*=-1*/, int nMaxHeight/*=-1*/ ) |
|
{ |
|
#ifndef _XBOX |
|
if ((pInPath == NULL) || (pInPath[0] == 0)) |
|
{ |
|
return CE_ERROR_PARSING_SOURCE; |
|
} |
|
|
|
ConversionErrorType nErrorCode = CE_SUCCESS; |
|
|
|
// get the extension of the file we're to convert |
|
char extension[MAX_PATH]; |
|
const char *constchar = pInPath + strlen(pInPath); |
|
while ((constchar > pInPath) && (*(constchar-1) != '.')) |
|
{ |
|
--constchar; |
|
} |
|
Q_strncpy(extension, constchar, MAX_PATH); |
|
|
|
bool deleteIntermediateTGA = false; |
|
bool deleteIntermediateVTF = false; |
|
bool convertTGAToVTF = true; |
|
char tgaPath[MAX_PATH*2]; |
|
char *c; |
|
bool failed = false; |
|
|
|
Q_strncpy(tgaPath, pInPath, sizeof(tgaPath)); |
|
|
|
// Construct a TGA version if necessary |
|
if (stricmp(extension, "tga")) |
|
{ |
|
// It is not a TGA file, so create a temporary file name for the TGA you have to create |
|
|
|
c = tgaPath + strlen(tgaPath); |
|
while ((c > tgaPath) && (*(c-1) != '\\') && (*(c-1) != '/')) |
|
{ |
|
--c; |
|
} |
|
*c = 0; |
|
|
|
char origpath[MAX_PATH*2]; |
|
Q_strncpy(origpath, tgaPath, sizeof(origpath)); |
|
|
|
// Look for an empty temp file - find the first one that doesn't exist. |
|
int index = 0; |
|
do { |
|
Q_snprintf(tgaPath, sizeof(tgaPath), "%stemp%d.tga", origpath, index); |
|
++index; |
|
} while (_access(tgaPath, 0) != -1); |
|
|
|
|
|
// Convert the other formats to TGA |
|
|
|
// jpeg files |
|
// |
|
if (!stricmp(extension, "jpg") || !stricmp(extension, "jpeg")) |
|
{ |
|
// convert from the jpeg file format to the TGA file format |
|
nErrorCode = ImgUtl_ConvertJPEGToTGA(pInPath, tgaPath, false); |
|
if (nErrorCode == CE_SUCCESS) |
|
{ |
|
deleteIntermediateTGA = true; |
|
} |
|
else |
|
{ |
|
failed = true; |
|
} |
|
} |
|
// bmp files |
|
// |
|
else if (!stricmp(extension, "bmp")) |
|
{ |
|
// convert from the bmp file format to the TGA file format |
|
nErrorCode = ImgUtl_ConvertBMPToTGA(pInPath, tgaPath); |
|
|
|
if (nErrorCode == CE_SUCCESS) |
|
{ |
|
deleteIntermediateTGA = true; |
|
} |
|
else |
|
{ |
|
failed = true; |
|
} |
|
} |
|
// vtf files |
|
// |
|
else if (!stricmp(extension, "vtf")) |
|
{ |
|
// if the file is already in the vtf format there's no need to convert it. |
|
convertTGAToVTF = false; |
|
|
|
} |
|
} |
|
|
|
// if we now have a TGA file, convert it to VTF |
|
if (convertTGAToVTF && !failed) |
|
{ |
|
nErrorCode = ImgUtl_ConvertTGA( tgaPath, nMaxWidth, nMaxHeight ); // resize TGA so that it has power-of-two dimensions with a max size of (nMaxWidth)x(nMaxHeight). |
|
if (nErrorCode != CE_SUCCESS) |
|
{ |
|
failed = true; |
|
} |
|
|
|
if (!failed) |
|
{ |
|
char tempPath[MAX_PATH*2]; |
|
Q_strncpy(tempPath, tgaPath, sizeof(tempPath)); |
|
|
|
nErrorCode = ImgUtl_ConvertTGAToVTF( tempPath, nMaxWidth, nMaxHeight ); |
|
if (nErrorCode == CE_SUCCESS) |
|
{ |
|
deleteIntermediateVTF = true; |
|
} |
|
else |
|
{ |
|
Msg( "Failed to convert TGA to VTF: %s\n", tempPath); |
|
failed = true; |
|
} |
|
} |
|
} |
|
|
|
// At this point everything should be a VTF file |
|
|
|
char finalPath[MAX_PATH*2]; |
|
finalPath[0] = 0; |
|
char vtfPath[MAX_PATH*2]; |
|
vtfPath[0] = 0; |
|
|
|
|
|
// If we haven't failed so far, create a VMT to go with this VTF |
|
if (!failed) |
|
{ |
|
|
|
// If I had to convert from another filetype (i.e. the original was NOT a .vtf) |
|
if ( convertTGAToVTF ) |
|
{ |
|
|
|
Q_strncpy(vtfPath, tgaPath, sizeof(vtfPath)); |
|
|
|
// rename the tga file to be a vtf file. |
|
c = vtfPath + strlen(vtfPath); |
|
while ((c > vtfPath) && (*(c-1) != '.')) |
|
{ |
|
--c; |
|
} |
|
*c = 0; |
|
Q_strncat(vtfPath, "vtf", sizeof(vtfPath), COPY_ALL_CHARACTERS); |
|
|
|
} |
|
else |
|
{ |
|
// We were handed a vtf file originally, so use it. |
|
Q_strncpy(vtfPath, pInPath, sizeof(vtfPath)); |
|
} |
|
|
|
// get the vtfFilename from the path. |
|
const char *vtfFilename = pInPath + strlen(pInPath); |
|
while ((vtfFilename > pInPath) && (*(vtfFilename-1) != '\\') && (*(vtfFilename-1) != '/')) |
|
{ |
|
--vtfFilename; |
|
} |
|
|
|
// Create a safe version of pOutDir with corrected slashes |
|
char szOutDir[MAX_PATH*2]; |
|
V_strcpy_safe( szOutDir, IsPosix() ? "/materials/" : "\\materials\\" ); |
|
if ( pMaterialsSubDir[0] == '\\' || pMaterialsSubDir[0] == '/' ) |
|
pMaterialsSubDir = pMaterialsSubDir + 1; |
|
V_strcat_safe(szOutDir, pMaterialsSubDir, sizeof(szOutDir) ); |
|
Q_StripTrailingSlash( szOutDir ); |
|
Q_AppendSlash( szOutDir, sizeof(szOutDir) ); |
|
Q_FixSlashes( szOutDir, CORRECT_PATH_SEPARATOR ); |
|
|
|
#ifdef ENGINE_DLL |
|
Q_strncpy(finalPath, com_gamedir, sizeof(finalPath)); |
|
#elif REPLAY_DLL |
|
Q_strncpy(finalPath, g_pEngine->GetGameDir(), sizeof(finalPath)); |
|
#else |
|
Q_strncpy(finalPath, engine->GetGameDirectory(), sizeof(finalPath)); |
|
#endif |
|
Q_strncat(finalPath, szOutDir, sizeof(finalPath), COPY_ALL_CHARACTERS); |
|
Q_strncat(finalPath, vtfFilename, sizeof(finalPath), COPY_ALL_CHARACTERS); |
|
|
|
c = finalPath + strlen(finalPath); |
|
while ((c > finalPath) && (*(c-1) != '.')) |
|
{ |
|
--c; |
|
} |
|
*c = 0; |
|
Q_strncat(finalPath,"vtf", sizeof(finalPath), COPY_ALL_CHARACTERS); |
|
|
|
// make sure the directory exists before we try to copy the file. |
|
g_pFullFileSystem->CreateDirHierarchy(szOutDir + 1, "GAME"); |
|
//g_pFullFileSystem->CreateDirHierarchy("materials/VGUI/logos/", "GAME"); |
|
|
|
// write out the spray VMT file. |
|
if ( strcmp(vtfPath, finalPath) ) // If they're not already the same |
|
{ |
|
nErrorCode = ImgUtl_WriteGenericVMT(finalPath, pMaterialsSubDir); |
|
if (nErrorCode != CE_SUCCESS) |
|
{ |
|
failed = true; |
|
} |
|
|
|
if (!failed) |
|
{ |
|
// copy vtf file to the final location, only if we're not already in vtf |
|
|
|
DoCopyFile( vtfPath, finalPath ); |
|
} |
|
} |
|
} |
|
|
|
// delete the intermediate VTF file if one was made. |
|
if (deleteIntermediateVTF) |
|
{ |
|
DoDeleteFile( vtfPath ); |
|
|
|
// the TGA->VTF conversion process generates a .txt file if one wasn't already there. |
|
// in this case, delete the .txt file. |
|
c = vtfPath + strlen(vtfPath); |
|
while ((c > vtfPath) && (*(c-1) != '.')) |
|
{ |
|
--c; |
|
} |
|
Q_strncpy(c, "txt", sizeof(vtfPath)-(c-vtfPath)); |
|
|
|
DoDeleteFile( vtfPath ); |
|
} |
|
|
|
// delete the intermediate TGA file if one was made. |
|
if (deleteIntermediateTGA) |
|
{ |
|
DoDeleteFile( tgaPath ); |
|
} |
|
|
|
return nErrorCode; |
|
#endif |
|
} |
|
|
|
ConversionErrorType ImgUtl_WriteGenericVMT( const char *vtfPath, const char *pMaterialsSubDir ) |
|
{ |
|
if (vtfPath == NULL || pMaterialsSubDir == NULL ) |
|
{ |
|
return CE_ERROR_WRITING_OUTPUT_FILE; |
|
} |
|
|
|
// make the vmt filename |
|
char vmtPath[MAX_PATH*4]; |
|
Q_strncpy(vmtPath, vtfPath, sizeof(vmtPath)); |
|
char *c = vmtPath + strlen(vmtPath); |
|
while ((c > vmtPath) && (*(c-1) != '.')) |
|
{ |
|
--c; |
|
} |
|
Q_strncpy(c, "vmt", sizeof(vmtPath) - (c - vmtPath)); |
|
|
|
// get the root filename for the vtf file |
|
char filename[MAX_PATH]; |
|
while ((c > vmtPath) && (*(c-1) != '/') && (*(c-1) != '\\')) |
|
{ |
|
--c; |
|
} |
|
|
|
int i = 0; |
|
while ((*c != 0) && (*c != '.')) |
|
{ |
|
filename[i++] = *(c++); |
|
} |
|
filename[i] = 0; |
|
|
|
// create the vmt file. |
|
FILE *vmtFile = fopen(vmtPath, "w"); |
|
if (vmtFile == NULL) |
|
{ |
|
return CE_ERROR_WRITING_OUTPUT_FILE; |
|
} |
|
|
|
// make a copy of the subdir and remove any trailing slash |
|
char szMaterialsSubDir[ MAX_PATH*2 ]; |
|
V_strcpy_safe( szMaterialsSubDir, pMaterialsSubDir ); |
|
V_StripTrailingSlash( szMaterialsSubDir ); |
|
|
|
// fix slashes |
|
V_FixSlashes( szMaterialsSubDir ); |
|
|
|
// write the contents of the file. |
|
fprintf(vmtFile, "\"UnlitGeneric\"\n{\n\t\"$basetexture\" \"%s%c%s\"\n\t\"$translucent\" \"1\"\n\t\"$ignorez\" \"1\"\n\t\"$vertexcolor\" \"1\"\n\t\"$vertexalpha\" \"1\"\n}\n", szMaterialsSubDir, CORRECT_PATH_SEPARATOR, filename); |
|
|
|
fclose(vmtFile); |
|
|
|
return CE_SUCCESS; |
|
} |
|
|
|
static void WritePNGData( png_structp png_ptr, png_bytep inBytes, png_size_t byteCountToWrite ) |
|
{ |
|
|
|
// Cast pointer |
|
CUtlBuffer *pBuf = (CUtlBuffer *)png_get_io_ptr( png_ptr ); |
|
Assert( pBuf ); |
|
|
|
// Write the bytes |
|
pBuf->Put( inBytes, byteCountToWrite ); |
|
|
|
// What? Put() returns void. No way to detect error? |
|
} |
|
|
|
static void FlushPNGData( png_structp png_ptr ) |
|
{ |
|
// We're writing to a memory buffer, it's a NOP |
|
} |
|
|
|
ConversionErrorType ImgUtl_WriteRGBAAsPNGToBuffer( const unsigned char *pRGBAData, int nWidth, int nHeight, CUtlBuffer &bufOutData, int nStride ) |
|
{ |
|
#if !defined( _X360 ) |
|
// Auto detect image stride |
|
if ( nStride <= 0 ) |
|
{ |
|
nStride = nWidth*4; |
|
} |
|
|
|
/* could pass pointers to user-defined error handlers instead of NULLs: */ |
|
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, |
|
NULL, NULL, NULL); |
|
if (png_ptr == NULL) |
|
{ |
|
return CE_MEMORY_ERROR; |
|
} |
|
|
|
ConversionErrorType errcode = CE_MEMORY_ERROR; |
|
|
|
png_bytepp row_pointers = NULL; |
|
|
|
png_infop info_ptr = png_create_info_struct(png_ptr); |
|
if ( !info_ptr ) |
|
{ |
|
errcode = CE_MEMORY_ERROR; |
|
fail: |
|
if ( row_pointers ) |
|
{ |
|
free( row_pointers ); |
|
} |
|
png_destroy_write_struct( &png_ptr, &info_ptr ); |
|
return errcode; |
|
} |
|
|
|
// We'll use the default setjmp / longjmp error handling. |
|
if ( setjmp( png_jmpbuf(png_ptr) ) ) |
|
{ |
|
// Error "writing". But since we're writing to a memory bufferm, |
|
// that just means we must have run out of memory |
|
errcode = CE_MEMORY_ERROR; |
|
goto fail; |
|
} |
|
|
|
// Setup stream writing callbacks |
|
png_set_write_fn(png_ptr, (void *)&bufOutData, WritePNGData, FlushPNGData); |
|
|
|
// Setup info structure |
|
png_set_IHDR(png_ptr, info_ptr, nWidth, nHeight, 8, PNG_COLOR_TYPE_RGB_ALPHA, |
|
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); |
|
|
|
// !FIXME! Here we really should scan for the common case of |
|
// an opaque image (all alpha=255) and strip the alpha channel |
|
// in that case. |
|
|
|
// Write the file header information. |
|
png_write_info(png_ptr, info_ptr); |
|
|
|
row_pointers = (png_bytepp)malloc( nHeight*sizeof(png_bytep) ); |
|
if ( row_pointers == NULL ) |
|
{ |
|
errcode = CE_MEMORY_ERROR; |
|
goto fail; |
|
} |
|
|
|
/* set the individual row_pointers to point at the correct offsets */ |
|
for ( int i = 0; i < nHeight; ++i) |
|
row_pointers[i] = const_cast<unsigned char *>(pRGBAData + i*nStride); |
|
|
|
// Write the image |
|
png_write_image(png_ptr, row_pointers); |
|
|
|
/* It is REQUIRED to call this to finish writing the rest of the file */ |
|
png_write_end(png_ptr, info_ptr); |
|
|
|
// Clean up, and we're done |
|
free( row_pointers ); |
|
row_pointers = NULL; |
|
png_destroy_write_struct(&png_ptr, &info_ptr); |
|
return CE_SUCCESS; |
|
#else |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Initialize destination --- called by jpeg_start_compress |
|
// before any data is actually written. |
|
//----------------------------------------------------------------------------- |
|
METHODDEF(void) init_destination (j_compress_ptr cinfo) |
|
{ |
|
JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t *) cinfo->dest; |
|
|
|
// Allocate the output buffer --- it will be released when done with image |
|
dest->buffer = (byte *) |
|
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
|
JPEG_OUTPUT_BUF_SIZE * sizeof(byte)); |
|
|
|
dest->pub.next_output_byte = dest->buffer; |
|
dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Empty the output buffer --- called whenever buffer fills up. |
|
// Input : boolean - |
|
//----------------------------------------------------------------------------- |
|
METHODDEF(boolean) empty_output_buffer (j_compress_ptr cinfo) |
|
{ |
|
JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t * ) cinfo->dest; |
|
|
|
CUtlBuffer *buf = dest->pBuffer; |
|
|
|
// Add some data |
|
buf->Put( dest->buffer, JPEG_OUTPUT_BUF_SIZE ); |
|
|
|
dest->pub.next_output_byte = dest->buffer; |
|
dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE; |
|
|
|
return TRUE; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Terminate destination --- called by jpeg_finish_compress |
|
// after all data has been written. Usually needs to flush buffer. |
|
// |
|
// NB: *not* called by jpeg_abort or jpeg_destroy; surrounding |
|
// application must deal with any cleanup that should happen even |
|
// for error exit. |
|
//----------------------------------------------------------------------------- |
|
METHODDEF(void) term_destination (j_compress_ptr cinfo) |
|
{ |
|
JPEGDestinationManager_t *dest = (JPEGDestinationManager_t *) cinfo->dest; |
|
size_t datacount = JPEG_OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; |
|
|
|
CUtlBuffer *buf = dest->pBuffer; |
|
|
|
/* Write any data remaining in the buffer */ |
|
if (datacount > 0) |
|
{ |
|
buf->Put( dest->buffer, datacount ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Set up functions for writing data to a CUtlBuffer instead of FILE * |
|
//----------------------------------------------------------------------------- |
|
GLOBAL(void) jpeg_UtlBuffer_dest (j_compress_ptr cinfo, CUtlBuffer *pBuffer ) |
|
{ |
|
JPEGDestinationManager_t *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(JPEGDestinationManager_t)); |
|
} |
|
|
|
dest = ( JPEGDestinationManager_t * ) cinfo->dest; |
|
|
|
dest->pub.init_destination = init_destination; |
|
dest->pub.empty_output_buffer = empty_output_buffer; |
|
dest->pub.term_destination = term_destination; |
|
dest->pBuffer = pBuffer; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Write three channel RGB data to a JPEG file |
|
//----------------------------------------------------------------------------- |
|
bool ImgUtl_WriteRGBToJPEG( unsigned char *pSrcBuf, unsigned int nSrcWidth, unsigned int nSrcHeight, const char *lpszFilename ) |
|
{ |
|
CUtlBuffer dstBuf; |
|
|
|
JSAMPROW row_pointer[1]; // pointer to JSAMPLE row[s] |
|
int row_stride; // physical row width in image buffer |
|
|
|
// stderr handler |
|
struct jpeg_error_mgr jerr; |
|
|
|
// compression data structure |
|
struct jpeg_compress_struct cinfo; |
|
|
|
row_stride = nSrcWidth * 3; // JSAMPLEs per row in image_buffer |
|
|
|
// point at stderr |
|
cinfo.err = jpeg_std_error(&jerr); |
|
|
|
// create compressor |
|
jpeg_create_compress(&cinfo); |
|
|
|
// Hook CUtlBuffer to compression |
|
jpeg_UtlBuffer_dest(&cinfo, &dstBuf ); |
|
|
|
// image width and height, in pixels |
|
cinfo.image_width = nSrcWidth; |
|
cinfo.image_height = nSrcHeight; |
|
// RGB is 3 component |
|
cinfo.input_components = 3; |
|
// # of color components per pixel |
|
cinfo.in_color_space = JCS_RGB; |
|
|
|
// Apply settings |
|
jpeg_set_defaults(&cinfo); |
|
jpeg_set_quality(&cinfo, 100, TRUE ); |
|
|
|
// Start compressor |
|
jpeg_start_compress(&cinfo, TRUE); |
|
|
|
// Write scanlines |
|
while ( cinfo.next_scanline < cinfo.image_height ) |
|
{ |
|
row_pointer[ 0 ] = &pSrcBuf[ cinfo.next_scanline * row_stride ]; |
|
jpeg_write_scanlines( &cinfo, row_pointer, 1 ); |
|
} |
|
|
|
// Finalize image |
|
jpeg_finish_compress(&cinfo); |
|
|
|
// Cleanup |
|
jpeg_destroy_compress(&cinfo); |
|
|
|
return CE_SUCCESS; |
|
} |
|
|
|
ConversionErrorType ImgUtl_WriteRGBAAsJPEGToBuffer( const unsigned char *pRGBAData, int nWidth, int nHeight, CUtlBuffer &bufOutData, int nStride ) |
|
{ |
|
#if !defined( _X360 ) |
|
|
|
JSAMPROW row_pointer[1]; // pointer to JSAMPLE row[s] |
|
int row_stride; // physical row width in image buffer |
|
|
|
// stderr handler |
|
struct jpeg_error_mgr jerr; |
|
|
|
// compression data structure |
|
struct jpeg_compress_struct cinfo; |
|
|
|
row_stride = nWidth * 4; |
|
|
|
// point at stderr |
|
cinfo.err = jpeg_std_error(&jerr); |
|
|
|
// create compressor |
|
jpeg_create_compress(&cinfo); |
|
|
|
// Hook CUtlBuffer to compression |
|
jpeg_UtlBuffer_dest(&cinfo, &bufOutData ); |
|
|
|
// image width and height, in pixels |
|
cinfo.image_width = nWidth; |
|
cinfo.image_height = nHeight; |
|
// RGB is 3 component |
|
cinfo.input_components = 3; |
|
// # of color components per pixel |
|
cinfo.in_color_space = JCS_RGB; |
|
|
|
// Apply settings |
|
jpeg_set_defaults(&cinfo); |
|
jpeg_set_quality(&cinfo, 100, TRUE ); |
|
|
|
// Start compressor |
|
jpeg_start_compress(&cinfo, TRUE); |
|
|
|
// Write scanlines |
|
unsigned char *pDstRow = (unsigned char *)malloc( sizeof(unsigned char) * nWidth * 4 ); |
|
while ( cinfo.next_scanline < cinfo.image_height ) |
|
{ |
|
const unsigned char *pSrcRow = &(pRGBAData[cinfo.next_scanline * row_stride]); |
|
// convert row from RGBA to RGB |
|
for ( int x = nWidth-1 ; x >= 0 ; --x ) |
|
{ |
|
pDstRow[x*3+2] = pSrcRow[x*4+2]; |
|
pDstRow[x*3+1] = pSrcRow[x*4+1]; |
|
pDstRow[x*3] = pSrcRow[x*4]; |
|
} |
|
row_pointer[ 0 ] = pDstRow; |
|
jpeg_write_scanlines( &cinfo, row_pointer, 1 ); |
|
} |
|
|
|
// Finalize image |
|
jpeg_finish_compress(&cinfo); |
|
|
|
// Cleanup |
|
jpeg_destroy_compress(&cinfo); |
|
|
|
free( pDstRow ); |
|
|
|
return CE_SUCCESS; |
|
#else |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
#endif |
|
} |
|
|
|
ConversionErrorType ImgUtl_LoadBitmap( const char *pszFilename, Bitmap_t &bitmap ) |
|
{ |
|
bitmap.Clear(); |
|
ConversionErrorType nErrorCode; |
|
int width, height; |
|
unsigned char *buffer = ImgUtl_ReadImageAsRGBA( pszFilename, width, height, nErrorCode ); |
|
if ( nErrorCode != CE_SUCCESS ) |
|
{ |
|
return nErrorCode; |
|
} |
|
|
|
// Install the buffer into the bitmap, and transfer ownership |
|
bitmap.SetBuffer( width, height, IMAGE_FORMAT_RGBA8888, buffer, true, width*4 ); |
|
return CE_SUCCESS; |
|
} |
|
|
|
static ConversionErrorType ImgUtl_LoadJPEGBitmapFromBuffer( CUtlBuffer &fileData, Bitmap_t &bitmap ) |
|
{ |
|
// @todo implement |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
} |
|
|
|
static ConversionErrorType ImgUtl_SaveJPEGBitmapToBuffer( CUtlBuffer &fileData, const Bitmap_t &bitmap ) |
|
{ |
|
if ( !bitmap.IsValid() ) |
|
{ |
|
Assert( bitmap.IsValid() ); |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
// Sorry, only RGBA8888 supported right now |
|
if ( bitmap.Format() != IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
Assert( bitmap.Format() == IMAGE_FORMAT_RGBA8888 ); |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
} |
|
|
|
// Do it |
|
ConversionErrorType result = ImgUtl_WriteRGBAAsJPEGToBuffer( |
|
bitmap.GetBits(), |
|
bitmap.Width(), |
|
bitmap.Height(), |
|
fileData, |
|
bitmap.Stride() |
|
); |
|
return result; |
|
} |
|
|
|
ConversionErrorType ImgUtl_LoadBitmapFromBuffer( CUtlBuffer &fileData, Bitmap_t &bitmap, ImageFileFormat eImageFileFormat ) |
|
{ |
|
switch ( eImageFileFormat ) |
|
{ |
|
case kImageFileFormat_PNG: |
|
return ImgUtl_LoadPNGBitmapFromBuffer( fileData, bitmap ); |
|
case kImageFileFormat_JPG: |
|
return ImgUtl_LoadJPEGBitmapFromBuffer( fileData, bitmap ); |
|
} |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
} |
|
|
|
ConversionErrorType ImgUtl_SaveBitmapToBuffer( CUtlBuffer &fileData, const Bitmap_t &bitmap, ImageFileFormat eImageFileFormat ) |
|
{ |
|
switch ( eImageFileFormat ) |
|
{ |
|
case kImageFileFormat_PNG: |
|
return ImgUtl_SavePNGBitmapToBuffer( fileData, bitmap ); |
|
case kImageFileFormat_JPG: |
|
return ImgUtl_SaveJPEGBitmapToBuffer( fileData, bitmap ); |
|
} |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
} |
|
|
|
ConversionErrorType ImgUtl_LoadPNGBitmapFromBuffer( CUtlBuffer &fileData, Bitmap_t &bitmap ) |
|
{ |
|
bitmap.Clear(); |
|
ConversionErrorType nErrorCode; |
|
int width, height; |
|
unsigned char *buffer = ImgUtl_ReadPNGAsRGBAFromBuffer( fileData, width, height, nErrorCode ); |
|
if ( nErrorCode != CE_SUCCESS ) |
|
{ |
|
return nErrorCode; |
|
} |
|
|
|
// Install the buffer into the bitmap, and transfer ownership |
|
bitmap.SetBuffer( width, height, IMAGE_FORMAT_RGBA8888, buffer, true, width*4 ); |
|
return CE_SUCCESS; |
|
} |
|
|
|
ConversionErrorType ImgUtl_SavePNGBitmapToBuffer( CUtlBuffer &fileData, const Bitmap_t &bitmap ) |
|
{ |
|
if ( !bitmap.IsValid() ) |
|
{ |
|
Assert( bitmap.IsValid() ); |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
// Sorry, only RGBA8888 supported right now |
|
if ( bitmap.Format() != IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
Assert( bitmap.Format() == IMAGE_FORMAT_RGBA8888 ); |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
} |
|
|
|
// Do it |
|
ConversionErrorType result = ImgUtl_WriteRGBAAsPNGToBuffer( |
|
bitmap.GetBits(), |
|
bitmap.Width(), |
|
bitmap.Height(), |
|
fileData, |
|
bitmap.Stride() |
|
); |
|
return result; |
|
} |
|
|
|
ConversionErrorType ImgUtl_ResizeBitmap( Bitmap_t &destBitmap, int nWidth, int nHeight, const Bitmap_t *pImgSource ) |
|
{ |
|
|
|
// Check for resizing in place, then save off data into a temp |
|
Bitmap_t temp; |
|
if ( pImgSource == NULL || pImgSource == &destBitmap ) |
|
{ |
|
temp.MakeLogicalCopyOf( destBitmap, destBitmap.GetOwnsBuffer() ); |
|
pImgSource = &temp; |
|
} |
|
|
|
// No source image? |
|
if ( !pImgSource->IsValid() ) |
|
{ |
|
Assert( pImgSource->IsValid() ); |
|
return CE_CANT_OPEN_SOURCE_FILE; |
|
} |
|
|
|
// Sorry, we're using an existing rescaling routine that |
|
// only withs for RGBA images with assumed stride |
|
if ( |
|
pImgSource->Format() != IMAGE_FORMAT_RGBA8888 |
|
|| pImgSource->Stride() != pImgSource->Width()*4 |
|
) { |
|
Assert( pImgSource->Format() == IMAGE_FORMAT_RGBA8888 ); |
|
Assert( pImgSource->Stride() == pImgSource->Width()*4 ); |
|
return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED; |
|
} |
|
|
|
// Allocate buffer |
|
destBitmap.Init( nWidth, nHeight, IMAGE_FORMAT_RGBA8888 ); |
|
|
|
// Something wrong? |
|
if ( !destBitmap.IsValid() ) |
|
{ |
|
Assert( destBitmap.IsValid() ); |
|
return CE_MEMORY_ERROR; |
|
} |
|
|
|
// Do it |
|
return ImgUtl_StretchRGBAImage( |
|
pImgSource->GetBits(), pImgSource->Width(), pImgSource->Height(), |
|
destBitmap.GetBits(), destBitmap.Width(), destBitmap.Height() |
|
); |
|
}
|
|
|