OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
64 Commits
80 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: d4250e19b5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd4250e19b5'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plJPEG/plJPEG.cpp

524 lines
15 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
// //
// plJPEG - JPEG Codec Wrapper for Plasma //
// Cyan, Inc. //
// //
//// Version History //////////////////////////////////////////////////////////
// //
// 2.1.2002 mcn - Created. //
// //
///////////////////////////////////////////////////////////////////////////////
#include "hsTypes.h"
#include "plJPEG.h"
#include "hsStream.h"
#include "hsExceptions.h"
#include "hsUtils.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 <jerror.h>
#endif
//// Local Statics ////////////////////////////////////////////////////////////
// Done this way so we don't have to declare them in the .h file and pull in
// 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
// 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.
static char jpegmsg[JMSG_LENGTH_MAX];
// jpeglib error handlers
static void plJPEG_error_exit( j_common_ptr cinfo )
{
(*cinfo->err->format_message) ( cinfo, jpegmsg );
throw ( false );
}
static void plJPEG_emit_message( j_common_ptr cinfo, int msg_level )
{
// log NOTHING
}
static void clear_jpegmsg()
{
// "Success" is what IJL produced for no error
strcpy( jpegmsg, "Success" );
}
#endif
//// Instance /////////////////////////////////////////////////////////////////
plJPEG &plJPEG::Instance( void )
{
#ifndef IJL_SDK_AVAILABLE
clear_jpegmsg();
#endif
static plJPEG theInstance;
return theInstance;
}
//// GetLastError /////////////////////////////////////////////////////////////
const char *plJPEG::GetLastError( void )
{
#ifdef IJL_SDK_AVAILABLE
return ijlErrorStr( sLastErrCode );
#else
return jpegmsg;
#endif
}
//// IRead ////////////////////////////////////////////////////////////////////
// Given an open hsStream (or a filename), reads the JPEG data off of the
// stream and decodes it into a new plMipmap. The mipmap's buffer ends up
// being a packed RGBx buffer, where x is 8 bits of unused alpha (go figure
// that JPEG images can't store alpha, or even if they can, IJL certainly
// doesn't know about it).
// Returns a pointer to the new mipmap if successful, nil otherwise.
// Note: more or less lifted straight out of the IJL documentation, with
// some changes to fit Plasma coding style and formats.
plMipmap *plJPEG::IRead( hsStream *inStream )
{
MemPushDisableTracking();
plMipmap *newMipmap = nil;
UInt8 *jpegSourceBuffer = nil;
UInt32 jpegSourceSize;
#ifdef IJL_SDK_AVAILABLE
JPEG_CORE_PROPERTIES jcProps;
#else
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
#endif
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_OK;
#else
clear_jpegmsg();
cinfo.err = jpeg_std_error( &jerr );
jerr.error_exit = plJPEG_error_exit;
jerr.emit_message = plJPEG_emit_message;
#endif
try
{
#ifdef IJL_SDK_AVAILABLE
/// Init the IJL library
sLastErrCode = ijlInit( &jcProps );
if( sLastErrCode != IJL_OK )
throw( false );
#else
jpeg_create_decompress( &cinfo );
#endif
/// Read in the JPEG header
if ( inStream->GetEOF() == 0 )
throw( false );
/// Wonderful limitation of mixing our streams with IJL--it wants either a filename
/// or a memory buffer. Since we can't give it the former, we have to read the entire
/// JPEG stream into a separate buffer before we can decode it. Which means we ALSO
/// have to write/read a length of said buffer. Such is life, I guess...
jpegSourceSize = inStream->ReadSwap32();
jpegSourceBuffer = TRACKED_NEW UInt8[ jpegSourceSize ];
if( jpegSourceBuffer == nil )
{
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_MEMORY_ERROR;
throw( false );
#else
// waah.
ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
#endif
}
inStream->Read( jpegSourceSize, jpegSourceBuffer );
#ifdef IJL_SDK_AVAILABLE
jcProps.JPGFile = nil;
jcProps.JPGBytes = jpegSourceBuffer;
jcProps.JPGSizeBytes = jpegSourceSize;
#else
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 );
#endif
/// So we got lots of data to play with now. First, set the JPEG color
/// space to read in from/as...
/// From the IJL code:
// "Set the JPG color space ... this will always be
// somewhat of an educated guess at best because JPEG
// is "color blind" (i.e., nothing in the bit stream
// tells you what color space the data was encoded from).
// However, in this example we assume that we are
// reading JFIF files which means that 3 channel images
// are in the YCbCr color space and 1 channel images are
// in the Y color space."
#ifdef IJL_SDK_AVAILABLE
switch( jcProps.JPGChannels )
#else
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_YCbCr:
cinfo.out_color_space = JCS_RGB;
break;
#endif
default:
// We should probably assert here, since we're pretty sure we WON'T get ARGB. <sigh>
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;
#endif
break;
}
#ifndef IJL_SDK_AVAILABLE
(void) jpeg_start_decompress( &cinfo );
#endif
/// 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 );
#endif
if( newMipmap == nil || newMipmap->GetImage() == nil )
{
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_MEMORY_ERROR;
throw( false );
#else
ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
#endif
}
/// 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;
int row_stride = cinfo.output_width * cinfo.output_components;
int out_stride = cinfo.output_width * 4; // Decompress to RGBA
jbuffer = TRACKED_NEW JSAMPLE[row_stride];
UInt8 *destp = (UInt8 *)newMipmap->GetImage();
while( cinfo.output_scanline < cinfo.output_height )
{
(void) jpeg_read_scanlines( &cinfo, &jbuffer, 1 );
(void) memset( destp, 0xFF, out_stride );
for( size_t pixel = 0; pixel < cinfo.output_width; ++pixel )
{
(void) memcpy( destp + (pixel * 4),
jbuffer + (pixel * cinfo.output_components),
cinfo.out_color_components );
}
}
(void) jpeg_finish_decompress(&cinfo);
delete [] jbuffer;
#endif
// Sometimes life just sucks
ISwapRGBAComponents( (UInt32 *)newMipmap->GetImage(), newMipmap->GetWidth() * newMipmap->GetHeight() );
}
catch( ... )
{
delete newMipmap;
newMipmap = nil;
}
// Cleanup
delete [] jpegSourceBuffer;
// Clean up the IJL Library
#ifdef IJL_SDK_AVAILABLE
ijlFree( &jcProps );
#else
jpeg_destroy_decompress( &cinfo );
#endif
MemPopDisableTracking();
// All done!
return newMipmap;
}
plMipmap* plJPEG::ReadFromFile( const char *fileName )
{
wchar* wFilename = hsStringToWString(fileName);
plMipmap* retVal = ReadFromFile(wFilename);
delete [] wFilename;
return retVal;
}
plMipmap* plJPEG::ReadFromFile( const wchar *fileName )
{
// we use a stream because the IJL can't handle unicode
hsUNIXStream out;
if (!out.Open(fileName, L"rb"))
return false;
plMipmap* ret = IRead(&out);
out.Close();
return ret;
}
//// IWrite ///////////////////////////////////////////////////////////////////
// Oh, figure it out yourself. :P
hsBool plJPEG::IWrite( plMipmap *source, hsStream *outStream )
{
hsBool result = true, swapped = false;
UInt8 *jpgBuffer = nil;
UInt32 jpgBufferSize = 0;
#ifdef IJL_SDK_AVAILABLE
JPEG_CORE_PROPERTIES jcProps;
#else
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
#endif
#ifndef IJL_SDK_AVAILABLE
clear_jpegmsg();
cinfo.err = jpeg_std_error( &jerr );
jerr.error_exit = plJPEG_error_exit;
jerr.emit_message = plJPEG_emit_message;
#endif
try
{
#ifdef IJL_SDK_AVAILABLE
// Init the IJL Library
sLastErrCode = ijlInit( &jcProps );
if( sLastErrCode != IJL_OK )
throw( false );
#else
jpeg_create_compress( &cinfo );
#endif
// Create a buffer to hold the data
jpgBufferSize = source->GetWidth() * source->GetHeight() * 3;
jpgBuffer = TRACKED_NEW UInt8[ jpgBufferSize ];
if( jpgBuffer == nil )
{
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = IJL_MEMORY_ERROR;
throw( false );
#else
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;
UInt32 bufferSize = jpgBufferSize;
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_height = source->GetHeight();
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
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_height = source->GetHeight(); // default
cinfo.jpeg_color_space = JCS_YCbCr; // default
// not sure how to set 4:1:1 but supposedly it's the default
jpeg_set_quality( &cinfo, fWriteQuality, TRUE );
jpeg_start_compress( &cinfo, TRUE );
#endif
// Sometimes life just sucks
ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() );
swapped = true;
// Write it!
#ifdef IJL_SDK_AVAILABLE
sLastErrCode = ijlWrite( &jcProps, IJL_JBUFF_WRITEWHOLEIMAGE );
if( sLastErrCode != IJL_OK )
throw( false );
#else
JSAMPROW jbuffer;
int in_stride = cinfo.image_width * 4; // Input is always RGBA
int row_stride = cinfo.image_width * cinfo.input_components;
jbuffer = TRACKED_NEW JSAMPLE[row_stride];
UInt8 *srcp = (UInt8 *)source->GetImage();
while( cinfo.next_scanline < cinfo.image_height )
{
for( size_t pixel = 0; pixel < cinfo.image_width; ++pixel )
{
(void) memcpy( jbuffer + (pixel * cinfo.input_components),
srcp + (pixel * 4), cinfo.input_components );
}
(void) jpeg_write_scanlines( &cinfo, &jbuffer, 1 );
}
jpeg_finish_compress( &cinfo );
delete [] jbuffer;
#endif
#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->Write( bufferSize, bufferAddr );
#endif
}
catch( ... )
{
result = false;
}
// Cleanup
if ( jpgBuffer )
delete [] jpgBuffer;
#ifdef IJL_SDK_AVAILABLE
ijlFree( &jcProps );
#else
jpeg_destroy_compress( &cinfo );
#endif
if( swapped )
ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() );
return result;
}
hsBool plJPEG::WriteToFile( const char *fileName, plMipmap *sourceData )
{
wchar* wFilename = hsStringToWString(fileName);
hsBool retVal = WriteToFile(wFilename, sourceData);
delete [] wFilename;
return retVal;
}
hsBool plJPEG::WriteToFile( const wchar *fileName, plMipmap *sourceData )
{
// we use a stream because the IJL can't handle unicode
hsUNIXStream out;
if (!out.Open(fileName, L"wb"))
return false;
hsBool ret = IWrite(sourceData, &out);
out.Close();
return ret;
}
//// ISwapRGBAComponents //////////////////////////////////////////////////////
void plJPEG::ISwapRGBAComponents( UInt32 *data, UInt32 count )
{
while( count-- )
{
*data = ( ( ( *data ) & 0xff00ff00 ) ) |
( ( ( *data ) & 0x00ff0000 ) >> 16 ) |
// ( ( ( *data ) & 0x0000ff00 ) << 8 ) |
( ( ( *data ) & 0x000000ff ) << 16 );
data++;
}
}