OU/CWE-ou-minkata
2
3
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-14 02:27:40 -04:00
Code Releases Activity

AStyle formatting fixes.

Browse Source
This commit is contained in:
Joseph Davies
2011-05-11 00:17:55 -07:00
parent e08ed20947
commit 555b0d94b2
2 changed files with 76 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
Sources/Plasma/PubUtilLib/plGImage/plPNG.cpp
View File

@ -38,19 +38,19 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
// used by libPNG's respective functions // used by libPNG's respective functions
void pngReadDelegate(png_structp png_ptr, png_bytep png_data, png_size_t length) void pngReadDelegate(png_structp png_ptr, png_bytep png_data, png_size_t length)
{ {
hsStream *inStream = (hsStream *)png_get_io_ptr(png_ptr); hsStream* inStream = (hsStream*)png_get_io_ptr(png_ptr);
inStream->Read(length, (UInt8 *)png_data); inStream->Read(length, (UInt8*)png_data);
} }
void pngWriteDelegate(png_structp png_ptr, png_bytep png_data, png_size_t length) void pngWriteDelegate(png_structp png_ptr, png_bytep png_data, png_size_t length)
{ {
hsStream *outStream = (hsStream *)png_get_io_ptr(png_ptr); hsStream* outStream = (hsStream*)png_get_io_ptr(png_ptr);
outStream->Write(length, (UInt8 *)png_data); outStream->Write(length, (UInt8*)png_data);
} }
//// Singleton Instance /////////////////////////////////////////////////////// //// Singleton Instance ///////////////////////////////////////////////////////
plPNG &plPNG::Instance( void ) plPNG& plPNG::Instance(void)
{ {
static plPNG theInstance; static plPNG theInstance;
return theInstance; return theInstance;
@ -62,42 +62,42 @@ plPNG &plPNG::Instance( void )
// being a packed RGBA buffer. // being a packed RGBA buffer.
// Returns a pointer to the new mipmap if successful, NULL otherwise. // Returns a pointer to the new mipmap if successful, NULL otherwise.
plMipmap* plPNG::IRead( hsStream *inStream ) plMipmap* plPNG::IRead(hsStream* inStream)
{ {
plMipmap *newMipmap = NULL; plMipmap* newMipmap = NULL;
png_structp png_ptr; png_structp png_ptr;
png_infop info_ptr; png_infop info_ptr;
png_infop end_info; png_infop end_info;
try try {
{
// Check PNG Signature // Check PNG Signature
png_byte sig[PNGSIGSIZE]; png_byte sig[PNGSIGSIZE];
inStream->Read8Bytes((char *) sig); inStream->Read8Bytes((char*) sig);
if (!png_sig_cmp(sig, 0, PNGSIGSIZE))
{ if (!png_sig_cmp(sig, 0, PNGSIGSIZE)) {
// Allocate required structs // Allocate required structs
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
throw( false ); if (!png_ptr) {
throw(false);
}
info_ptr = png_create_info_struct(png_ptr); info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{ if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
throw( false ); throw(false);
} }
end_info = png_create_info_struct(png_ptr); end_info = png_create_info_struct(png_ptr);
if (!end_info)
{ if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
throw( false ); throw(false);
} }
// Assign delegate function for reading from hsStream // Assign delegate function for reading from hsStream
png_set_read_fn(png_ptr, (png_voidp)inStream, pngReadDelegate); png_set_read_fn(png_ptr, (png_voidp)inStream, pngReadDelegate);
// Get PNG Header information // Get PNG Header information
png_set_sig_bytes(png_ptr, PNGSIGSIZE); png_set_sig_bytes(png_ptr, PNGSIGSIZE);
png_read_info(png_ptr, info_ptr); png_read_info(png_ptr, info_ptr);
@ -114,45 +114,41 @@ plMipmap* plPNG::IRead( hsStream *inStream )
channels = 3; channels = 3;
break; break;
case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_GRAY:
if (bitdepth < 8)
if (bitdepth < 8) {
png_set_expand_gray_1_2_4_to_8(png_ptr); png_set_expand_gray_1_2_4_to_8(png_ptr);
}
bitdepth = 8; bitdepth = 8;
break; break;
} }
// Convert transparency (if needed) to a full alpha channel // Convert transparency (if needed) to a full alpha channel
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
{
png_set_tRNS_to_alpha(png_ptr); png_set_tRNS_to_alpha(png_ptr);
channels+=1; channels += 1;
} }
// Invert color byte-order as used by plMipmap for DirectX // Invert color byte-order as used by plMipmap for DirectX
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
/// Construct a new mipmap to hold everything /// Construct a new mipmap to hold everything
newMipmap = TRACKED_NEW plMipmap(imgWidth, imgHeight, plMipmap::kARGB32Config, 1, plMipmap::kUncompressed); newMipmap = TRACKED_NEW plMipmap(imgWidth, imgHeight, plMipmap::kARGB32Config, 1, plMipmap::kUncompressed);
char* destp = (char*)newMipmap->GetImage();
char *destp = (char *)newMipmap->GetImage(); png_bytep* row_ptrs = TRACKED_NEW png_bytep[imgHeight];
png_bytep *row_ptrs = TRACKED_NEW png_bytep[imgHeight];
const unsigned int stride = imgWidth * bitdepth * channels / 8; const unsigned int stride = imgWidth * bitdepth * channels / 8;
// Assign row pointers to the appropriate locations in the newly-created Mipmap // Assign row pointers to the appropriate locations in the newly-created Mipmap
for (size_t i = 0; i < imgHeight; i++) for (size_t i = 0; i < imgHeight; i++) {
{
row_ptrs[i] = (png_bytep)destp + (i * stride); row_ptrs[i] = (png_bytep)destp + (i * stride);
} }
png_read_image(png_ptr, row_ptrs);
png_read_image(png_ptr, row_ptrs);
// Clean up allocated structs // Clean up allocated structs
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
delete [] row_ptrs; delete [] row_ptrs;
} }
} } catch (...) {
catch( ... ) if (newMipmap != NULL) {
{
if (newMipmap != NULL)
{
delete newMipmap; delete newMipmap;
newMipmap = NULL; newMipmap = NULL;
} }
@ -161,7 +157,7 @@ plMipmap* plPNG::IRead( hsStream *inStream )
return newMipmap; return newMipmap;
} }
plMipmap* plPNG::ReadFromFile( const char *fileName ) plMipmap* plPNG::ReadFromFile(const char* fileName)
{ {
wchar* wFilename = hsStringToWString(fileName); wchar* wFilename = hsStringToWString(fileName);
plMipmap* retVal = ReadFromFile(wFilename); plMipmap* retVal = ReadFromFile(wFilename);
@ -169,72 +165,69 @@ plMipmap* plPNG::ReadFromFile( const char *fileName )
return retVal; return retVal;
} }
plMipmap* plPNG::ReadFromFile( const wchar *fileName ) plMipmap* plPNG::ReadFromFile(const wchar* fileName)
{ {
hsUNIXStream in; hsUNIXStream in;
if (!in.Open(fileName, L"rb"))
if (!in.Open(fileName, L"rb")) {
return false; return false;
}
plMipmap* ret = IRead(&in); plMipmap* ret = IRead(&in);
in.Close(); in.Close();
return ret; return ret;
} }
hsBool plPNG::IWrite( plMipmap *source, hsStream *outStream ) hsBool plPNG::IWrite(plMipmap* source, hsStream* outStream)
{ {
hsBool result = true; hsBool result = true;
try try {
{
// Allocate required structs // Allocate required structs
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
throw( false ); if (!png_ptr) {
throw(false);
}
png_infop info_ptr = png_create_info_struct(png_ptr); png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{ if (!info_ptr) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL); png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
throw( false ); throw(false);
} }
// Assign delegate function for writing to hsStream // Assign delegate function for writing to hsStream
png_set_write_fn(png_ptr, (png_voidp)outStream, pngWriteDelegate, NULL); png_set_write_fn(png_ptr, (png_voidp)outStream, pngWriteDelegate, NULL);
UInt8 psize = source->GetPixelSize(); UInt8 psize = source->GetPixelSize();
png_set_IHDR(png_ptr, info_ptr, source->GetWidth(), source->GetHeight(), 8, PNG_COLOR_TYPE_RGB_ALPHA, png_set_IHDR(png_ptr, info_ptr, source->GetWidth(), source->GetHeight(), 8, PNG_COLOR_TYPE_RGB_ALPHA,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
// Invert color byte-order as used by plMipmap for DirectX // Invert color byte-order as used by plMipmap for DirectX
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
// Write out the image metadata // Write out the image metadata
png_write_info(png_ptr, info_ptr); png_write_info(png_ptr, info_ptr);
char* srcp = (char*)source->GetImage();
char *srcp = (char *)source->GetImage(); png_bytep* row_ptrs = TRACKED_NEW png_bytep[source->GetHeight()];
png_bytep *row_ptrs = TRACKED_NEW png_bytep[source->GetHeight()];
const unsigned int stride = source->GetWidth() * source->GetPixelSize() / 8; const unsigned int stride = source->GetWidth() * source->GetPixelSize() / 8;
// Assign row pointers to the appropriate locations in the newly-created Mipmap // Assign row pointers to the appropriate locations in the newly-created Mipmap
for (size_t i = 0; i < source->GetHeight(); i++) for (size_t i = 0; i < source->GetHeight(); i++) {
{
row_ptrs[i] = (png_bytep)srcp + (i * stride); row_ptrs[i] = (png_bytep)srcp + (i * stride);
} }
png_write_image(png_ptr, row_ptrs); png_write_image(png_ptr, row_ptrs);
png_write_end(png_ptr, info_ptr); png_write_end(png_ptr, info_ptr);
// Clean up allocated structs // Clean up allocated structs
png_destroy_write_struct(&png_ptr, &info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr);
delete [] row_ptrs; delete [] row_ptrs;
} } catch (...) {
catch( ... )
{
result = false; result = false;
} }
return result; return result;
} }
hsBool plPNG::WriteToFile( const char *fileName, plMipmap *sourceData ) hsBool plPNG::WriteToFile(const char* fileName, plMipmap* sourceData)
{ {
wchar* wFilename = hsStringToWString(fileName); wchar* wFilename = hsStringToWString(fileName);
hsBool retVal = WriteToFile(wFilename, sourceData); hsBool retVal = WriteToFile(wFilename, sourceData);
@ -242,11 +235,14 @@ hsBool plPNG::WriteToFile( const char *fileName, plMipmap *sourceData )
return retVal; return retVal;
} }
hsBool plPNG::WriteToFile( const wchar *fileName, plMipmap *sourceData ) hsBool plPNG::WriteToFile(const wchar* fileName, plMipmap* sourceData)
{ {
hsUNIXStream out; hsUNIXStream out;
if (!out.Open(fileName, L"wb"))
if (!out.Open(fileName, L"wb")) {
return false; return false;
}
hsBool ret = IWrite(sourceData, &out); hsBool ret = IWrite(sourceData, &out);
out.Close(); out.Close();
return ret; return ret;

25
Sources/Plasma/PubUtilLib/plGImage/plPNG.h
View File

@ -33,24 +33,23 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
class plMipmap; class plMipmap;
class hsStream; class hsStream;
class plPNG class plPNG {
{ protected:
protected:
plMipmap *IRead( hsStream *inStream ); plMipmap* IRead(hsStream* inStream);
hsBool IWrite( plMipmap *source, hsStream *outStream ); hsBool IWrite(plMipmap* source, hsStream* outStream);
public: public:
plMipmap *ReadFromStream( hsStream *inStream ) { return IRead( inStream ); } plMipmap* ReadFromStream(hsStream* inStream) { return IRead(inStream); }
plMipmap *ReadFromFile( const char *fileName ); plMipmap* ReadFromFile(const char* fileName);
plMipmap *ReadFromFile( const wchar *fileName ); plMipmap* ReadFromFile(const wchar* fileName);
hsBool WriteToStream( hsStream *outStream, plMipmap *sourceData ) { return IWrite( sourceData, outStream ); } hsBool WriteToStream(hsStream* outStream, plMipmap* sourceData) { return IWrite(sourceData, outStream); }
hsBool WriteToFile( const char *fileName, plMipmap *sourceData ); hsBool WriteToFile(const char* fileName, plMipmap* sourceData);
hsBool WriteToFile( const wchar *fileName, plMipmap *sourceData ); hsBool WriteToFile(const wchar* fileName, plMipmap* sourceData);
static plPNG &Instance( void ); static plPNG& Instance(void);
}; };
#endif // _plPNG_h #endif // _plPNG_h