OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Remove old deprecated IJL code

Michael Hansen 14 years ago
parent
7eeafccd57
commit
30d60d8954
1 changed files with 8 additions and 167 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 173
      Sources/Plasma/PubUtilLib/plJPEG/plJPEG.cpp

173
Sources/Plasma/PubUtilLib/plJPEG/plJPEG.cpp
Unescape View File

@ -41,24 +41,13 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "hsUtils.h" #include "hsUtils.h"
#include "plGImage/plMipmap.h" #include "plGImage/plMipmap.h"
#ifdef IJL_SDK_AVAILABLE
#ifndef HS_BUILD_FOR_WIN32
#error Currently the JPEG libraries don't build for anything but Win32. If you're building this on a non-Win32 platform....WHY??
#endif
#include <ijl.h>
#else
#include <jpeglib.h> #include <jpeglib.h>
#include <jerror.h> #include <jerror.h>
#endif
//// Local Statics //////////////////////////////////////////////////////////// //// Local Statics ////////////////////////////////////////////////////////////
// Done this way so we don't have to declare them in the .h file and pull in // Done this way so we don't have to declare them in the .h file and pull in
// the platform-specific library // the platform-specific library
#ifdef IJL_SDK_AVAILABLE
static IJLERR sLastErrCode = IJL_OK;
#else
// It is not thread-safe to use a static char buffer, but it wasn't really // It is not thread-safe to use a static char buffer, but it wasn't really
// thread-safe to use a static int either. The char buffer is slightly // thread-safe to use a static int either. The char buffer is slightly
// worse since you could get mangled strings instead of just a stale error. // worse since you could get mangled strings instead of just a stale error.
@ -79,16 +68,14 @@ static void clear_jpegmsg()
// "Success" is what IJL produced for no error // "Success" is what IJL produced for no error
strcpy( jpegmsg, "Success" ); strcpy( jpegmsg, "Success" );
} }
#endif
//// Instance ///////////////////////////////////////////////////////////////// //// Instance /////////////////////////////////////////////////////////////////
plJPEG &plJPEG::Instance( void ) plJPEG &plJPEG::Instance( void )
{ {
#ifndef IJL_SDK_AVAILABLE
clear_jpegmsg(); clear_jpegmsg();
#endif
static plJPEG theInstance; static plJPEG theInstance;
return theInstance; return theInstance;
} }
@ -97,11 +84,7 @@ plJPEG &plJPEG::Instance( void )
const char *plJPEG::GetLastError( void ) const char *plJPEG::GetLastError( void )
{ {
#ifdef IJL_SDK_AVAILABLE
return ijlErrorStr( sLastErrCode );
#else
return jpegmsg; return jpegmsg;
#endif
} }
//// IRead //////////////////////////////////////////////////////////////////// //// IRead ////////////////////////////////////////////////////////////////////
@ -122,33 +105,18 @@ plMipmap *plJPEG::IRead( hsStream *inStream )
UInt8 *jpegSourceBuffer = nil; UInt8 *jpegSourceBuffer = nil;
UInt32 jpegSourceSize; UInt32 jpegSourceSize;
#ifdef IJL_SDK_AVAILABLE
JPEG_CORE_PROPERTIES jcProps;
#else
struct jpeg_decompress_struct cinfo; struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr; struct jpeg_error_mgr jerr;
#endif
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_OK;
#else
clear_jpegmsg(); clear_jpegmsg();
cinfo.err = jpeg_std_error( &jerr ); cinfo.err = jpeg_std_error( &jerr );
jerr.error_exit = plJPEG_error_exit; jerr.error_exit = plJPEG_error_exit;
jerr.emit_message = plJPEG_emit_message; jerr.emit_message = plJPEG_emit_message;
#endif
try try
{ {
#ifdef IJL_SDK_AVAILABLE
/// Init the IJL library
sLastErrCode = ijlInit( &jcProps );
if( sLastErrCode != IJL_OK )
throw( false );
#else
jpeg_create_decompress( &cinfo ); jpeg_create_decompress( &cinfo );
#endif
/// Read in the JPEG header /// Read in the JPEG header
if ( inStream->GetEOF() == 0 ) if ( inStream->GetEOF() == 0 )
@ -162,32 +130,13 @@ plMipmap *plJPEG::IRead( hsStream *inStream )
jpegSourceBuffer = TRACKED_NEW UInt8[ jpegSourceSize ]; jpegSourceBuffer = TRACKED_NEW UInt8[ jpegSourceSize ];
if( jpegSourceBuffer == nil ) if( jpegSourceBuffer == nil )
{ {
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_MEMORY_ERROR;
throw( false );
#else
// waah. // waah.
ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 ); ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
#endif
} }
inStream->Read( jpegSourceSize, jpegSourceBuffer ); inStream->Read( jpegSourceSize, jpegSourceBuffer );
#ifdef IJL_SDK_AVAILABLE
jcProps.JPGFile = nil;
jcProps.JPGBytes = jpegSourceBuffer;
jcProps.JPGSizeBytes = jpegSourceSize;
#else
jpeg_mem_src( &cinfo, jpegSourceBuffer, jpegSourceSize ); jpeg_mem_src( &cinfo, jpegSourceBuffer, jpegSourceSize );
#endif
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = ijlRead( &jcProps, IJL_JBUFF_READPARAMS );
if( sLastErrCode != IJL_OK )
throw( false );
#else
(void) jpeg_read_header( &cinfo, TRUE ); (void) jpeg_read_header( &cinfo, TRUE );
#endif
/// So we got lots of data to play with now. First, set the JPEG color /// So we got lots of data to play with now. First, set the JPEG color
/// space to read in from/as... /// space to read in from/as...
@ -201,75 +150,31 @@ plMipmap *plJPEG::IRead( hsStream *inStream )
// are in the YCbCr color space and 1 channel images are // are in the YCbCr color space and 1 channel images are
// in the Y color space." // in the Y color space."
#ifdef IJL_SDK_AVAILABLE
switch( jcProps.JPGChannels )
#else
switch( cinfo.jpeg_color_space ) switch( cinfo.jpeg_color_space )
#endif
{ {
#ifdef IJL_SDK_AVAILABLE
case 1:
jcProps.JPGColor = IJL_G;
jcProps.DIBColor = IJL_RGBA_FPX;
jcProps.DIBChannels = 4; // We ALWAYS try to decode to 4 channels
break;
case 3:
jcProps.JPGColor = IJL_YCBCR;
jcProps.DIBColor = IJL_RGBA_FPX;
jcProps.DIBChannels = 4;
break;
#else
case JCS_GRAYSCALE: case JCS_GRAYSCALE:
case JCS_YCbCr: case JCS_YCbCr:
cinfo.out_color_space = JCS_RGB; cinfo.out_color_space = JCS_RGB;
break; break;
#endif
default: default:
// We should probably assert here, since we're pretty sure we WON'T get ARGB. <sigh> // We should probably assert here, since we're pretty sure we WON'T get ARGB. <sigh>
hsAssert( false, "Unknown JPEG stream format in ReadFromStream()" ); hsAssert( false, "Unknown JPEG stream format in ReadFromStream()" );
#ifdef IJL_SDK_AVAILABLE
jcProps.JPGColor = IJL_OTHER;
jcProps.DIBColor = IJL_OTHER;
jcProps.DIBChannels = jcProps.JPGChannels;
#else
cinfo.out_color_space = JCS_UNKNOWN; cinfo.out_color_space = JCS_UNKNOWN;
#endif
break; break;
} }
#ifndef IJL_SDK_AVAILABLE
(void) jpeg_start_decompress( &cinfo ); (void) jpeg_start_decompress( &cinfo );
#endif
/// Construct a new mipmap to hold everything /// Construct a new mipmap to hold everything
#ifdef IJL_SDK_AVAILABLE
newMipmap = TRACKED_NEW plMipmap( jcProps.JPGWidth, jcProps.JPGHeight, plMipmap::kRGB32Config, 1, plMipmap::kJPEGCompression );
#else
newMipmap = TRACKED_NEW plMipmap( cinfo.output_width, cinfo.output_height, plMipmap::kRGB32Config, 1, plMipmap::kJPEGCompression ); newMipmap = TRACKED_NEW plMipmap( cinfo.output_width, cinfo.output_height, plMipmap::kRGB32Config, 1, plMipmap::kJPEGCompression );
#endif
if( newMipmap == nil || newMipmap->GetImage() == nil ) if( newMipmap == nil || newMipmap->GetImage() == nil )
{ {
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_MEMORY_ERROR;
throw( false );
#else
ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 ); ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
#endif
} }
/// Set up to read in to that buffer we now have /// Set up to read in to that buffer we now have
#ifdef IJL_SDK_AVAILABLE
jcProps.DIBWidth = newMipmap->GetWidth();
jcProps.DIBHeight = newMipmap->GetHeight();
jcProps.DIBPadBytes = 0;
jcProps.DIBBytes = (UInt8 *)newMipmap->GetImage();
sLastErrCode = ijlRead( &jcProps, IJL_JBUFF_READWHOLEIMAGE );
if( sLastErrCode != IJL_OK )
throw( false );
#else
JSAMPROW jbuffer; JSAMPROW jbuffer;
int row_stride = cinfo.output_width * cinfo.output_components; int row_stride = cinfo.output_width * cinfo.output_components;
int out_stride = cinfo.output_width * 4; // Decompress to RGBA int out_stride = cinfo.output_width * 4; // Decompress to RGBA
@ -293,7 +198,6 @@ plMipmap *plJPEG::IRead( hsStream *inStream )
(void) jpeg_finish_decompress(&cinfo); (void) jpeg_finish_decompress(&cinfo);
delete [] jbuffer; delete [] jbuffer;
#endif
// Sometimes life just sucks // Sometimes life just sucks
ISwapRGBAComponents( (UInt32 *)newMipmap->GetImage(), newMipmap->GetWidth() * newMipmap->GetHeight() ); ISwapRGBAComponents( (UInt32 *)newMipmap->GetImage(), newMipmap->GetWidth() * newMipmap->GetHeight() );
@ -307,12 +211,8 @@ plMipmap *plJPEG::IRead( hsStream *inStream )
// Cleanup // Cleanup
delete [] jpegSourceBuffer; delete [] jpegSourceBuffer;
// Clean up the IJL Library // Clean up the JPEG Library
#ifdef IJL_SDK_AVAILABLE
ijlFree( &jcProps );
#else
jpeg_destroy_decompress( &cinfo ); jpeg_destroy_decompress( &cinfo );
#endif
MemPopDisableTracking(); MemPopDisableTracking();
// All done! // All done!
@ -347,79 +247,38 @@ hsBool plJPEG::IWrite( plMipmap *source, hsStream *outStream )
UInt8 *jpgBuffer = nil; UInt8 *jpgBuffer = nil;
UInt32 jpgBufferSize = 0; UInt32 jpgBufferSize = 0;
#ifdef IJL_SDK_AVAILABLE
JPEG_CORE_PROPERTIES jcProps;
#else
struct jpeg_compress_struct cinfo; struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr; struct jpeg_error_mgr jerr;
#endif
#ifndef IJL_SDK_AVAILABLE
clear_jpegmsg(); clear_jpegmsg();
cinfo.err = jpeg_std_error( &jerr ); cinfo.err = jpeg_std_error( &jerr );
jerr.error_exit = plJPEG_error_exit; jerr.error_exit = plJPEG_error_exit;
jerr.emit_message = plJPEG_emit_message; jerr.emit_message = plJPEG_emit_message;
#endif
try try
{ {
#ifdef IJL_SDK_AVAILABLE
// Init the IJL Library
sLastErrCode = ijlInit( &jcProps );
if( sLastErrCode != IJL_OK )
throw( false );
#else
jpeg_create_compress( &cinfo ); jpeg_create_compress( &cinfo );
#endif
// Create a buffer to hold the data // Create a buffer to hold the data
jpgBufferSize = source->GetWidth() * source->GetHeight() * 3; jpgBufferSize = source->GetWidth() * source->GetHeight() * 3;
jpgBuffer = TRACKED_NEW UInt8[ jpgBufferSize ]; jpgBuffer = TRACKED_NEW UInt8[ jpgBufferSize ];
if( jpgBuffer == nil ) if( jpgBuffer == nil )
{ {
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_MEMORY_ERROR;
throw( false );
#else
ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 ); ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
#endif
} }
#ifdef IJL_SDK_AVAILABLE
jcProps.JPGFile = nil;
jcProps.JPGBytes = jpgBuffer;
jcProps.JPGSizeBytes = jpgBufferSize;
#else
UInt8 *bufferAddr = jpgBuffer; UInt8 *bufferAddr = jpgBuffer;
UInt32 bufferSize = jpgBufferSize; UInt32 bufferSize = jpgBufferSize;
jpeg_mem_dest( &cinfo, &bufferAddr, &bufferSize ); jpeg_mem_dest( &cinfo, &bufferAddr, &bufferSize );
#endif
#ifdef IJL_SDK_AVAILABLE
jcProps.DIBWidth = source->GetWidth();
jcProps.DIBHeight = source->GetHeight();
jcProps.DIBBytes = (UInt8 *)source->GetImage();
jcProps.DIBPadBytes = 0;
jcProps.DIBChannels = 4;
jcProps.DIBColor = IJL_RGB;
#else
cinfo.image_width = source->GetWidth(); cinfo.image_width = source->GetWidth();
cinfo.image_height = source->GetHeight(); cinfo.image_height = source->GetHeight();
cinfo.input_components = 3; cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB; cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults( &cinfo ); jpeg_set_defaults( &cinfo );
#endif
#ifdef IJL_SDK_AVAILABLE
jcProps.JPGWidth = source->GetWidth();
jcProps.JPGHeight = source->GetHeight();
jcProps.JPGChannels = 3;
jcProps.JPGColor = IJL_YCBCR;
jcProps.JPGSubsampling = IJL_411; // 4:1:1 subsampling
jcProps.jquality = fWriteQuality;
#else
cinfo.jpeg_width = source->GetWidth(); // default cinfo.jpeg_width = source->GetWidth(); // default
cinfo.jpeg_height = source->GetHeight(); // default cinfo.jpeg_height = source->GetHeight(); // default
cinfo.jpeg_color_space = JCS_YCbCr; // default cinfo.jpeg_color_space = JCS_YCbCr; // default
@ -427,18 +286,12 @@ hsBool plJPEG::IWrite( plMipmap *source, hsStream *outStream )
jpeg_set_quality( &cinfo, fWriteQuality, TRUE ); jpeg_set_quality( &cinfo, fWriteQuality, TRUE );
jpeg_start_compress( &cinfo, TRUE ); jpeg_start_compress( &cinfo, TRUE );
#endif
// Sometimes life just sucks // Sometimes life just sucks
ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() ); ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() );
swapped = true; swapped = true;
// Write it! // Write it!
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = ijlWrite( &jcProps, IJL_JBUFF_WRITEWHOLEIMAGE );
if( sLastErrCode != IJL_OK )
throw( false );
#else
JSAMPROW jbuffer; JSAMPROW jbuffer;
int in_stride = cinfo.image_width * 4; // Input is always RGBA int in_stride = cinfo.image_width * 4; // Input is always RGBA
int row_stride = cinfo.image_width * cinfo.input_components; int row_stride = cinfo.image_width * cinfo.input_components;
@ -459,18 +312,10 @@ hsBool plJPEG::IWrite( plMipmap *source, hsStream *outStream )
jpeg_finish_compress( &cinfo ); jpeg_finish_compress( &cinfo );
delete [] jbuffer; delete [] jbuffer;
#endif
// jpeglib changes bufferSize and bufferAddr
#ifdef IJL_SDK_AVAILABLE
// On output, the IJL fills our image buffer with the JPEG stream, plus changes JPGSizeBytes to
// the length of the stream
outStream->WriteSwap32( jcProps.JPGSizeBytes );
outStream->Write( jcProps.JPGSizeBytes, jcProps.JPGBytes );
#else
// jpeglib similarly changes bufferSize and bufferAddr
outStream->WriteSwap32( bufferSize ); outStream->WriteSwap32( bufferSize );
outStream->Write( bufferSize, bufferAddr ); outStream->Write( bufferSize, bufferAddr );
#endif
} }
catch( ... ) catch( ... )
{ {
@ -480,11 +325,7 @@ hsBool plJPEG::IWrite( plMipmap *source, hsStream *outStream )
// Cleanup // Cleanup
if ( jpgBuffer ) if ( jpgBuffer )
delete [] jpgBuffer; delete [] jpgBuffer;
#ifdef IJL_SDK_AVAILABLE
ijlFree( &jcProps );
#else
jpeg_destroy_compress( &cinfo ); jpeg_destroy_compress( &cinfo );
#endif
if( swapped ) if( swapped )
ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() ); ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() );

Write Preview
Loading…
Cancel
Save